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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
41,500 | google::protobuf::RepeatedField<bool>::at(int) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/repeated_field.h | inline Element& RepeatedField<Element>::at(int index) {
GOOGLE_CHECK_GE(index, 0);
GOOGLE_CHECK_LT(index, current_size_);
return elements()[index];
} | O0 | c | google::protobuf::RepeatedField<bool>::at(int):
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movl %esi, 0xbc(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0xbc(%rsp), %eax
movb $0x0, 0x7f(%rsp)
cmpl $0x0, %eax
jl 0x1bae06
jmp 0x1bae59
leaq 0x3de37(%rip), %rdx # 0x1f8c44
leaq 0x80(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x3, %esi
movl $0x29b, %ecx # imm = 0x29B
callq 0x237e0
movq 0x10(%rsp), %rdi
movb $0x1, 0x7f(%rsp)
leaq 0x35068(%rip), %rsi # 0x1efea2
callq 0x230a0
movq %rax, 0x18(%rsp)
jmp 0x1bae46
movq 0x18(%rsp), %rsi
leaq 0x6b(%rsp), %rdi
callq 0x23250
jmp 0x1bae57
jmp 0x1bae59
testb $0x1, 0x7f(%rsp)
jne 0x1bae62
jmp 0x1bae6f
leaq 0x80(%rsp), %rdi
callq 0x23820
movq 0x20(%rsp), %rcx
movl 0xbc(%rsp), %eax
movl (%rcx), %ecx
movb $0x0, 0x2f(%rsp)
cmpl %ecx, %eax
jge 0x1bae88
jmp 0x1baed6
leaq 0x3ddb5(%rip), %rdx # 0x1f8c44
leaq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
movl $0x3, %esi
movl $0x29c, %ecx # imm = 0x29C
callq 0x237e0
movq (%rsp), %rdi
movb $0x1, 0x2f(%rsp)
leaq 0x3500a(%rip), %rsi # 0x1efec1
callq 0x230a0
movq %rax, 0x8(%rsp)
jmp 0x1baec3
movq 0x8(%rsp), %rsi
leaq 0x2e(%rsp), %rdi
callq 0x23250
jmp 0x1baed4
jmp 0x1baed6
testb $0x1, 0x2f(%rsp)
jne 0x1baedf
jmp 0x1baee9
leaq 0x30(%rsp), %rdi
callq 0x23820
movq 0x20(%rsp), %rdi
callq 0x1bab20
movslq 0xbc(%rsp), %rcx
addq %rcx, %rax
addq $0xc8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
testb $0x1, 0x7f(%rsp)
jne 0x1baf1d
jmp 0x1baf2a
leaq 0x80(%rsp), %rdi
callq 0x23820
jmp 0x1baf4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
testb $0x1, 0x2f(%rsp)
jne 0x1baf43
jmp 0x1baf4d
leaq 0x30(%rsp), %rdi
callq 0x23820
jmp 0x1baf4f
movq 0x70(%rsp), %rdi
callq 0x13750
nopl (%rax)
| _ZN6google8protobuf13RepeatedFieldIbE2atEi:
sub rsp, 0C8h
mov [rsp+0C8h+var_8], rdi
mov [rsp+0C8h+var_C], esi
mov rax, [rsp+0C8h+var_8]
mov [rsp+0C8h+var_A8], rax
mov eax, [rsp+0C8h+var_C]
mov [rsp+0C8h+var_49], 0
cmp eax, 0
jl short loc_1BAE06
jmp short loc_1BAE59
loc_1BAE06:
lea rdx, aWorkspaceLlm4b_44; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+0C8h+var_48]
mov [rsp+0C8h+var_B8], rdi
mov esi, 3
mov ecx, 29Bh
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+0C8h+var_B8]
mov [rsp+0C8h+var_49], 1
lea rsi, aCheckFailedInd; "CHECK failed: (index) >= (0): "
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+0C8h+var_B0], rax
jmp short $+2
loc_1BAE46:
mov rsi, [rsp+0C8h+var_B0]
lea rdi, [rsp+0C8h+var_5D]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_1BAE57:
jmp short $+2
loc_1BAE59:
test [rsp+0C8h+var_49], 1
jnz short loc_1BAE62
jmp short loc_1BAE6F
loc_1BAE62:
lea rdi, [rsp+0C8h+var_48]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_1BAE6F:
mov rcx, [rsp+0C8h+var_A8]
mov eax, [rsp+0C8h+var_C]
mov ecx, [rcx]
mov [rsp+0C8h+var_99], 0
cmp eax, ecx
jge short loc_1BAE88
jmp short loc_1BAED6
loc_1BAE88:
lea rdx, aWorkspaceLlm4b_44; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+0C8h+var_98]
mov [rsp+0C8h+var_C8], rdi
mov esi, 3
mov ecx, 29Ch
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+0C8h+var_C8]
mov [rsp+0C8h+var_99], 1
lea rsi, aCheckFailedInd_0; "CHECK failed: (index) < (current_size_)"...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+0C8h+var_C0], rax
jmp short $+2
loc_1BAEC3:
mov rsi, [rsp+0C8h+var_C0]
lea rdi, [rsp+0C8h+var_9A]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_1BAED4:
jmp short $+2
loc_1BAED6:
test [rsp+0C8h+var_99], 1
jnz short loc_1BAEDF
jmp short loc_1BAEE9
loc_1BAEDF:
lea rdi, [rsp+0C8h+var_98]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_1BAEE9:
mov rdi, [rsp+0C8h+var_A8]
call _ZNK6google8protobuf13RepeatedFieldIbE8elementsEv; google::protobuf::RepeatedField<bool>::elements(void)
movsxd rcx, [rsp+0C8h+var_C]
add rax, rcx
add rsp, 0C8h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_68], rcx
mov [rsp+arg_64], eax
test [rsp+arg_77], 1
jnz short loc_1BAF1D
jmp short loc_1BAF2A
loc_1BAF1D:
lea rdi, [rsp+arg_78]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_1BAF2A:
jmp short loc_1BAF4F
mov rcx, rax
mov eax, edx
mov [rsp+arg_68], rcx
mov [rsp+arg_64], eax
test [rsp+arg_27], 1
jnz short loc_1BAF43
jmp short loc_1BAF4D
loc_1BAF43:
lea rdi, [rsp+arg_28]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_1BAF4D:
jmp short $+2
loc_1BAF4F:
mov rdi, [rsp+arg_68]
call __Unwind_Resume
| long long google::protobuf::RepeatedField<bool>::at(_DWORD *a1, int a2)
{
int v2; // ecx
long long v3; // rax
google::protobuf::internal::LogMessage *v5; // [rsp+8h] [rbp-C0h]
google::protobuf::internal::LogMessage *v6; // [rsp+18h] [rbp-B0h]
char v7; // [rsp+2Eh] [rbp-9Ah] BYREF
char v8; // [rsp+2Fh] [rbp-99h]
_BYTE v9[59]; // [rsp+30h] [rbp-98h] BYREF
char v10[20]; // [rsp+6Bh] [rbp-5Dh] BYREF
char v11; // [rsp+7Fh] [rbp-49h]
_BYTE v12[60]; // [rsp+80h] [rbp-48h] BYREF
int v13; // [rsp+BCh] [rbp-Ch]
_DWORD *v14; // [rsp+C0h] [rbp-8h]
v14 = a1;
v13 = a2;
v11 = 0;
if ( a2 < 0 )
{
google::protobuf::internal::LogMessage::LogMessage(
(long long)v12,
3,
(long long)"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/repeated_field.h",
667);
v11 = 1;
v6 = (google::protobuf::internal::LogMessage *)google::protobuf::internal::LogMessage::operator<<(
(long long)v12,
(long long)"CHECK failed: (index) >= (0): ");
google::protobuf::internal::LogFinisher::operator=((long long)v10, v6);
}
if ( (v11 & 1) != 0 )
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v12);
v2 = *a1;
v8 = 0;
if ( v13 >= v2 )
{
google::protobuf::internal::LogMessage::LogMessage(
(long long)v9,
3,
(long long)"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/repeated_field.h",
668);
v8 = 1;
v5 = (google::protobuf::internal::LogMessage *)google::protobuf::internal::LogMessage::operator<<(
(long long)v9,
(long long)"CHECK failed: (index) < (current_size_): ");
google::protobuf::internal::LogFinisher::operator=((long long)&v7, v5);
}
if ( (v8 & 1) != 0 )
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v9);
v3 = google::protobuf::RepeatedField<bool>::elements((long long)a1);
return v13 + v3;
}
| |||
41,501 | google::protobuf::RepeatedField<bool>::at(int) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/repeated_field.h | inline Element& RepeatedField<Element>::at(int index) {
GOOGLE_CHECK_GE(index, 0);
GOOGLE_CHECK_LT(index, current_size_);
return elements()[index];
} | O3 | c | google::protobuf::RepeatedField<bool>::at(int):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebp
movq %rdi, %rbx
testl %esi, %esi
jns 0xa32f3
leaq 0x1afca(%rip), %rdx # 0xbe280
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x3, %esi
movl $0x29b, %ecx # imm = 0x29B
callq 0x169ca
leaq 0x1b016(%rip), %rsi # 0xbe2ea
movq %r14, %rdi
callq 0x164c8
leaq 0x7(%rsp), %rdi
movq %rax, %rsi
callq 0x165a2
leaq 0x8(%rsp), %rdi
callq 0x169e8
cmpl %ebp, (%rbx)
jg 0xa333b
leaq 0x1af82(%rip), %rdx # 0xbe280
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x3, %esi
movl $0x29c, %ecx # imm = 0x29C
callq 0x169ca
leaq 0x1afed(%rip), %rsi # 0xbe309
movq %r14, %rdi
callq 0x164c8
leaq 0x7(%rsp), %rdi
movq %rax, %rsi
callq 0x165a2
leaq 0x8(%rsp), %rdi
callq 0x169e8
movslq %ebp, %rax
shlq $0x3, %rax
addq 0x8(%rbx), %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xa3355
jmp 0xa3355
jmp 0xa3355
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x169e8
movq %rbx, %rdi
callq 0xf570
| _ZN6google8protobuf13RepeatedFieldIlE2atEi:
push rbp
push r14
push rbx
sub rsp, 40h
mov ebp, esi
mov rbx, rdi
test esi, esi
jns short loc_A32F3
lea rdx, aWorkspaceLlm4b_26; "/workspace/llm4binary/github2025/aimrt_"...
lea r14, [rsp+58h+var_50]
mov rdi, r14
mov esi, 3
mov ecx, 29Bh
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
lea rsi, aCheckFailedInd; "CHECK failed: (index) >= (0): "
mov rdi, r14
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rdi, [rsp+58h+var_51]
mov rsi, rax
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
lea rdi, [rsp+58h+var_50]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_A32F3:
cmp [rbx], ebp
jg short loc_A333B
lea rdx, aWorkspaceLlm4b_26; "/workspace/llm4binary/github2025/aimrt_"...
lea r14, [rsp+58h+var_50]
mov rdi, r14
mov esi, 3
mov ecx, 29Ch
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
lea rsi, aCheckFailedInd_0; "CHECK failed: (index) < (current_size_)"...
mov rdi, r14
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rdi, [rsp+58h+var_51]
mov rsi, rax
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
lea rdi, [rsp+58h+var_50]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_A333B:
movsxd rax, ebp
shl rax, 3
add rax, [rbx+8]
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
jmp short loc_A3355
jmp short loc_A3355
jmp short $+2
loc_A3355:
mov rbx, rax
lea rdi, [rsp+arg_0]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
mov rdi, rbx
call __Unwind_Resume
| long long google::protobuf::RepeatedField<long>::at(long long a1, int a2)
{
google::protobuf::internal::LogMessage *v2; // rax
google::protobuf::internal::LogMessage *v3; // rax
char v5; // [rsp+7h] [rbp-51h] BYREF
_BYTE v6[80]; // [rsp+8h] [rbp-50h] BYREF
if ( a2 < 0 )
{
google::protobuf::internal::LogMessage::LogMessage(
(long long)v6,
3,
(long long)"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/repeated_field.h",
667);
v2 = (google::protobuf::internal::LogMessage *)google::protobuf::internal::LogMessage::operator<<(
(long long)v6,
(long long)"CHECK failed: (index) >= (0): ");
google::protobuf::internal::LogFinisher::operator=((long long)&v5, v2);
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v6);
}
if ( *(_DWORD *)a1 <= a2 )
{
google::protobuf::internal::LogMessage::LogMessage(
(long long)v6,
3,
(long long)"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/repeated_field.h",
668);
v3 = (google::protobuf::internal::LogMessage *)google::protobuf::internal::LogMessage::operator<<(
(long long)v6,
(long long)"CHECK failed: (index) < (current_size_): ");
google::protobuf::internal::LogFinisher::operator=((long long)&v5, v3);
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v6);
}
return *(_QWORD *)(a1 + 8) + 8LL * a2;
}
| at:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV EBP,ESI
MOV RBX,RDI
TEST ESI,ESI
JNS 0x001a32f3
LEA RDX,[0x1be280]
LEA R14,[RSP + 0x8]
MOV RDI,R14
MOV ESI,0x3
MOV ECX,0x29b
CALL 0x001169ca
LAB_001a32cd:
LEA RSI,[0x1be2ea]
MOV RDI,R14
CALL 0x001164c8
LAB_001a32dc:
LEA RDI,[RSP + 0x7]
MOV RSI,RAX
CALL 0x001165a2
LAB_001a32e9:
LEA RDI,[RSP + 0x8]
CALL 0x001169e8
LAB_001a32f3:
CMP dword ptr [RBX],EBP
JG 0x001a333b
LEA RDX,[0x1be280]
LEA R14,[RSP + 0x8]
MOV RDI,R14
MOV ESI,0x3
MOV ECX,0x29c
CALL 0x001169ca
LAB_001a3315:
LEA RSI,[0x1be309]
MOV RDI,R14
CALL 0x001164c8
LAB_001a3324:
LEA RDI,[RSP + 0x7]
MOV RSI,RAX
CALL 0x001165a2
LAB_001a3331:
LEA RDI,[RSP + 0x8]
CALL 0x001169e8
LAB_001a333b:
MOVSXD RAX,EBP
SHL RAX,0x3
ADD RAX,qword ptr [RBX + 0x8]
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
|
/* google::protobuf::RepeatedField<long>::at(int) */
long __thiscall google::protobuf::RepeatedField<long>::at(RepeatedField<long> *this,int param_1)
{
LogMessage *pLVar1;
LogFinisher local_51;
LogMessage local_50 [56];
if (param_1 < 0) {
internal::LogMessage::LogMessage
(local_50,3,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/repeated_field.h"
,0x29b);
/* try { // try from 001a32cd to 001a32db has its CatchHandler @ 001a3351 */
pLVar1 = (LogMessage *)
internal::LogMessage::operator<<(local_50,"CHECK failed: (index) >= (0): ");
/* try { // try from 001a32dc to 001a32e8 has its CatchHandler @ 001a334f */
internal::LogFinisher::operator=(&local_51,pLVar1);
internal::LogMessage::~LogMessage(local_50);
}
if (*(int *)this <= param_1) {
internal::LogMessage::LogMessage
(local_50,3,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/repeated_field.h"
,0x29c);
/* try { // try from 001a3315 to 001a3323 has its CatchHandler @ 001a3355 */
pLVar1 = (LogMessage *)
internal::LogMessage::operator<<(local_50,"CHECK failed: (index) < (current_size_): ");
/* try { // try from 001a3324 to 001a3330 has its CatchHandler @ 001a3353 */
internal::LogFinisher::operator=(&local_51,pLVar1);
internal::LogMessage::~LogMessage(local_50);
}
return (long)param_1 * 8 + *(long *)(this + 8);
}
| |
41,502 | protocol::encode(protocol::EntitySound const&, unsigned int) | untodesu[P]voxelius/game/shared/protocol.cc | ENetPacket *protocol::encode(const protocol::EntitySound &packet, enet_uint32 flags)
{
write_buffer.reset();
write_buffer.write_UI16(protocol::EntitySound::ID);
write_buffer.write_UI64(static_cast<std::uint64_t>(packet.entity));
write_buffer.write_string(packet.sound.substr(0, protocol::MAX_SOUNDNAME));
write_buffer.write_UI8(packet.looping);
write_buffer.write_FP32(packet.pitch);
return write_buffer.to_packet(flags);
} | O1 | cpp | protocol::encode(protocol::EntitySound const&, unsigned int):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0xc799a(%rip), %r15 # 0x10b0c8
movq %r15, %rdi
callq 0x4fad2
movq %r15, %rdi
movl $0x11, %esi
callq 0x4fafa
movl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x4fb8e
leaq 0x18(%r14), %rsi
leaq 0x8(%rsp), %r12
movl $0x400, %ecx # imm = 0x400
movq %r12, %rdi
xorl %edx, %edx
callq 0x176d0
movq %r15, %rdi
movq %r12, %rsi
callq 0x4fc48
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4378d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x176b0
movzbl 0x38(%r14), %esi
leaq 0xc792f(%rip), %r15 # 0x10b0c8
movq %r15, %rdi
callq 0x4fae2
movl 0x3c(%r14), %esi
movq %r15, %rdi
callq 0x4fb30
movq %r15, %rdi
movl %ebx, %esi
callq 0x4fd0a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x437e1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x176b0
movq %rbx, %rdi
callq 0x17c80
| _ZN8protocol6encodeERKNS_11EntitySoundEj:
push r15
push r14
push r12
push rbx
sub rsp, 28h
mov ebx, esi
mov r14, rdi
lea r15, _ZL12write_buffer; write_buffer
mov rdi, r15; this
call _ZN11WriteBuffer5resetEv; WriteBuffer::reset(void)
mov rdi, r15; this
mov esi, 11h; unsigned __int16
call _ZN11WriteBuffer10write_UI16Et; WriteBuffer::write_UI16(ushort)
mov esi, [r14+10h]; unsigned __int64
mov rdi, r15; this
call _ZN11WriteBuffer10write_UI64Em; WriteBuffer::write_UI64(ulong)
lea rsi, [r14+18h]
lea r12, [rsp+48h+var_40]
mov ecx, 400h
mov rdi, r12
xor edx, edx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rdi, r15
mov rsi, r12
call _ZN11WriteBuffer12write_stringERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; WriteBuffer::write_string(std::string const&)
lea rax, [rsp+48h+var_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_4378D
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4378D:
movzx esi, byte ptr [r14+38h]; unsigned __int8
lea r15, _ZL12write_buffer; write_buffer
mov rdi, r15; this
call _ZN11WriteBuffer9write_UI8Eh; WriteBuffer::write_UI8(uchar)
mov esi, [r14+3Ch]; unsigned int
mov rdi, r15; this
call _ZN11WriteBuffer10write_UI32Ej; WriteBuffer::write_UI32(uint)
mov rdi, r15; this
mov esi, ebx; unsigned int
call _ZNK11WriteBuffer9to_packetEj; WriteBuffer::to_packet(uint)
add rsp, 28h
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_437E1
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_437E1:
mov rdi, rbx
call __Unwind_Resume
| long long protocol::encode(protocol *this, const protocol::EntitySound *a2)
{
void *v3[2]; // [rsp+8h] [rbp-40h] BYREF
long long v4; // [rsp+18h] [rbp-30h] BYREF
WriteBuffer::reset((WriteBuffer *)&write_buffer);
WriteBuffer::write_UI16((WriteBuffer *)&write_buffer, 0x11u);
WriteBuffer::write_UI64((WriteBuffer *)&write_buffer, *((unsigned int *)this + 4));
std::string::substr(v3, (char *)this + 24, 0LL, 1024LL);
WriteBuffer::write_string(&write_buffer, v3);
if ( v3[0] != &v4 )
operator delete(v3[0], v4 + 1);
WriteBuffer::write_UI8((WriteBuffer *)&write_buffer, *((_BYTE *)this + 56));
WriteBuffer::write_UI32((WriteBuffer *)&write_buffer, *((_DWORD *)this + 15));
return WriteBuffer::to_packet((WriteBuffer *)&write_buffer, (unsigned int)a2);
}
| encode:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV EBX,ESI
MOV R14,RDI
LEA R15,[0x20b0c8]
MOV RDI,R15
CALL 0x0014fad2
MOV RDI,R15
MOV ESI,0x11
CALL 0x0014fafa
MOV ESI,dword ptr [R14 + 0x10]
MOV RDI,R15
CALL 0x0014fb8e
LEA RSI,[R14 + 0x18]
LEA R12,[RSP + 0x8]
MOV ECX,0x400
MOV RDI,R12
XOR EDX,EDX
CALL 0x001176d0
LAB_00143767:
MOV RDI,R15
MOV RSI,R12
CALL 0x0014fc48
LAB_00143772:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0014378d
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001176b0
LAB_0014378d:
MOVZX ESI,byte ptr [R14 + 0x38]
LEA R15,[0x20b0c8]
MOV RDI,R15
CALL 0x0014fae2
MOV ESI,dword ptr [R14 + 0x3c]
MOV RDI,R15
CALL 0x0014fb30
MOV RDI,R15
MOV ESI,EBX
CALL 0x0014fd0a
ADD RSP,0x28
POP RBX
POP R12
POP R14
POP R15
RET
|
/* protocol::encode(protocol::EntitySound const&, unsigned int) */
void protocol::encode(EntitySound *param_1,uint param_2)
{
long *local_40 [2];
long local_30 [2];
WriteBuffer::reset((WriteBuffer *)write_buffer);
WriteBuffer::write_UI16(0xb0c8);
WriteBuffer::write_UI64((WriteBuffer *)write_buffer,(ulong)*(uint *)(param_1 + 0x10));
std::__cxx11::string::substr((ulong)local_40,(ulong)(param_1 + 0x18));
/* try { // try from 00143767 to 00143771 has its CatchHandler @ 001437c3 */
WriteBuffer::write_string((WriteBuffer *)write_buffer,(string *)local_40);
if (local_40[0] != local_30) {
operator_delete(local_40[0],local_30[0] + 1);
}
WriteBuffer::write_UI8((WriteBuffer *)write_buffer,(uchar)param_1[0x38]);
WriteBuffer::write_UI32(0x20b0c8);
WriteBuffer::to_packet((WriteBuffer *)write_buffer,param_2);
return;
}
| |
41,503 | stbi__ldr_to_hdr(unsigned char*, int, int, int) | SDL3Lite/dependencies/stb_image.h | static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
{
int i,k,n;
float *output;
if (!data) return NULL;
output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0);
if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); }
// compute number of non-alpha components
if (comp & 1) n = comp; else n = comp-1;
for (i=0; i < x*y; ++i) {
for (k=0; k < n; ++k) {
output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale);
}
}
if (n < comp) {
for (i=0; i < x*y; ++i) {
output[i*comp + n] = data[i*comp + n]/255.0f;
}
}
STBI_FREE(data);
return output;
} | O0 | c | stbi__ldr_to_hdr(unsigned char*, int, int, int):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2b699
movq $0x0, -0x8(%rbp)
jmp 0x2b804
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
movl $0x4, %ecx
xorl %r8d, %r8d
callq 0x2b810
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x2b6e3
movq -0x10(%rbp), %rdi
callq 0x1a310
leaq 0x8a15(%rip), %rdi # 0x340df
callq 0x27ea0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
jmp 0x2b804
movl -0x1c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2b6f6
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x2b6ff
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0x14(%rbp), %ecx
imull -0x18(%rbp), %ecx
cmpl %ecx, %eax
jge 0x2b78e
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x2b77e
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cvtsi2ss %eax, %xmm0
movss 0x328c(%rip), %xmm1 # 0x2e9d0
divss %xmm1, %xmm0
movss 0xfb50(%rip), %xmm1 # 0x3b2a0
callq 0x2b9e0
mulss 0xfb47(%rip), %xmm0 # 0x3b2a4
movq -0x30(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2b71b
jmp 0x2b780
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2b706
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2b7f3
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0x14(%rbp), %ecx
imull -0x18(%rbp), %ecx
cmpl %ecx, %eax
jge 0x2b7f1
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cvtsi2ss %eax, %xmm0
movss 0x3204(%rip), %xmm1 # 0x2e9d0
divss %xmm1, %xmm0
movq -0x30(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2b79d
jmp 0x2b7f3
movq -0x10(%rbp), %rdi
callq 0x1a310
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
| _ZL16stbi__ldr_to_hdrPhiii:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_1C], ecx
cmp [rbp+var_10], 0
jnz short loc_2B699
mov [rbp+var_8], 0
jmp loc_2B804
loc_2B699:
mov edi, [rbp+var_14]; int
mov esi, [rbp+var_18]; int
mov edx, [rbp+var_1C]; int
mov ecx, 4; int
xor r8d, r8d; int
call _ZL17stbi__malloc_mad4iiiii; stbi__malloc_mad4(int,int,int,int,int)
mov [rbp+var_30], rax
cmp [rbp+var_30], 0
jnz short loc_2B6E3
mov rdi, [rbp+var_10]
call _free
lea rdi, aOutofmem; "outofmem"
call _ZL9stbi__errPKc; stbi__err(char const*)
mov ecx, eax
xor eax, eax
cmp ecx, 0
cmovnz rax, rax
mov [rbp+var_8], rax
jmp loc_2B804
loc_2B6E3:
mov eax, [rbp+var_1C]
and eax, 1
cmp eax, 0
jz short loc_2B6F6
mov eax, [rbp+var_1C]
mov [rbp+var_28], eax
jmp short loc_2B6FF
loc_2B6F6:
mov eax, [rbp+var_1C]
sub eax, 1
mov [rbp+var_28], eax
loc_2B6FF:
mov [rbp+var_20], 0
loc_2B706:
mov eax, [rbp+var_20]
mov ecx, [rbp+var_14]
imul ecx, [rbp+var_18]
cmp eax, ecx
jge short loc_2B78E
mov [rbp+var_24], 0
loc_2B71B:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_28]
jge short loc_2B77E
mov rax, [rbp+var_10]
mov ecx, [rbp+var_20]
imul ecx, [rbp+var_1C]
add ecx, [rbp+var_24]
movsxd rcx, ecx
movzx eax, byte ptr [rax+rcx]
cvtsi2ss xmm0, eax
movss xmm1, cs:dword_2E9D0
divss xmm0, xmm1; float
movss xmm1, cs:_ZL15stbi__l2h_gamma; float
call _ZSt3powff; std::pow(float,float)
mulss xmm0, cs:_ZL15stbi__l2h_scale; stbi__l2h_scale
mov rax, [rbp+var_30]
mov ecx, [rbp+var_20]
imul ecx, [rbp+var_1C]
add ecx, [rbp+var_24]
movsxd rcx, ecx
movss dword ptr [rax+rcx*4], xmm0
mov eax, [rbp+var_24]
add eax, 1
mov [rbp+var_24], eax
jmp short loc_2B71B
loc_2B77E:
jmp short $+2
loc_2B780:
mov eax, [rbp+var_20]
add eax, 1
mov [rbp+var_20], eax
jmp loc_2B706
loc_2B78E:
mov eax, [rbp+var_28]
cmp eax, [rbp+var_1C]
jge short loc_2B7F3
mov [rbp+var_20], 0
loc_2B79D:
mov eax, [rbp+var_20]
mov ecx, [rbp+var_14]
imul ecx, [rbp+var_18]
cmp eax, ecx
jge short loc_2B7F1
mov rax, [rbp+var_10]
mov ecx, [rbp+var_20]
imul ecx, [rbp+var_1C]
add ecx, [rbp+var_28]
movsxd rcx, ecx
movzx eax, byte ptr [rax+rcx]
cvtsi2ss xmm0, eax
movss xmm1, cs:dword_2E9D0
divss xmm0, xmm1
mov rax, [rbp+var_30]
mov ecx, [rbp+var_20]
imul ecx, [rbp+var_1C]
add ecx, [rbp+var_28]
movsxd rcx, ecx
movss dword ptr [rax+rcx*4], xmm0
mov eax, [rbp+var_20]
add eax, 1
mov [rbp+var_20], eax
jmp short loc_2B79D
loc_2B7F1:
jmp short $+2
loc_2B7F3:
mov rdi, [rbp+var_10]
call _free
mov rax, [rbp+var_30]
mov [rbp+var_8], rax
loc_2B804:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| long long stbi__ldr_to_hdr(unsigned __int8 *a1, int a2, int a3, int a4)
{
float v4; // xmm0_4
long long v6; // [rsp+0h] [rbp-30h]
int v7; // [rsp+8h] [rbp-28h]
int j; // [rsp+Ch] [rbp-24h]
int i; // [rsp+10h] [rbp-20h]
int k; // [rsp+10h] [rbp-20h]
if ( !a1 )
return 0LL;
v6 = stbi__malloc_mad4(a2, a3, a4, 4, 0);
if ( v6 )
{
if ( (a4 & 1) != 0 )
v7 = a4;
else
v7 = a4 - 1;
for ( i = 0; i < a3 * a2; ++i )
{
for ( j = 0; j < v7; ++j )
{
v4 = (float)a1[j + a4 * i] / 255.0;
std::pow(v4, stbi__l2h_gamma);
*(float *)(v6 + 4LL * (j + a4 * i)) = v4 * *(float *)&stbi__l2h_scale;
}
}
if ( v7 < a4 )
{
for ( k = 0; k < a3 * a2; ++k )
*(float *)(v6 + 4LL * (v7 + a4 * k)) = (float)a1[v7 + a4 * k] / 255.0;
}
free(a1);
return v6;
}
else
{
free(a1);
stbi__err("outofmem");
return 0LL;
}
}
| stbi__ldr_to_hdr:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV dword ptr [RBP + -0x1c],ECX
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x0012b699
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0012b804
LAB_0012b699:
MOV EDI,dword ptr [RBP + -0x14]
MOV ESI,dword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
MOV ECX,0x4
XOR R8D,R8D
CALL 0x0012b810
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x0012b6e3
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0011a310
LEA RDI,[0x1340df]
CALL 0x00127ea0
MOV ECX,EAX
XOR EAX,EAX
CMP ECX,0x0
CMOVNZ RAX,RAX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0012b804
LAB_0012b6e3:
MOV EAX,dword ptr [RBP + -0x1c]
AND EAX,0x1
CMP EAX,0x0
JZ 0x0012b6f6
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x28],EAX
JMP 0x0012b6ff
LAB_0012b6f6:
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
MOV dword ptr [RBP + -0x28],EAX
LAB_0012b6ff:
MOV dword ptr [RBP + -0x20],0x0
LAB_0012b706:
MOV EAX,dword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x14]
IMUL ECX,dword ptr [RBP + -0x18]
CMP EAX,ECX
JGE 0x0012b78e
MOV dword ptr [RBP + -0x24],0x0
LAB_0012b71b:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x28]
JGE 0x0012b77e
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x20]
IMUL ECX,dword ptr [RBP + -0x1c]
ADD ECX,dword ptr [RBP + -0x24]
MOVSXD RCX,ECX
MOVZX EAX,byte ptr [RAX + RCX*0x1]
CVTSI2SS XMM0,EAX
MOVSS XMM1,dword ptr [0x0012e9d0]
DIVSS XMM0,XMM1
MOVSS XMM1,dword ptr [0x0013b2a0]
CALL 0x0012b9e0
MULSS XMM0,dword ptr [0x0013b2a4]
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RBP + -0x20]
IMUL ECX,dword ptr [RBP + -0x1c]
ADD ECX,dword ptr [RBP + -0x24]
MOVSXD RCX,ECX
MOVSS dword ptr [RAX + RCX*0x4],XMM0
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
JMP 0x0012b71b
LAB_0012b77e:
JMP 0x0012b780
LAB_0012b780:
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,0x1
MOV dword ptr [RBP + -0x20],EAX
JMP 0x0012b706
LAB_0012b78e:
MOV EAX,dword ptr [RBP + -0x28]
CMP EAX,dword ptr [RBP + -0x1c]
JGE 0x0012b7f3
MOV dword ptr [RBP + -0x20],0x0
LAB_0012b79d:
MOV EAX,dword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x14]
IMUL ECX,dword ptr [RBP + -0x18]
CMP EAX,ECX
JGE 0x0012b7f1
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x20]
IMUL ECX,dword ptr [RBP + -0x1c]
ADD ECX,dword ptr [RBP + -0x28]
MOVSXD RCX,ECX
MOVZX EAX,byte ptr [RAX + RCX*0x1]
CVTSI2SS XMM0,EAX
MOVSS XMM1,dword ptr [0x0012e9d0]
DIVSS XMM0,XMM1
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RBP + -0x20]
IMUL ECX,dword ptr [RBP + -0x1c]
ADD ECX,dword ptr [RBP + -0x28]
MOVSXD RCX,ECX
MOVSS dword ptr [RAX + RCX*0x4],XMM0
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,0x1
MOV dword ptr [RBP + -0x20],EAX
JMP 0x0012b79d
LAB_0012b7f1:
JMP 0x0012b7f3
LAB_0012b7f3:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0011a310
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x8],RAX
LAB_0012b804:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
/* stbi__ldr_to_hdr(unsigned char*, int, int, int) */
long stbi__ldr_to_hdr(uchar *param_1,int param_2,int param_3,int param_4)
{
float fVar1;
int local_30;
int local_2c;
int local_28;
long local_10;
if (param_1 == (uchar *)0x0) {
local_10 = 0;
}
else {
local_10 = stbi__malloc_mad4(param_2,param_3,param_4,4,0);
if (local_10 == 0) {
free(param_1);
stbi__err("outofmem");
local_10 = 0;
}
else {
local_30 = param_4;
if ((param_4 & 1U) == 0) {
local_30 = param_4 + -1;
}
for (local_28 = 0; local_28 < param_2 * param_3; local_28 = local_28 + 1) {
for (local_2c = 0; local_2c < local_30; local_2c = local_2c + 1) {
fVar1 = (float)std::pow((float)param_1[local_28 * param_4 + local_2c] / DAT_0012e9d0,
stbi__l2h_gamma);
*(float *)(local_10 + (long)(local_28 * param_4 + local_2c) * 4) = fVar1 * stbi__l2h_scale
;
}
}
if (local_30 < param_4) {
for (local_28 = 0; local_28 < param_2 * param_3; local_28 = local_28 + 1) {
*(float *)(local_10 + (long)(local_28 * param_4 + local_30) * 4) =
(float)param_1[local_28 * param_4 + local_30] / DAT_0012e9d0;
}
}
free(param_1);
}
}
return local_10;
}
| |
41,504 | ExampleGuardedVector<unsigned long>::push_back(unsigned long const&) | BadAccessGuards/benchmarks/../examples/GuardedVectorExample.h | void push_back(const T& val) {
BA_GUARD_WRITE(BAShadow);
super::push_back(val);
} | O0 | c | ExampleGuardedVector<unsigned long>::push_back(unsigned long const&):
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rsi, -0xc0(%rbp)
movq -0xb8(%rbp), %rax
movq %rax, -0xe0(%rbp)
addq $0x18, %rax
leaq -0xc8(%rbp), %rcx
movq %rcx, -0x98(%rbp)
movq %rax, -0xa0(%rbp)
movq -0x98(%rbp), %rax
movq -0xa0(%rbp), %rcx
movq %rcx, (%rax)
movq -0xa0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
je 0x1098a
movq -0xa8(%rbp), %rdi
movl $0x1, %esi
callq 0x10370
movq -0xe0(%rbp), %rdi
movq -0xa0(%rbp), %rax
movq %rax, -0x8(%rbp)
movq $0x1, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rbp, %rcx
andq $-0x4, %rcx
movq -0x10(%rbp), %rdx
orq %rdx, %rcx
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0xc0(%rbp), %rsi
callq 0xfcd0
jmp 0x109cf
leaq -0xc8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
andq $0x3, %rax
cmpq $0x1, %rax
je 0x10a36
movq -0x88(%rbp), %rdi
movl $0x1, %esi
callq 0x10370
jmp 0x10a2c
jmp 0x10a36
movq %rax, %rdi
callq 0xf7b0
movq -0xe8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rbp, %rcx
andq $-0x4, %rcx
movq -0x28(%rbp), %rdx
orq %rdx, %rcx
movq %rcx, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0xc8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
andq $0x3, %rax
cmpq $0x1, %rax
je 0x10adc
movq -0x70(%rbp), %rdi
movl $0x1, %esi
callq 0x10370
jmp 0x10ad2
jmp 0x10adc
movq %rax, %rdi
callq 0xf7b0
movq -0xf0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq %rbp, %rcx
andq $-0x4, %rcx
movq -0x40(%rbp), %rdx
orq %rdx, %rcx
movq %rcx, -0x48(%rbp)
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq -0xd0(%rbp), %rdi
callq 0x47a0
nopl (%rax,%rax)
| _ZN20ExampleGuardedVectorImE9push_backERKm:
push rbp
mov rbp, rsp
sub rsp, 0F0h
mov [rbp+var_B8], rdi
mov [rbp+var_C0], rsi
mov rax, [rbp+var_B8]
mov [rbp+var_E0], rax
add rax, 18h
lea rcx, [rbp+var_C8]
mov [rbp+var_98], rcx
mov [rbp+var_A0], rax
mov rax, [rbp+var_98]
mov rcx, [rbp+var_A0]
mov [rax], rcx
mov rax, [rbp+var_A0]
mov rax, [rax]
mov [rbp+var_B0], rax
mov rax, [rbp+var_B0]
mov [rbp+var_A8], rax
mov rax, [rbp+var_A8]
mov [rbp+var_50], rax
mov rax, [rbp+var_50]
and rax, 3
cmp rax, 0
jz short loc_1098A
mov rdi, [rbp+var_A8]
mov esi, 1
call _Z22BAGuardHandleBadAccessm19BadAccessGuardState; BAGuardHandleBadAccess(ulong,BadAccessGuardState)
loc_1098A:
mov rdi, [rbp+var_E0]
mov rax, [rbp+var_A0]
mov [rbp+var_8], rax
mov [rbp+var_10], 1
mov rax, [rbp+var_8]
mov rcx, rbp
and rcx, 0FFFFFFFFFFFFFFFCh
mov rdx, [rbp+var_10]
or rcx, rdx
mov [rbp+var_18], rcx
mov rcx, [rbp+var_18]
mov [rax], rcx
mov rsi, [rbp+var_C0]
call _ZNSt6vectorImSaImEE9push_backERKm; std::vector<ulong>::push_back(ulong const&)
jmp short $+2
loc_109CF:
lea rax, [rbp+var_C8]
mov [rbp+var_80], rax
mov rax, [rbp+var_80]
mov [rbp+var_E8], rax
mov rax, [rax]
mov rax, [rax]
mov [rbp+var_90], rax
mov rax, [rbp+var_90]
mov [rbp+var_88], rax
mov rax, [rbp+var_88]
mov [rbp+var_58], rax
mov rax, [rbp+var_58]
and rax, 3
cmp rax, 1
jz short loc_10A36
mov rdi, [rbp+var_88]
mov esi, 1
call _Z22BAGuardHandleBadAccessm19BadAccessGuardState; BAGuardHandleBadAccess(ulong,BadAccessGuardState)
jmp short $+2
loc_10A2C:
jmp short loc_10A36
mov rdi, rax
call __clang_call_terminate
loc_10A36:
mov rax, [rbp+var_E8]
mov rax, [rax]
mov [rbp+var_20], rax
mov [rbp+var_28], 0
mov rax, [rbp+var_20]
mov rcx, rbp
and rcx, 0FFFFFFFFFFFFFFFCh
mov rdx, [rbp+var_28]
or rcx, rdx
mov [rbp+var_30], rcx
mov rcx, [rbp+var_30]
mov [rax], rcx
add rsp, 0F0h
pop rbp
retn
mov rcx, rax
mov eax, edx
mov [rbp+var_D0], rcx
mov [rbp+var_D4], eax
lea rax, [rbp+var_C8]
mov [rbp+var_68], rax
mov rax, [rbp+var_68]
mov [rbp+var_F0], rax
mov rax, [rax]
mov rax, [rax]
mov [rbp+var_78], rax
mov rax, [rbp+var_78]
mov [rbp+var_70], rax
mov rax, [rbp+var_70]
mov [rbp+var_60], rax
mov rax, [rbp+var_60]
and rax, 3
cmp rax, 1
jz short loc_10ADC
mov rdi, [rbp+var_70]
mov esi, 1
call _Z22BAGuardHandleBadAccessm19BadAccessGuardState; BAGuardHandleBadAccess(ulong,BadAccessGuardState)
jmp short $+2
loc_10AD2:
jmp short loc_10ADC
mov rdi, rax
call __clang_call_terminate
loc_10ADC:
mov rax, [rbp+var_F0]
mov rax, [rax]
mov [rbp+var_38], rax
mov [rbp+var_40], 0
mov rax, [rbp+var_38]
mov rcx, rbp
and rcx, 0FFFFFFFFFFFFFFFCh
mov rdx, [rbp+var_40]
or rcx, rdx
mov [rbp+var_48], rcx
mov rcx, [rbp+var_48]
mov [rax], rcx
mov rdi, [rbp+var_D0]
call __Unwind_Resume
| long long * ExampleGuardedVector<unsigned long>::push_back(long long a1, long long a2)
{
long long *result; // rax
long long *v3; // [rsp+28h] [rbp-C8h] BYREF
long long v4; // [rsp+30h] [rbp-C0h]
long long v5; // [rsp+38h] [rbp-B8h]
long long v6; // [rsp+40h] [rbp-B0h]
long long v7; // [rsp+48h] [rbp-A8h]
_QWORD *v8; // [rsp+50h] [rbp-A0h]
long long **v9; // [rsp+58h] [rbp-98h]
long long v10; // [rsp+60h] [rbp-90h]
long long v11; // [rsp+68h] [rbp-88h]
long long **v12; // [rsp+70h] [rbp-80h]
long long v13; // [rsp+98h] [rbp-58h]
long long v14; // [rsp+A0h] [rbp-50h]
char *v15; // [rsp+D8h] [rbp-18h]
long long v16; // [rsp+E0h] [rbp-10h]
_QWORD *v17; // [rsp+E8h] [rbp-8h]
long long savedregs; // [rsp+F0h] [rbp+0h] BYREF
v5 = a1;
v4 = a2;
v9 = &v3;
v8 = (_QWORD *)(a1 + 24);
v3 = (long long *)(a1 + 24);
v6 = *(_QWORD *)(a1 + 24);
v7 = v6;
v14 = v6;
if ( (v6 & 3) != 0 )
BAGuardHandleBadAccess(v7, 1LL);
v17 = v8;
v16 = 1LL;
v15 = (char *)&savedregs + 1;
*v8 = (char *)&savedregs + 1;
std::vector<unsigned long>::push_back(a1, v4);
v12 = &v3;
v10 = *v3;
v11 = v10;
v13 = v10;
if ( (v10 & 3) != 1 )
BAGuardHandleBadAccess(v11, 1LL);
result = v3;
*v3 = (long long)&savedregs;
return result;
}
| push_back:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xf0
MOV qword ptr [RBP + -0xb8],RDI
MOV qword ptr [RBP + -0xc0],RSI
MOV RAX,qword ptr [RBP + -0xb8]
MOV qword ptr [RBP + -0xe0],RAX
ADD RAX,0x18
LEA RCX,[RBP + -0xc8]
MOV qword ptr [RBP + -0x98],RCX
MOV qword ptr [RBP + -0xa0],RAX
MOV RAX,qword ptr [RBP + -0x98]
MOV RCX,qword ptr [RBP + -0xa0]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0xa0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0xb0],RAX
MOV RAX,qword ptr [RBP + -0xb0]
MOV qword ptr [RBP + -0xa8],RAX
MOV RAX,qword ptr [RBP + -0xa8]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x50]
AND RAX,0x3
CMP RAX,0x0
JZ 0x0011098a
MOV RDI,qword ptr [RBP + -0xa8]
MOV ESI,0x1
CALL 0x00110370
LAB_0011098a:
MOV RDI,qword ptr [RBP + -0xe0]
MOV RAX,qword ptr [RBP + -0xa0]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x10],0x1
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,RBP
AND RCX,-0x4
MOV RDX,qword ptr [RBP + -0x10]
OR RCX,RDX
MOV qword ptr [RBP + -0x18],RCX
MOV RCX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV RSI,qword ptr [RBP + -0xc0]
LAB_001109c8:
CALL 0x0010fcd0
JMP 0x001109cf
LAB_001109cf:
LEA RAX,[RBP + -0xc8]
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x80]
MOV qword ptr [RBP + -0xe8],RAX
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x90],RAX
MOV RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x58]
AND RAX,0x3
CMP RAX,0x1
JZ 0x00110a36
MOV RDI,qword ptr [RBP + -0x88]
LAB_00110a20:
MOV ESI,0x1
CALL 0x00110370
JMP 0x00110a2c
LAB_00110a2c:
JMP 0x00110a36
LAB_00110a36:
MOV RAX,qword ptr [RBP + -0xe8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
MOV qword ptr [RBP + -0x28],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,RBP
AND RCX,-0x4
MOV RDX,qword ptr [RBP + -0x28]
OR RCX,RDX
MOV qword ptr [RBP + -0x30],RCX
MOV RCX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
ADD RSP,0xf0
POP RBP
RET
|
/* ExampleGuardedVector<unsigned long>::push_back(unsigned long const&) */
void __thiscall
ExampleGuardedVector<unsigned_long>::push_back
(ExampleGuardedVector<unsigned_long> *this,ulong *param_1)
{
ExampleGuardedVector<unsigned_long> *local_d0;
ulong *local_c8;
ExampleGuardedVector<unsigned_long> *local_c0;
ulong local_b8;
ulong local_b0;
ExampleGuardedVector<unsigned_long> *local_a8;
ExampleGuardedVector<unsigned_long> **local_a0;
ulong local_98;
ulong local_90;
ExampleGuardedVector<unsigned_long> **local_88;
ulong local_60;
ulong local_58;
ulong local_20;
int8 local_18;
ExampleGuardedVector<unsigned_long> *local_10;
local_a8 = this + 0x18;
local_a0 = &local_d0;
local_b8 = *(ulong *)local_a8;
local_c8 = param_1;
local_c0 = this;
local_b0 = local_b8;
local_58 = local_b8;
local_d0 = local_a8;
if ((local_b8 & 3) != 0) {
BAGuardHandleBadAccess(local_b8,1);
}
local_10 = local_a8;
local_18 = 1;
local_20 = (ulong)&stack0xfffffffffffffff8 | 1;
*(ulong *)local_a8 = local_20;
/* try { // try from 001109c8 to 001109cc has its CatchHandler @ 00110a72 */
std::vector<unsigned_long,std::allocator<unsigned_long>>::push_back
((vector<unsigned_long,std::allocator<unsigned_long>> *)this,local_c8);
local_88 = &local_d0;
local_98 = *(ulong *)local_d0;
if ((local_98 & 3) != 1) {
local_90 = local_98;
local_60 = local_98;
/* try { // try from 00110a20 to 00110a29 has its CatchHandler @ 00110a2e */
BAGuardHandleBadAccess(local_98,1);
}
*(int1 **)local_d0 = &stack0xfffffffffffffff8;
return;
}
| |
41,505 | ExampleGuardedVector<unsigned long>::push_back(unsigned long const&) | BadAccessGuards/benchmarks/../examples/GuardedVectorExample.h | void push_back(const T& val) {
BA_GUARD_WRITE(BAShadow);
super::push_back(val);
} | O3 | c | ExampleGuardedVector<unsigned long>::push_back(unsigned long const&):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testb $0x3, %dil
jne 0x673d
movq %rbp, %r15
andq $-0x4, %r15
leaq 0x1(%r15), %rax
movq %rax, 0x18(%rbx)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x6715
movq (%r14), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x6720
movq %rbx, %rdi
movq %r14, %rdx
callq 0x6286
movq 0x18(%rbx), %rdi
movl %edi, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x6749
movq %r15, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %esi
callq 0x63a5
jmp 0x66ec
movl $0x1, %esi
callq 0x63a5
jmp 0x672e
movq %rax, %rdi
callq 0x6109
movq %rax, %r14
movq 0x18(%rbx), %rdi
movl %edi, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x677a
movq %r15, 0x18(%rbx)
movq %r14, %rdi
callq 0x35a0
movl $0x1, %esi
callq 0x63a5
jmp 0x676e
jmp 0x6755
| _ZN20ExampleGuardedVectorImE9push_backERKm:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov rdi, [rdi+18h]
test dil, 3
jnz short loc_673D
loc_66EC:
mov r15, rbp
and r15, 0FFFFFFFFFFFFFFFCh
lea rax, [r15+1]
mov [rbx+18h], rax
mov rsi, [rbx+8]
cmp rsi, [rbx+10h]
jz short loc_6715
mov rax, [r14]
mov [rsi], rax
add rsi, 8
mov [rbx+8], rsi
jmp short loc_6720
loc_6715:
mov rdi, rbx
mov rdx, r14
call _ZNSt6vectorImSaImEE17_M_realloc_insertIJRKmEEEvN9__gnu_cxx17__normal_iteratorIPmS1_EEDpOT_; std::vector<ulong>::_M_realloc_insert<ulong const&>(__gnu_cxx::__normal_iterator<ulong *,std::vector<ulong>>,ulong const&)
loc_6720:
mov rdi, [rbx+18h]
mov eax, edi
and eax, 3
cmp eax, 1
jnz short loc_6749
loc_672E:
mov [rbx+18h], r15
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_673D:
mov esi, 1
call _Z22BAGuardHandleBadAccessm19BadAccessGuardState; BAGuardHandleBadAccess(ulong,BadAccessGuardState)
jmp short loc_66EC
loc_6749:
mov esi, 1
call _Z22BAGuardHandleBadAccessm19BadAccessGuardState; BAGuardHandleBadAccess(ulong,BadAccessGuardState)
jmp short loc_672E
loc_6755:
mov rdi, rax
call __clang_call_terminate
mov r14, rax
mov rdi, [rbx+18h]
mov eax, edi
and eax, 3
cmp eax, 1
jnz short loc_677A
loc_676E:
mov [rbx+18h], r15
mov rdi, r14
call __Unwind_Resume
loc_677A:
mov esi, 1
call _Z22BAGuardHandleBadAccessm19BadAccessGuardState; BAGuardHandleBadAccess(ulong,BadAccessGuardState)
jmp short loc_676E
jmp short loc_6755
| long long ExampleGuardedVector<unsigned long>::push_back(long long *a1, _QWORD *a2)
{
long long v4; // rdi
_QWORD *v5; // rsi
long long result; // rax
long long savedregs; // [rsp+18h] [rbp+0h] BYREF
v4 = a1[3];
if ( (v4 & 3) != 0 )
BAGuardHandleBadAccess(v4, 1LL);
a1[3] = (long long)&savedregs + 1;
v5 = (_QWORD *)a1[1];
if ( v5 == (_QWORD *)a1[2] )
{
std::vector<unsigned long>::_M_realloc_insert<unsigned long const&>(a1, (long long)v5, a2);
}
else
{
*v5 = *a2;
a1[1] = (long long)(v5 + 1);
}
result = a1[3] & 3;
if ( (_DWORD)result != 1 )
result = BAGuardHandleBadAccess(a1[3], 1LL);
a1[3] = (long long)&savedregs;
return result;
}
| push_back:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x18]
TEST DIL,0x3
JNZ 0x0010673d
LAB_001066ec:
MOV R15,RBP
AND R15,-0x4
LEA RAX,[R15 + 0x1]
MOV qword ptr [RBX + 0x18],RAX
MOV RSI,qword ptr [RBX + 0x8]
CMP RSI,qword ptr [RBX + 0x10]
JZ 0x00106715
MOV RAX,qword ptr [R14]
MOV qword ptr [RSI],RAX
ADD RSI,0x8
MOV qword ptr [RBX + 0x8],RSI
JMP 0x00106720
LAB_00106715:
MOV RDI,RBX
MOV RDX,R14
CALL 0x00106286
LAB_00106720:
MOV RDI,qword ptr [RBX + 0x18]
MOV EAX,EDI
AND EAX,0x3
CMP EAX,0x1
JNZ 0x00106749
LAB_0010672e:
MOV qword ptr [RBX + 0x18],R15
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0010673d:
MOV ESI,0x1
CALL 0x001063a5
JMP 0x001066ec
LAB_00106749:
MOV ESI,0x1
CALL 0x001063a5
LAB_00106753:
JMP 0x0010672e
|
/* ExampleGuardedVector<unsigned long>::push_back(unsigned long const&) */
void __thiscall
ExampleGuardedVector<unsigned_long>::push_back
(ExampleGuardedVector<unsigned_long> *this,ulong *param_1)
{
ulong *puVar1;
if ((*(ulong *)(this + 0x18) & 3) != 0) {
BAGuardHandleBadAccess(*(ulong *)(this + 0x18),1);
}
*(int1 **)(this + 0x18) = &stack0xfffffffffffffff9;
puVar1 = *(ulong **)(this + 8);
if (puVar1 == *(ulong **)(this + 0x10)) {
/* try { // try from 00106715 to 0010671f has its CatchHandler @ 0010675d */
std::vector<unsigned_long,std::allocator<unsigned_long>>::
_M_realloc_insert<unsigned_long_const&>
((vector<unsigned_long,std::allocator<unsigned_long>> *)this,puVar1,param_1);
}
else {
*puVar1 = *param_1;
*(ulong **)(this + 8) = puVar1 + 1;
}
if (((uint)*(int8 *)(this + 0x18) & 3) != 1) {
/* try { // try from 00106749 to 00106752 has its CatchHandler @ 00106755 */
BAGuardHandleBadAccess(*(int8 *)(this + 0x18),1);
}
*(int1 **)(this + 0x18) = &stack0xfffffffffffffff8;
return;
}
| |
41,506 | crc32_pclmul | eloqsql/mysys/crc32/crc32_x86.c | unsigned int crc32_pclmul(unsigned int crc32, const void *buf, size_t len)
{
return ~crcr32_calc_pclmulqdq(buf, (uint32_t)len, ~crc32, ðer_crc32_clmul);
} | O3 | c | crc32_pclmul:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %fs:0x28, %rax
movq %rax, -0x18(%rbp)
testl %ebx, %ebx
je 0x256c7
notl %edi
movd %edi, %xmm2
cmpl $0x1f, %ebx
jbe 0x256e1
movdqu (%rsi), %xmm1
pxor %xmm2, %xmm1
pushq $0x10
popq %rax
movl $0xccaa009e, %ecx # imm = 0xCCAA009E
movq %rcx, %xmm0
movdqa 0x428bd(%rip), %xmm2 # 0x67e90
movl %eax, %ecx
movdqu (%rsi,%rcx), %xmm3
movdqa %xmm1, %xmm4
pclmulqdq $0x1, %xmm0, %xmm4
pxor %xmm3, %xmm4
pclmulqdq $0x10, %xmm2, %xmm1
pxor %xmm4, %xmm1
leal 0x10(%rax), %ecx
addl $0x20, %eax
cmpl %ebx, %eax
movl %ecx, %eax
jbe 0x255d3
cmpl %ebx, %ecx
jae 0x2565a
leal -0x10(%rbx), %eax
movdqu (%rsi,%rax), %xmm2
andl $0xf, %ebx
leaq 0x43b5c(%rip), %rax # 0x69170
movdqu (%rbx,%rax), %xmm0
movdqa %xmm1, %xmm3
pshufb %xmm0, %xmm3
pxor 0x42876(%rip), %xmm0 # 0x67ea0
pshufb %xmm0, %xmm1
pblendvb %xmm0, %xmm2, %xmm1
movl $0xccaa009e, %eax # imm = 0xCCAA009E
movq %rax, %xmm0
pclmulqdq $0x10, %xmm3, %xmm0
pxor %xmm1, %xmm0
pclmulqdq $0x10, 0x4283e(%rip), %xmm3 # 0x67e90
pxor %xmm0, %xmm3
movdqa %xmm3, %xmm1
movl $0xccaa009e, %eax # imm = 0xCCAA009E
movq %rax, %xmm0
pclmulqdq $0x0, %xmm1, %xmm0
psrldq $0x8, %xmm1 # xmm1 = xmm1[8,9,10,11,12,13,14,15],zero,zero,zero,zero,zero,zero,zero,zero
pxor %xmm0, %xmm1
movdqa %xmm1, %xmm2
psllq $0x20, %xmm2
pclmulqdq $0x10, 0x4282a(%rip), %xmm2 # 0x67eb0
pxor %xmm1, %xmm2
pxor %xmm0, %xmm0
pblendw $0xfc, %xmm2, %xmm0 # xmm0 = xmm0[0,1],xmm2[2,3,4,5,6,7]
movabsq $0x1f7011640, %rax # imm = 0x1F7011640
movq %rax, %xmm1
pclmulqdq $0x0, %xmm0, %xmm1
pxor %xmm0, %xmm1
movq %xmm1, %xmm0 # xmm0 = xmm1[0],zero
pclmulqdq $0x10, 0x42805(%rip), %xmm0 # 0x67ec0
pxor %xmm2, %xmm0
pextrd $0x2, %xmm0, %edi
notl %edi
movq %fs:0x28, %rax
cmpq -0x18(%rbp), %rax
jne 0x256f8
movl %edi, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x10, %ebx
je 0x256fd
jb 0x2570a
movdqu (%rsi), %xmm1
pxor %xmm2, %xmm1
pushq $0x10
popq %rcx
jmp 0x255fe
callq 0x24390
movdqu (%rsi), %xmm1
pxor %xmm2, %xmm1
jmp 0x2565a
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %r14
movaps %xmm0, (%r14)
movl %ebx, %edx
andl $0xf, %edx
pushq $0x10
popq %rcx
movq %r14, %rdi
movdqa %xmm2, -0x40(%rbp)
callq 0x24600
movdqa -0x40(%rbp), %xmm1
pxor (%r14), %xmm1
cmpl $0x4, %ebx
jae 0x2575e
pushq $0x8
popq %rax
subl %ebx, %eax
andl $0xf, %eax
leaq 0x43a48(%rip), %rcx # 0x69190
subq %rax, %rcx
movdqu 0x10(%rcx), %xmm0
movdqa %xmm1, %xmm2
pshufb %xmm0, %xmm2
jmp 0x2568a
pushq $0x10
popq %rax
subl %ebx, %eax
andl $0x1f, %eax
leaq 0x43a23(%rip), %rcx # 0x69190
subq %rax, %rcx
movdqu 0x10(%rcx), %xmm0
pshufb %xmm0, %xmm1
jmp 0x2565a
| crc32_pclmul:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 30h
mov rbx, rdx
mov rax, fs:28h
mov [rbp+var_18], rax
test ebx, ebx
jz loc_256C7
not edi
movd xmm2, edi
cmp ebx, 1Fh
jbe loc_256E1
movdqu xmm1, xmmword ptr [rsi]
pxor xmm1, xmm2
push 10h
pop rax
mov ecx, 0CCAA009Eh
movq xmm0, rcx
movdqa xmm2, cs:xmmword_67E90
loc_255D3:
mov ecx, eax
movdqu xmm3, xmmword ptr [rsi+rcx]
movdqa xmm4, xmm1
pclmulqdq xmm4, xmm0, 1
pxor xmm4, xmm3
pclmulqdq xmm1, xmm2, 10h
pxor xmm1, xmm4
lea ecx, [rax+10h]
add eax, 20h ; ' '
cmp eax, ebx
mov eax, ecx
jbe short loc_255D3
loc_255FE:
cmp ecx, ebx
jnb short loc_2565A
lea eax, [rbx-10h]
movdqu xmm2, xmmword ptr [rsi+rax]
and ebx, 0Fh
lea rax, crcr32_calc_pclmulqdq_shf_table
movdqu xmm0, xmmword ptr [rbx+rax]
movdqa xmm3, xmm1
pshufb xmm3, xmm0
pxor xmm0, cs:xmmword_67EA0
pshufb xmm1, xmm0
pblendvb xmm1, xmm2
mov eax, 0CCAA009Eh
movq xmm0, rax
pclmulqdq xmm0, xmm3, 10h
pxor xmm0, xmm1
pclmulqdq xmm3, cs:xmmword_67E90, 10h
pxor xmm3, xmm0
movdqa xmm1, xmm3
loc_2565A:
mov eax, 0CCAA009Eh
movq xmm0, rax
pclmulqdq xmm0, xmm1, 0
psrldq xmm1, 8
pxor xmm1, xmm0
movdqa xmm2, xmm1
psllq xmm2, 20h ; ' '
pclmulqdq xmm2, cs:xmmword_67EB0, 10h
pxor xmm2, xmm1
loc_2568A:
pxor xmm0, xmm0
pblendw xmm0, xmm2, 0FCh
mov rax, 1F7011640h
movq xmm1, rax
pclmulqdq xmm1, xmm0, 0
pxor xmm1, xmm0
movq xmm0, xmm1
pclmulqdq xmm0, cs:xmmword_67EC0, 10h
pxor xmm0, xmm2
pextrd edi, xmm0, 2
not edi
loc_256C7:
mov rax, fs:28h
cmp rax, [rbp+var_18]
jnz short loc_256F8
mov eax, edi
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_256E1:
cmp ebx, 10h
jz short loc_256FD
jb short loc_2570A
movdqu xmm1, xmmword ptr [rsi]
pxor xmm1, xmm2
push 10h
pop rcx
jmp loc_255FE
loc_256F8:
call ___stack_chk_fail
loc_256FD:
movdqu xmm1, xmmword ptr [rsi]
pxor xmm1, xmm2
jmp loc_2565A
loc_2570A:
xorps xmm0, xmm0
lea r14, [rbp+var_30]
movaps xmmword ptr [r14], xmm0
mov edx, ebx
and edx, 0Fh
push 10h
pop rcx
mov rdi, r14
movdqa [rbp+var_40], xmm2
call ___memcpy_chk
movdqa xmm1, [rbp+var_40]
pxor xmm1, xmmword ptr [r14]
cmp ebx, 4
jnb short loc_2575E
push 8
pop rax
sub eax, ebx
and eax, 0Fh
lea rcx, xmm_shift_left_crc_xmm_shift_tab
sub rcx, rax
movdqu xmm0, xmmword ptr [rcx+10h]
movdqa xmm2, xmm1
pshufb xmm2, xmm0
jmp loc_2568A
loc_2575E:
push 10h
pop rax
sub eax, ebx
and eax, 1Fh
lea rcx, xmm_shift_left_crc_xmm_shift_tab
sub rcx, rax
movdqu xmm0, xmmword ptr [rcx+10h]
pshufb xmm1, xmm0
jmp loc_2565A
| long long crc32_pclmul(unsigned int a1, const __m128i *a2, unsigned int a3)
{
__m128i v4; // xmm2
unsigned int v6; // eax
unsigned int v12; // ecx
bool v13; // cc
__m128i v14; // xmm0
__m128i v16; // xmm0
__m128i v17; // xmm1
__m128i v23; // xmm1
__m128i v26; // xmm2
__m128i v33; // xmm1
__m128i v34; // [rsp+0h] [rbp-40h] BYREF
__m128i v35; // [rsp+10h] [rbp-30h] BYREF
unsigned long long v36; // [rsp+28h] [rbp-18h]
v36 = __readfsqword(0x28u);
if ( a3 )
{
v4 = _mm_cvtsi32_si128(~a1);
if ( a3 > 0x1F )
{
_XMM1 = _mm_xor_si128(_mm_loadu_si128(a2), v4);
v6 = 1;
_XMM0 = 0xCCAA009EuLL;
_XMM2 = _mm_load_si128((const __m128i *)&xmmword_67E90);
do
{
_XMM4 = _XMM1;
__asm
{
pclmulqdq xmm4, xmm0, 1
pclmulqdq xmm1, xmm2, 10h
}
_XMM1 = _mm_xor_si128(_XMM1, _mm_xor_si128(_XMM4, _mm_loadu_si128(&a2[v6])));
v12 = v6 * 16 + 16;
v13 = v6 * 16 + 32 <= a3;
++v6;
}
while ( v13 );
LABEL_5:
if ( v12 < a3 )
{
v14 = _mm_loadu_si128((const __m128i *)((char *)&crcr32_calc_pclmulqdq_shf_table + (a3 & 0xF)));
_XMM3 = _mm_shuffle_epi8(_XMM1, v14);
v16 = _mm_xor_si128(v14, (__m128i)xmmword_67EA0);
v17 = _mm_blendv_epi8(
_mm_shuffle_epi8(_XMM1, v16),
_mm_loadu_si128((const __m128i *)((char *)a2 + a3 - 16)),
v16);
_XMM0 = 0xCCAA009EuLL;
__asm
{
pclmulqdq xmm0, xmm3, 10h
pclmulqdq xmm3, cs:xmmword_67E90, 10h
}
_XMM1 = _mm_xor_si128(_XMM3, _mm_xor_si128(_XMM0, v17));
}
goto LABEL_7;
}
if ( a3 == 16 )
{
_XMM1 = _mm_xor_si128(_mm_loadu_si128(a2), v4);
}
else
{
if ( a3 >= 0x10 )
{
_XMM1 = _mm_xor_si128(_mm_loadu_si128(a2), v4);
v12 = 16;
goto LABEL_5;
}
v35 = 0LL;
v34 = v4;
__memcpy_chk(&v35, a2, a3 & 0xF, 16LL);
v33 = _mm_xor_si128(_mm_load_si128(&v34), v35);
if ( a3 < 4 )
{
v26 = _mm_shuffle_epi8(
v33,
_mm_loadu_si128((const __m128i *)((char *)&xmm_shift_left_crc_xmm_shift_tab
- ((8 - (_BYTE)a3) & 0xF)
+ 16)));
goto LABEL_8;
}
_XMM1 = _mm_shuffle_epi8(
v33,
_mm_loadu_si128((const __m128i *)((char *)&xmm_shift_left_crc_xmm_shift_tab
- ((16 - (_BYTE)a3) & 0x1F)
+ 16)));
}
LABEL_7:
_XMM0 = 0xCCAA009EuLL;
__asm { pclmulqdq xmm0, xmm1, 0 }
v23 = _mm_xor_si128(_mm_srli_si128(_XMM1, 8), _XMM0);
_XMM2 = _mm_slli_epi64(v23, 0x20u);
__asm { pclmulqdq xmm2, cs:xmmword_67EB0, 10h }
v26 = _mm_xor_si128(_XMM2, v23);
LABEL_8:
_XMM0 = _mm_blend_epi16((__m128i)0LL, v26, 252);
_XMM1 = 0x1F7011640uLL;
__asm { pclmulqdq xmm1, xmm0, 0 }
_XMM0 = _mm_move_epi64(_mm_xor_si128(_XMM1, _XMM0));
__asm { pclmulqdq xmm0, cs:xmmword_67EC0, 10h }
return (unsigned int)~_mm_extract_epi32(_mm_xor_si128(_XMM0, v26), 2);
}
return a1;
}
| crc32_pclmul:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RBX,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
TEST EBX,EBX
JZ 0x001256c7
NOT EDI
MOVD XMM2,EDI
CMP EBX,0x1f
JBE 0x001256e1
MOVDQU XMM1,xmmword ptr [RSI]
PXOR XMM1,XMM2
PUSH 0x10
POP RAX
MOV ECX,0xccaa009e
MOVQ XMM0,RCX
MOVDQA XMM2,xmmword ptr [0x00167e90]
LAB_001255d3:
MOV ECX,EAX
MOVDQU XMM3,xmmword ptr [RSI + RCX*0x1]
MOVDQA XMM4,XMM1
PCLMULHQLQDQ XMM4,XMM0
PXOR XMM4,XMM3
PCLMULLQHQDQ XMM1,XMM2
PXOR XMM1,XMM4
LEA ECX,[RAX + 0x10]
ADD EAX,0x20
CMP EAX,EBX
MOV EAX,ECX
JBE 0x001255d3
LAB_001255fe:
CMP ECX,EBX
JNC 0x0012565a
LEA EAX,[RBX + -0x10]
MOVDQU XMM2,xmmword ptr [RSI + RAX*0x1]
AND EBX,0xf
LEA RAX,[0x169170]
MOVDQU XMM0,xmmword ptr [RBX + RAX*0x1]
MOVDQA XMM3,XMM1
PSHUFB XMM3,XMM0
PXOR XMM0,xmmword ptr [0x00167ea0]
PSHUFB XMM1,XMM0
PBLENDVB XMM1,XMM2
MOV EAX,0xccaa009e
MOVQ XMM0,RAX
PCLMULLQHQDQ XMM0,XMM3
PXOR XMM0,XMM1
PCLMULQDQ XMM3,xmmword ptr [0x00167e90],0x10
PXOR XMM3,XMM0
MOVDQA XMM1,XMM3
LAB_0012565a:
MOV EAX,0xccaa009e
MOVQ XMM0,RAX
PCLMULLQLQDQ XMM0,XMM1
PSRLDQ XMM1,0x8
PXOR XMM1,XMM0
MOVDQA XMM2,XMM1
PSLLQ XMM2,0x20
PCLMULQDQ XMM2,xmmword ptr [0x00167eb0],0x10
PXOR XMM2,XMM1
LAB_0012568a:
PXOR XMM0,XMM0
PBLENDW XMM0,XMM2,0xfc
MOV RAX,0x1f7011640
MOVQ XMM1,RAX
PCLMULLQLQDQ XMM1,XMM0
PXOR XMM1,XMM0
MOVQ XMM0,XMM1
PCLMULQDQ XMM0,xmmword ptr [0x00167ec0],0x10
PXOR XMM0,XMM2
PEXTRD EDI,XMM0,0x2
NOT EDI
LAB_001256c7:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x18]
JNZ 0x001256f8
MOV EAX,EDI
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_001256e1:
CMP EBX,0x10
JZ 0x001256fd
JC 0x0012570a
MOVDQU XMM1,xmmword ptr [RSI]
PXOR XMM1,XMM2
PUSH 0x10
POP RCX
JMP 0x001255fe
LAB_001256f8:
CALL 0x00124390
LAB_001256fd:
MOVDQU XMM1,xmmword ptr [RSI]
PXOR XMM1,XMM2
JMP 0x0012565a
LAB_0012570a:
XORPS XMM0,XMM0
LEA R14,[RBP + -0x30]
MOVAPS xmmword ptr [R14],XMM0
MOV EDX,EBX
AND EDX,0xf
PUSH 0x10
POP RCX
MOV RDI,R14
MOVDQA xmmword ptr [RBP + -0x40],XMM2
CALL 0x00124600
MOVDQA XMM1,xmmword ptr [RBP + -0x40]
PXOR XMM1,xmmword ptr [R14]
CMP EBX,0x4
JNC 0x0012575e
PUSH 0x8
POP RAX
SUB EAX,EBX
AND EAX,0xf
LEA RCX,[0x169190]
SUB RCX,RAX
MOVDQU XMM0,xmmword ptr [RCX + 0x10]
MOVDQA XMM2,XMM1
PSHUFB XMM2,XMM0
JMP 0x0012568a
LAB_0012575e:
PUSH 0x10
POP RAX
SUB EAX,EBX
AND EAX,0x1f
LEA RCX,[0x169190]
SUB RCX,RAX
MOVDQU XMM0,xmmword ptr [RCX + 0x10]
PSHUFB XMM1,XMM0
JMP 0x0012565a
|
/* WARNING: Removing unreachable block (ram,0x001256b1) */
/* WARNING: Removing unreachable block (ram,0x0012567c) */
/* WARNING: Removing unreachable block (ram,0x00125648) */
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
uint crc32_pclmul(uint param_1,int1 (*param_2) [16],uint param_3)
{
int1 auVar1 [16];
int1 auVar2 [16];
int1 auVar3 [16];
int1 auVar4 [16];
int1 auVar5 [16];
int1 auVar6 [16];
int1 auVar7 [16];
int1 auVar8 [16];
int1 auVar9 [16];
uint uVar10;
uint uVar11;
uint uVar12;
long in_FS_OFFSET;
int1 auVar13 [16];
int1 auVar14 [16];
int1 auVar15 [16];
int1 auVar16 [16];
int8 local_38;
int8 uStack_30;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
if (param_3 == 0) goto LAB_001256c7;
auVar15 = ZEXT416(~param_1);
if (param_3 < 0x20) {
if (param_3 == 0x10) {
auVar15 = *param_2 ^ auVar15;
goto LAB_0012565a;
}
if (0xf < param_3) {
auVar15 = *param_2 ^ auVar15;
uVar12 = 0x10;
goto LAB_001255fe;
}
local_38 = 0;
uStack_30 = 0;
__memcpy_chk(&local_38,param_2,param_3 & 0xf,0x10);
auVar13._8_8_ = uStack_30;
auVar13._0_8_ = local_38;
if (3 < param_3) {
auVar15 = pshufb(auVar15 ^ auVar13,
*(int1 (*) [16])
(xmm_shift_left_crc_xmm_shift_tab + (0x10 - (ulong)(0x10 - param_3 & 0x1f)))
);
goto LAB_0012565a;
}
auVar15 = pshufb(auVar15 ^ auVar13,
*(int1 (*) [16])
(xmm_shift_left_crc_xmm_shift_tab + (0x10 - (ulong)(8 - param_3 & 0xf))));
}
else {
auVar15 = *param_2 ^ auVar15;
uVar10 = 0x10;
do {
auVar14._8_8_ = 0;
auVar14._0_8_ = auVar15._8_8_;
auVar13 = (int1 [16])0x0;
for (uVar12 = 0; uVar12 < 0x40; uVar12 = uVar12 + 1) {
if ((auVar14 & (int1 [16])0x1 << uVar12) != (int1 [16])0x0) {
auVar13 = auVar13 ^ ZEXT816(0xccaa009e) << uVar12;
}
}
auVar16._8_8_ = 0;
auVar16._0_8_ = auVar15._0_8_;
auVar3._8_8_ = 0;
auVar3._0_8_ = _UNK_00167e98;
auVar15 = (int1 [16])0x0;
for (uVar12 = 0; uVar12 < 0x40; uVar12 = uVar12 + 1) {
if ((auVar16 & (int1 [16])0x1 << uVar12) != (int1 [16])0x0) {
auVar15 = auVar15 ^ auVar3 << uVar12;
}
}
auVar15 = auVar15 ^ auVar13 ^ *(int1 (*) [16])(*param_2 + uVar10);
uVar12 = uVar10 + 0x10;
uVar11 = uVar10 + 0x20;
uVar10 = uVar12;
} while (uVar11 <= param_3);
LAB_001255fe:
if (uVar12 < param_3) {
auVar16 = pshufb(auVar15,*(int1 (*) [16])
(crcr32_calc_pclmulqdq_shf_table + (param_3 & 0xf)));
auVar13 = *(int1 (*) [16])(crcr32_calc_pclmulqdq_shf_table + (param_3 & 0xf)) ^
_DAT_00167ea0;
auVar15 = pshufb(auVar15,auVar13);
auVar14 = pblendvb(auVar15,*(int1 (*) [16])(*param_2 + (param_3 - 0x10)),auVar13);
auVar15._8_8_ = 0;
auVar15._0_8_ = auVar16._8_8_;
auVar13 = (int1 [16])0x0;
for (uVar12 = 0; uVar12 < 0x40; uVar12 = uVar12 + 1) {
if ((ZEXT816(0xccaa009e) & (int1 [16])0x1 << uVar12) != (int1 [16])0x0) {
auVar13 = auVar13 ^ auVar15 << uVar12;
}
}
auVar4._8_8_ = 0;
auVar4._0_8_ = auVar16._0_8_;
auVar7._8_8_ = 0;
auVar7._0_8_ = _UNK_00167e98;
auVar15 = (int1 [16])0x0;
for (uVar12 = 0; uVar12 < 0x40; uVar12 = uVar12 + 1) {
if ((auVar4 & (int1 [16])0x1 << uVar12) != (int1 [16])0x0) {
auVar15 = auVar15 ^ auVar7 << uVar12;
}
}
auVar15 = auVar15 ^ auVar13 ^ auVar14;
}
LAB_0012565a:
auVar1._8_8_ = 0;
auVar1._0_8_ = auVar15._0_8_;
auVar13 = (int1 [16])0x0;
for (uVar12 = 0; uVar12 < 0x40; uVar12 = uVar12 + 1) {
if ((ZEXT816(0xccaa009e) & (int1 [16])0x1 << uVar12) != (int1 [16])0x0) {
auVar13 = auVar13 ^ auVar1 << uVar12;
}
}
auVar13 = auVar15 >> 0x40 ^ auVar13;
auVar5._8_8_ = 0;
auVar5._0_8_ = auVar13._0_8_ << 0x20;
auVar8._8_8_ = 0;
auVar8._0_8_ = _UNK_00167eb8;
auVar15 = (int1 [16])0x0;
for (uVar12 = 0; uVar12 < 0x40; uVar12 = uVar12 + 1) {
if ((auVar5 & (int1 [16])0x1 << uVar12) != (int1 [16])0x0) {
auVar15 = auVar15 ^ auVar8 << uVar12;
}
}
auVar15 = auVar15 ^ auVar13;
}
auVar14 = pblendw((int1 [16])0x0,auVar15,0xfc);
auVar2._8_8_ = 0;
auVar2._0_8_ = auVar14._0_8_;
auVar13 = (int1 [16])0x0;
for (uVar12 = 0; uVar12 < 0x40; uVar12 = uVar12 + 1) {
if ((ZEXT816(0x1f7011640) & (int1 [16])0x1 << uVar12) != (int1 [16])0x0) {
auVar13 = auVar13 ^ auVar2 << uVar12;
}
}
auVar6._8_8_ = 0;
auVar6._0_8_ = auVar13._0_8_ ^ auVar14._0_8_;
auVar9._8_8_ = 0;
auVar9._0_8_ = _UNK_00167ec8;
auVar13 = (int1 [16])0x0;
for (uVar12 = 0; uVar12 < 0x40; uVar12 = uVar12 + 1) {
if ((auVar6 & (int1 [16])0x1 << uVar12) != (int1 [16])0x0) {
auVar13 = auVar13 ^ auVar9 << uVar12;
}
}
param_1 = ~(auVar13._8_4_ ^ auVar15._8_4_);
LAB_001256c7:
if (*(long *)(in_FS_OFFSET + 0x28) != local_20) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
}
| |
41,507 | gguf_kv::gguf_kv<signed char>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, signed char) | monkey531[P]llama/ggml/src/gguf.cpp | gguf_kv(const std::string & key, const T value)
: key(key), is_array(false), type(type_to_gguf_type<T>::value) {
GGML_ASSERT(!key.empty());
data.resize(sizeof(T));
memcpy(data.data(), &value, sizeof(T));
} | O1 | cpp | gguf_kv::gguf_kv<signed char>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, signed char):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
movq %rbx, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
callq 0x16630
movb $0x0, 0x20(%r14)
movl $0x1, 0x24(%r14)
leaq 0x28(%r14), %r15
leaq 0x40(%r14), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x48(%r14)
cmpq $0x0, 0x8(%r13)
je 0x42d5b
movl $0x1, %esi
movq %r15, %rdi
callq 0x16130
movq (%r15), %rax
movb %bpl, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16fb3(%rip), %rdi # 0x59d15
leaq 0x78f0(%rip), %rdx # 0x4a659
leaq 0x17754(%rip), %rcx # 0x5a4c4
movl $0x84, %esi
xorl %eax, %eax
callq 0x17c70
movq %rax, %r13
movq %r12, %rdi
callq 0x16c50
movq (%r15), %rdi
testq %rdi, %rdi
je 0x42d9b
movq 0x38(%r14), %rsi
subq %rdi, %rsi
callq 0x17080
movq %r14, %rdi
movq %rbx, %rsi
callq 0x188bf
movq %r13, %rdi
callq 0x17e30
| _ZN7gguf_kvC2IaEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET_:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebp, edx
mov r13, rsi
mov r14, rdi
lea rbx, [rdi+10h]
mov [rdi], rbx
mov rsi, [rsi]
mov rdx, [r13+8]
add rdx, rsi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
mov byte ptr [r14+20h], 0
mov dword ptr [r14+24h], 1
lea r15, [r14+28h]
lea r12, [r14+40h]
xorps xmm0, xmm0
movups xmmword ptr [r14+28h], xmm0
movups xmmword ptr [r14+38h], xmm0
movups xmmword ptr [r14+48h], xmm0
cmp qword ptr [r13+8], 0
jz short loc_42D5B
mov esi, 1
mov rdi, r15
call __ZNSt6vectorIaSaIaEE6resizeEm; std::vector<signed char>::resize(ulong)
mov rax, [r15]
mov [rax], bpl
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_42D5B:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeyEmpty; "!key.empty()"
mov esi, 84h
xor eax, eax
call _ggml_abort
mov r13, rax
mov rdi, r12
call __ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, [r15]; void *
test rdi, rdi
jz short loc_42D9B
mov rsi, [r14+38h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_42D9B:
mov rdi, r14
mov rsi, rbx
call _ZN7gguf_kvC2IaEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET__cold_1; gguf_kv::gguf_kv<signed char>(std::string const&,signed char) [clone]
mov rdi, r13
call __Unwind_Resume
| _BYTE * gguf_kv::gguf_kv<signed char>(long long a1, _QWORD *a2, char a3)
{
int v4; // r8d
int v5; // r9d
_QWORD *v6; // r15
_BYTE *result; // rax
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<char *>(a1, *a2, *a2 + a2[1]);
*(_BYTE *)(a1 + 32) = 0;
*(_DWORD *)(a1 + 36) = 1;
v6 = (_QWORD *)(a1 + 40);
*(_OWORD *)(a1 + 40) = 0LL;
*(_OWORD *)(a1 + 56) = 0LL;
*(_OWORD *)(a1 + 72) = 0LL;
if ( !a2[1] )
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/gguf.cpp",
132,
(unsigned int)"GGML_ASSERT(%s) failed",
(unsigned int)"!key.empty()",
v4,
v5);
std::vector<signed char>::resize(a1 + 40, 1LL);
result = (_BYTE *)*v6;
*(_BYTE *)*v6 = a3;
return result;
}
| gguf_kv<signed_char>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EBP,EDX
MOV R13,RSI
MOV R14,RDI
LEA RBX,[RDI + 0x10]
MOV qword ptr [RDI],RBX
MOV RSI,qword ptr [RSI]
MOV RDX,qword ptr [R13 + 0x8]
ADD RDX,RSI
CALL 0x00116630
MOV byte ptr [R14 + 0x20],0x0
MOV dword ptr [R14 + 0x24],0x1
LEA R15,[R14 + 0x28]
LEA R12,[R14 + 0x40]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x28],XMM0
MOVUPS xmmword ptr [R14 + 0x38],XMM0
MOVUPS xmmword ptr [R14 + 0x48],XMM0
CMP qword ptr [R13 + 0x8],0x0
JZ 0x00142d5b
LAB_00142d39:
MOV ESI,0x1
MOV RDI,R15
CALL 0x00116130
MOV RAX,qword ptr [R15]
MOV byte ptr [RAX],BPL
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00142d5b:
LEA RDI,[0x159d15]
LEA RDX,[0x14a659]
LEA RCX,[0x15a4c4]
MOV ESI,0x84
XOR EAX,EAX
CALL 0x00117c70
|
/* gguf_kv::gguf_kv<signed char>(std::__cxx11::string const&, signed char) */
void __thiscall gguf_kv::gguf_kv<signed_char>(gguf_kv *this,long *param_1,int1 param_3)
{
*(gguf_kv **)this = this + 0x10;
std::__cxx11::string::_M_construct<char*>(this,*param_1,param_1[1] + *param_1);
this[0x20] = (gguf_kv)0x0;
*(int4 *)(this + 0x24) = 1;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 0x50) = 0;
if (param_1[1] != 0) {
/* try { // try from 00142d39 to 00142d7b has its CatchHandler @ 00142d7c */
std::vector<signed_char,std::allocator<signed_char>>::resize
((vector<signed_char,std::allocator<signed_char>> *)(this + 0x28),1);
**(int1 **)(this + 0x28) = param_3;
return;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/gguf.cpp",0x84,
"GGML_ASSERT(%s) failed","!key.empty()");
}
| |
41,508 | gguf_kv::gguf_kv<signed char>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, signed char) | monkey531[P]llama/ggml/src/gguf.cpp | gguf_kv(const std::string & key, const T value)
: key(key), is_array(false), type(type_to_gguf_type<T>::value) {
GGML_ASSERT(!key.empty());
data.resize(sizeof(T));
memcpy(data.data(), &value, sizeof(T));
} | O2 | cpp | gguf_kv::gguf_kv<signed char>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, signed char):
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %r15
movq %rdi, %rbx
callq 0x1e010
movb $0x0, 0x20(%rbx)
movl $0xc, 0x24(%rbx)
leaq 0x28(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
cmpq $0x0, 0x8(%r15)
je 0x48b45
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x1c200
movq (%r14), %rax
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x11cb9(%rip), %rdi # 0x5a805
leaq 0x2a7a(%rip), %rdx # 0x4b5cd
leaq 0x1245a(%rip), %rcx # 0x5afb4
movl $0x84, %esi
xorl %eax, %eax
callq 0x1e760
movq %rax, %r15
leaq 0x40(%rbx), %rdi
callq 0x1d0b0
movq %r14, %rdi
callq 0x1e680
movq %rbx, %rdi
callq 0x1c990
movq %r15, %rdi
callq 0x1e9a0
| _ZN7gguf_kvC2IdEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET_:
push r15
push r14
push rbx
sub rsp, 10h
movsd [rsp+28h+var_20], xmm0
mov r15, rsi
mov rbx, rdi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
mov byte ptr [rbx+20h], 0
mov dword ptr [rbx+24h], 0Ch
lea r14, [rbx+28h]
xorps xmm0, xmm0
movups xmmword ptr [rbx+28h], xmm0
movups xmmword ptr [rbx+38h], xmm0
movups xmmword ptr [rbx+48h], xmm0
cmp qword ptr [r15+8], 0
jz short loc_48B45
push 8
pop rsi
mov rdi, r14
call __ZNSt6vectorIaSaIaEE6resizeEm; std::vector<signed char>::resize(ulong)
mov rax, [r14]
movsd xmm0, [rsp+28h+var_20]
movsd qword ptr [rax], xmm0
add rsp, 10h
pop rbx
pop r14
pop r15
retn
loc_48B45:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeyEmpty; "!key.empty()"
mov esi, 84h
xor eax, eax
call _ggml_abort
mov r15, rax
lea rdi, [rbx+40h]
call __ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, r14
call __ZNSt12_Vector_baseIaSaIaEED2Ev; std::_Vector_base<signed char>::~_Vector_base()
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r15
call __Unwind_Resume
| double * gguf_kv::gguf_kv<double>(
long long a1,
long long a2,
double a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
long long v10; // r8
long long v11; // r9
__m128 v12; // xmm4
__m128 v13; // xmm5
double **v14; // r14
double *result; // rax
char v16; // [rsp+0h] [rbp-28h]
std::string::basic_string(a1, a2);
*(_BYTE *)(a1 + 32) = 0;
*(_DWORD *)(a1 + 36) = 12;
v14 = (double **)(a1 + 40);
*(_OWORD *)(a1 + 40) = 0LL;
*(_OWORD *)(a1 + 56) = 0LL;
*(_OWORD *)(a1 + 72) = 0LL;
if ( !*(_QWORD *)(a2 + 8) )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/gguf.cpp",
132,
(long long)"GGML_ASSERT(%s) failed",
(long long)"!key.empty()",
v10,
v11,
(__m128)0LL,
a4,
a5,
a6,
v12,
v13,
a9,
a10,
v16);
std::vector<signed char>::resize(a1 + 40, 8LL);
result = *v14;
**v14 = a3;
return result;
}
| gguf_kv<double>:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOVSD qword ptr [RSP + 0x8],XMM0
MOV R15,RSI
MOV RBX,RDI
CALL 0x0011e010
MOV byte ptr [RBX + 0x20],0x0
MOV dword ptr [RBX + 0x24],0xc
LEA R14,[RBX + 0x28]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x28],XMM0
MOVUPS xmmword ptr [RBX + 0x38],XMM0
MOVUPS xmmword ptr [RBX + 0x48],XMM0
CMP qword ptr [R15 + 0x8],0x0
JZ 0x00148b45
LAB_00148b23:
PUSH 0x8
POP RSI
MOV RDI,R14
CALL 0x0011c200
MOV RAX,qword ptr [R14]
MOVSD XMM0,qword ptr [RSP + 0x8]
MOVSD qword ptr [RAX],XMM0
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
LAB_00148b45:
LEA RDI,[0x15a805]
LEA RDX,[0x14b5cd]
LEA RCX,[0x15afb4]
MOV ESI,0x84
XOR EAX,EAX
CALL 0x0011e760
|
/* gguf_kv::gguf_kv<double>(std::__cxx11::string const&, double) */
void __thiscall gguf_kv::gguf_kv<double>(gguf_kv *this,string *param_1,double param_2)
{
std::__cxx11::string::string((string *)this,param_1);
this[0x20] = (gguf_kv)0x0;
*(int4 *)(this + 0x24) = 0xc;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 0x50) = 0;
if (*(long *)(param_1 + 8) != 0) {
/* try { // try from 00148b23 to 00148b65 has its CatchHandler @ 00148b66 */
std::vector<signed_char,std::allocator<signed_char>>::resize
((vector<signed_char,std::allocator<signed_char>> *)(this + 0x28),8);
**(double **)(this + 0x28) = param_2;
return;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/gguf.cpp",0x84,
"GGML_ASSERT(%s) failed","!key.empty()");
}
| |
41,509 | core_tensor_logic_ref_count_raii_Test::~core_tensor_logic_ref_count_raii_Test() | magnetron/test/unittests/tensor/core_logic.cpp | TEST(core_tensor_logic, ref_count_raii) {
context ctx {compute_device::cpu};
tensor a {ctx, dtype::e8m23, 10};
ASSERT_EQ(a.refcount(), 1);
{
tensor b {a};
ASSERT_EQ(a.refcount(), 2);
ASSERT_EQ(b.refcount(), 2);
{
tensor c {b};
ASSERT_EQ(a.refcount(), 3);
ASSERT_EQ(b.refcount(), 3);
ASSERT_EQ(c.refcount(), 3);
}
ASSERT_EQ(a.refcount(), 2);
ASSERT_EQ(b.refcount(), 2);
}
ASSERT_EQ(a.refcount(), 1);
} | O0 | cpp | core_tensor_logic_ref_count_raii_Test::~core_tensor_logic_ref_count_raii_Test():
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9ede0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ZN37core_tensor_logic_ref_count_raii_TestD2Ev:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]; this
call _ZN7testing4TestD2Ev; testing::Test::~Test()
add rsp, 10h
pop rbp
retn
| void core_tensor_logic_ref_count_raii_Test::~core_tensor_logic_ref_count_raii_Test(
core_tensor_logic_ref_count_raii_Test *this)
{
testing::Test::~Test(this);
}
| ~core_tensor_logic_ref_count_raii_Test:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0019ede0
ADD RSP,0x10
POP RBP
RET
|
/* core_tensor_logic_ref_count_raii_Test::~core_tensor_logic_ref_count_raii_Test() */
void __thiscall
core_tensor_logic_ref_count_raii_Test::~core_tensor_logic_ref_count_raii_Test
(core_tensor_logic_ref_count_raii_Test *this)
{
testing::Test::~Test((Test *)this);
return;
}
| |
41,510 | ggml_compute_forward_sum | ngxson[P]ggml-easy/ggml/src/ggml-cpu/ops.cpp | void ggml_compute_forward_sum(
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_sum_f32(params, dst);
} break;
case GGML_TYPE_F16:
{
ggml_compute_forward_sum_f16(params, dst);
} break;
case GGML_TYPE_BF16:
{
ggml_compute_forward_sum_bf16(params, dst);
} break;
default:
{
GGML_ABORT("fatal error");
}
}
} | O0 | cpp | ggml_compute_forward_sum:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x98(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x8b1b6
jmp 0x8b1a0
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0x8b1c7
jmp 0x8b1ab
movl 0xc(%rsp), %eax
subl $0x1e, %eax
je 0x8b1d8
jmp 0x8b1e9
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x8b210
jmp 0x8b203
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x8b3d0
jmp 0x8b203
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x8b5e0
jmp 0x8b203
leaq 0x2a4a8(%rip), %rdi # 0xb5698
movl $0x7aa, %esi # imm = 0x7AA
leaq 0x20898(%rip), %rdx # 0xaba94
movb $0x0, %al
callq 0x10660
addq $0x28, %rsp
retq
nopl (%rax,%rax)
| ggml_compute_forward_sum:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_10], rsi
mov rax, [rsp+28h+var_10]
mov rax, [rax+98h]
mov [rsp+28h+var_18], rax
mov rax, [rsp+28h+var_18]
mov eax, [rax]
mov [rsp+28h+var_1C], eax
test eax, eax
jz short loc_8B1B6
jmp short $+2
loc_8B1A0:
mov eax, [rsp+28h+var_1C]
sub eax, 1
jz short loc_8B1C7
jmp short $+2
loc_8B1AB:
mov eax, [rsp+28h+var_1C]
sub eax, 1Eh
jz short loc_8B1D8
jmp short loc_8B1E9
loc_8B1B6:
mov rdi, [rsp+28h+var_8]
mov rsi, [rsp+28h+var_10]
call _ZL28ggml_compute_forward_sum_f32PK19ggml_compute_paramsP11ggml_tensor; ggml_compute_forward_sum_f32(ggml_compute_params const*,ggml_tensor *)
jmp short loc_8B203
loc_8B1C7:
mov rdi, [rsp+28h+var_8]
mov rsi, [rsp+28h+var_10]
call _ZL28ggml_compute_forward_sum_f16PK19ggml_compute_paramsP11ggml_tensor; ggml_compute_forward_sum_f16(ggml_compute_params const*,ggml_tensor *)
jmp short loc_8B203
loc_8B1D8:
mov rdi, [rsp+28h+var_8]
mov rsi, [rsp+28h+var_10]
call _ZL29ggml_compute_forward_sum_bf16PK19ggml_compute_paramsP11ggml_tensor; ggml_compute_forward_sum_bf16(ggml_compute_params const*,ggml_tensor *)
jmp short loc_8B203
loc_8B1E9:
lea rdi, aWorkspaceLlm4b_6; "/workspace/llm4binary/github/2025_star3"...
mov esi, 7AAh
lea rdx, aFatalError; "fatal error"
mov al, 0
call _ggml_abort
loc_8B203:
add rsp, 28h
retn
| double ggml_compute_forward_sum(long long a1, long long a2)
{
double result; // xmm0_8
int v3; // [rsp+Ch] [rbp-1Ch]
v3 = **(_DWORD **)(a2 + 152);
if ( v3 )
{
if ( v3 == 1 )
{
ggml_compute_forward_sum_f16(a1, a2);
}
else if ( v3 == 30 )
{
ggml_compute_forward_sum_bf16(a1, a2);
}
else
{
return ggml_abort(
"/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml-cpu/ops.cpp",
1962LL,
"fatal error");
}
}
else
{
ggml_compute_forward_sum_f32(a1, a2);
}
return result;
}
| ggml_compute_forward_sum:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RSI
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x98]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RSP + 0xc],EAX
TEST EAX,EAX
JZ 0x0018b1b6
JMP 0x0018b1a0
LAB_0018b1a0:
MOV EAX,dword ptr [RSP + 0xc]
SUB EAX,0x1
JZ 0x0018b1c7
JMP 0x0018b1ab
LAB_0018b1ab:
MOV EAX,dword ptr [RSP + 0xc]
SUB EAX,0x1e
JZ 0x0018b1d8
JMP 0x0018b1e9
LAB_0018b1b6:
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x0018b210
JMP 0x0018b203
LAB_0018b1c7:
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x0018b3d0
JMP 0x0018b203
LAB_0018b1d8:
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x0018b5e0
JMP 0x0018b203
LAB_0018b1e9:
LEA RDI,[0x1b5698]
MOV ESI,0x7aa
LEA RDX,[0x1aba94]
MOV AL,0x0
CALL 0x00110660
LAB_0018b203:
ADD RSP,0x28
RET
|
void ggml_compute_forward_sum(ggml_compute_params *param_1,ggml_tensor *param_2)
{
int iVar1;
iVar1 = **(int **)(param_2 + 0x98);
if (iVar1 == 0) {
ggml_compute_forward_sum_f32(param_1,param_2);
}
else if (iVar1 == 1) {
ggml_compute_forward_sum_f16(param_1,param_2);
}
else if (iVar1 == 0x1e) {
ggml_compute_forward_sum_bf16(param_1,param_2);
}
else {
ggml_abort("/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml-cpu/ops.cpp"
,0x7aa,"fatal error");
}
return;
}
| |
41,511 | convert_froma_string | eloqsql/libmariadb/libmariadb/ma_stmt_codec.c | static void convert_froma_string(MYSQL_BIND *r_param, char *buffer, size_t len)
{
int error= 0;
switch (r_param->buffer_type)
{
case MYSQL_TYPE_TINY:
{
longlong val= my_atoll(buffer, buffer + len, &error);
*r_param->error= error ? 1 : r_param->is_unsigned ? NUMERIC_TRUNCATION(val, 0, UINT_MAX8) : NUMERIC_TRUNCATION(val, INT_MIN8, INT_MAX8) || error > 0;
int1store(r_param->buffer, (uchar) val);
r_param->buffer_length= sizeof(uchar);
}
break;
case MYSQL_TYPE_YEAR:
case MYSQL_TYPE_SHORT:
{
longlong val= my_atoll(buffer, buffer + len, &error);
*r_param->error= error ? 1 : r_param->is_unsigned ? NUMERIC_TRUNCATION(val, 0, UINT_MAX16) : NUMERIC_TRUNCATION(val, INT_MIN16, INT_MAX16) || error > 0;
shortstore(r_param->buffer, (short)val);
r_param->buffer_length= sizeof(short);
}
break;
case MYSQL_TYPE_LONG:
{
longlong val= my_atoll(buffer, buffer + len, &error);
*r_param->error=error ? 1 : r_param->is_unsigned ? NUMERIC_TRUNCATION(val, 0, UINT_MAX32) : NUMERIC_TRUNCATION(val, INT_MIN32, INT_MAX32) || error > 0;
longstore(r_param->buffer, (int32)val);
r_param->buffer_length= sizeof(uint32);
}
break;
case MYSQL_TYPE_LONGLONG:
{
longlong val= r_param->is_unsigned ? (longlong)my_atoull(buffer, buffer + len, &error) : my_atoll(buffer, buffer + len, &error);
*r_param->error= error > 0; /* no need to check for truncation */
longlongstore(r_param->buffer, val);
r_param->buffer_length= sizeof(longlong);
}
break;
case MYSQL_TYPE_DOUBLE:
{
double val= my_atod(buffer, buffer + len, &error);
*r_param->error= error > 0; /* no need to check for truncation */
doublestore((uchar *)r_param->buffer, val);
r_param->buffer_length= sizeof(double);
}
break;
case MYSQL_TYPE_FLOAT:
{
float val= (float)my_atod(buffer, buffer + len, &error);
*r_param->error= error > 0; /* no need to check for truncation */
floatstore((uchar *)r_param->buffer, val);
r_param->buffer_length= sizeof(float);
}
break;
case MYSQL_TYPE_TIME:
case MYSQL_TYPE_DATE:
case MYSQL_TYPE_DATETIME:
case MYSQL_TYPE_TIMESTAMP:
{
MYSQL_TIME *tm= (MYSQL_TIME *)r_param->buffer;
str_to_TIME(buffer, len, tm);
break;
}
break;
case MYSQL_TYPE_TINY_BLOB:
case MYSQL_TYPE_MEDIUM_BLOB:
case MYSQL_TYPE_LONG_BLOB:
case MYSQL_TYPE_BLOB:
case MYSQL_TYPE_DECIMAL:
case MYSQL_TYPE_NEWDECIMAL:
default:
{
if (len >= r_param->offset)
{
char *start= buffer + r_param->offset; /* stmt_fetch_column sets offset */
char *end= buffer + len;
size_t copylen= 0;
if (start < end)
{
copylen= end - start;
if (r_param->buffer_length)
memcpy(r_param->buffer, start, MIN(copylen, r_param->buffer_length));
}
if (copylen < r_param->buffer_length)
((char *)r_param->buffer)[copylen]= 0;
*r_param->error= (copylen > r_param->buffer_length);
}
*r_param->length= (ulong)len;
}
break;
}
} | O3 | c | convert_froma_string:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movl $0x0, -0x2c(%rbp)
movl 0x60(%rdi), %eax
decl %eax
cmpl $0xc, %eax
ja 0x2752d
leaq 0x13958(%rip), %rcx # 0x3acb0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rbx), %rdx
movq %r14, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x25aac
addq %r14, %r12
leaq -0x2c(%rbp), %r15
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x276b4
movb $0x1, %cl
cmpl $0x0, (%r15)
jne 0x2758b
cmpb $0x0, 0x65(%rbx)
je 0x27581
cmpq $0x10000, %rax # imm = 0x10000
setae %cl
jmp 0x2758b
addq %r14, %r12
leaq -0x2c(%rbp), %r15
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x276b4
movb $0x1, %cl
cmpl $0x0, (%r15)
jne 0x27655
cmpb $0x0, 0x65(%rbx)
je 0x2764b
cmpq $0x100, %rax # imm = 0x100
setae %cl
jmp 0x27655
addq %r14, %r12
leaq -0x2c(%rbp), %r15
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x276b4
movb $0x1, %cl
cmpl $0x0, (%r15)
jne 0x27674
cmpb $0x0, 0x65(%rbx)
je 0x2766b
movq %rax, %rcx
shrq $0x20, %rcx
jmp 0x27671
leaq (%r14,%r12), %r15
cmpb $0x0, 0x65(%rbx)
je 0x27563
testq %r12, %r12
jle 0x27458
callq 0x134c0
movq (%rax), %rax
movsbq (%r14), %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x27458
incq %r14
decq %r12
jne 0x27442
movq %r15, %r14
movq %r15, %rax
subq %r14, %rax
testq %rax, %rax
jle 0x275d9
xorl %r13d, %r13d
movabsq $0x1999999999999999, %rcx # imm = 0x1999999999999999
xorl %eax, %eax
xorl %r12d, %r12d
movsbq (%r14,%rax), %rdx
leal -0x3a(%rdx), %esi
cmpb $-0xa, %sil
jb 0x275eb
cmpq %rcx, %r12
ja 0x275de
leaq (%r12,%r12), %rsi
leaq (%rsi,%rsi,4), %rsi
movl $0x2f, %edi
subq %rdx, %rdi
cmpq %rdi, %rsi
ja 0x275de
leaq (%rsi,%rdx), %r12
addq $-0x30, %r12
leaq (%r14,%rax), %rdx
incq %rdx
incq %rax
cmpq %r15, %rdx
jb 0x27479
addq %rax, %r14
xorl %r13d, %r13d
jmp 0x27602
addq %r14, %r12
leaq -0x2c(%rbp), %r15
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x259fa
cvtsd2ss %xmm0, %xmm0
cmpl $0x0, (%r15)
movq 0x18(%rbx), %rax
setg (%rax)
movq 0x10(%rbx), %rax
movss %xmm0, (%rax)
jmp 0x2769d
addq %r14, %r12
leaq -0x2c(%rbp), %r15
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x259fa
cmpl $0x0, (%r15)
movq 0x18(%rbx), %rax
setg (%rax)
movq 0x10(%rbx), %rax
movsd %xmm0, (%rax)
jmp 0x27641
movq 0x48(%rbx), %rax
cmpq %rax, %r12
jb 0x275ce
movq %r12, %r15
subq %rax, %r15
jle 0x275ab
movq 0x40(%rbx), %rdx
testq %rdx, %rdx
je 0x275ae
addq %rax, %r14
movq 0x10(%rbx), %rdi
cmpq %rdx, %r15
cmovbq %r15, %rdx
movq %r14, %rsi
callq 0x13390
jmp 0x275ae
leaq -0x2c(%rbp), %r13
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x276b4
movq %rax, %r12
movl (%r13), %eax
jmp 0x27631
movswq %ax, %rcx
cmpq %rax, %rcx
setne %cl
movq 0x18(%rbx), %rdx
movb %cl, (%rdx)
movq 0x10(%rbx), %rcx
movb %al, (%rcx)
movq 0x10(%rbx), %rcx
movb %ah, 0x1(%rcx)
movq $0x2, 0x40(%rbx)
jmp 0x276a5
xorl %r15d, %r15d
movq 0x40(%rbx), %rax
cmpq %rax, %r15
jae 0x275c4
movq 0x10(%rbx), %rax
movb $0x0, (%rax,%r15)
movq 0x40(%rbx), %rax
cmpq %rax, %r15
movq 0x18(%rbx), %rax
seta (%rax)
movq (%rbx), %rax
movq %r12, (%rax)
jmp 0x276a5
xorl %r12d, %r12d
jmp 0x275f5
movl $0x22, -0x2c(%rbp)
movl $0x22, %r13d
testq %rax, %rax
je 0x275f5
addq %rax, %r14
jmp 0x27602
movl $0x22, -0x2c(%rbp)
movl $0x22, %r13d
cmpq %r15, %r14
jae 0x27625
callq 0x134c0
movq (%rax), %rax
movsbq (%r14), %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x27625
incq %r14
cmpq %r15, %r14
jne 0x2760f
movq %r15, %r14
cmpq %r15, %r14
movl $0x1, %eax
cmovel %r13d, %eax
testl %eax, %eax
movq 0x18(%rbx), %rax
setg (%rax)
movq 0x10(%rbx), %rax
movq %r12, (%rax)
movq $0x8, 0x40(%rbx)
jmp 0x276a5
movsbq %al, %rcx
cmpq %rax, %rcx
setne %cl
movq 0x18(%rbx), %rdx
movb %cl, (%rdx)
movq 0x10(%rbx), %rcx
movb %al, (%rcx)
movq $0x1, 0x40(%rbx)
jmp 0x276a5
movslq %eax, %rcx
cmpq %rax, %rcx
setne %cl
movq 0x18(%rbx), %rdx
movb %cl, (%rdx)
movq 0x10(%rbx), %rcx
movb %al, (%rcx)
movq 0x10(%rbx), %rcx
movb %ah, 0x1(%rcx)
movl %eax, %ecx
shrl $0x10, %ecx
movq 0x10(%rbx), %rdx
movb %cl, 0x2(%rdx)
shrl $0x18, %eax
movq 0x10(%rbx), %rcx
movb %al, 0x3(%rcx)
movq $0x4, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| convert_froma_string:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r12, rdx
mov r14, rsi
mov rbx, rdi
mov [rbp+var_2C], 0
mov eax, [rdi+60h]
dec eax; switch 13 cases
cmp eax, 0Ch
ja def_2735F; jumptable 000000000002735F default case, cases 6,9
lea rcx, jpt_2735F
movsxd rax, ds:(jpt_2735F - 3ACB0h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_27361:
mov rdx, [rbx+10h]; jumptable 000000000002735F cases 7,10-12
mov rdi, r14
mov rsi, r12
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp str_to_TIME
loc_2737E:
add r12, r14; jumptable 000000000002735F cases 2,13
lea r15, [rbp+var_2C]
mov rdi, r14
mov rsi, r12
mov rdx, r15
call my_atoll
mov cl, 1
cmp dword ptr [r15], 0
jnz loc_2758B
cmp byte ptr [rbx+65h], 0
jz loc_27581
cmp rax, 10000h
setnb cl
jmp loc_2758B
loc_273B7:
add r12, r14; jumptable 000000000002735F case 1
lea r15, [rbp+var_2C]
mov rdi, r14
mov rsi, r12
mov rdx, r15
call my_atoll
mov cl, 1
cmp dword ptr [r15], 0
jnz loc_27655
cmp byte ptr [rbx+65h], 0
jz loc_2764B
cmp rax, 100h
setnb cl
jmp loc_27655
loc_273F0:
add r12, r14; jumptable 000000000002735F case 3
lea r15, [rbp+var_2C]
mov rdi, r14
mov rsi, r12
mov rdx, r15
call my_atoll
mov cl, 1
cmp dword ptr [r15], 0
jnz loc_27674
cmp byte ptr [rbx+65h], 0
jz loc_2766B
mov rcx, rax
shr rcx, 20h
jmp loc_27671
loc_27427:
lea r15, [r14+r12]; jumptable 000000000002735F case 8
cmp byte ptr [rbx+65h], 0
jz loc_27563
test r12, r12
jle short loc_27458
call ___ctype_b_loc
mov rax, [rax]
loc_27442:
movsx rcx, byte ptr [r14]
test byte ptr [rax+rcx*2+1], 20h
jz short loc_27458
inc r14
dec r12
jnz short loc_27442
mov r14, r15
loc_27458:
mov rax, r15
sub rax, r14
test rax, rax
jle loc_275D9
xor r13d, r13d
mov rcx, 1999999999999999h
xor eax, eax
xor r12d, r12d
loc_27479:
movsx rdx, byte ptr [r14+rax]
lea esi, [rdx-3Ah]
cmp sil, 0F6h
jb loc_275EB
cmp r12, rcx
ja loc_275DE
lea rsi, [r12+r12]
lea rsi, [rsi+rsi*4]
mov edi, 2Fh ; '/'
sub rdi, rdx
cmp rsi, rdi
ja loc_275DE
lea r12, [rsi+rdx]
add r12, 0FFFFFFFFFFFFFFD0h
lea rdx, [r14+rax]
inc rdx
inc rax
cmp rdx, r15
jb short loc_27479
add r14, rax
xor r13d, r13d
jmp loc_27602
loc_274CF:
add r12, r14; jumptable 000000000002735F case 4
lea r15, [rbp+var_2C]
mov rdi, r14
mov rsi, r12
mov rdx, r15
call my_atod
cvtsd2ss xmm0, xmm0
cmp dword ptr [r15], 0
mov rax, [rbx+18h]
setnle byte ptr [rax]
mov rax, [rbx+10h]
movss dword ptr [rax], xmm0
jmp loc_2769D
loc_27500:
add r12, r14; jumptable 000000000002735F case 5
lea r15, [rbp+var_2C]
mov rdi, r14
mov rsi, r12
mov rdx, r15
call my_atod
cmp dword ptr [r15], 0
mov rax, [rbx+18h]
setnle byte ptr [rax]
mov rax, [rbx+10h]
movsd qword ptr [rax], xmm0
jmp loc_27641
def_2735F:
mov rax, [rbx+48h]; jumptable 000000000002735F default case, cases 6,9
cmp r12, rax
jb loc_275CE
mov r15, r12
sub r15, rax
jle short loc_275AB
mov rdx, [rbx+40h]
test rdx, rdx
jz short loc_275AE
add r14, rax
mov rdi, [rbx+10h]
cmp r15, rdx
cmovb rdx, r15
mov rsi, r14
call _memcpy
jmp short loc_275AE
loc_27563:
lea r13, [rbp+var_2C]
mov rdi, r14
mov rsi, r15
mov rdx, r13
call my_atoll
mov r12, rax
mov eax, [r13+0]
jmp loc_27631
loc_27581:
movsx rcx, ax
cmp rcx, rax
setnz cl
loc_2758B:
mov rdx, [rbx+18h]
mov [rdx], cl
mov rcx, [rbx+10h]
mov [rcx], al
mov rcx, [rbx+10h]
mov [rcx+1], ah
mov qword ptr [rbx+40h], 2
jmp loc_276A5
loc_275AB:
xor r15d, r15d
loc_275AE:
mov rax, [rbx+40h]
cmp r15, rax
jnb short loc_275C4
mov rax, [rbx+10h]
mov byte ptr [rax+r15], 0
mov rax, [rbx+40h]
loc_275C4:
cmp r15, rax
mov rax, [rbx+18h]
setnbe byte ptr [rax]
loc_275CE:
mov rax, [rbx]
mov [rax], r12
jmp loc_276A5
loc_275D9:
xor r12d, r12d
jmp short loc_275F5
loc_275DE:
mov [rbp+var_2C], 22h ; '"'
mov r13d, 22h ; '"'
loc_275EB:
test rax, rax
jz short loc_275F5
add r14, rax
jmp short loc_27602
loc_275F5:
mov [rbp+var_2C], 22h ; '"'
mov r13d, 22h ; '"'
loc_27602:
cmp r14, r15
jnb short loc_27625
call ___ctype_b_loc
mov rax, [rax]
loc_2760F:
movsx rcx, byte ptr [r14]
test byte ptr [rax+rcx*2+1], 20h
jz short loc_27625
inc r14
cmp r14, r15
jnz short loc_2760F
mov r14, r15
loc_27625:
cmp r14, r15
mov eax, 1
cmovz eax, r13d
loc_27631:
test eax, eax
mov rax, [rbx+18h]
setnle byte ptr [rax]
mov rax, [rbx+10h]
mov [rax], r12
loc_27641:
mov qword ptr [rbx+40h], 8
jmp short loc_276A5
loc_2764B:
movsx rcx, al
cmp rcx, rax
setnz cl
loc_27655:
mov rdx, [rbx+18h]
mov [rdx], cl
mov rcx, [rbx+10h]
mov [rcx], al
mov qword ptr [rbx+40h], 1
jmp short loc_276A5
loc_2766B:
movsxd rcx, eax
cmp rcx, rax
loc_27671:
setnz cl
loc_27674:
mov rdx, [rbx+18h]
mov [rdx], cl
mov rcx, [rbx+10h]
mov [rcx], al
mov rcx, [rbx+10h]
mov [rcx+1], ah
mov ecx, eax
shr ecx, 10h
mov rdx, [rbx+10h]
mov [rdx+2], cl
shr eax, 18h
mov rcx, [rbx+10h]
mov [rcx+3], al
loc_2769D:
mov qword ptr [rbx+40h], 4
loc_276A5:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| unsigned long long convert_froma_string(long long a1, char *a2, long long a3, double a4)
{
long long v4; // r12
char *v5; // r14
long long v6; // rbx
unsigned long long result; // rax
bool v8; // cl
bool v9; // cl
unsigned long long v10; // rax
bool v11; // cl
bool v12; // zf
char *v13; // r15
long long v14; // rax
int v15; // r13d
long long v16; // rax
unsigned long long v17; // r12
long long v18; // rdx
unsigned long long v19; // rdx
float v20; // xmm0_4
unsigned long long v21; // rax
unsigned long long v22; // r15
unsigned long long v23; // rdx
long long v24; // rdi
int v25; // eax
unsigned long long v26; // rax
long long v27; // rax
_DWORD v28[11]; // [rsp+0h] [rbp-2Ch] BYREF
v4 = a3;
v5 = a2;
v6 = a1;
v28[0] = 0;
switch ( *(_DWORD *)(a1 + 96) )
{
case 1:
result = my_atoll(a2, &a2[a3], v28);
v9 = 1;
if ( !v28[0] )
{
if ( *(_BYTE *)(a1 + 101) )
v9 = result >= 0x100;
else
v9 = (char)result != result;
}
**(_BYTE **)(a1 + 24) = v9;
**(_BYTE **)(a1 + 16) = result;
*(_QWORD *)(a1 + 64) = 1LL;
return result;
case 2:
case 0xD:
result = my_atoll(a2, &a2[a3], v28);
v8 = 1;
if ( !v28[0] )
{
if ( *(_BYTE *)(a1 + 101) )
v8 = result >= 0x10000;
else
v8 = (__int16)result != result;
}
**(_BYTE **)(a1 + 24) = v8;
**(_WORD **)(a1 + 16) = result;
*(_QWORD *)(a1 + 64) = 2LL;
return result;
case 3:
v10 = my_atoll(a2, &a2[a3], v28);
v11 = 1;
if ( !v28[0] )
{
if ( *(_BYTE *)(a1 + 101) )
v12 = HIDWORD(v10) == 0;
else
v12 = (int)v10 == v10;
v11 = !v12;
}
**(_BYTE **)(a1 + 24) = v11;
**(_WORD **)(a1 + 16) = v10;
*(_BYTE *)(*(_QWORD *)(a1 + 16) + 2LL) = BYTE2(v10);
result = BYTE3(v10);
*(_BYTE *)(*(_QWORD *)(a1 + 16) + 3LL) = result;
goto LABEL_60;
case 4:
my_atod((long long)a2, (_DWORD)a2 + a3, v28);
v20 = a4;
**(_BYTE **)(a1 + 24) = v28[0] > 0;
result = *(_QWORD *)(a1 + 16);
*(float *)result = v20;
LABEL_60:
*(_QWORD *)(a1 + 64) = 4LL;
return result;
case 5:
my_atod((long long)a2, (_DWORD)a2 + a3, v28);
**(_BYTE **)(a1 + 24) = v28[0] > 0;
result = *(_QWORD *)(a1 + 16);
*(double *)result = a4;
goto LABEL_54;
case 7:
case 0xA:
case 0xB:
case 0xC:
return str_to_TIME(a2, a3, *(_QWORD *)(a1 + 16));
case 8:
v13 = &a2[a3];
if ( !*(_BYTE *)(a1 + 101) )
{
v17 = my_atoll(a2, &a2[a3], v28);
v25 = v28[0];
goto LABEL_53;
}
if ( a3 <= 0 )
goto LABEL_18;
v14 = *(_QWORD *)__ctype_b_loc(a1);
break;
default:
v21 = *(_QWORD *)(a1 + 72);
if ( a3 >= v21 )
{
v22 = a3 - v21;
if ( a3 <= (long long)v21 )
{
v22 = 0LL;
}
else
{
v23 = *(_QWORD *)(a1 + 64);
if ( v23 )
{
v24 = *(_QWORD *)(a1 + 16);
if ( v22 < v23 )
v23 = v4 - v21;
memcpy(v24, &a2[v21], v23);
}
}
v26 = *(_QWORD *)(v6 + 64);
if ( v22 < v26 )
{
*(_BYTE *)(*(_QWORD *)(v6 + 16) + v22) = 0;
v26 = *(_QWORD *)(v6 + 64);
}
**(_BYTE **)(v6 + 24) = v22 > v26;
}
result = *(_QWORD *)v6;
**(_QWORD **)v6 = v4;
return result;
}
while ( (*(_BYTE *)(v14 + 2LL * *v5 + 1) & 0x20) != 0 )
{
++v5;
if ( !--v4 )
{
v5 = v13;
break;
}
}
LABEL_18:
if ( v13 - v5 <= 0 )
{
v17 = 0LL;
}
else
{
v15 = 0;
v16 = 0LL;
v17 = 0LL;
while ( 1 )
{
v18 = v5[v16];
if ( (unsigned __int8)(v18 - 58) < 0xF6u )
break;
if ( v17 > 0x1999999999999999LL || (a1 = 47 - v18, 10 * v17 > 47 - v18) )
{
v28[0] = 34;
v15 = 34;
break;
}
v17 = 10 * v17 + v18 - 48;
v19 = (unsigned long long)&v5[++v16];
if ( v19 >= (unsigned long long)v13 )
{
v5 += v16;
v15 = 0;
goto LABEL_46;
}
}
if ( v16 )
{
v5 += v16;
goto LABEL_46;
}
}
v28[0] = 34;
v15 = 34;
LABEL_46:
if ( v5 < v13 )
{
v27 = *(_QWORD *)__ctype_b_loc(a1);
while ( (*(_BYTE *)(v27 + 2LL * *v5 + 1) & 0x20) != 0 )
{
if ( ++v5 == v13 )
{
v5 = v13;
break;
}
}
}
v25 = 1;
if ( v5 == v13 )
v25 = v15;
LABEL_53:
**(_BYTE **)(v6 + 24) = v25 > 0;
result = *(_QWORD *)(v6 + 16);
*(_QWORD *)result = v17;
LABEL_54:
*(_QWORD *)(v6 + 64) = 8LL;
return result;
}
| convert_froma_string:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R12,RDX
MOV R14,RSI
MOV RBX,RDI
MOV dword ptr [RBP + -0x2c],0x0
MOV EAX,dword ptr [RDI + 0x60]
DEC EAX
CMP EAX,0xc
JA 0x0012752d
LEA RCX,[0x13acb0]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_7:
MOV RDX,qword ptr [RBX + 0x10]
MOV RDI,R14
MOV RSI,R12
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00125aac
caseD_2:
ADD R12,R14
LEA R15,[RBP + -0x2c]
MOV RDI,R14
MOV RSI,R12
MOV RDX,R15
CALL 0x001276b4
MOV CL,0x1
CMP dword ptr [R15],0x0
JNZ 0x0012758b
CMP byte ptr [RBX + 0x65],0x0
JZ 0x00127581
CMP RAX,0x10000
SETNC CL
JMP 0x0012758b
caseD_1:
ADD R12,R14
LEA R15,[RBP + -0x2c]
MOV RDI,R14
MOV RSI,R12
MOV RDX,R15
CALL 0x001276b4
MOV CL,0x1
CMP dword ptr [R15],0x0
JNZ 0x00127655
CMP byte ptr [RBX + 0x65],0x0
JZ 0x0012764b
CMP RAX,0x100
SETNC CL
JMP 0x00127655
caseD_3:
ADD R12,R14
LEA R15,[RBP + -0x2c]
MOV RDI,R14
MOV RSI,R12
MOV RDX,R15
CALL 0x001276b4
MOV CL,0x1
CMP dword ptr [R15],0x0
JNZ 0x00127674
CMP byte ptr [RBX + 0x65],0x0
JZ 0x0012766b
MOV RCX,RAX
SHR RCX,0x20
JMP 0x00127671
caseD_8:
LEA R15,[R14 + R12*0x1]
CMP byte ptr [RBX + 0x65],0x0
JZ 0x00127563
TEST R12,R12
JLE 0x00127458
CALL 0x001134c0
MOV RAX,qword ptr [RAX]
LAB_00127442:
MOVSX RCX,byte ptr [R14]
TEST byte ptr [RAX + RCX*0x2 + 0x1],0x20
JZ 0x00127458
INC R14
DEC R12
JNZ 0x00127442
MOV R14,R15
LAB_00127458:
MOV RAX,R15
SUB RAX,R14
TEST RAX,RAX
JLE 0x001275d9
XOR R13D,R13D
MOV RCX,0x1999999999999999
XOR EAX,EAX
XOR R12D,R12D
LAB_00127479:
MOVSX RDX,byte ptr [R14 + RAX*0x1]
LEA ESI,[RDX + -0x3a]
CMP SIL,0xf6
JC 0x001275eb
CMP R12,RCX
JA 0x001275de
LEA RSI,[R12 + R12*0x1]
LEA RSI,[RSI + RSI*0x4]
MOV EDI,0x2f
SUB RDI,RDX
CMP RSI,RDI
JA 0x001275de
LEA R12,[RSI + RDX*0x1]
ADD R12,-0x30
LEA RDX,[R14 + RAX*0x1]
INC RDX
INC RAX
CMP RDX,R15
JC 0x00127479
ADD R14,RAX
XOR R13D,R13D
JMP 0x00127602
caseD_4:
ADD R12,R14
LEA R15,[RBP + -0x2c]
MOV RDI,R14
MOV RSI,R12
MOV RDX,R15
CALL 0x001259fa
CVTSD2SS XMM0,XMM0
CMP dword ptr [R15],0x0
MOV RAX,qword ptr [RBX + 0x18]
SETG byte ptr [RAX]
MOV RAX,qword ptr [RBX + 0x10]
MOVSS dword ptr [RAX],XMM0
JMP 0x0012769d
caseD_5:
ADD R12,R14
LEA R15,[RBP + -0x2c]
MOV RDI,R14
MOV RSI,R12
MOV RDX,R15
CALL 0x001259fa
CMP dword ptr [R15],0x0
MOV RAX,qword ptr [RBX + 0x18]
SETG byte ptr [RAX]
MOV RAX,qword ptr [RBX + 0x10]
MOVSD qword ptr [RAX],XMM0
JMP 0x00127641
caseD_6:
MOV RAX,qword ptr [RBX + 0x48]
CMP R12,RAX
JC 0x001275ce
MOV R15,R12
SUB R15,RAX
JLE 0x001275ab
MOV RDX,qword ptr [RBX + 0x40]
TEST RDX,RDX
JZ 0x001275ae
ADD R14,RAX
MOV RDI,qword ptr [RBX + 0x10]
CMP R15,RDX
CMOVC RDX,R15
MOV RSI,R14
CALL 0x00113390
JMP 0x001275ae
LAB_00127563:
LEA R13,[RBP + -0x2c]
MOV RDI,R14
MOV RSI,R15
MOV RDX,R13
CALL 0x001276b4
MOV R12,RAX
MOV EAX,dword ptr [R13]
JMP 0x00127631
LAB_00127581:
MOVSX RCX,AX
CMP RCX,RAX
SETNZ CL
LAB_0012758b:
MOV RDX,qword ptr [RBX + 0x18]
MOV byte ptr [RDX],CL
MOV RCX,qword ptr [RBX + 0x10]
MOV byte ptr [RCX],AL
MOV RCX,qword ptr [RBX + 0x10]
MOV byte ptr [RCX + 0x1],AH
MOV qword ptr [RBX + 0x40],0x2
JMP 0x001276a5
LAB_001275ab:
XOR R15D,R15D
LAB_001275ae:
MOV RAX,qword ptr [RBX + 0x40]
CMP R15,RAX
JNC 0x001275c4
MOV RAX,qword ptr [RBX + 0x10]
MOV byte ptr [RAX + R15*0x1],0x0
MOV RAX,qword ptr [RBX + 0x40]
LAB_001275c4:
CMP R15,RAX
MOV RAX,qword ptr [RBX + 0x18]
SETA byte ptr [RAX]
LAB_001275ce:
MOV RAX,qword ptr [RBX]
MOV qword ptr [RAX],R12
JMP 0x001276a5
LAB_001275d9:
XOR R12D,R12D
JMP 0x001275f5
LAB_001275de:
MOV dword ptr [RBP + -0x2c],0x22
MOV R13D,0x22
LAB_001275eb:
TEST RAX,RAX
JZ 0x001275f5
ADD R14,RAX
JMP 0x00127602
LAB_001275f5:
MOV dword ptr [RBP + -0x2c],0x22
MOV R13D,0x22
LAB_00127602:
CMP R14,R15
JNC 0x00127625
CALL 0x001134c0
MOV RAX,qword ptr [RAX]
LAB_0012760f:
MOVSX RCX,byte ptr [R14]
TEST byte ptr [RAX + RCX*0x2 + 0x1],0x20
JZ 0x00127625
INC R14
CMP R14,R15
JNZ 0x0012760f
MOV R14,R15
LAB_00127625:
CMP R14,R15
MOV EAX,0x1
CMOVZ EAX,R13D
LAB_00127631:
TEST EAX,EAX
MOV RAX,qword ptr [RBX + 0x18]
SETG byte ptr [RAX]
MOV RAX,qword ptr [RBX + 0x10]
MOV qword ptr [RAX],R12
LAB_00127641:
MOV qword ptr [RBX + 0x40],0x8
JMP 0x001276a5
LAB_0012764b:
MOVSX RCX,AL
CMP RCX,RAX
SETNZ CL
LAB_00127655:
MOV RDX,qword ptr [RBX + 0x18]
MOV byte ptr [RDX],CL
MOV RCX,qword ptr [RBX + 0x10]
MOV byte ptr [RCX],AL
MOV qword ptr [RBX + 0x40],0x1
JMP 0x001276a5
LAB_0012766b:
MOVSXD RCX,EAX
CMP RCX,RAX
LAB_00127671:
SETNZ CL
LAB_00127674:
MOV RDX,qword ptr [RBX + 0x18]
MOV byte ptr [RDX],CL
MOV RCX,qword ptr [RBX + 0x10]
MOV byte ptr [RCX],AL
MOV RCX,qword ptr [RBX + 0x10]
MOV byte ptr [RCX + 0x1],AH
MOV ECX,EAX
SHR ECX,0x10
MOV RDX,qword ptr [RBX + 0x10]
MOV byte ptr [RDX + 0x2],CL
SHR EAX,0x18
MOV RCX,qword ptr [RBX + 0x10]
MOV byte ptr [RCX + 0x3],AL
LAB_0012769d:
MOV qword ptr [RBX + 0x40],0x4
LAB_001276a5:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void convert_froma_string(int8 *param_1,char *param_2,ulong param_3)
{
char *pcVar1;
char cVar2;
int8 uVar3;
double dVar4;
long lVar5;
uint in_EAX;
ulong uVar6;
ushort **ppuVar7;
long lVar8;
ulong __n;
int iVar9;
char *pcVar10;
char *pcVar11;
ulong uVar12;
bool bVar13;
int8 uStack_38;
uStack_38 = (ulong)in_EAX;
switch(*(int4 *)(param_1 + 0xc)) {
case 1:
uVar6 = my_atoll(param_2,param_2 + param_3,(long)&uStack_38 + 4);
bVar13 = true;
if (uStack_38._4_4_ == 0) {
if (*(char *)((long)param_1 + 0x65) == '\0') {
bVar13 = (long)(char)uVar6 != uVar6;
}
else {
bVar13 = 0xff < uVar6;
}
}
*(bool *)param_1[3] = bVar13;
*(char *)param_1[2] = (char)uVar6;
param_1[8] = 1;
break;
case 2:
case 0xd:
uVar6 = my_atoll(param_2,param_2 + param_3,(long)&uStack_38 + 4);
bVar13 = true;
if (uStack_38._4_4_ == 0) {
if (*(char *)((long)param_1 + 0x65) == '\0') {
bVar13 = (long)(short)uVar6 != uVar6;
}
else {
bVar13 = 0xffff < uVar6;
}
}
*(bool *)param_1[3] = bVar13;
*(char *)param_1[2] = (char)uVar6;
*(char *)(param_1[2] + 1) = (char)(uVar6 >> 8);
param_1[8] = 2;
break;
case 3:
uVar6 = my_atoll(param_2,param_2 + param_3,(long)&uStack_38 + 4);
bVar13 = true;
if (uStack_38._4_4_ == 0) {
if (*(char *)((long)param_1 + 0x65) == '\0') {
bVar13 = (long)(int)uVar6 == uVar6;
}
else {
bVar13 = uVar6 >> 0x20 == 0;
}
bVar13 = !bVar13;
}
*(bool *)param_1[3] = bVar13;
*(char *)param_1[2] = (char)uVar6;
*(char *)(param_1[2] + 1) = (char)(uVar6 >> 8);
*(char *)(param_1[2] + 2) = (char)(uVar6 >> 0x10);
*(char *)(param_1[2] + 3) = (char)(uVar6 >> 0x18);
goto LAB_0012769d;
case 4:
dVar4 = (double)my_atod(param_2,param_2 + param_3,(long)&uStack_38 + 4);
*(bool *)param_1[3] = 0 < uStack_38._4_4_;
*(float *)param_1[2] = (float)dVar4;
LAB_0012769d:
param_1[8] = 4;
break;
case 5:
uVar3 = my_atod(param_2,param_2 + param_3,(long)&uStack_38 + 4);
*(bool *)param_1[3] = 0 < uStack_38._4_4_;
*(int8 *)param_1[2] = uVar3;
goto LAB_00127641;
default:
uVar6 = param_1[9];
if (uVar6 <= param_3) {
uVar12 = param_3 - uVar6;
if (uVar12 == 0 || (long)param_3 < (long)uVar6) {
uVar12 = 0;
}
else {
__n = param_1[8];
if (__n != 0) {
if (uVar12 < __n) {
__n = uVar12;
}
memcpy((void *)param_1[2],param_2 + uVar6,__n);
}
}
uVar6 = param_1[8];
if (uVar12 < uVar6) {
*(int1 *)(param_1[2] + uVar12) = 0;
uVar6 = param_1[8];
}
*(bool *)param_1[3] = uVar6 < uVar12;
}
*(ulong *)*param_1 = param_3;
break;
case 7:
case 10:
case 0xb:
case 0xc:
str_to_TIME(param_2,param_3,param_1[2]);
return;
case 8:
pcVar1 = param_2 + param_3;
if (*(char *)((long)param_1 + 0x65) == '\0') {
uVar6 = my_atoll(param_2,pcVar1,(long)&uStack_38 + 4);
}
else {
pcVar10 = param_2;
if (0 < (long)param_3) {
ppuVar7 = __ctype_b_loc();
do {
pcVar10 = param_2;
if ((*(byte *)((long)*ppuVar7 + (long)*param_2 * 2 + 1) & 0x20) == 0) break;
param_2 = param_2 + 1;
param_3 = param_3 - 1;
pcVar10 = pcVar1;
} while (param_3 != 0);
}
if (pcVar1 == pcVar10 || (long)pcVar1 - (long)pcVar10 < 0) {
uVar6 = 0;
LAB_001275f5:
uStack_38 = CONCAT44(0x22,(int4)uStack_38);
iVar9 = 0x22;
}
else {
iVar9 = 0;
lVar8 = 0;
uVar6 = 0;
do {
cVar2 = pcVar10[lVar8];
if ((byte)(cVar2 - 0x3aU) < 0xf6) {
LAB_001275eb:
if (lVar8 == 0) goto LAB_001275f5;
pcVar10 = pcVar10 + lVar8;
goto LAB_00127602;
}
if ((0x1999999999999999 < uVar6) || (0x2fU - (long)cVar2 < uVar6 * 10)) {
uStack_38 = CONCAT44(0x22,(int4)uStack_38);
iVar9 = 0x22;
goto LAB_001275eb;
}
uVar6 = (uVar6 * 10 + (long)cVar2) - 0x30;
lVar5 = lVar8 + 1;
lVar8 = lVar8 + 1;
} while (pcVar10 + lVar5 < pcVar1);
pcVar10 = pcVar10 + lVar8;
iVar9 = 0;
}
LAB_00127602:
pcVar11 = pcVar10;
if (pcVar10 < pcVar1) {
ppuVar7 = __ctype_b_loc();
do {
pcVar11 = pcVar10;
if ((*(byte *)((long)*ppuVar7 + (long)*pcVar10 * 2 + 1) & 0x20) == 0) break;
pcVar10 = pcVar10 + 1;
pcVar11 = pcVar1;
} while (pcVar10 != pcVar1);
}
uStack_38._4_4_ = 1;
if (pcVar11 == pcVar1) {
uStack_38._4_4_ = iVar9;
}
}
*(bool *)param_1[3] = 0 < uStack_38._4_4_;
*(ulong *)param_1[2] = uVar6;
LAB_00127641:
param_1[8] = 8;
}
return;
}
| |
41,512 | js_host_resolve_imported_module | bluesky950520[P]quickjs/quickjs.c | static JSModuleDef *js_host_resolve_imported_module(JSContext *ctx,
const char *base_cname,
const char *cname1)
{
JSRuntime *rt = ctx->rt;
JSModuleDef *m;
char *cname;
JSAtom module_name;
if (!rt->module_normalize_func) {
cname = js_default_module_normalize_name(ctx, base_cname, cname1);
} else {
cname = rt->module_normalize_func(ctx, base_cname, cname1,
rt->module_loader_opaque);
}
if (!cname)
return NULL;
module_name = JS_NewAtom(ctx, cname);
if (module_name == JS_ATOM_NULL) {
js_free(ctx, cname);
return NULL;
}
/* first look at the loaded modules */
m = js_find_loaded_module(ctx, module_name);
if (m) {
js_free(ctx, cname);
JS_FreeAtom(ctx, module_name);
return m;
}
JS_FreeAtom(ctx, module_name);
/* load the module */
if (!rt->module_loader_func) {
/* XXX: use a syntax error ? */
// XXX: update JS_DetectModule when you change this
JS_ThrowReferenceError(ctx, "could not load module '%s'",
cname);
js_free(ctx, cname);
return NULL;
}
m = rt->module_loader_func(ctx, cname, rt->module_loader_opaque);
js_free(ctx, cname);
return m;
} | O1 | c | js_host_resolve_imported_module:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x18(%rdi), %r13
movq 0x140(%r13), %rax
testq %rax, %rax
je 0x43c68
movq 0x150(%r13), %rcx
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *%rax
movq %rax, %r14
testq %r14, %r14
je 0x43be8
movq %r14, %rdi
callq 0xe240
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1fdc0
testl %eax, %eax
je 0x43bc1
movl %eax, %ebp
leaq 0x1e0(%rbx), %rax
movq 0x1e8(%rbx), %r15
cmpq %rax, %r15
je 0x43bbc
cmpl %ebp, -0x4(%r15)
je 0x43bf0
movq 0x8(%r15), %r15
jmp 0x43bab
xorl %r15d, %r15d
jmp 0x43bf4
movq 0x18(%rbx), %rbx
decq 0x28(%rbx)
movq %r14, %rdi
callq *0x20(%rbx)
movq 0x30(%rbx), %rcx
movq 0x40(%rbx), %rdi
subq %rax, %rcx
addq $-0x8, %rcx
movq %rcx, 0x30(%rbx)
movq %r14, %rsi
callq *0x10(%rbx)
xorl %r15d, %r15d
jmp 0x43dbc
addq $-0x8, %r15
testq %r15, %r15
je 0x43c37
movq 0x18(%rbx), %r12
decq 0x28(%r12)
movq %r14, %rdi
callq *0x20(%r12)
movq 0x30(%r12), %rcx
movq 0x40(%r12), %rdi
subq %rax, %rcx
addq $-0x8, %rcx
movq %rcx, 0x30(%r12)
movq %r14, %rsi
callq *0x10(%r12)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x207d8
jmp 0x43dbc
movq %rbx, %rdi
movl %ebp, %esi
callq 0x207d8
movq 0x148(%r13), %rax
testq %rax, %rax
je 0x43d7e
movq 0x150(%r13), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq *%rax
movq %rax, %r15
jmp 0x43d95
cmpb $0x2e, (%r15)
jne 0x43dce
movq %r13, (%rsp)
movq %r12, %rdi
movl $0x2f, %esi
callq 0xe300
movl %eax, %ecx
subl %r12d, %ecx
testq %rax, %rax
movslq %ecx, %r13
cmoveq %rax, %r13
movq %r15, %rdi
callq 0xe240
leal (%rax,%r13), %ebp
addl $0x2, %ebp
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0xede6
testq %rax, %rax
je 0x43e07
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xe5b0
movb $0x0, (%r14,%r13)
cmpb $0x2e, (%r15)
sete %al
jne 0x43dde
leaq 0x5cf17(%rip), %r12 # 0xa0bf6
movb 0x1(%r15), %dl
movl $0x2, %ecx
cmpb $0x2f, %dl
je 0x43d67
cmpb $0x2e, %dl
setne %cl
notb %al
orb %cl, %al
testb $0x1, %al
jne 0x43dde
cmpb $0x2f, 0x2(%r15)
jne 0x43dde
cmpb $0x0, (%r14)
je 0x43dde
movq %r14, %rdi
movl $0x2f, %esi
callq 0xe300
leaq 0x1(%rax), %r13
testq %rax, %rax
cmoveq %r14, %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0xe510
testl %eax, %eax
je 0x43dde
movq %r13, %rdi
leaq 0x5ceac(%rip), %rsi # 0xa0bf5
callq 0xe510
testl %eax, %eax
je 0x43dde
cmpq %r13, %r14
sbbq $0x0, %r13
movb $0x0, (%r13)
movl $0x3, %ecx
leaq (%r15,%rcx), %r13
cmpb $0x2e, (%r15,%rcx)
sete %al
movq %r13, %r15
je 0x43cdf
jmp 0x43de1
leaq 0x5ba5d(%rip), %rsi # 0x9f7e2
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x225fd
movq 0x18(%rbx), %rbx
decq 0x28(%rbx)
movq %r14, %rdi
callq *0x20(%rbx)
movq 0x30(%rbx), %rcx
movq 0x40(%rbx), %rdi
subq %rax, %rcx
addq $-0x8, %rcx
movq %rcx, 0x30(%rbx)
movq %r14, %rsi
callq *0x10(%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r15, %rsi
callq 0xee64
jmp 0x43b79
movq %r15, %r13
cmpb $0x0, (%r14)
je 0x43df8
leaq 0x57bf2(%rip), %rdx # 0x9b9e0
movq %r14, %rdi
movl %ebp, %esi
callq 0x1b26a
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
callq 0x1b26a
jmp 0x43e0a
xorl %r14d, %r14d
movq (%rsp), %r13
jmp 0x43b7c
| js_host_resolve_imported_module:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rdx
mov r12, rsi
mov rbx, rdi
mov r13, [rdi+18h]
mov rax, [r13+140h]
test rax, rax
jz loc_43C68
mov rcx, [r13+150h]
mov rdi, rbx
mov rsi, r12
mov rdx, r15
call rax
loc_43B79:
mov r14, rax
loc_43B7C:
test r14, r14
jz short loc_43BE8
mov rdi, r14
call _strlen
mov rdi, rbx
mov rsi, r14
mov rdx, rax
call JS_NewAtomLen
test eax, eax
jz short loc_43BC1
mov ebp, eax
lea rax, [rbx+1E0h]
mov r15, [rbx+1E8h]
loc_43BAB:
cmp r15, rax
jz short loc_43BBC
cmp [r15-4], ebp
jz short loc_43BF0
mov r15, [r15+8]
jmp short loc_43BAB
loc_43BBC:
xor r15d, r15d
jmp short loc_43BF4
loc_43BC1:
mov rbx, [rbx+18h]
dec qword ptr [rbx+28h]
mov rdi, r14
call qword ptr [rbx+20h]
mov rcx, [rbx+30h]
mov rdi, [rbx+40h]
sub rcx, rax
add rcx, 0FFFFFFFFFFFFFFF8h
mov [rbx+30h], rcx
mov rsi, r14
call qword ptr [rbx+10h]
loc_43BE8:
xor r15d, r15d
jmp loc_43DBC
loc_43BF0:
add r15, 0FFFFFFFFFFFFFFF8h
loc_43BF4:
test r15, r15
jz short loc_43C37
mov r12, [rbx+18h]
dec qword ptr [r12+28h]
mov rdi, r14
call qword ptr [r12+20h]
mov rcx, [r12+30h]
mov rdi, [r12+40h]
sub rcx, rax
add rcx, 0FFFFFFFFFFFFFFF8h
mov [r12+30h], rcx
mov rsi, r14
call qword ptr [r12+10h]
mov rdi, rbx
mov esi, ebp
call JS_FreeAtom
jmp loc_43DBC
loc_43C37:
mov rdi, rbx
mov esi, ebp
call JS_FreeAtom
mov rax, [r13+148h]
test rax, rax
jz loc_43D7E
mov rdx, [r13+150h]
mov rdi, rbx
mov rsi, r14
call rax
mov r15, rax
jmp loc_43D95
loc_43C68:
cmp byte ptr [r15], 2Eh ; '.'
jnz loc_43DCE
mov [rsp+38h+var_38], r13
mov rdi, r12
mov esi, 2Fh ; '/'
call _strrchr
mov ecx, eax
sub ecx, r12d
test rax, rax
movsxd r13, ecx
cmovz r13, rax
mov rdi, r15
call _strlen
lea ebp, [rax+r13]
add ebp, 2
movsxd rsi, ebp
mov rdi, rbx
call js_malloc
test rax, rax
jz loc_43E07
mov r14, rax
mov rdi, rax
mov rsi, r12
mov rdx, r13
call _memcpy
mov byte ptr [r14+r13], 0
cmp byte ptr [r15], 2Eh ; '.'
setz al
jnz loc_43DDE
lea r12, aMissingBinding+19h; "."
loc_43CDF:
mov dl, [r15+1]
mov ecx, 2
cmp dl, 2Fh ; '/'
jz short loc_43D67
cmp dl, 2Eh ; '.'
setnz cl
not al
or al, cl
test al, 1
jnz loc_43DDE
cmp byte ptr [r15+2], 2Fh ; '/'
jnz loc_43DDE
cmp byte ptr [r14], 0
jz loc_43DDE
mov rdi, r14
mov esi, 2Fh ; '/'
call _strrchr
lea r13, [rax+1]
test rax, rax
cmovz r13, r14
mov rdi, r13
mov rsi, r12
call _strcmp
test eax, eax
jz loc_43DDE
mov rdi, r13
lea rsi, aMissingBinding+18h; ".."
call _strcmp
test eax, eax
jz loc_43DDE
cmp r14, r13
sbb r13, 0
mov byte ptr [r13+0], 0
mov ecx, 3
loc_43D67:
lea r13, [r15+rcx]
cmp byte ptr [r15+rcx], 2Eh ; '.'
setz al
mov r15, r13
jz loc_43CDF
jmp short loc_43DE1
loc_43D7E:
lea rsi, aCouldNotLoadMo_3; "could not load module '%s'"
xor r15d, r15d
mov rdi, rbx
mov rdx, r14
xor eax, eax
call JS_ThrowReferenceError
loc_43D95:
mov rbx, [rbx+18h]
dec qword ptr [rbx+28h]
mov rdi, r14
call qword ptr [rbx+20h]
mov rcx, [rbx+30h]
mov rdi, [rbx+40h]
sub rcx, rax
add rcx, 0FFFFFFFFFFFFFFF8h
mov [rbx+30h], rcx
mov rsi, r14
call qword ptr [rbx+10h]
loc_43DBC:
mov rax, r15
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_43DCE:
mov rdi, rbx
mov rsi, r15
call js_strdup
jmp loc_43B79
loc_43DDE:
mov r13, r15
loc_43DE1:
cmp byte ptr [r14], 0
jz short loc_43DF8
lea rdx, asc_9B9DF+1; "/"
mov rdi, r14
mov esi, ebp
call js__pstrcat
loc_43DF8:
mov rdi, r14
mov esi, ebp
mov rdx, r13
call js__pstrcat
jmp short loc_43E0A
loc_43E07:
xor r14d, r14d
loc_43E0A:
mov r13, [rsp+38h+var_38]
jmp loc_43B7C
| long long js_host_resolve_imported_module(
long long a1,
long long a2,
char *a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
char v11; // al
char *v12; // r15
_QWORD *v14; // r13
long long ( *v15)(long long, long long, char *, _QWORD); // rax
long long v16; // rax
unsigned __int8 *v17; // r14
long long v18; // rax
int v19; // eax
int v20; // ebp
long long i; // r15
long long v22; // r15
long long v23; // rbx
long long v24; // rax
long long v25; // rdi
long long v26; // r12
long long v27; // rax
long long v28; // rdi
long long v29; // rcx
long long v30; // r8
long long v31; // r9
__m128 v32; // xmm4
__m128 v33; // xmm5
long long ( *v34)(long long, unsigned __int8 *, _QWORD); // rax
long long v35; // rax
long long v36; // r13
int v37; // ebp
long long v38; // rax
bool v39; // al
char v40; // dl
long long v41; // rcx
long long v42; // rax
unsigned __int8 *v43; // r13
char *v44; // r13
long long v45; // rbx
long long v46; // rax
long long v47; // rdi
_QWORD *v49; // [rsp+0h] [rbp-38h]
LOBYTE(v49) = v11;
v12 = a3;
v14 = *(_QWORD **)(a1 + 24);
v15 = (long long ( *)(long long, long long, char *, _QWORD))v14[40];
if ( v15 )
{
v16 = v15(a1, a2, a3, v14[42]);
LABEL_3:
v17 = (unsigned __int8 *)v16;
goto LABEL_4;
}
if ( *a3 != 46 )
{
v16 = js_strdup(a1, (long long)a3);
goto LABEL_3;
}
v49 = *(_QWORD **)(a1 + 24);
v35 = strrchr(a2, 47LL);
v36 = (int)v35 - (int)a2;
if ( !v35 )
v36 = 0LL;
v37 = strlen(v12) + v36 + 2;
v38 = js_malloc(a1, v37);
if ( v38 )
{
v17 = (unsigned __int8 *)v38;
memcpy(v38, a2, v36);
v17[v36] = 0;
v39 = *v12 == 46;
if ( *v12 == 46 )
{
while ( 1 )
{
v40 = v12[1];
v41 = 2LL;
if ( v40 != 47 )
{
if ( v40 != 46 || !v39 || v12[2] != 47 || !*v17 )
break;
v42 = strrchr(v17, 47LL);
v43 = (unsigned __int8 *)(v42 + 1);
if ( !v42 )
v43 = v17;
if ( !(unsigned int)strcmp(v43, ".") || !(unsigned int)strcmp(v43, "..") )
break;
*(_BYTE *)((__PAIR128__((unsigned long long)v43, (unsigned long long)v17) - (unsigned long long)v43) >> 64) = 0;
v41 = 3LL;
}
v44 = &v12[v41];
v39 = v12[v41] == 46;
v12 += v41;
if ( !v39 )
goto LABEL_39;
}
}
v44 = v12;
LABEL_39:
if ( *v17 )
js__pstrcat((long long)v17, v37, "/");
js__pstrcat((long long)v17, v37, v44);
}
else
{
v17 = 0LL;
}
v14 = v49;
LABEL_4:
if ( !v17 )
return 0LL;
v18 = strlen(v17);
v19 = JS_NewAtomLen(a1, v17, v18);
if ( !v19 )
{
v23 = *(_QWORD *)(a1 + 24);
--*(_QWORD *)(v23 + 40);
v24 = (*(long long ( **)(unsigned __int8 *))(v23 + 32))(v17);
v25 = *(_QWORD *)(v23 + 64);
*(_QWORD *)(v23 + 48) = *(_QWORD *)(v23 + 48) - v24 - 8;
(*(void ( **)(long long, unsigned __int8 *))(v23 + 16))(v25, v17);
return 0LL;
}
v20 = v19;
for ( i = *(_QWORD *)(a1 + 488); ; i = *(_QWORD *)(i + 8) )
{
if ( i == a1 + 480 )
{
v22 = 0LL;
goto LABEL_14;
}
if ( *(_DWORD *)(i - 4) == v19 )
break;
}
v22 = i - 8;
LABEL_14:
if ( v22 )
{
v26 = *(_QWORD *)(a1 + 24);
--*(_QWORD *)(v26 + 40);
v27 = (*(long long ( **)(unsigned __int8 *))(v26 + 32))(v17);
v28 = *(_QWORD *)(v26 + 64);
*(_QWORD *)(v26 + 48) = *(_QWORD *)(v26 + 48) - v27 - 8;
(*(void ( **)(long long, unsigned __int8 *))(v26 + 16))(v28, v17);
JS_FreeAtom(a1, v20);
}
else
{
JS_FreeAtom(a1, v19);
v34 = (long long ( *)(long long, unsigned __int8 *, _QWORD))v14[41];
if ( v34 )
{
v22 = v34(a1, v17, v14[42]);
}
else
{
v22 = 0LL;
JS_ThrowReferenceError(
a1,
(long long)"could not load module '%s'",
(long long)v17,
v29,
v30,
v31,
a4,
a5,
a6,
a7,
v32,
v33,
a10,
a11,
(char)v49);
}
v45 = *(_QWORD *)(a1 + 24);
--*(_QWORD *)(v45 + 40);
v46 = (*(long long ( **)(unsigned __int8 *))(v45 + 32))(v17);
v47 = *(_QWORD *)(v45 + 64);
*(_QWORD *)(v45 + 48) = *(_QWORD *)(v45 + 48) - v46 - 8;
(*(void ( **)(long long, unsigned __int8 *))(v45 + 16))(v47, v17);
}
return v22;
}
| js_host_resolve_imported_module:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDX
MOV R12,RSI
MOV RBX,RDI
MOV R13,qword ptr [RDI + 0x18]
MOV RAX,qword ptr [R13 + 0x140]
TEST RAX,RAX
JZ 0x00143c68
MOV RCX,qword ptr [R13 + 0x150]
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R15
CALL RAX
LAB_00143b79:
MOV R14,RAX
LAB_00143b7c:
TEST R14,R14
JZ 0x00143be8
MOV RDI,R14
CALL 0x0010e240
MOV RDI,RBX
MOV RSI,R14
MOV RDX,RAX
CALL 0x0011fdc0
TEST EAX,EAX
JZ 0x00143bc1
MOV EBP,EAX
LEA RAX,[RBX + 0x1e0]
MOV R15,qword ptr [RBX + 0x1e8]
LAB_00143bab:
CMP R15,RAX
JZ 0x00143bbc
CMP dword ptr [R15 + -0x4],EBP
JZ 0x00143bf0
MOV R15,qword ptr [R15 + 0x8]
JMP 0x00143bab
LAB_00143bbc:
XOR R15D,R15D
JMP 0x00143bf4
LAB_00143bc1:
MOV RBX,qword ptr [RBX + 0x18]
DEC qword ptr [RBX + 0x28]
MOV RDI,R14
CALL qword ptr [RBX + 0x20]
MOV RCX,qword ptr [RBX + 0x30]
MOV RDI,qword ptr [RBX + 0x40]
SUB RCX,RAX
ADD RCX,-0x8
MOV qword ptr [RBX + 0x30],RCX
MOV RSI,R14
CALL qword ptr [RBX + 0x10]
LAB_00143be8:
XOR R15D,R15D
JMP 0x00143dbc
LAB_00143bf0:
ADD R15,-0x8
LAB_00143bf4:
TEST R15,R15
JZ 0x00143c37
MOV R12,qword ptr [RBX + 0x18]
DEC qword ptr [R12 + 0x28]
MOV RDI,R14
CALL qword ptr [R12 + 0x20]
MOV RCX,qword ptr [R12 + 0x30]
MOV RDI,qword ptr [R12 + 0x40]
SUB RCX,RAX
ADD RCX,-0x8
MOV qword ptr [R12 + 0x30],RCX
MOV RSI,R14
CALL qword ptr [R12 + 0x10]
MOV RDI,RBX
MOV ESI,EBP
CALL 0x001207d8
JMP 0x00143dbc
LAB_00143c37:
MOV RDI,RBX
MOV ESI,EBP
CALL 0x001207d8
MOV RAX,qword ptr [R13 + 0x148]
TEST RAX,RAX
JZ 0x00143d7e
MOV RDX,qword ptr [R13 + 0x150]
MOV RDI,RBX
MOV RSI,R14
CALL RAX
MOV R15,RAX
JMP 0x00143d95
LAB_00143c68:
CMP byte ptr [R15],0x2e
JNZ 0x00143dce
MOV qword ptr [RSP],R13
MOV RDI,R12
MOV ESI,0x2f
CALL 0x0010e300
MOV ECX,EAX
SUB ECX,R12D
TEST RAX,RAX
MOVSXD R13,ECX
CMOVZ R13,RAX
MOV RDI,R15
CALL 0x0010e240
LEA EBP,[RAX + R13*0x1]
ADD EBP,0x2
MOVSXD RSI,EBP
MOV RDI,RBX
CALL 0x0010ede6
TEST RAX,RAX
JZ 0x00143e07
MOV R14,RAX
MOV RDI,RAX
MOV RSI,R12
MOV RDX,R13
CALL 0x0010e5b0
MOV byte ptr [R14 + R13*0x1],0x0
CMP byte ptr [R15],0x2e
SETZ AL
JNZ 0x00143dde
LEA R12,[0x1a0bf6]
LAB_00143cdf:
MOV DL,byte ptr [R15 + 0x1]
MOV ECX,0x2
CMP DL,0x2f
JZ 0x00143d67
CMP DL,0x2e
SETNZ CL
NOT AL
OR AL,CL
TEST AL,0x1
JNZ 0x00143dde
CMP byte ptr [R15 + 0x2],0x2f
JNZ 0x00143dde
CMP byte ptr [R14],0x0
JZ 0x00143dde
MOV RDI,R14
MOV ESI,0x2f
CALL 0x0010e300
LEA R13,[RAX + 0x1]
TEST RAX,RAX
CMOVZ R13,R14
MOV RDI,R13
MOV RSI,R12
CALL 0x0010e510
TEST EAX,EAX
JZ 0x00143dde
MOV RDI,R13
LEA RSI,[0x1a0bf5]
CALL 0x0010e510
TEST EAX,EAX
JZ 0x00143dde
CMP R14,R13
SBB R13,0x0
MOV byte ptr [R13],0x0
MOV ECX,0x3
LAB_00143d67:
LEA R13,[R15 + RCX*0x1]
CMP byte ptr [R15 + RCX*0x1],0x2e
SETZ AL
MOV R15,R13
JZ 0x00143cdf
JMP 0x00143de1
LAB_00143d7e:
LEA RSI,[0x19f7e2]
XOR R15D,R15D
MOV RDI,RBX
MOV RDX,R14
XOR EAX,EAX
CALL 0x001225fd
LAB_00143d95:
MOV RBX,qword ptr [RBX + 0x18]
DEC qword ptr [RBX + 0x28]
MOV RDI,R14
CALL qword ptr [RBX + 0x20]
MOV RCX,qword ptr [RBX + 0x30]
MOV RDI,qword ptr [RBX + 0x40]
SUB RCX,RAX
ADD RCX,-0x8
MOV qword ptr [RBX + 0x30],RCX
MOV RSI,R14
CALL qword ptr [RBX + 0x10]
LAB_00143dbc:
MOV RAX,R15
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00143dce:
MOV RDI,RBX
MOV RSI,R15
CALL 0x0010ee64
JMP 0x00143b79
LAB_00143dde:
MOV R13,R15
LAB_00143de1:
CMP byte ptr [R14],0x0
JZ 0x00143df8
LEA RDX,[0x19b9e0]
MOV RDI,R14
MOV ESI,EBP
CALL 0x0011b26a
LAB_00143df8:
MOV RDI,R14
MOV ESI,EBP
MOV RDX,R13
CALL 0x0011b26a
JMP 0x00143e0a
LAB_00143e07:
XOR R14D,R14D
LAB_00143e0a:
MOV R13,qword ptr [RSP]
JMP 0x00143b7c
|
long js_host_resolve_imported_module(long param_1,char *param_2,char *param_3)
{
char cVar1;
int iVar2;
int iVar3;
char *pcVar4;
size_t sVar5;
long lVar6;
long lVar7;
size_t sVar8;
char *pcVar9;
char *__s1;
long lVar10;
lVar7 = *(long *)(param_1 + 0x18);
if (*(code **)(lVar7 + 0x140) == (code *)0x0) {
if (*param_3 == '.') {
pcVar4 = strrchr(param_2,0x2f);
sVar5 = (size_t)((int)pcVar4 - (int)param_2);
if (pcVar4 == (char *)0x0) {
sVar5 = 0;
}
sVar8 = strlen(param_3);
iVar2 = (int)sVar8 + (int)sVar5 + 2;
pcVar4 = (char *)js_malloc(param_1,(long)iVar2);
if (pcVar4 == (char *)0x0) {
pcVar4 = (char *)0x0;
}
else {
memcpy(pcVar4,param_2,sVar5);
pcVar4[sVar5] = '\0';
cVar1 = *param_3;
while (cVar1 == '.') {
lVar10 = 2;
if (param_3[1] != '/') {
if ((((bool)(~(cVar1 == '.') & 1U | param_3[1] != '.')) || (param_3[2] != '/')) ||
(*pcVar4 == '\0')) break;
pcVar9 = strrchr(pcVar4,0x2f);
__s1 = pcVar9 + 1;
if (pcVar9 == (char *)0x0) {
__s1 = pcVar4;
}
iVar3 = strcmp(__s1,".");
if ((iVar3 == 0) || (iVar3 = strcmp(__s1,".."), iVar3 == 0)) break;
__s1[-(ulong)(pcVar4 < __s1)] = '\0';
lVar10 = 3;
}
cVar1 = param_3[lVar10];
param_3 = param_3 + lVar10;
}
if (*pcVar4 != '\0') {
js__pstrcat(pcVar4,iVar2,&DAT_0019b9e0);
}
js__pstrcat(pcVar4,iVar2,param_3);
}
}
else {
pcVar4 = (char *)js_strdup(param_1,param_3);
}
}
else {
pcVar4 = (char *)(**(code **)(lVar7 + 0x140))
(param_1,param_2,param_3,*(int8 *)(lVar7 + 0x150));
}
if (pcVar4 != (char *)0x0) {
sVar5 = strlen(pcVar4);
iVar2 = JS_NewAtomLen(param_1,pcVar4,sVar5);
if (iVar2 != 0) {
lVar10 = *(long *)(param_1 + 0x1e8);
do {
if (lVar10 == param_1 + 0x1e0) {
lVar10 = 0;
LAB_00143bf4:
if (lVar10 != 0) {
lVar7 = *(long *)(param_1 + 0x18);
*(long *)(lVar7 + 0x28) = *(long *)(lVar7 + 0x28) + -1;
lVar6 = (**(code **)(lVar7 + 0x20))(pcVar4);
*(long *)(lVar7 + 0x30) = (*(long *)(lVar7 + 0x30) - lVar6) + -8;
(**(code **)(lVar7 + 0x10))(*(int8 *)(lVar7 + 0x40),pcVar4);
JS_FreeAtom(param_1,iVar2);
return lVar10;
}
JS_FreeAtom(param_1,iVar2);
if (*(code **)(lVar7 + 0x148) == (code *)0x0) {
lVar7 = 0;
JS_ThrowReferenceError(param_1,"could not load module \'%s\'",pcVar4);
}
else {
lVar7 = (**(code **)(lVar7 + 0x148))(param_1,pcVar4,*(int8 *)(lVar7 + 0x150));
}
lVar10 = *(long *)(param_1 + 0x18);
*(long *)(lVar10 + 0x28) = *(long *)(lVar10 + 0x28) + -1;
lVar6 = (**(code **)(lVar10 + 0x20))(pcVar4);
*(long *)(lVar10 + 0x30) = (*(long *)(lVar10 + 0x30) - lVar6) + -8;
(**(code **)(lVar10 + 0x10))(*(int8 *)(lVar10 + 0x40),pcVar4);
return lVar7;
}
if (*(int *)(lVar10 + -4) == iVar2) {
lVar10 = lVar10 + -8;
goto LAB_00143bf4;
}
lVar10 = *(long *)(lVar10 + 8);
} while( true );
}
lVar7 = *(long *)(param_1 + 0x18);
*(long *)(lVar7 + 0x28) = *(long *)(lVar7 + 0x28) + -1;
lVar10 = (**(code **)(lVar7 + 0x20))(pcVar4);
*(long *)(lVar7 + 0x30) = (*(long *)(lVar7 + 0x30) - lVar10) + -8;
(**(code **)(lVar7 + 0x10))(*(int8 *)(lVar7 + 0x40),pcVar4);
}
return 0;
}
| |
41,513 | find_weight | memononen[P]budouxc/src/budoux.c | static int32_t find_weight(const budoux_weights_t* w, const uint64_t key)
{
if (key < w->keys[0] || key > w->keys[w->count-1])
return 0;
// binary search
int32_t low = 0;
int32_t high = w->count - 1;
while (low != high) {
const int32_t mid = low + (high - low + 1) / 2; // ceil
if (w->keys[mid] > key)
high = mid - 1;
else
low = mid;
}
if (w->keys[low] == key)
return w->values[low];
return 0;
} | O2 | c | find_weight:
movq (%rdi), %rcx
xorl %eax, %eax
cmpq %rsi, (%rcx)
ja 0x2dc1
movslq 0x10(%rdi), %r8
cmpq %rsi, -0x8(%rcx,%r8,8)
jb 0x2dc1
decq %r8
xorl %r10d, %r10d
pushq $0x2
popq %r9
movl %r8d, %eax
subl %r10d, %eax
je 0x2dae
incl %eax
cltd
idivl %r9d
leal (%rax,%r10), %edx
movslq %edx, %rdx
cmpq %rsi, (%rcx,%rdx,8)
leal -0x1(%rax,%r10), %eax
cmoval %r10d, %edx
cmoval %eax, %r8d
movl %edx, %r10d
jmp 0x2d83
movslq %r10d, %rdx
xorl %eax, %eax
cmpq %rsi, (%rcx,%rdx,8)
jne 0x2dc1
movq 0x8(%rdi), %rax
movswl (%rax,%rdx,2), %eax
retq
| find_weight:
mov rcx, [rdi]
xor eax, eax
cmp [rcx], rsi
ja short locret_2DC1
movsxd r8, dword ptr [rdi+10h]
cmp [rcx+r8*8-8], rsi
jb short locret_2DC1
dec r8
xor r10d, r10d
push 2
pop r9
loc_2D83:
mov eax, r8d
sub eax, r10d
jz short loc_2DAE
inc eax
cdq
idiv r9d
lea edx, [rax+r10]
movsxd rdx, edx
cmp [rcx+rdx*8], rsi
lea eax, [rax+r10-1]
cmova edx, r10d
cmova r8d, eax
mov r10d, edx
jmp short loc_2D83
loc_2DAE:
movsxd rdx, r10d
xor eax, eax
cmp [rcx+rdx*8], rsi
jnz short locret_2DC1
mov rax, [rdi+8]
movsx eax, word ptr [rax+rdx*2]
locret_2DC1:
retn
| long long find_weight(long long a1, unsigned long long a2)
{
_QWORD *v2; // rcx
long long result; // rax
long long v4; // r8
int v5; // r8d
int i; // r10d
long long v7; // rdx
int v8; // eax
v2 = *(_QWORD **)a1;
result = 0LL;
if ( **(_QWORD **)a1 <= a2 )
{
v4 = *(int *)(a1 + 16);
if ( v2[v4 - 1] >= a2 )
{
v5 = v4 - 1;
for ( i = 0; v5 != i; i = v7 )
{
v7 = (v5 - i + 1) / 2 + i;
v8 = v7 - 1;
if ( v2[v7] > a2 )
{
LODWORD(v7) = i;
v5 = v8;
}
}
result = 0LL;
if ( v2[i] == a2 )
return (unsigned int)*(__int16 *)(*(_QWORD *)(a1 + 8) + 2LL * i);
}
}
return result;
}
| find_weight:
MOV RCX,qword ptr [RDI]
XOR EAX,EAX
CMP qword ptr [RCX],RSI
JA 0x00102dc1
MOVSXD R8,dword ptr [RDI + 0x10]
CMP qword ptr [RCX + R8*0x8 + -0x8],RSI
JC 0x00102dc1
DEC R8
XOR R10D,R10D
PUSH 0x2
POP R9
LAB_00102d83:
MOV EAX,R8D
SUB EAX,R10D
JZ 0x00102dae
INC EAX
CDQ
IDIV R9D
LEA EDX,[RAX + R10*0x1]
MOVSXD RDX,EDX
CMP qword ptr [RCX + RDX*0x8],RSI
LEA EAX,[RAX + R10*0x1 + -0x1]
CMOVA EDX,R10D
CMOVA R8D,EAX
MOV R10D,EDX
JMP 0x00102d83
LAB_00102dae:
MOVSXD RDX,R10D
XOR EAX,EAX
CMP qword ptr [RCX + RDX*0x8],RSI
JNZ 0x00102dc1
MOV RAX,qword ptr [RDI + 0x8]
MOVSX EAX,word ptr [RAX + RDX*0x2]
LAB_00102dc1:
RET
|
int find_weight(long *param_1,ulong param_2)
{
uint uVar1;
ulong *puVar2;
int iVar3;
int iVar4;
ulong uVar5;
int iVar6;
puVar2 = (ulong *)*param_1;
iVar3 = 0;
if ((*puVar2 <= param_2) && (param_2 <= puVar2[(long)(int)param_1[2] + -1])) {
uVar5 = (long)(int)param_1[2] - 1;
iVar6 = 0;
while (iVar3 = (int)uVar5 - iVar6, iVar3 != 0) {
iVar4 = (iVar3 + 1) / 2;
iVar3 = iVar4 + iVar6;
uVar1 = iVar4 + -1 + iVar6;
iVar4 = iVar3;
if (param_2 < puVar2[iVar3]) {
iVar4 = iVar6;
}
iVar6 = iVar4;
uVar5 = uVar5 & 0xffffffff;
if (param_2 < puVar2[iVar3]) {
uVar5 = (ulong)uVar1;
}
}
iVar3 = 0;
if (puVar2[iVar6] == param_2) {
iVar3 = (int)*(short *)(param_1[1] + (long)iVar6 * 2);
}
}
return iVar3;
}
| |
41,514 | minja::Value::empty() const | monkey531[P]llama/common/minja.hpp | bool empty() const {
if (is_null())
throw std::runtime_error("Undefined value or reference");
if (is_string()) return primitive_.empty();
if (is_array()) return array_->empty();
if (is_object()) return object_->empty();
return false;
} | O3 | cpp | minja::Value::empty() const:
pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rdx
movq 0x20(%rdi), %rcx
movb 0x40(%rdi), %sil
testq %rcx, %rcx
jne 0x86fd2
testq %rdx, %rdx
jne 0x86fd2
testb %sil, %sil
jne 0x86fd2
cmpq $0x0, 0x30(%rdi)
je 0x87002
movq %rdx, %rax
orq %rcx, %rax
sete %dil
xorl %eax, %eax
cmpb $0x3, %sil
je 0x86ffa
testb %dil, %dil
jne 0x86ffa
testq %rdx, %rdx
cmovneq %rdx, %rcx
movq (%rcx), %rax
cmpq 0x8(%rcx), %rax
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x1a460
movq %rax, %rbx
leaq 0x68cc4(%rip), %rsi # 0xefcda
movq %rax, %rdi
callq 0x1a340
movq 0xa4fcb(%rip), %rsi # 0x12bff0
movq 0xa4f34(%rip), %rdx # 0x12bf60
movq %rbx, %rdi
callq 0x1af30
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a690
movq %r14, %rdi
callq 0x1afd0
| _ZNK5minja5Value5emptyEv:
push r14
push rbx
push rax
mov rdx, [rdi+10h]
mov rcx, [rdi+20h]
mov sil, [rdi+40h]
test rcx, rcx
jnz short loc_86FD2
test rdx, rdx
jnz short loc_86FD2
test sil, sil
jnz short loc_86FD2
cmp qword ptr [rdi+30h], 0
jz short loc_87002
loc_86FD2:
mov rax, rdx
or rax, rcx
setz dil
xor eax, eax
cmp sil, 3
jz short loc_86FFA
test dil, dil
jnz short loc_86FFA
test rdx, rdx
cmovnz rcx, rdx
mov rax, [rcx]
cmp rax, [rcx+8]
setz al
loc_86FFA:
add rsp, 8
pop rbx
pop r14
retn
loc_87002:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aUndefinedValue; "Undefined value or reference"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
mov rdi, r14
call __Unwind_Resume
| bool minja::Value::empty(minja::Value *this)
{
unsigned long long v1; // rdx
_QWORD *v2; // rcx
char v3; // si
bool result; // al
std::runtime_error *exception; // rbx
v1 = *((_QWORD *)this + 2);
v2 = (_QWORD *)*((_QWORD *)this + 4);
v3 = *((_BYTE *)this + 64);
if ( __PAIR128__((unsigned long long)v2, v1) == 0 && !v3 && !*((_QWORD *)this + 6) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Undefined value or reference");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
result = 0;
if ( v3 != 3 && __PAIR128__((unsigned long long)v2, v1) != 0 )
{
if ( v1 )
v2 = (_QWORD *)*((_QWORD *)this + 2);
return *v2 == v2[1];
}
return result;
}
| empty:
PUSH R14
PUSH RBX
PUSH RAX
MOV RDX,qword ptr [RDI + 0x10]
MOV RCX,qword ptr [RDI + 0x20]
MOV SIL,byte ptr [RDI + 0x40]
TEST RCX,RCX
JNZ 0x00186fd2
TEST RDX,RDX
JNZ 0x00186fd2
TEST SIL,SIL
JNZ 0x00186fd2
CMP qword ptr [RDI + 0x30],0x0
JZ 0x00187002
LAB_00186fd2:
MOV RAX,RDX
OR RAX,RCX
SETZ DIL
XOR EAX,EAX
CMP SIL,0x3
JZ 0x00186ffa
TEST DIL,DIL
JNZ 0x00186ffa
TEST RDX,RDX
CMOVNZ RCX,RDX
MOV RAX,qword ptr [RCX]
CMP RAX,qword ptr [RCX + 0x8]
SETZ AL
LAB_00186ffa:
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_00187002:
MOV EDI,0x10
CALL 0x0011a460
MOV RBX,RAX
LAB_0018700f:
LEA RSI,[0x1efcda]
MOV RDI,RAX
CALL 0x0011a340
LAB_0018701e:
MOV RSI,qword ptr [0x0022bff0]
MOV RDX,qword ptr [0x0022bf60]
MOV RDI,RBX
CALL 0x0011af30
|
/* minja::Value::empty() const */
int8 __thiscall minja::Value::empty(Value *this)
{
long *plVar1;
int8 uVar2;
runtime_error *this_00;
long *plVar3;
plVar1 = *(long **)(this + 0x10);
plVar3 = *(long **)(this + 0x20);
if ((((plVar3 == (long *)0x0) && (plVar1 == (long *)0x0)) && (this[0x40] == (Value)0x0)) &&
(*(long *)(this + 0x30) == 0)) {
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0018700f to 0018701d has its CatchHandler @ 00187034 */
std::runtime_error::runtime_error(this_00,"Undefined value or reference");
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_0022bff0,PTR__runtime_error_0022bf60);
}
uVar2 = 0;
if ((this[0x40] != (Value)0x3) && (plVar1 != (long *)0x0 || plVar3 != (long *)0x0)) {
if (plVar1 != (long *)0x0) {
plVar3 = plVar1;
}
uVar2 = CONCAT71((int7)((ulong)*plVar3 >> 8),*plVar3 == plVar3[1]);
}
return uVar2;
}
| |
41,515 | eval_num_suffix_ull | eloqsql/mysys/my_getopt.c | static ulonglong eval_num_suffix_ull(char *argument,
int *error, char *option_name)
{
char *endchar;
ulonglong num;
DBUG_ENTER("eval_num_suffix_ull");
if (*argument == '-')
{
my_getopt_error_reporter(ERROR_LEVEL,
"Incorrect unsigned value: '%s' for %s",
argument, option_name);
*error= 1;
DBUG_RETURN(0);
}
*error= 0;
errno= 0;
num= strtoull(argument, &endchar, 10);
if (errno == ERANGE)
{
my_getopt_error_reporter(ERROR_LEVEL,
"Incorrect integer value: '%s' for %s",
argument, option_name);
*error= 1;
DBUG_RETURN(0);
}
num*= eval_num_suffix(endchar, error);
if (*error)
my_getopt_error_reporter(ERROR_LEVEL,
"Unknown suffix '%c' used for variable '%s' (value '%s')",
*endchar, option_name, argument);
DBUG_RETURN(num);
} | O0 | c | eval_num_suffix_ull:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0xf8807
leaq 0x1d4e09(%rip), %rax # 0x2cd5e0
movq (%rax), %r8
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
xorl %edi, %edi
leaq 0x67735(%rip), %rsi # 0x15ff20
movb $0x0, %al
callq *%r8
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0xf88c0
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
callq 0x2a750
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0xa, %edx
callq 0x2a0a0
movq %rax, -0x30(%rbp)
callq 0x2a750
cmpl $0x22, (%rax)
jne 0xf8870
leaq 0x1d4d9d(%rip), %rax # 0x2cd5e0
movq (%rax), %r8
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
xorl %edi, %edi
leaq 0x676ef(%rip), %rsi # 0x15ff46
movb $0x0, %al
callq *%r8
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0xf88c0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xf8700
imulq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0xf88b6
leaq 0x1d4d4a(%rip), %rax # 0x2cd5e0
movq (%rax), %r9
movq -0x28(%rbp), %rax
movsbl (%rax), %edx
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %r8
xorl %edi, %edi
leaq 0x676ba(%rip), %rsi # 0x15ff6b
movb $0x0, %al
callq *%r9
jmp 0xf88b8
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| eval_num_suffix_ull:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 2Dh ; '-'
jnz short loc_F8807
lea rax, my_getopt_error_reporter
mov r8, [rax]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_20]
xor edi, edi
lea rsi, aIncorrectUnsig; "Incorrect unsigned value: '%s' for %s"
mov al, 0
call r8
mov rax, [rbp+var_18]
mov dword ptr [rax], 1
mov [rbp+var_8], 0
jmp loc_F88C0
loc_F8807:
mov rax, [rbp+var_18]
mov dword ptr [rax], 0
call ___errno_location
mov dword ptr [rax], 0
mov rdi, [rbp+var_10]
lea rsi, [rbp+var_28]
mov edx, 0Ah
call ___isoc23_strtoul
mov [rbp+var_30], rax
call ___errno_location
cmp dword ptr [rax], 22h ; '"'
jnz short loc_F8870
lea rax, my_getopt_error_reporter
mov r8, [rax]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_20]
xor edi, edi
lea rsi, aIncorrectInteg_0; "Incorrect integer value: '%s' for %s"
mov al, 0
call r8
mov rax, [rbp+var_18]
mov dword ptr [rax], 1
mov [rbp+var_8], 0
jmp short loc_F88C0
loc_F8870:
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_18]
call eval_num_suffix
imul rax, [rbp+var_30]
mov [rbp+var_30], rax
mov rax, [rbp+var_18]
cmp dword ptr [rax], 0
jz short loc_F88B6
lea rax, my_getopt_error_reporter
mov r9, [rax]
mov rax, [rbp+var_28]
movsx edx, byte ptr [rax]
mov rcx, [rbp+var_20]
mov r8, [rbp+var_10]
xor edi, edi
lea rsi, aUnknownSuffixC_0; "Unknown suffix '%c' used for variable '"...
mov al, 0
call r9
loc_F88B6:
jmp short $+2
loc_F88B8:
mov rax, [rbp+var_30]
mov [rbp+var_8], rax
loc_F88C0:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| long long eval_num_suffix_ull(const char *a1, _DWORD *a2, const char *a3)
{
long long v4; // [rsp+0h] [rbp-30h]
long long v5; // [rsp+0h] [rbp-30h]
_BYTE *v6; // [rsp+8h] [rbp-28h] BYREF
const char *v7; // [rsp+10h] [rbp-20h]
_DWORD *v8; // [rsp+18h] [rbp-18h]
const char *v9; // [rsp+20h] [rbp-10h]
v9 = a1;
v8 = a2;
v7 = a3;
if ( *a1 == 45 )
{
my_getopt_error_reporter(0, (long long)"Incorrect unsigned value: '%s' for %s", v9, v7);
*v8 = 1;
return 0LL;
}
else
{
*v8 = 0;
*(_DWORD *)__errno_location() = 0;
v4 = __isoc23_strtoul(v9, &v6, 10LL);
if ( *(_DWORD *)__errno_location() == 34 )
{
my_getopt_error_reporter(0, (long long)"Incorrect integer value: '%s' for %s", v9, v7);
*v8 = 1;
return 0LL;
}
else
{
v5 = v4 * eval_num_suffix(v6, v8);
if ( *v8 )
my_getopt_error_reporter(
0,
(long long)"Unknown suffix '%c' used for variable '%s' (value '%s')",
(unsigned int)(char)*v6,
v7,
v9);
return v5;
}
}
}
| eval_num_suffix_ull:
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 RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2d
JNZ 0x001f8807
LEA RAX,[0x3cd5e0]
MOV R8,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x20]
XOR EDI,EDI
LEA RSI,[0x25ff20]
MOV AL,0x0
CALL R8
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX],0x1
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001f88c0
LAB_001f8807:
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX],0x0
CALL 0x0012a750
MOV dword ptr [RAX],0x0
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[RBP + -0x28]
MOV EDX,0xa
CALL 0x0012a0a0
MOV qword ptr [RBP + -0x30],RAX
CALL 0x0012a750
CMP dword ptr [RAX],0x22
JNZ 0x001f8870
LEA RAX,[0x3cd5e0]
MOV R8,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x20]
XOR EDI,EDI
LEA RSI,[0x25ff46]
MOV AL,0x0
CALL R8
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX],0x1
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001f88c0
LAB_001f8870:
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001f8700
IMUL RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX],0x0
JZ 0x001f88b6
LEA RAX,[0x3cd5e0]
MOV R9,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EDX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + -0x10]
XOR EDI,EDI
LEA RSI,[0x25ff6b]
MOV AL,0x0
CALL R9
LAB_001f88b6:
JMP 0x001f88b8
LAB_001f88b8:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x8],RAX
LAB_001f88c0:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
long eval_num_suffix_ull(char *param_1,int *param_2,int8 param_3)
{
int *piVar1;
long lVar2;
char *local_30;
int8 local_28;
int *local_20;
char *local_18;
long local_10;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
if (*param_1 == '-') {
(*(code *)my_getopt_error_reporter)(0,"Incorrect unsigned value: \'%s\' for %s",param_1,param_3)
;
*local_20 = 1;
local_10 = 0;
}
else {
*param_2 = 0;
piVar1 = __errno_location();
*piVar1 = 0;
lVar2 = __isoc23_strtoul(local_18,&local_30,10);
piVar1 = __errno_location();
if (*piVar1 == 0x22) {
(*(code *)my_getopt_error_reporter)
(0,"Incorrect integer value: \'%s\' for %s",local_18,local_28);
*local_20 = 1;
local_10 = 0;
}
else {
local_10 = eval_num_suffix(local_30,local_20);
local_10 = local_10 * lVar2;
if (*local_20 != 0) {
(*(code *)my_getopt_error_reporter)
(0,"Unknown suffix \'%c\' used for variable \'%s\' (value \'%s\')",(int)*local_30,
local_28,local_18);
}
}
}
return local_10;
}
| |
41,516 | pagecache_delete_pages | eloqsql/storage/maria/ma_pagecache.c | my_bool pagecache_delete_pages(PAGECACHE *pagecache,
PAGECACHE_FILE *file,
pgcache_page_no_t pageno,
uint page_count,
enum pagecache_page_lock lock,
my_bool flush)
{
pgcache_page_no_t page_end;
DBUG_ENTER("pagecache_delete_pages");
DBUG_ASSERT(page_count > 0);
page_end= pageno + page_count;
do
{
if (pagecache_delete(pagecache, file, pageno,
lock, flush))
DBUG_RETURN(1);
} while (++pageno != page_end);
DBUG_RETURN(0);
} | O0 | c | pagecache_delete_pages:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r9b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movb %al, -0x29(%rbp)
jmp 0x2efe3
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x28(%rbp), %ecx
movsbl -0x29(%rbp), %r8d
callq 0x2ecd0
cmpb $0x0, %al
je 0x2f016
jmp 0x2f010
movb $0x1, -0x1(%rbp)
jmp 0x2f030
jmp 0x2f018
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
cmpq -0x38(%rbp), %rax
jne 0x2eff1
jmp 0x2f02c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
| pagecache_delete_pages:
push rbp
mov rbp, rsp
sub rsp, 40h
mov al, r9b
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov [rbp+var_28], r8d
mov [rbp+var_29], al
jmp short $+2
loc_2EFE3:
mov rax, [rbp+var_20]
mov ecx, [rbp+var_24]
add rax, rcx
mov [rbp+var_38], rax
loc_2EFF1:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov ecx, [rbp+var_28]
movsx r8d, [rbp+var_29]
call pagecache_delete
cmp al, 0
jz short loc_2F016
jmp short $+2
loc_2F010:
mov [rbp+var_1], 1
jmp short loc_2F030
loc_2F016:
jmp short $+2
loc_2F018:
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
cmp rax, [rbp+var_38]
jnz short loc_2EFF1
jmp short $+2
loc_2F02C:
mov [rbp+var_1], 0
loc_2F030:
mov al, [rbp+var_1]
add rsp, 40h
pop rbp
retn
| char pagecache_delete_pages(_QWORD *a1, long long a2, long long a3, unsigned int a4, unsigned int a5, bool a6)
{
long long v7; // [rsp+8h] [rbp-38h]
long long v10; // [rsp+20h] [rbp-20h]
v10 = a3;
v7 = a4 + a3;
do
{
if ( pagecache_delete(a1, a2, v10, a5, a6) )
return 1;
++v10;
}
while ( v10 != v7 );
return 0;
}
| pagecache_delete_pages:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV AL,R9B
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV dword ptr [RBP + -0x28],R8D
MOV byte ptr [RBP + -0x29],AL
JMP 0x0012efe3
LAB_0012efe3:
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x24]
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
LAB_0012eff1:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x28]
MOVSX R8D,byte ptr [RBP + -0x29]
CALL 0x0012ecd0
CMP AL,0x0
JZ 0x0012f016
JMP 0x0012f010
LAB_0012f010:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0012f030
LAB_0012f016:
JMP 0x0012f018
LAB_0012f018:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,qword ptr [RBP + -0x38]
JNZ 0x0012eff1
JMP 0x0012f02c
LAB_0012f02c:
MOV byte ptr [RBP + -0x1],0x0
LAB_0012f030:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x40
POP RBP
RET
|
int1
pagecache_delete_pages
(int8 param_1,int8 param_2,long param_3,uint param_4,int4 param_5,
char param_6)
{
char cVar1;
long local_28;
local_28 = param_3;
do {
cVar1 = pagecache_delete(param_1,param_2,local_28,param_5,(int)param_6);
if (cVar1 != '\0') {
return 1;
}
local_28 = local_28 + 1;
} while (local_28 != param_3 + (ulong)param_4);
return 0;
}
| |
41,517 | Item_sum_avg::val_decimal(my_decimal*) | eloqsql/sql/item_sum.cc | my_decimal *Item_sum_avg::val_decimal(my_decimal *val)
{
my_decimal cnt;
const my_decimal *sum_dec;
DBUG_ASSERT(fixed());
if (aggr)
aggr->endup();
if (!count)
{
null_value=1;
return NULL;
}
/*
For non-DECIMAL result_type() the division will be done in
Item_sum_avg::val_real().
*/
if (result_type() != DECIMAL_RESULT)
return val_decimal_from_real(val);
sum_dec= dec_buffs + curr_dec_buff;
int2my_decimal(E_DEC_FATAL_ERROR, count, 0, &cnt);
my_decimal_div(E_DEC_FATAL_ERROR, val, sum_dec, &cnt, prec_increment);
return val;
} | O0 | cpp | Item_sum_avg::val_decimal(my_decimal*):
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x58(%rbp)
movq %rsi, -0x60(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4a2fa0
jmp 0x9c6cb3
jmp 0x9c6cb5
movq -0x80(%rbp), %rax
cmpq $0x0, 0xa0(%rax)
je 0x9c6cf5
movq -0x80(%rbp), %rax
movq 0xa0(%rax), %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
callq *%rax
jmp 0x9c6cd9
jmp 0x9c6cf5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4a2fc0
jmp 0x9c6e00
movq -0x80(%rbp), %rax
cmpq $0x0, 0x1f8(%rax)
jne 0x9c6d1f
movq -0x80(%rbp), %rax
movb $0x1, 0x64(%rax)
movq $0x0, -0x50(%rbp)
movl $0x1, -0x78(%rbp)
jmp 0x9c6dca
movq -0x80(%rbp), %rdi
callq 0x4c24f0
movl %eax, -0x84(%rbp)
jmp 0x9c6d30
movl -0x84(%rbp), %eax
cmpl $0x4, %eax
je 0x9c6d65
movq -0x80(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x8f3610
movq %rax, -0x90(%rbp)
jmp 0x9c6d51
movq -0x90(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x1, -0x78(%rbp)
jmp 0x9c6dca
movq -0x80(%rbp), %rax
movl 0x1e8(%rax), %ecx
shlq $0x6, %rcx
leaq 0x168(%rax,%rcx), %rcx
movq %rcx, -0x68(%rbp)
movq 0x1f8(%rax), %rsi
movl $0x1e, %edi
xorl %edx, %edx
leaq -0x48(%rbp), %rcx
callq 0x793b40
jmp 0x9c6d98
movq -0x80(%rbp), %rax
movq -0x60(%rbp), %rsi
movq -0x68(%rbp), %rdx
movl 0x200(%rax), %r8d
movl $0x1e, %edi
leaq -0x48(%rbp), %rcx
callq 0x96a300
jmp 0x9c6dbb
movq -0x60(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x1, -0x78(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4a2fc0
movq -0x50(%rbp), %rax
movq %rax, -0x98(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x9c6e29
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x9c6e29
movq -0xa0(%rbp), %rdi
callq 0x433ff0
callq 0x433650
nop
| _ZN12Item_sum_avg11val_decimalEP10my_decimal:
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov rax, [rbp+var_58]
mov [rbp+var_80], rax
lea rdi, [rbp+var_48]; this
call _ZN10my_decimalC2Ev; my_decimal::my_decimal(void)
jmp short $+2
loc_9C6CB3:
jmp short $+2
loc_9C6CB5:
mov rax, [rbp+var_80]
cmp qword ptr [rax+0A0h], 0
jz short loc_9C6CF5
mov rax, [rbp+var_80]
mov rdi, [rax+0A0h]
mov rax, [rdi]
mov rax, [rax+30h]
call rax
jmp short $+2
loc_9C6CD9:
jmp short loc_9C6CF5
mov rcx, rax
mov eax, edx
mov [rbp+var_70], rcx
mov [rbp+var_74], eax
lea rdi, [rbp+var_48]; void *
call _ZN10my_decimalD2Ev; my_decimal::~my_decimal()
jmp loc_9C6E00
loc_9C6CF5:
mov rax, [rbp+var_80]
cmp qword ptr [rax+1F8h], 0
jnz short loc_9C6D1F
mov rax, [rbp+var_80]
mov byte ptr [rax+64h], 1
mov [rbp+var_50], 0
mov [rbp+var_78], 1
jmp loc_9C6DCA
loc_9C6D1F:
mov rdi, [rbp+var_80]; this
call _ZNK4Item11result_typeEv; Item::result_type(void)
mov [rbp+var_84], eax
jmp short $+2
loc_9C6D30:
mov eax, [rbp+var_84]
cmp eax, 4
jz short loc_9C6D65
mov rdi, [rbp+var_80]; this
mov rsi, [rbp+var_60]; my_decimal *
call _ZN4Item21val_decimal_from_realEP10my_decimal; Item::val_decimal_from_real(my_decimal *)
mov [rbp+var_90], rax
jmp short $+2
loc_9C6D51:
mov rax, [rbp+var_90]
mov [rbp+var_50], rax
mov [rbp+var_78], 1
jmp short loc_9C6DCA
loc_9C6D65:
mov rax, [rbp+var_80]
mov ecx, [rax+1E8h]
shl rcx, 6
lea rcx, [rax+rcx+168h]
mov [rbp+var_68], rcx
mov rsi, [rax+1F8h]; __int64
mov edi, 1Eh; unsigned int
xor edx, edx; char
lea rcx, [rbp+var_48]; my_decimal *
call _Z14int2my_decimaljxcP10my_decimal; int2my_decimal(uint,long long,char,my_decimal *)
jmp short $+2
loc_9C6D98:
mov rax, [rbp+var_80]
mov rsi, [rbp+var_60]; my_decimal *
mov rdx, [rbp+var_68]; my_decimal *
mov r8d, [rax+200h]; int
mov edi, 1Eh; unsigned int
lea rcx, [rbp+var_48]; my_decimal *
call _Z14my_decimal_divjP10my_decimalPKS_S2_i; my_decimal_div(uint,my_decimal *,my_decimal const*,my_decimal const*,int)
jmp short $+2
loc_9C6DBB:
mov rax, [rbp+var_60]
mov [rbp+var_50], rax
mov [rbp+var_78], 1
loc_9C6DCA:
lea rdi, [rbp+var_48]; void *
call _ZN10my_decimalD2Ev; my_decimal::~my_decimal()
mov rax, [rbp+var_50]
mov [rbp+var_98], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_9C6E29
mov rax, [rbp+var_98]
add rsp, 0A0h
pop rbp
retn
loc_9C6E00:
mov rax, [rbp+var_70]
mov [rbp+var_A0], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_9C6E29
mov rdi, [rbp+var_A0]
call __Unwind_Resume
loc_9C6E29:
call ___stack_chk_fail
| my_decimal * Item_sum_avg::val_decimal(Item_sum_avg *this, my_decimal *a2)
{
my_decimal *v3; // [rsp+38h] [rbp-68h]
my_decimal *v4; // [rsp+50h] [rbp-50h]
_BYTE v5[64]; // [rsp+58h] [rbp-48h] BYREF
unsigned long long v6; // [rsp+98h] [rbp-8h]
v6 = __readfsqword(0x28u);
my_decimal::my_decimal((my_decimal *)v5);
if ( *((_QWORD *)this + 20) )
(*(void ( **)(_QWORD))(**((_QWORD **)this + 20) + 48LL))(*((_QWORD *)this + 20));
if ( *((_QWORD *)this + 63) )
{
if ( (unsigned int)Item::result_type(this) == 4 )
{
v3 = (Item_sum_avg *)((char *)this + 64 * (unsigned long long)*((unsigned int *)this + 122) + 360);
int2my_decimal(30, *((_QWORD *)this + 63), 0, (my_decimal *)v5);
my_decimal_div(30, a2, v3, (const my_decimal *)v5, *((_DWORD *)this + 128));
v4 = a2;
}
else
{
v4 = Item::val_decimal_from_real(this, a2);
}
}
else
{
*((_BYTE *)this + 100) = 1;
v4 = 0LL;
}
my_decimal::~my_decimal((my_decimal *)v5);
return v4;
}
| fix_attributes_real:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RAX + 0x8],0x0
JNZ 0x009c6cba
MOV RAX,qword ptr [RBP + -0x20]
CMP word ptr [RAX + 0x28],0x0
JNZ 0x009c6cba
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x14]
MOV qword ptr [RAX + 0x8],RCX
MOV word ptr [RAX + 0x28],0x27
LAB_009c6cba:
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RCX + 0x8]
MOVZX ECX,word ptr [RCX + 0x28]
CMP RAX,RCX
JNC 0x009c6cf6
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,word ptr [RAX + 0x28]
CMP EAX,0x27
JZ 0x009c6cf6
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RAX + 0x38]
MOV EDI,0x593
XOR EAX,EAX
MOV ESI,EAX
MOV AL,0x0
CALL 0x00d12b50
MOV byte ptr [RBP + -0x1],0x1
JMP 0x009c6d52
LAB_009c6cf6:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,word ptr [RAX + 0x28]
CMP EAX,0x27
JZ 0x009c6d3a
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,word ptr [RAX + 0x28]
CMP EAX,0x1f
JL 0x009c6d3a
MOV RAX,qword ptr [RBP + -0x20]
MOVZX ECX,word ptr [RAX + 0x28]
MOV EDX,ECX
MOV RCX,qword ptr [RAX + 0x38]
MOV EDI,0x591
XOR EAX,EAX
MOV ESI,EAX
MOV R8D,0x1e
MOV AL,0x0
CALL 0x00d12b50
MOV byte ptr [RBP + -0x1],0x1
JMP 0x009c6d52
LAB_009c6d3a:
MOV RDI,qword ptr [RBP + -0x20]
MOV ESI,0x59f
MOV EDX,0xff
CALL 0x009c6bc0
AND AL,0x1
MOV byte ptr [RBP + -0x1],AL
LAB_009c6d52:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0x20
POP RBP
RET
|
/* Column_definition::fix_attributes_real(unsigned int) */
byte __thiscall Column_definition::fix_attributes_real(Column_definition *this,uint param_1)
{
byte local_9;
if ((*(long *)(this + 8) == 0) && (*(short *)(this + 0x28) == 0)) {
*(ulong *)(this + 8) = (ulong)param_1;
*(int2 *)(this + 0x28) = 0x27;
}
if ((*(ulong *)(this + 8) < (ulong)*(ushort *)(this + 0x28)) && (*(short *)(this + 0x28) != 0x27))
{
my_error(0x593,0,*(int8 *)(this + 0x38));
local_9 = 1;
}
else if ((*(short *)(this + 0x28) == 0x27) || (*(ushort *)(this + 0x28) < 0x1f)) {
local_9 = check_length(this,0x59f,0xff);
local_9 = local_9 & 1;
}
else {
my_error(0x591,0,*(int2 *)(this + 0x28),*(int8 *)(this + 0x38),0x1e);
local_9 = 1;
}
return local_9;
}
| |
41,518 | srw_lock_impl<true>::psi_rd_lock(char const*, unsigned int) | eloqsql/storage/innobase/sync/srw_lock.cc | void srw_lock_impl<spinloop>::psi_rd_lock(const char *file, unsigned line)
{
PSI_rwlock_locker_state state;
const bool nowait= lock.rd_lock_try();
if (PSI_rwlock_locker *locker= PSI_RWLOCK_CALL(start_rwlock_rdwait)
(&state, pfs_psi,
nowait ? PSI_RWLOCK_TRYREADLOCK : PSI_RWLOCK_READLOCK, file, line))
{
if (!nowait)
lock.rd_lock();
PSI_RWLOCK_CALL(end_rwlock_rdwait)(locker, 0);
}
else if (!nowait)
lock.rd_lock();
} | O3 | cpp | srw_lock_impl<true>::psi_rd_lock(char const*, unsigned int):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %r8d
movq %rsi, %rcx
movq %rdi, %rbx
xorl %eax, %eax
xorl %edx, %edx
leal 0x1(%rax), %esi
lock
cmpxchgl %esi, 0xc(%rbx)
sete %r13b
je 0x25ccc
testl %eax, %eax
jns 0x25cba
leaq 0x8(%rbx), %r14
leaq 0x2c9b59(%rip), %r12 # 0x2ef830
movq (%r12), %rax
movq (%rbx), %rsi
movb %r13b, %dl
addl %edx, %edx
leaq -0x58(%rbp), %rdi
callq *0x1a0(%rax)
testq %rax, %rax
je 0x25d2a
movq %rax, %r15
testb %r13b, %r13b
jne 0x25d19
xorl %eax, %eax
leal 0x1(%rax), %ecx
lock
cmpxchgl %ecx, 0xc(%rbx)
sete %cl
je 0x25d0d
testl %eax, %eax
jns 0x25cfc
testb %cl, %cl
jne 0x25d19
movq %r14, %rdi
callq 0x2599a
movq (%r12), %rax
movq %r15, %rdi
xorl %esi, %esi
callq *0x1a8(%rax)
jmp 0x25d4e
testb %r13b, %r13b
jne 0x25d4e
xorl %eax, %eax
leal 0x1(%rax), %ecx
lock
cmpxchgl %ecx, 0xc(%rbx)
sete %cl
je 0x25d42
testl %eax, %eax
jns 0x25d31
testb %cl, %cl
jne 0x25d4e
movq %r14, %rdi
callq 0x2599a
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| _ZN13srw_lock_implILb1EE11psi_rd_lockEPKcj:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r8d, edx
mov rcx, rsi
mov rbx, rdi
xor eax, eax
xor edx, edx
loc_25CBA:
lea esi, [rax+1]
lock cmpxchg [rbx+0Ch], esi
setz r13b
jz short loc_25CCC
test eax, eax
jns short loc_25CBA
loc_25CCC:
lea r14, [rbx+8]
lea r12, PSI_server
mov rax, [r12]
mov rsi, [rbx]
mov dl, r13b
add edx, edx
lea rdi, [rbp+var_58]
call qword ptr [rax+1A0h]
test rax, rax
jz short loc_25D2A
mov r15, rax
test r13b, r13b
jnz short loc_25D19
xor eax, eax
loc_25CFC:
lea ecx, [rax+1]
lock cmpxchg [rbx+0Ch], ecx
setz cl
jz short loc_25D0D
test eax, eax
jns short loc_25CFC
loc_25D0D:
test cl, cl
jnz short loc_25D19
mov rdi, r14
call _ZN14ssux_lock_implILb1EE7rd_waitEv; ssux_lock_impl<true>::rd_wait(void)
loc_25D19:
mov rax, [r12]
mov rdi, r15
xor esi, esi
call qword ptr [rax+1A8h]
jmp short loc_25D4E
loc_25D2A:
test r13b, r13b
jnz short loc_25D4E
xor eax, eax
loc_25D31:
lea ecx, [rax+1]
lock cmpxchg [rbx+0Ch], ecx
setz cl
jz short loc_25D42
test eax, eax
jns short loc_25D31
loc_25D42:
test cl, cl
jnz short loc_25D4E
mov rdi, r14
call _ZN14ssux_lock_implILb1EE7rd_waitEv; ssux_lock_impl<true>::rd_wait(void)
loc_25D4E:
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long srw_lock_impl<true>::psi_rd_lock(long long a1, long long a2, unsigned int a3)
{
long long v3; // r8
signed __int32 v4; // eax
int v5; // edx
signed __int32 v6; // ett
bool v7; // r13
long long result; // rax
long long v9; // r15
signed __int32 v10; // eax
signed __int32 v11; // ett
bool v12; // cl
int v13; // ett
bool v14; // cl
_BYTE v15[88]; // [rsp+8h] [rbp-58h] BYREF
v3 = a3;
v4 = 0;
v5 = 0;
do
{
v6 = v4;
v4 = _InterlockedCompareExchange((volatile signed __int32 *)(a1 + 12), v4 + 1, v4);
v7 = v6 == v4;
}
while ( v6 != v4 && v4 >= 0 );
LOBYTE(v5) = v7;
result = ((long long ( *)(_BYTE *, _QWORD, _QWORD, long long, long long))PSI_server[52])(
v15,
*(_QWORD *)a1,
(unsigned int)(2 * v5),
a2,
v3);
if ( result )
{
v9 = result;
if ( !v7 )
{
v10 = 0;
do
{
v11 = v10;
v10 = _InterlockedCompareExchange((volatile signed __int32 *)(a1 + 12), v10 + 1, v10);
v12 = v11 == v10;
}
while ( v11 != v10 && v10 >= 0 );
if ( !v12 )
ssux_lock_impl<true>::rd_wait((volatile signed __int32 *)(a1 + 8));
}
return ((long long ( *)(long long, _QWORD))PSI_server[53])(v9, 0LL);
}
else if ( !v7 )
{
LODWORD(result) = 0;
do
{
v13 = result;
result = (unsigned int)_InterlockedCompareExchange((volatile signed __int32 *)(a1 + 12), result + 1, result);
v14 = v13 == (_DWORD)result;
}
while ( v13 != (_DWORD)result && (int)result >= 0 );
if ( !v14 )
return ssux_lock_impl<true>::rd_wait((volatile signed __int32 *)(a1 + 8));
}
return result;
}
| psi_rd_lock:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R8D,EDX
MOV RCX,RSI
MOV RBX,RDI
XOR EAX,EAX
XOR EDX,EDX
LAB_00125cba:
LEA ESI,[RAX + 0x1]
CMPXCHG.LOCK dword ptr [RBX + 0xc],ESI
SETZ R13B
JZ 0x00125ccc
TEST EAX,EAX
JNS 0x00125cba
LAB_00125ccc:
LEA R14,[RBX + 0x8]
LEA R12,[0x3ef830]
MOV RAX,qword ptr [R12]
MOV RSI,qword ptr [RBX]
MOV DL,R13B
ADD EDX,EDX
LEA RDI,[RBP + -0x58]
CALL qword ptr [RAX + 0x1a0]
TEST RAX,RAX
JZ 0x00125d2a
MOV R15,RAX
TEST R13B,R13B
JNZ 0x00125d19
XOR EAX,EAX
LAB_00125cfc:
LEA ECX,[RAX + 0x1]
CMPXCHG.LOCK dword ptr [RBX + 0xc],ECX
SETZ CL
JZ 0x00125d0d
TEST EAX,EAX
JNS 0x00125cfc
LAB_00125d0d:
TEST CL,CL
JNZ 0x00125d19
MOV RDI,R14
CALL 0x0012599a
LAB_00125d19:
MOV RAX,qword ptr [R12]
MOV RDI,R15
XOR ESI,ESI
CALL qword ptr [RAX + 0x1a8]
JMP 0x00125d4e
LAB_00125d2a:
TEST R13B,R13B
JNZ 0x00125d4e
XOR EAX,EAX
LAB_00125d31:
LEA ECX,[RAX + 0x1]
CMPXCHG.LOCK dword ptr [RBX + 0xc],ECX
SETZ CL
JZ 0x00125d42
TEST EAX,EAX
JNS 0x00125d31
LAB_00125d42:
TEST CL,CL
JNZ 0x00125d4e
MOV RDI,R14
CALL 0x0012599a
LAB_00125d4e:
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* srw_lock_impl<true>::psi_rd_lock(char const*, unsigned int) */
void __thiscall
srw_lock_impl<true>::psi_rd_lock(srw_lock_impl<true> *this,char *param_1,uint param_2)
{
int iVar1;
int iVar2;
long lVar3;
bool bVar4;
int1 local_60 [48];
iVar2 = 0;
do {
LOCK();
iVar1 = *(int *)(this + 0xc);
bVar4 = iVar2 == iVar1;
if (bVar4) {
*(int *)(this + 0xc) = iVar2 + 1;
iVar1 = iVar2;
}
iVar2 = iVar1;
UNLOCK();
} while ((!bVar4) && (-1 < iVar2));
lVar3 = (**(code **)(PSI_server + 0x1a0))
(local_60,*(int8 *)this,bVar4 * '\x02',param_1,param_2);
if (lVar3 == 0) {
if (!bVar4) {
iVar2 = 0;
do {
LOCK();
iVar1 = *(int *)(this + 0xc);
bVar4 = iVar2 == iVar1;
if (bVar4) {
*(int *)(this + 0xc) = iVar2 + 1;
iVar1 = iVar2;
}
iVar2 = iVar1;
UNLOCK();
} while ((!bVar4) && (-1 < iVar2));
if (!bVar4) {
ssux_lock_impl<true>::rd_wait((ssux_lock_impl<true> *)(this + 8));
}
}
}
else {
if (!bVar4) {
iVar2 = 0;
do {
LOCK();
iVar1 = *(int *)(this + 0xc);
bVar4 = iVar2 == iVar1;
if (bVar4) {
*(int *)(this + 0xc) = iVar2 + 1;
iVar1 = iVar2;
}
iVar2 = iVar1;
UNLOCK();
} while ((!bVar4) && (-1 < iVar2));
if (!bVar4) {
ssux_lock_impl<true>::rd_wait((ssux_lock_impl<true> *)(this + 8));
}
}
(**(code **)(PSI_server + 0x1a8))(lVar3,0);
}
return;
}
| |
41,519 | list_free | eloqsql/mysys/list.c | void list_free(LIST *root, uint free_data)
{
LIST *next;
while (root)
{
next=root->next;
if (free_data)
my_free(root->data);
my_free(root);
root=next;
}
} | O3 | c | list_free:
testq %rdi, %rdi
je 0x9436e
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x8(%r14), %r15
testl %ebx, %ebx
je 0x94354
movq 0x10(%r14), %rdi
callq 0x9fb2e
movq %r14, %rdi
callq 0x9fb2e
movq %r15, %r14
testq %r15, %r15
jne 0x94343
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| list_free:
test rdi, rdi
jz short locret_9436E
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov ebx, esi
mov r14, rdi
loc_94343:
mov r15, [r14+8]
test ebx, ebx
jz short loc_94354
mov rdi, [r14+10h]
call my_free
loc_94354:
mov rdi, r14
call my_free
mov r14, r15
test r15, r15
jnz short loc_94343
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
locret_9436E:
retn
| long long list_free(long long a1, int a2)
{
long long v2; // r14
long long v3; // r15
long long result; // rax
if ( a1 )
{
v2 = a1;
do
{
v3 = *(_QWORD *)(v2 + 8);
if ( a2 )
my_free(*(_QWORD *)(v2 + 16));
result = my_free(v2);
v2 = v3;
}
while ( v3 );
}
return result;
}
| list_free:
TEST RDI,RDI
JZ 0x0019436e
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EBX,ESI
MOV R14,RDI
LAB_00194343:
MOV R15,qword ptr [R14 + 0x8]
TEST EBX,EBX
JZ 0x00194354
MOV RDI,qword ptr [R14 + 0x10]
CALL 0x0019fb2e
LAB_00194354:
MOV RDI,R14
CALL 0x0019fb2e
MOV R14,R15
TEST R15,R15
JNZ 0x00194343
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
LAB_0019436e:
RET
|
void list_free(long param_1,int param_2)
{
long lVar1;
if (param_1 != 0) {
do {
lVar1 = *(long *)(param_1 + 8);
if (param_2 != 0) {
my_free(*(int8 *)(param_1 + 0x10));
}
my_free(param_1);
param_1 = lVar1;
} while (lVar1 != 0);
}
return;
}
| |
41,520 | LEX_MASTER_INFO::init() | eloqsql/sql/sql_lex.h | void init()
{
bzero(this, sizeof(*this));
my_init_dynamic_array(PSI_INSTRUMENT_ME, &repl_ignore_server_ids,
sizeof(::server_id), 0, 16, MYF(0));
my_init_dynamic_array(PSI_INSTRUMENT_ME, &repl_do_domain_ids,
sizeof(ulong), 0, 16, MYF(0));
my_init_dynamic_array(PSI_INSTRUMENT_ME, &repl_ignore_domain_ids,
sizeof(ulong), 0, 16, MYF(0));
sql_delay= -1;
} | O0 | c | LEX_MASTER_INFO::init():
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
xorl %esi, %esi
movl $0x140, %edx # imm = 0x140
callq 0x433730
movq -0x10(%rbp), %rsi
xorl %r8d, %r8d
movl $0x8, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x10, %r9d
movl %r8d, %edi
movq $0x0, (%rsp)
callq 0xbf79e0
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
xorl %r8d, %r8d
movl $0x8, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x10, %r9d
movl %r8d, %edi
movq $0x0, (%rsp)
callq 0xbf79e0
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
xorl %r8d, %r8d
movl $0x8, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x10, %r9d
movl %r8d, %edi
movq $0x0, (%rsp)
callq 0xbf79e0
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x11c(%rax) # imm = 0xFFFFFFFF
addq $0x20, %rsp
popq %rbp
retq
nop
| _ZN15LEX_MASTER_INFO4initEv:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]
mov [rbp+var_10], rdi
xor esi, esi
mov edx, 140h
call _memset
mov rsi, [rbp+var_10]
xor r8d, r8d
mov edx, 8
xor eax, eax
mov ecx, eax
mov r9d, 10h
mov edi, r8d
mov [rsp+20h+var_20], 0
call init_dynamic_array2
mov rsi, [rbp+var_10]
add rsi, 28h ; '('
xor r8d, r8d
mov edx, 8
xor eax, eax
mov ecx, eax
mov r9d, 10h
mov edi, r8d
mov [rsp+20h+var_20], 0
call init_dynamic_array2
mov rsi, [rbp+var_10]
add rsi, 50h ; 'P'
xor r8d, r8d
mov edx, 8
xor eax, eax
mov ecx, eax
mov r9d, 10h
mov edi, r8d
mov [rsp+20h+var_20], 0
call init_dynamic_array2
mov rax, [rbp+var_10]
mov dword ptr [rax+11Ch], 0FFFFFFFFh
add rsp, 20h
pop rbp
retn
| LEX_MASTER_INFO * LEX_MASTER_INFO::init(LEX_MASTER_INFO *this)
{
LEX_MASTER_INFO *result; // rax
memset(this, 0LL, 320LL);
init_dynamic_array2(0, (_DWORD)this, 8, 0, 0, 16, 0LL);
init_dynamic_array2(0, (_DWORD)this + 40, 8, 0, 0, 16, 0LL);
init_dynamic_array2(0, (_DWORD)this + 80, 8, 0, 0, 16, 0LL);
result = this;
*((_DWORD *)this + 71) = -1;
return result;
}
| operator!=:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x005a06d0
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x005a06d0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RCX]
SETNZ AL
AND AL,0x1
ADD RSP,0x20
POP RBP
RET
|
/* bool __gnu_cxx::TEMPNAMEPLACEHOLDERVALUE(__gnu_cxx::__normal_iterator<unsigned long long*,
std::vector<unsigned long long, std::allocator<unsigned long long> > > const&,
__gnu_cxx::__normal_iterator<unsigned long long*, std::vector<unsigned long long,
std::allocator<unsigned long long> > > const&) */
bool __gnu_cxx::operator!=(__normal_iterator *param_1,__normal_iterator *param_2)
{
long lVar1;
long *plVar2;
plVar2 = (long *)__normal_iterator<unsigned_long_long*,std::vector<unsigned_long_long,std::allocator<unsigned_long_long>>>
::base((__normal_iterator<unsigned_long_long*,std::vector<unsigned_long_long,std::allocator<unsigned_long_long>>>
*)param_1);
lVar1 = *plVar2;
plVar2 = (long *)__normal_iterator<unsigned_long_long*,std::vector<unsigned_long_long,std::allocator<unsigned_long_long>>>
::base((__normal_iterator<unsigned_long_long*,std::vector<unsigned_long_long,std::allocator<unsigned_long_long>>>
*)param_2);
return lVar1 != *plVar2;
}
| |
41,521 | glfwPlatformWindowHovered | untodesu[P]riteg/build_O2/_deps/glfw-src/src/x11_window.c | int _glfwPlatformWindowHovered(_GLFWwindow* window)
{
Window w = _glfw.x11.root;
while (w)
{
Window root;
int rootX, rootY, childX, childY;
unsigned int mask;
if (!XQueryPointer(_glfw.x11.display, w,
&root, &w, &rootX, &rootY, &childX, &childY, &mask))
{
return GLFW_FALSE;
}
if (w == window->x11.handle)
return GLFW_TRUE;
}
return GLFW_FALSE;
} | O2 | c | glfwPlatformWindowHovered:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x7c41e(%rip), %rax # 0x9b648
movq 0x1fed0(%rax), %rsi
movq %rsp, %r14
movq %rsi, (%r14)
leaq 0x20(%rsp), %r15
leaq 0x1c(%rsp), %r12
leaq 0x18(%rsp), %r13
xorl %ebp, %ebp
testq %rsi, %rsi
je 0x1f29a
leaq 0x7c3f4(%rip), %rax # 0x9b648
movq 0x1fec0(%rax), %rdi
subq $0x8, %rsp
movq %r15, %rdx
movq %r14, %rcx
movq %r12, %r8
movq %r13, %r9
leaq 0x14(%rsp), %rax
pushq %rax
leaq 0x20(%rsp), %rax
pushq %rax
leaq 0x2c(%rsp), %rax
pushq %rax
callq 0xb980
addq $0x20, %rsp
testl %eax, %eax
je 0x1f29a
movq (%rsp), %rsi
cmpq 0x348(%rbx), %rsi
jne 0x1f248
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _glfwPlatformWindowHovered:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, rdi
lea rax, _glfw
mov rsi, [rax+1FED0h]
mov r14, rsp
mov [r14], rsi
lea r15, [rsp+58h+var_38]
lea r12, [rsp+58h+var_3C]
lea r13, [rsp+58h+var_40]
xor ebp, ebp
loc_1F248:
test rsi, rsi
jz short loc_1F29A
lea rax, _glfw
mov rdi, [rax+1FEC0h]
sub rsp, 8
mov rdx, r15
mov rcx, r14
mov r8, r12
mov r9, r13
lea rax, [rsp+60h+var_4C]
push rax
lea rax, [rsp+68h+var_48]
push rax
lea rax, [rsp+70h+var_44]
push rax
call _XQueryPointer
add rsp, 20h
test eax, eax
jz short loc_1F29A
mov rsi, [rsp+58h+var_58]
cmp rsi, [rbx+348h]
jnz short loc_1F248
push 1
pop rbp
loc_1F29A:
mov eax, ebp
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long glfwPlatformWindowHovered(long long a1)
{
long long v1; // rsi
unsigned int v2; // ebp
long long v4; // [rsp+0h] [rbp-58h] BYREF
_BYTE v5[4]; // [rsp+Ch] [rbp-4Ch] BYREF
_BYTE v6[4]; // [rsp+10h] [rbp-48h] BYREF
_BYTE v7[4]; // [rsp+14h] [rbp-44h] BYREF
_BYTE v8[4]; // [rsp+18h] [rbp-40h] BYREF
_BYTE v9[4]; // [rsp+1Ch] [rbp-3Ch] BYREF
_BYTE v10[56]; // [rsp+20h] [rbp-38h] BYREF
v1 = *(_QWORD *)&glfw[32692];
v4 = v1;
v2 = 0;
while ( v1 && (unsigned int)XQueryPointer(*(_QWORD *)&glfw[32688], v1, v10, &v4, v9, v8, v7, v6, v5) )
{
v1 = v4;
if ( v4 == *(_QWORD *)(a1 + 840) )
return 1;
}
return v2;
}
| _glfwPlatformWindowHovered:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
LEA RAX,[0x19b648]
MOV RSI,qword ptr [RAX + 0x1fed0]
MOV R14,RSP
MOV qword ptr [R14],RSI
LEA R15,[RSP + 0x20]
LEA R12,[RSP + 0x1c]
LEA R13,[RSP + 0x18]
XOR EBP,EBP
LAB_0011f248:
TEST RSI,RSI
JZ 0x0011f29a
LEA RAX,[0x19b648]
MOV RDI,qword ptr [RAX + 0x1fec0]
SUB RSP,0x8
MOV RDX,R15
MOV RCX,R14
MOV R8,R12
MOV R9,R13
LEA RAX,[RSP + 0x14]
PUSH RAX
LEA RAX,[RSP + 0x20]
PUSH RAX
LEA RAX,[RSP + 0x2c]
PUSH RAX
CALL 0x0010b980
ADD RSP,0x20
TEST EAX,EAX
JZ 0x0011f29a
MOV RSI,qword ptr [RSP]
CMP RSI,qword ptr [RBX + 0x348]
JNZ 0x0011f248
PUSH 0x1
POP RBP
LAB_0011f29a:
MOV EAX,EBP
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 _glfwPlatformWindowHovered(long param_1)
{
int iVar1;
long local_58;
int1 local_4c [4];
int1 local_48 [4];
int1 local_44 [4];
int1 local_40 [4];
int1 local_3c [4];
int1 local_38 [8];
local_58 = DAT_001bb518;
while( true ) {
if (local_58 == 0) {
return 0;
}
iVar1 = XQueryPointer(DAT_001bb508,local_58,local_38,&local_58,local_3c,local_40,local_44,
local_48,local_4c);
if (iVar1 == 0) break;
if (local_58 == *(long *)(param_1 + 0x348)) {
return 1;
}
}
return 0;
}
| |
41,522 | void OpenSubdiv::v3_6_0::Far::convertToGregory<double>(OpenSubdiv::v3_6_0::Far::SourcePatch const&, OpenSubdiv::v3_6_0::Far::SparseMatrix<double>&) | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/loopPatchBuilder.cpp | void
convertToGregory(SourcePatch const & sourcePatch, SparseMatrix<REAL> & matrix) {
GregoryTriConverter<REAL> gregoryConverter(sourcePatch);
gregoryConverter.Convert(matrix);
} | O1 | cpp | void OpenSubdiv::v3_6_0::Far::convertToGregory<double>(OpenSubdiv::v3_6_0::Far::SourcePatch const&, OpenSubdiv::v3_6_0::Far::SparseMatrix<double>&):
pushq %r14
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rsi, %rbx
movq %rdi, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x3b750
movq %r14, %rdi
movq %rbx, %rsi
callq 0x39d20
xorl %ebx, %ebx
leaq (%rsp,%rbx), %r14
addq $0x1a8, %r14 # imm = 0x1A8
movq 0x78(%r14), %rdi
callq 0x3a0c0
movq %r14, -0x10(%r14)
movl $0x1e, -0x4(%r14)
addq $-0xb0, %rbx
cmpq $-0x210, %rbx # imm = 0xFDF0
jne 0x5986c
addq $0x228, %rsp # imm = 0x228
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3c8a0
movq %rbx, %rdi
callq 0x3bd70
| _ZN10OpenSubdiv6v3_6_03Far16convertToGregoryIdEEvRKNS1_11SourcePatchERNS1_12SparseMatrixIT_EE:
push r14
push rbx
sub rsp, 228h
mov rbx, rsi
mov rsi, rdi
mov r14, rsp
mov rdi, r14
call __ZN10OpenSubdiv6v3_6_03Far19GregoryTriConverterIdEC2ERKNS1_11SourcePatchE; OpenSubdiv::v3_6_0::Far::GregoryTriConverter<double>::GregoryTriConverter(OpenSubdiv::v3_6_0::Far::SourcePatch const&)
mov rdi, r14
mov rsi, rbx
call __ZNK10OpenSubdiv6v3_6_03Far19GregoryTriConverterIdE7ConvertERNS1_12SparseMatrixIdEE; OpenSubdiv::v3_6_0::Far::GregoryTriConverter<double>::Convert(OpenSubdiv::v3_6_0::Far::SparseMatrix<double> &)
xor ebx, ebx
loc_5986C:
lea r14, [rsp+rbx+238h+var_238]
add r14, 1A8h
mov rdi, [r14+78h]; void *
call __ZdlPv; operator delete(void *)
mov [r14-10h], r14
mov dword ptr [r14-4], 1Eh
add rbx, 0FFFFFFFFFFFFFF50h
cmp rbx, 0FFFFFFFFFFFFFDF0h
jnz short loc_5986C
add rsp, 228h
pop rbx
pop r14
retn
mov rbx, rax
mov rdi, rsp
call _ZN10OpenSubdiv6v3_6_03Far16convertToGregoryIdEEvRKNS1_11SourcePatchERNS1_12SparseMatrixIT_EE_cold_1; OpenSubdiv::v3_6_0::Far::convertToGregory<double>(OpenSubdiv::v3_6_0::Far::SourcePatch const&,OpenSubdiv::v3_6_0::Far::SparseMatrix<double> &) [clone]
mov rdi, rbx
call __Unwind_Resume
| void OpenSubdiv::v3_6_0::Far::convertToGregory<double>(long long a1, long long a2)
{
long long i; // rbx
_BYTE *v3; // r14
_BYTE v4[568]; // [rsp+0h] [rbp-238h] BYREF
OpenSubdiv::v3_6_0::Far::GregoryTriConverter<double>::GregoryTriConverter(v4, a1);
OpenSubdiv::v3_6_0::Far::GregoryTriConverter<double>::Convert(v4, a2);
for ( i = 0LL; i != -528; i -= 176LL )
{
v3 = &v4[i + 424];
operator delete(*(void **)&v4[i + 544]);
*((_QWORD *)v3 - 2) = v3;
*((_DWORD *)v3 - 1) = 30;
}
}
| convertToGregory<double>:
PUSH R14
PUSH RBX
SUB RSP,0x228
MOV RBX,RSI
MOV RSI,RDI
MOV R14,RSP
MOV RDI,R14
CALL 0x0013b750
LAB_0015985f:
MOV RDI,R14
MOV RSI,RBX
CALL 0x00139d20
LAB_0015986a:
XOR EBX,EBX
LAB_0015986c:
LEA R14,[RSP + RBX*0x1]
ADD R14,0x1a8
MOV RDI,qword ptr [R14 + 0x78]
CALL 0x0013a0c0
MOV qword ptr [R14 + -0x10],R14
MOV dword ptr [R14 + -0x4],0x1e
ADD RBX,-0xb0
CMP RBX,-0x210
JNZ 0x0015986c
ADD RSP,0x228
POP RBX
POP R14
RET
|
/* void OpenSubdiv::v3_6_0::Far::convertToGregory<double>(OpenSubdiv::v3_6_0::Far::SourcePatch
const&, OpenSubdiv::v3_6_0::Far::SparseMatrix<double>&) */
void OpenSubdiv::v3_6_0::Far::convertToGregory<double>(SourcePatch *param_1,SparseMatrix *param_2)
{
long lVar1;
GregoryTriConverter<double> local_238 [408];
int8 local_a0;
int4 local_94;
int1 auStack_90 [120];
int8 local_18;
GregoryTriConverter<double>::GregoryTriConverter(local_238,param_1);
/* try { // try from 0015985f to 00159869 has its CatchHandler @ 001598a7 */
GregoryTriConverter<double>::Convert(local_238,param_2);
lVar1 = 0;
do {
operator_delete(*(void **)((long)&local_18 + lVar1));
*(int1 **)((long)&local_a0 + lVar1) = auStack_90 + lVar1;
*(int4 *)((long)&local_94 + lVar1) = 0x1e;
lVar1 = lVar1 + -0xb0;
} while (lVar1 != -0x210);
return;
}
| |
41,523 | minja::Parser::parseStringConcat() | monkey531[P]llama/common/minja.hpp | std::shared_ptr<Expression> parseStringConcat() {
auto left = parseMathPow();
if (!left) throw std::runtime_error("Expected left side of 'string concat' expression");
static std::regex concat_tok(R"(~(?!\}))");
if (!consumeToken(concat_tok).empty()) {
auto right = parseLogicalAnd();
if (!right) throw std::runtime_error("Expected right side of 'string concat' expression");
left = std::make_shared<BinaryOpExpr>(get_location(), std::move(left), std::move(right), BinaryOpExpr::Op::StrConcat);
}
return left;
} | O2 | cpp | minja::Parser::parseStringConcat():
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x68c40
cmpq $0x0, (%rbx)
je 0x68ad1
leaq 0x9c749(%rip), %rax # 0x105168
movb (%rax), %al
testb %al, %al
je 0x68b06
leaq 0x9c718(%rip), %rdx # 0x105148
leaq 0x30(%rsp), %rdi
pushq $0x1
popq %rcx
movq %r14, %rsi
callq 0x65288
leaq 0x30(%rsp), %rdi
movq 0x8(%rdi), %r15
callq 0x25258
testq %r15, %r15
je 0x68ac4
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x6691a
cmpq $0x0, 0x8(%rsp)
je 0x68b5b
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x64e64
leaq 0x1c(%rsp), %r8
andl $0x0, (%r8)
leaq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rcx
movq %rbx, %rdx
callq 0x68df1
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x75c5a
leaq 0x28(%rsp), %rdi
callq 0x37354
leaq 0x38(%rsp), %rdi
callq 0x37354
leaq 0x10(%rsp), %rdi
callq 0x37354
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x24470
movq %rax, %r15
leaq 0x50473(%rip), %rsi # 0xb8f56
movq %rax, %rdi
callq 0x24330
movq 0x9b4fe(%rip), %rsi # 0x103ff0
movq 0x9b45f(%rip), %rdx # 0x103f58
movq %r15, %rdi
callq 0x24f50
jmp 0x68b8b
leaq 0x9c65b(%rip), %rdi # 0x105168
callq 0x25060
testl %eax, %eax
je 0x68a29
leaq 0x9c627(%rip), %rdi # 0x105148
leaq 0x5045f(%rip), %rsi # 0xb8f87
pushq $0x10
popq %rdx
callq 0x2b33e
leaq -0x3d743(%rip), %rdi # 0x2b3f4
leaq 0x9c60a(%rip), %rsi # 0x105148
leaq 0x9bdf3(%rip), %rdx # 0x104938
callq 0x24800
leaq 0x9c617(%rip), %rdi # 0x105168
callq 0x245f0
jmp 0x68a29
pushq $0x10
popq %rdi
callq 0x24470
movq %rax, %r15
leaq 0x50422(%rip), %rsi # 0xb8f8f
movq %rax, %rdi
callq 0x24330
movq 0x9b474(%rip), %rsi # 0x103ff0
movq 0x9b3d5(%rip), %rdx # 0x103f58
movq %r15, %rdi
callq 0x24f50
movq %rax, %r14
leaq 0x9c5d3(%rip), %rdi # 0x105168
callq 0x245e0
jmp 0x68bdd
jmp 0x68bc9
movq %rax, %r14
movq %r15, %rdi
callq 0x246b0
jmp 0x68bcc
jmp 0x68bda
movq %rax, %r14
movq %r15, %rdi
callq 0x246b0
jmp 0x68bdd
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x37354
jmp 0x68bcc
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x37354
jmp 0x68bdd
jmp 0x68bda
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x37354
movq %r14, %rdi
callq 0x24fe0
| _ZN5minja6Parser17parseStringConcatEv:
push r15
push r14
push rbx
sub rsp, 50h
mov r14, rsi
mov rbx, rdi
call _ZN5minja6Parser12parseMathPowEv; minja::Parser::parseMathPow(void)
cmp qword ptr [rbx], 0
jz loc_68AD1
lea rax, _ZGVZN5minja6Parser17parseStringConcatEvE10concat_tokB5cxx11; `guard variable for'minja::Parser::parseStringConcat(void)::concat_tok
mov al, [rax]
test al, al
jz loc_68B06
loc_68A29:
lea rdx, _ZZN5minja6Parser17parseStringConcatEvE10concat_tokB5cxx11; minja::Parser::parseStringConcat(void)::concat_tok
lea rdi, [rsp+68h+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+68h+var_38]; void *
mov r15, [rdi+8]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test r15, r15
jz short loc_68AC4
lea rdi, [rsp+68h+var_60]; this
mov rsi, r14
call _ZN5minja6Parser15parseLogicalAndEv; minja::Parser::parseLogicalAnd(void)
cmp [rsp+68h+var_60], 0
jz loc_68B5B
lea rdi, [rsp+68h+var_38]; this
mov rsi, r14
call _ZNK5minja6Parser12get_locationEv; minja::Parser::get_location(void)
lea r8, [rsp+68h+var_4C]
and dword ptr [r8], 0
lea rdi, [rsp+68h+var_48]
lea rsi, [rsp+68h+var_38]
lea rcx, [rsp+68h+var_60]
mov rdx, rbx
call _ZSt11make_sharedIN5minja12BinaryOpExprEJNS0_8LocationESt10shared_ptrINS0_10ExpressionEES5_NS1_2OpEEES3_IT_EDpOT0_; std::make_shared<minja::BinaryOpExpr,minja::Location,std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>,minja::BinaryOpExpr::Op>(minja::Location,std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>,minja::BinaryOpExpr::Op &&)
lea rsi, [rsp+68h+var_48]
mov rdi, rbx
call _ZNSt12__shared_ptrIN5minja10ExpressionELN9__gnu_cxx12_Lock_policyE2EEaSINS0_12BinaryOpExprEEENSt9enable_ifIXsr20__sp_compatible_withIPT_PS1_EE5valueERS4_E4typeEOS_IS8_LS3_2EE
lea rdi, [rsp+68h+var_40]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+68h+var_30]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+68h+var_58]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
loc_68AC4:
mov rax, rbx
add rsp, 50h
pop rbx
pop r14
pop r15
retn
loc_68AD1:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aExpectedLeftSi_2; "Expected left side of 'string concat' e"...
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
jmp loc_68B8B
loc_68B06:
lea rdi, _ZGVZN5minja6Parser17parseStringConcatEvE10concat_tokB5cxx11; __guard *
call ___cxa_guard_acquire
test eax, eax
jz loc_68A29
lea rdi, _ZZN5minja6Parser17parseStringConcatEvE10concat_tokB5cxx11; minja::Parser::parseStringConcat(void)::concat_tok
lea rsi, asc_B8F87; "~(?!\\})"
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, _ZZN5minja6Parser17parseStringConcatEvE10concat_tokB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN5minja6Parser17parseStringConcatEvE10concat_tokB5cxx11; __guard *
call ___cxa_guard_release
jmp loc_68A29
loc_68B5B:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aExpectedRightS_2; "Expected right side of 'string concat' "...
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
loc_68B8B:
mov r14, rax
lea rdi, _ZGVZN5minja6Parser17parseStringConcatEvE10concat_tokB5cxx11; __guard *
call ___cxa_guard_abort
jmp short loc_68BDD
jmp short loc_68BC9
mov r14, rax
mov rdi, r15; void *
call ___cxa_free_exception
jmp short loc_68BCC
jmp short loc_68BDA
mov r14, rax
mov rdi, r15; void *
call ___cxa_free_exception
jmp short loc_68BDD
mov r14, rax
lea rdi, [rsp+68h+var_30]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_68BCC
loc_68BC9:
mov r14, rax
loc_68BCC:
lea rdi, [rsp+68h+var_58]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_68BDD
jmp short $+2
loc_68BDA:
mov r14, rax
loc_68BDD:
add rbx, 8
mov rdi, rbx
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, r14
call __Unwind_Resume
| minja::Parser * minja::Parser::parseStringConcat(minja::Parser *this, _QWORD *a2)
{
long long v2; // r15
std::runtime_error *exception; // r15
std::runtime_error *v5; // r15
long long v6; // [rsp+8h] [rbp-60h] BYREF
long long v7; // [rsp+10h] [rbp-58h] BYREF
int v8; // [rsp+1Ch] [rbp-4Ch] BYREF
_BYTE v9[8]; // [rsp+20h] [rbp-48h] BYREF
long long v10; // [rsp+28h] [rbp-40h] BYREF
long long v11; // [rsp+30h] [rbp-38h] BYREF
_QWORD v12[6]; // [rsp+38h] [rbp-30h] BYREF
minja::Parser::parseMathPow(this);
if ( !*(_QWORD *)this )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expected left side of 'string concat' 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::parseStringConcat(void)::concat_tok[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseStringConcat(void)::concat_tok[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseStringConcat(void)::concat_tok[abi:cxx11],
(long long)"~(?!\\})",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseStringConcat(void)::concat_tok[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseStringConcat(void)::concat_tok[abi:cxx11]);
}
minja::Parser::consumeToken(
&v11,
(long long)a2,
(long long)&minja::Parser::parseStringConcat(void)::concat_tok[abi:cxx11],
1u);
v2 = v12[0];
std::string::~string(&v11);
if ( v2 )
{
minja::Parser::parseLogicalAnd((minja::Parser *)&v6, a2);
if ( !v6 )
{
v5 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v5, "Expected right side of 'string concat' expression");
__cxa_throw(
v5,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Parser::get_location((minja::Parser *)&v11, a2);
v8 = 0;
std::make_shared<minja::BinaryOpExpr,minja::Location,std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>,minja::BinaryOpExpr::Op>(
v9,
&v11,
this,
&v6,
&v8);
std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator=<minja::BinaryOpExpr>(this, v9);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v10);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v12);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v7);
}
return this;
}
| parseStringConcat:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV R14,RSI
MOV RBX,RDI
CALL 0x00168c40
CMP qword ptr [RBX],0x0
JZ 0x00168ad1
LEA RAX,[0x205168]
MOV AL,byte ptr [RAX]
TEST AL,AL
JZ 0x00168b06
LAB_00168a29:
LEA RDX,[0x205148]
LEA RDI,[RSP + 0x30]
PUSH 0x1
POP RCX
MOV RSI,R14
CALL 0x00165288
LEA RDI,[RSP + 0x30]
MOV R15,qword ptr [RDI + 0x8]
CALL 0x00125258
TEST R15,R15
JZ 0x00168ac4
LAB_00168a53:
LEA RDI,[RSP + 0x8]
MOV RSI,R14
CALL 0x0016691a
CMP qword ptr [RSP + 0x8],0x0
JZ 0x00168b5b
LAB_00168a6c:
LEA RDI,[RSP + 0x30]
MOV RSI,R14
CALL 0x00164e64
LEA R8,[RSP + 0x1c]
AND dword ptr [R8],0x0
LAB_00168a82:
LEA RDI,[RSP + 0x20]
LEA RSI,[RSP + 0x30]
LEA RCX,[RSP + 0x8]
MOV RDX,RBX
CALL 0x00168df1
LAB_00168a99:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x00175c5a
LEA RDI,[RSP + 0x28]
CALL 0x00137354
LEA RDI,[RSP + 0x38]
CALL 0x00137354
LEA RDI,[RSP + 0x10]
CALL 0x00137354
LAB_00168ac4:
MOV RAX,RBX
ADD RSP,0x50
POP RBX
POP R14
POP R15
RET
LAB_00168ad1:
PUSH 0x10
POP RDI
CALL 0x00124470
MOV R15,RAX
LAB_00168adc:
LEA RSI,[0x1b8f56]
MOV RDI,RAX
CALL 0x00124330
LAB_00168aeb:
MOV RSI,qword ptr [0x00203ff0]
MOV RDX,qword ptr [0x00203f58]
MOV RDI,R15
CALL 0x00124f50
LAB_00168b06:
LEA RDI,[0x205168]
CALL 0x00125060
TEST EAX,EAX
JZ 0x00168a29
LAB_00168b1a:
LEA RDI,[0x205148]
LEA RSI,[0x1b8f87]
PUSH 0x10
POP RDX
CALL 0x0012b33e
LAB_00168b30:
LEA RDI,[0x12b3f4]
LEA RSI,[0x205148]
LEA RDX,[0x204938]
CALL 0x00124800
LEA RDI,[0x205168]
CALL 0x001245f0
JMP 0x00168a29
LAB_00168b5b:
PUSH 0x10
POP RDI
CALL 0x00124470
MOV R15,RAX
LAB_00168b66:
LEA RSI,[0x1b8f8f]
MOV RDI,RAX
CALL 0x00124330
LAB_00168b75:
MOV RSI,qword ptr [0x00203ff0]
MOV RDX,qword ptr [0x00203f58]
MOV RDI,R15
CALL 0x00124f50
|
/* minja::Parser::parseStringConcat() */
void minja::Parser::parseStringConcat(void)
{
int iVar1;
runtime_error *prVar2;
__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2> *in_RDI;
long local_60;
__shared_count<(__gnu_cxx::_Lock_policy)2> local_58 [12];
int4 local_4c;
Location local_48 [8];
__shared_count<(__gnu_cxx::_Lock_policy)2> local_40 [8];
string local_38 [8];
long local_30 [3];
parseMathPow();
if (*(long *)in_RDI == 0) {
prVar2 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00168adc to 00168aea has its CatchHandler @ 00168bad */
std::runtime_error::runtime_error(prVar2,"Expected left side of \'string concat\' expression");
/* try { // try from 00168aeb to 00168b00 has its CatchHandler @ 00168bab */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar2,PTR_typeinfo_00203ff0,PTR__runtime_error_00203f58);
}
if (parseStringConcat()::concat_tok_abi_cxx11_ == '\0') {
iVar1 = __cxa_guard_acquire(&parseStringConcat()::concat_tok_abi_cxx11_);
if (iVar1 != 0) {
/* try { // try from 00168b1a to 00168b2f has its CatchHandler @ 00168b8b */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
((basic_regex<char,std::__cxx11::regex_traits<char>> *)
parseStringConcat()::concat_tok_abi_cxx11_,"~(?!\\})",0x10);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
parseStringConcat()::concat_tok_abi_cxx11_,&__dso_handle);
__cxa_guard_release(&parseStringConcat()::concat_tok_abi_cxx11_);
}
}
/* try { // try from 00168a29 to 00168a3f has its CatchHandler @ 00168bda */
consumeToken(local_38);
std::__cxx11::string::~string(local_38);
if (local_30[0] != 0) {
/* try { // try from 00168a53 to 00168a5f has its CatchHandler @ 00168bd8 */
parseLogicalAnd();
if (local_60 == 0) {
prVar2 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00168b66 to 00168b74 has its CatchHandler @ 00168b9e */
std::runtime_error::runtime_error
(prVar2,"Expected right side of \'string concat\' expression");
/* try { // try from 00168b75 to 00168b8a has its CatchHandler @ 00168b9c */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar2,PTR_typeinfo_00203ff0,PTR__runtime_error_00203f58);
}
/* try { // try from 00168a6c to 00168a78 has its CatchHandler @ 00168bc9 */
get_location();
local_4c = 0;
/* try { // try from 00168a82 to 00168a98 has its CatchHandler @ 00168bba */
std::
make_shared<minja::BinaryOpExpr,minja::Location,std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>,minja::BinaryOpExpr::Op>
(local_48,local_38,in_RDI,(Op *)&local_60);
std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator=
(in_RDI,(__shared_ptr *)local_48);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_40);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)local_30);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_58);
}
return;
}
| |
41,524 | minja::Value::contains(minja::Value const&) const | llama.cpp/common/minja/minja.hpp | bool contains(const Value & value) const {
if (is_null())
throw std::runtime_error("Undefined value or reference");
if (array_) {
for (const auto& item : *array_) {
if (item.to_bool() && item == value) return true;
}
return false;
} else if (object_) {
if (!value.is_hashable()) throw std::runtime_error("Unashable type: " + value.dump());
return object_->find(value.primitive_) != object_->end();
} else {
throw std::runtime_error("contains can only be called on arrays and objects: " + dump());
}
} | O3 | cpp | minja::Value::contains(minja::Value const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%rdi), %rax
movq 0x20(%rdi), %r12
testq %r12, %r12
jne 0xc4e9c
testq %rax, %rax
jne 0xc4e9c
cmpb $0x0, 0x40(%r15)
jne 0xc4e9c
cmpq $0x0, 0x30(%r15)
je 0xc4f4c
testq %rax, %rax
je 0xc4ed2
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0xc4ece
movq %r14, %rdi
callq 0xc3b8c
testb %al, %al
je 0xc4ec8
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc5278
testb %al, %al
jne 0xc4f3d
addq $0x50, %r14
jmp 0xc4ea8
xorl %eax, %eax
jmp 0xc4f3f
testq %r12, %r12
je 0xc4f7e
cmpq $0x0, 0x10(%rbx)
jne 0xc4fdb
cmpq $0x0, 0x20(%rbx)
jne 0xc4fdb
cmpq $0x0, 0x30(%rbx)
jne 0xc4fdb
movq (%r12), %r14
cmpq 0x8(%r12), %r14
je 0xc4f32
addq $0x40, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc11f8
testb %al, %al
jne 0xc4f25
addq $0x60, %r14
cmpq 0x8(%r12), %r14
jne 0xc4f0b
movq %r14, %rax
movq 0x20(%r15), %rcx
movq 0x8(%rcx), %r14
jmp 0xc4f35
movq %r14, %rax
cmpq %r14, %rax
setne %al
jmp 0xc4f3f
movb $0x1, %al
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x216a0
movq %rax, %r14
leaq 0x5f6f2(%rip), %rsi # 0x124652
movq %rax, %rdi
callq 0x21440
movq 0xa2049(%rip), %rsi # 0x166fb8
movq 0xa1ffa(%rip), %rdx # 0x166f70
movq %r14, %rdi
callq 0x21ae0
movl $0x10, %edi
callq 0x216a0
movq %rax, %r14
movq %rsp, %rdi
movq %r15, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0xbae64
leaq 0x5f6ff(%rip), %rsi # 0x1246a3
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xb5000
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x21490
xorl %ebp, %ebp
movq 0xa1fee(%rip), %rsi # 0x166fb8
movq 0xa1f9f(%rip), %rdx # 0x166f70
movq %r14, %rdi
callq 0x21ae0
jmp 0xc5036
movl $0x10, %edi
callq 0x216a0
movq %rax, %r14
movq %rsp, %rdi
movq %rbx, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0xbae64
leaq 0x5f691(%rip), %rsi # 0x124692
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xb5000
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x21490
xorl %ebp, %ebp
movq 0xa1f91(%rip), %rsi # 0x166fb8
movq 0xa1f42(%rip), %rdx # 0x166f70
movq %r14, %rdi
callq 0x21ae0
jmp 0xc503a
jmp 0xc507a
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc5058
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21180
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc5073
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21180
testb %bpl, %bpl
jne 0xc50a1
jmp 0xc50a9
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc50a1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21180
jmp 0xc50a1
jmp 0xc509e
jmp 0xc509e
movq %rax, %rbx
movq %r14, %rdi
callq 0x22020
movq %rbx, %rdi
callq 0x21b80
nop
| _ZNK5minja5Value8containsERKS0_:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 40h
mov rbx, rsi
mov r15, rdi
mov rax, [rdi+10h]
mov r12, [rdi+20h]
test r12, r12
jnz short loc_C4E9C
test rax, rax
jnz short loc_C4E9C
cmp byte ptr [r15+40h], 0
jnz short loc_C4E9C
cmp qword ptr [r15+30h], 0
jz loc_C4F4C
loc_C4E9C:
test rax, rax
jz short loc_C4ED2
mov r14, [rax]
mov r15, [rax+8]
loc_C4EA8:
cmp r14, r15
jz short loc_C4ECE
mov rdi, r14; this
call _ZNK5minja5Value7to_boolEv; minja::Value::to_bool(void)
test al, al
jz short loc_C4EC8
mov rdi, r14
mov rsi, rbx
call _ZNK5minja5ValueeqERKS0_; minja::Value::operator==(minja::Value const&)
test al, al
jnz short loc_C4F3D
loc_C4EC8:
add r14, 50h ; 'P'
jmp short loc_C4EA8
loc_C4ECE:
xor eax, eax
jmp short loc_C4F3F
loc_C4ED2:
test r12, r12
jz loc_C4F7E
cmp qword ptr [rbx+10h], 0
jnz loc_C4FDB
cmp qword ptr [rbx+20h], 0
jnz loc_C4FDB
cmp qword ptr [rbx+30h], 0
jnz loc_C4FDB
mov r14, [r12]
cmp r14, [r12+8]
jz short loc_C4F32
add rbx, 40h ; '@'
loc_C4F0B:
mov rdi, r14
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_3eqERKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEESF_; nlohmann::json_abi_v3_11_3::operator==(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
test al, al
jnz short loc_C4F25
add r14, 60h ; '`'
cmp r14, [r12+8]
jnz short loc_C4F0B
loc_C4F25:
mov rax, r14
mov rcx, [r15+20h]
mov r14, [rcx+8]
jmp short loc_C4F35
loc_C4F32:
mov rax, r14
loc_C4F35:
cmp rax, r14
setnz al
jmp short loc_C4F3F
loc_C4F3D:
mov al, 1
loc_C4F3F:
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_C4F4C:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aUndefinedValue; "Undefined value or reference"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
loc_C4F7E:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
mov rdi, rsp
mov rsi, r15
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aContainsCanOnl; "contains can only be called on arrays a"...
lea rdi, [rsp+68h+var_48]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+68h+var_48]
mov rdi, r14
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, r14; void *
call ___cxa_throw
jmp short loc_C5036
loc_C4FDB:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
mov rdi, rsp
mov rsi, rbx
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aUnashableType; "Unashable type: "
lea rdi, [rsp+68h+var_48]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+68h+var_48]
mov rdi, r14
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, r14; void *
call ___cxa_throw
loc_C5036:
jmp short loc_C503A
jmp short loc_C507A
loc_C503A:
mov rbx, rax
lea rax, [rsp+68h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_C5058
mov rsi, [rsp+68h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C5058:
lea rax, [rsp+68h+var_58]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_C5073
mov rsi, [rsp+68h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C5073:
test bpl, bpl
jnz short loc_C50A1
jmp short loc_C50A9
loc_C507A:
mov rbx, rax
lea rax, [rsp+68h+var_58]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_C50A1
mov rsi, [rsp+68h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_C50A1
jmp short loc_C509E
jmp short $+2
loc_C509E:
mov rbx, rax
loc_C50A1:
mov rdi, r14; void *
call ___cxa_free_exception
loc_C50A9:
mov rdi, rbx
call __Unwind_Resume
| bool minja::Value::contains(minja::Value *this, const minja::Value *a2, __m128d a3)
{
minja::Value **v3; // rax
unsigned __int8 **v4; // r12
minja::Value *v5; // r14
minja::Value *v6; // r15
unsigned __int8 *v8; // r14
unsigned __int8 *v9; // rax
std::runtime_error *exception; // r14
void *v11; // r14
void *v12; // r14
_BYTE v13[16]; // [rsp+0h] [rbp-68h] BYREF
_QWORD v14[2]; // [rsp+20h] [rbp-48h] BYREF
v3 = (minja::Value **)*((_QWORD *)this + 2);
v4 = (unsigned __int8 **)*((_QWORD *)this + 4);
if ( !v4 && !v3 && !*((_BYTE *)this + 64) && !*((_QWORD *)this + 6) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Undefined value or reference");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( v3 )
{
v5 = *v3;
v6 = v3[1];
while ( 1 )
{
if ( v5 == v6 )
return 0;
if ( (unsigned __int8)minja::Value::to_bool(v5) && (unsigned __int8)minja::Value::operator==(v5, a2) )
break;
v5 = (minja::Value *)((char *)v5 + 80);
}
return 1;
}
else
{
if ( !v4 )
{
v11 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v13, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>(v14, (long long)"contains can only be called on arrays and objects: ", (long long)v13);
std::runtime_error::runtime_error(v11, v14);
__cxa_throw(
v11,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( *((_QWORD *)a2 + 2) || *((_QWORD *)a2 + 4) || *((_QWORD *)a2 + 6) )
{
v12 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v13, (long long)a2, 0xFFFFFFFF, 0);
std::operator+<char>(v14, (long long)"Unashable type: ", (long long)v13);
std::runtime_error::runtime_error(v12, v14);
__cxa_throw(
v12,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v8 = *v4;
if ( *v4 == v4[1] )
{
v9 = *v4;
}
else
{
do
{
if ( (unsigned __int8)nlohmann::json_abi_v3_11_3::operator==(v8, (unsigned __int8 *)a2 + 64, a3) )
break;
v8 += 96;
}
while ( v8 != v4[1] );
v9 = v8;
v8 = *(unsigned __int8 **)(*((_QWORD *)this + 4) + 8LL);
}
return v9 != v8;
}
}
| contains:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV RBX,RSI
MOV R15,RDI
MOV RAX,qword ptr [RDI + 0x10]
MOV R12,qword ptr [RDI + 0x20]
TEST R12,R12
JNZ 0x001c4e9c
TEST RAX,RAX
JNZ 0x001c4e9c
CMP byte ptr [R15 + 0x40],0x0
JNZ 0x001c4e9c
CMP qword ptr [R15 + 0x30],0x0
JZ 0x001c4f4c
LAB_001c4e9c:
TEST RAX,RAX
JZ 0x001c4ed2
MOV R14,qword ptr [RAX]
MOV R15,qword ptr [RAX + 0x8]
LAB_001c4ea8:
CMP R14,R15
JZ 0x001c4ece
MOV RDI,R14
CALL 0x001c3b8c
TEST AL,AL
JZ 0x001c4ec8
MOV RDI,R14
MOV RSI,RBX
CALL 0x001c5278
TEST AL,AL
JNZ 0x001c4f3d
LAB_001c4ec8:
ADD R14,0x50
JMP 0x001c4ea8
LAB_001c4ece:
XOR EAX,EAX
JMP 0x001c4f3f
LAB_001c4ed2:
TEST R12,R12
JZ 0x001c4f7e
CMP qword ptr [RBX + 0x10],0x0
JNZ 0x001c4fdb
CMP qword ptr [RBX + 0x20],0x0
JNZ 0x001c4fdb
CMP qword ptr [RBX + 0x30],0x0
JNZ 0x001c4fdb
MOV R14,qword ptr [R12]
CMP R14,qword ptr [R12 + 0x8]
JZ 0x001c4f32
ADD RBX,0x40
LAB_001c4f0b:
MOV RDI,R14
MOV RSI,RBX
CALL 0x001c11f8
TEST AL,AL
JNZ 0x001c4f25
ADD R14,0x60
CMP R14,qword ptr [R12 + 0x8]
JNZ 0x001c4f0b
LAB_001c4f25:
MOV RAX,R14
MOV RCX,qword ptr [R15 + 0x20]
MOV R14,qword ptr [RCX + 0x8]
JMP 0x001c4f35
LAB_001c4f32:
MOV RAX,R14
LAB_001c4f35:
CMP RAX,R14
SETNZ AL
JMP 0x001c4f3f
LAB_001c4f3d:
MOV AL,0x1
LAB_001c4f3f:
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001c4f4c:
MOV EDI,0x10
CALL 0x001216a0
MOV R14,RAX
LAB_001c4f59:
LEA RSI,[0x224652]
MOV RDI,RAX
CALL 0x00121440
LAB_001c4f68:
MOV RSI,qword ptr [0x00266fb8]
MOV RDX,qword ptr [0x00266f70]
MOV RDI,R14
CALL 0x00121ae0
LAB_001c4f7e:
MOV EDI,0x10
CALL 0x001216a0
MOV R14,RAX
LAB_001c4f8b:
MOV RDI,RSP
MOV RSI,R15
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x001bae64
LAB_001c4f9d:
LEA RSI,[0x2246a3]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x001b5000
MOV BPL,0x1
LAB_001c4fb4:
LEA RSI,[RSP + 0x20]
MOV RDI,R14
CALL 0x00121490
XOR EBP,EBP
MOV RSI,qword ptr [0x00266fb8]
MOV RDX,qword ptr [0x00266f70]
MOV RDI,R14
CALL 0x00121ae0
LAB_001c4fdb:
MOV EDI,0x10
CALL 0x001216a0
MOV R14,RAX
LAB_001c4fe8:
MOV RDI,RSP
MOV RSI,RBX
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x001bae64
LAB_001c4ffa:
LEA RSI,[0x224692]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x001b5000
MOV BPL,0x1
LAB_001c5011:
LEA RSI,[RSP + 0x20]
MOV RDI,R14
CALL 0x00121490
XOR EBP,EBP
MOV RSI,qword ptr [0x00266fb8]
MOV RDX,qword ptr [0x00266f70]
MOV RDI,R14
CALL 0x00121ae0
|
/* minja::Value::contains(minja::Value const&) const */
bool __thiscall minja::Value::contains(Value *this,Value *param_1)
{
int8 *puVar1;
long *plVar2;
Value *pVVar3;
char cVar4;
runtime_error *prVar5;
Value *this_00;
basic_json *pbVar6;
basic_json *pbVar7;
bool bVar8;
int1 auStack_68 [32];
string local_48 [32];
puVar1 = *(int8 **)(this + 0x10);
plVar2 = *(long **)(this + 0x20);
if ((((plVar2 == (long *)0x0) && (puVar1 == (int8 *)0x0)) && (this[0x40] == (Value)0x0)) &&
(*(long *)(this + 0x30) == 0)) {
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001c4f59 to 001c4f67 has its CatchHandler @ 001c509e */
std::runtime_error::runtime_error(prVar5,"Undefined value or reference");
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_00266fb8,PTR__runtime_error_00266f70);
}
if (puVar1 == (int8 *)0x0) {
if (plVar2 == (long *)0x0) {
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001c4f8b to 001c4f9c has its CatchHandler @ 001c509c */
dump_abi_cxx11_((int)auStack_68,SUB81(this,0));
/* try { // try from 001c4f9d to 001c4fb0 has its CatchHandler @ 001c507a */
std::operator+((char *)local_48,
(string *)"contains can only be called on arrays and objects: ");
/* try { // try from 001c4fb4 to 001c4fd8 has its CatchHandler @ 001c503a */
std::runtime_error::runtime_error(prVar5,local_48);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_00266fb8,PTR__runtime_error_00266f70);
}
if (((*(long *)(param_1 + 0x10) != 0) || (*(long *)(param_1 + 0x20) != 0)) ||
(*(long *)(param_1 + 0x30) != 0)) {
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001c4fe8 to 001c4ff9 has its CatchHandler @ 001c509a */
dump_abi_cxx11_((int)auStack_68,SUB81(param_1,0));
/* try { // try from 001c4ffa to 001c500d has its CatchHandler @ 001c5038 */
std::operator+((char *)local_48,(string *)"Unashable type: ");
/* try { // try from 001c5011 to 001c5035 has its CatchHandler @ 001c5036 */
std::runtime_error::runtime_error(prVar5,local_48);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_00266fb8,PTR__runtime_error_00266f70);
}
pbVar6 = (basic_json *)*plVar2;
pbVar7 = pbVar6;
if (pbVar6 != (basic_json *)plVar2[1]) {
do {
cVar4 = nlohmann::json_abi_v3_11_3::operator==(pbVar6,(basic_json *)(param_1 + 0x40));
if (cVar4 != '\0') break;
pbVar6 = pbVar6 + 0x60;
} while (pbVar6 != (basic_json *)plVar2[1]);
pbVar7 = *(basic_json **)(*(long *)(this + 0x20) + 8);
}
bVar8 = pbVar6 != pbVar7;
}
else {
pVVar3 = (Value *)puVar1[1];
for (this_00 = (Value *)*puVar1; this_00 != pVVar3; this_00 = this_00 + 0x50) {
cVar4 = to_bool(this_00);
if ((cVar4 != '\0') && (cVar4 = operator==(this_00,param_1), cVar4 != '\0')) {
return true;
}
}
bVar8 = false;
}
return bVar8;
}
| |
41,525 | my_hash_sort_utf8mb3 | eloqsql/strings/ctype-utf8.c | static void my_hash_sort_utf8mb3(CHARSET_INFO *cs, const uchar *s, size_t slen,
ulong *nr1, ulong *nr2)
{
/*
Remove end space. We have to do this to be able to compare
'A ' and 'A' as identical
*/
const uchar *e= skip_trailing_space(s, slen);
my_hash_sort_utf8mb3_nopad(cs, s, e - s, nr1, nr2);
} | O3 | c | my_hash_sort_utf8mb3:
pushq %rbp
movq %rsp, %rbp
leaq (%rsi,%rdx), %r10
cmpq $0x15, %rdx
jb 0x4fe47
movq %r10, %r9
andq $-0x4, %r9
cmpq %rsi, %r9
jbe 0x4fe47
leaq 0x3(%rsi), %rdx
andq $-0x4, %rdx
movq %r10, %rax
movb -0x1(%r10), %r11b
cmpq %r9, %r10
jbe 0x4fe6c
leaq -0x1(%rax), %r10
cmpb $0x20, %r11b
je 0x4fe2f
jmp 0x4fe4a
movq %r10, %rax
movq %rax, %r9
subq %rsi, %r9
movq %r9, %rdx
cmpq %rsi, %rax
jbe 0x4fe66
cmpb $0x20, -0x1(%rax)
leaq -0x1(%rax), %rax
leaq -0x1(%rdx), %r9
je 0x4fe50
popq %rbp
jmp 0x50051
cmpb $0x20, %r11b
setne %r10b
cmpq %r9, %rdx
setae %r9b
orb %r10b, %r9b
jne 0x4fe4a
movq %rax, %r9
movq %r9, %rax
cmpq %rdx, %r9
jbe 0x4fe4a
leaq -0x4(%rax), %r9
cmpl $0x20202020, -0x4(%rax) # imm = 0x20202020
je 0x4fe83
jmp 0x4fe4a
| my_hash_sort_utf8mb3:
push rbp
mov rbp, rsp
lea r10, [rsi+rdx]
cmp rdx, 15h
jb short loc_4FE47
mov r9, r10
and r9, 0FFFFFFFFFFFFFFFCh
cmp r9, rsi
jbe short loc_4FE47
lea rdx, [rsi+3]
and rdx, 0FFFFFFFFFFFFFFFCh
loc_4FE2F:
mov rax, r10
mov r11b, [r10-1]
cmp r10, r9
jbe short loc_4FE6C
lea r10, [rax-1]
cmp r11b, 20h ; ' '
jz short loc_4FE2F
jmp short loc_4FE4A
loc_4FE47:
mov rax, r10
loc_4FE4A:
mov r9, rax
sub r9, rsi
loc_4FE50:
mov rdx, r9
cmp rax, rsi
jbe short loc_4FE66
cmp byte ptr [rax-1], 20h ; ' '
lea rax, [rax-1]
lea r9, [rdx-1]
jz short loc_4FE50
loc_4FE66:
pop rbp
jmp my_hash_sort_utf8mb3_nopad
loc_4FE6C:
cmp r11b, 20h ; ' '
setnz r10b
cmp rdx, r9
setnb r9b
or r9b, r10b
jnz short loc_4FE4A
mov r9, rax
loc_4FE83:
mov rax, r9
cmp r9, rdx
jbe short loc_4FE4A
lea r9, [rax-4]
cmp dword ptr [rax-4], 20202020h
jz short loc_4FE83
jmp short loc_4FE4A
| long long my_hash_sort_utf8mb3(long long a1, unsigned long long a2, unsigned long long a3, long long a4, long long a5)
{
unsigned long long v5; // r10
unsigned long long v6; // r9
unsigned long long v7; // rdx
unsigned long long v8; // rax
char v9; // r11
unsigned long long v10; // r9
unsigned long long v11; // rdx
bool v12; // zf
unsigned long long v14; // r9
v5 = a2 + a3;
if ( a3 < 0x15 || (v6 = v5 & 0xFFFFFFFFFFFFFFFCLL, (v5 & 0xFFFFFFFFFFFFFFFCLL) <= a2) )
{
v8 = a2 + a3;
}
else
{
v7 = (a2 + 3) & 0xFFFFFFFFFFFFFFFCLL;
while ( 1 )
{
v8 = v5;
v9 = *(_BYTE *)(v5 - 1);
if ( v5 <= v6 )
break;
--v5;
if ( v9 != 32 )
goto LABEL_8;
}
if ( v9 == 32 && v7 < v6 )
{
v14 = v5;
do
{
v8 = v14;
if ( v14 <= v7 )
break;
v14 -= 4LL;
}
while ( *(_DWORD *)(v8 - 4) == 538976288 );
}
}
LABEL_8:
v10 = v8 - a2;
do
{
v11 = v10;
if ( v8 <= a2 )
break;
v12 = *(_BYTE *)--v8 == 32;
--v10;
}
while ( v12 );
return my_hash_sort_utf8mb3_nopad(a1, a2, v11, a4, a5, v10);
}
| my_hash_sort_utf8mb3:
PUSH RBP
MOV RBP,RSP
LEA R10,[RSI + RDX*0x1]
CMP RDX,0x15
JC 0x0014fe47
MOV R9,R10
AND R9,-0x4
CMP R9,RSI
JBE 0x0014fe47
LEA RDX,[RSI + 0x3]
AND RDX,-0x4
LAB_0014fe2f:
MOV RAX,R10
MOV R11B,byte ptr [R10 + -0x1]
CMP R10,R9
JBE 0x0014fe6c
LEA R10,[RAX + -0x1]
CMP R11B,0x20
JZ 0x0014fe2f
JMP 0x0014fe4a
LAB_0014fe47:
MOV RAX,R10
LAB_0014fe4a:
MOV R9,RAX
SUB R9,RSI
LAB_0014fe50:
MOV RDX,R9
CMP RAX,RSI
JBE 0x0014fe66
CMP byte ptr [RAX + -0x1],0x20
LEA RAX,[RAX + -0x1]
LEA R9,[RDX + -0x1]
JZ 0x0014fe50
LAB_0014fe66:
POP RBP
JMP 0x00150051
LAB_0014fe6c:
CMP R11B,0x20
SETNZ R10B
CMP RDX,R9
SETNC R9B
OR R9B,R10B
JNZ 0x0014fe4a
MOV R9,RAX
LAB_0014fe83:
MOV RAX,R9
CMP R9,RDX
JBE 0x0014fe4a
LEA R9,[RAX + -0x4]
CMP dword ptr [RAX + -0x4],0x20202020
JZ 0x0014fe83
JMP 0x0014fe4a
|
void my_hash_sort_utf8mb3(int8 param_1,ulong param_2,ulong param_3)
{
char *pcVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
ulong uVar5;
uVar3 = param_2 + param_3;
if ((0x14 < param_3) && (uVar5 = uVar3 & 0xfffffffffffffffc, param_2 < uVar5)) {
uVar4 = param_2 + 3 & 0xfffffffffffffffc;
uVar2 = uVar3;
do {
uVar3 = uVar2;
if (uVar3 <= uVar5) {
uVar2 = uVar3;
if (uVar4 < uVar5 && *(char *)(uVar3 - 1) == ' ') goto LAB_0014fe83;
break;
}
uVar2 = uVar3 - 1;
} while (*(char *)(uVar3 - 1) == ' ');
}
goto LAB_0014fe50;
while (uVar2 = uVar3 - 4, *(int *)(uVar3 - 4) == 0x20202020) {
LAB_0014fe83:
uVar3 = uVar2;
if (uVar3 <= uVar4) break;
}
LAB_0014fe50:
do {
if (uVar3 <= param_2) break;
pcVar1 = (char *)(uVar3 - 1);
uVar3 = uVar3 - 1;
} while (*pcVar1 == ' ');
my_hash_sort_utf8mb3_nopad();
return;
}
| |
41,526 | mi_rec_pack | eloqsql/storage/myisam/mi_dynrec.c | uint _mi_rec_pack(MI_INFO *info, register uchar *to,
register const uchar *from)
{
uint length,new_length,flag,bit,i;
uchar *pos,*end,*startpos,*packpos;
enum en_fieldtype type;
reg3 MI_COLUMNDEF *rec;
MI_BLOB *blob;
DBUG_ENTER("_mi_rec_pack");
flag=0 ; bit=1;
startpos=packpos=to; to+= info->s->base.pack_bits; blob=info->blobs;
rec=info->s->rec;
for (i=info->s->base.fields ; i-- > 0; from+= length,rec++)
{
length=(uint) rec->length;
if ((type = (enum en_fieldtype) rec->type) != FIELD_NORMAL)
{
if (type == FIELD_BLOB)
{
if (!blob->length)
flag|=bit;
else
{
char *temp_pos;
size_t tmp_length=length-portable_sizeof_char_ptr;
memcpy((uchar*) to,from,tmp_length);
memcpy(&temp_pos,from+tmp_length,sizeof(char*));
memcpy(to+tmp_length,temp_pos,(size_t) blob->length);
to+=tmp_length+blob->length;
}
blob++;
}
else if (type == FIELD_SKIP_ZERO)
{
if (memcmp((uchar*) from,zero_string,length) == 0)
flag|=bit;
else
{
memcpy((uchar*) to,from,(size_t) length); to+=length;
}
}
else if (type == FIELD_SKIP_ENDSPACE ||
type == FIELD_SKIP_PRESPACE)
{
pos= (uchar*) from; end= (uchar*) from + length;
if (type == FIELD_SKIP_ENDSPACE)
{ /* Pack trailing spaces */
while (end > from && *(end-1) == ' ')
end--;
}
else
{ /* Pack pref-spaces */
while (pos < end && *pos == ' ')
pos++;
}
new_length=(uint) (end-pos);
if (new_length + 1 + MY_TEST(rec->length > 255 && new_length > 127)
< length)
{
if (rec->length > 255 && new_length > 127)
{
to[0]= (uchar) ((new_length & 127) + 128);
to[1]= (uchar) (new_length >> 7);
to+=2;
}
else
*to++= (uchar) new_length;
memcpy((uchar*) to,pos,(size_t) new_length); to+=new_length;
flag|=bit;
}
else
{
memcpy(to,from,(size_t) length); to+=length;
}
}
else if (type == FIELD_VARCHAR)
{
uint pack_length= HA_VARCHAR_PACKLENGTH(rec->length -1);
uint tmp_length;
if (pack_length == 1)
{
tmp_length= (uint) *(uchar*) from;
*to++= *from;
}
else
{
tmp_length= uint2korr(from);
store_key_length_inc(to,tmp_length);
}
memcpy(to, from+pack_length,tmp_length);
to+= tmp_length;
continue;
}
else
{
memcpy(to,from,(size_t) length); to+=length;
continue; /* Normal field */
}
if ((bit= bit << 1) >= 256)
{
*packpos++= (uchar) flag;
bit=1; flag=0;
}
}
else
{
memcpy(to,from,(size_t) length); to+=length;
}
}
if (bit != 1)
*packpos= (uchar) flag;
if (info->s->calc_checksum)
*to++= (uchar) info->checksum;
DBUG_PRINT("exit",("packed length: %d",(int) (to-startpos)));
DBUG_RETURN((uint) (to-startpos));
} | O3 | c | mi_rec_pack:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq (%rdi), %rax
movl 0x168(%rax), %r13d
movl 0x18c(%rax), %ebx
addq %rsi, %rbx
testl %r13d, %r13d
je 0x312f5
movq %rdx, %r12
movq 0x230(%rax), %r15
movq 0x48(%rdi), %rdx
movq %rsi, -0x58(%rbp)
movq %rsi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movl $0x1, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
decl %r13d
movzwl 0x4(%r15), %r8d
movl (%r15), %ecx
testl %ecx, %ecx
je 0x310b1
cmpl $0x3, %ecx
je 0x3107a
cmpl $0x4, %ecx
jne 0x310e1
cmpq $0x0, 0x10(%rdx)
je 0x31158
movl %r13d, -0x3c(%rbp)
movq %rbx, %r13
leal -0x8(%r8), %ebx
movq %r13, %rdi
movq %r12, %rsi
movq %rdx, %r14
movq %rbx, %rdx
movq %r8, -0x60(%rbp)
callq 0x282c0
movq (%r12,%rbx), %rsi
leaq (%rbx,%r13), %rdi
movq 0x10(%r14), %rdx
callq 0x282c0
movq -0x60(%rbp), %r8
movq %r14, %rdx
addq 0x10(%r14), %rbx
addq %rbx, %r13
movq %r13, %rbx
movl -0x3c(%rbp), %r13d
jmp 0x31161
movq %rdx, -0x38(%rbp)
movq %r12, %rdi
leaq 0x37ce08(%rip), %rsi # 0x3ade90
movq %r8, %rdx
movq %r8, %r14
callq 0x283b0
testl %eax, %eax
je 0x31146
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x282c0
addq %r14, %rbx
jmp 0x3114f
movq %rbx, %rdi
movq %r12, %rsi
movq %rbx, -0x68(%rbp)
movq %rdx, %rbx
movq %r8, %rdx
movl %r13d, %r14d
movq %r8, %r13
callq 0x282c0
movq %r13, %r8
movl %r14d, %r13d
movq %rbx, %rdx
movq -0x68(%rbp), %rbx
addq %r8, %rbx
jmp 0x31178
cmpl $0x2, %ecx
ja 0x31111
leaq (%r12,%r8), %rax
cmpl $0x1, %ecx
movq %rdx, -0x38(%rbp)
jne 0x3118d
movq %rax, %rcx
cmpq %r12, %rax
jbe 0x31109
leaq -0x1(%rcx), %rax
cmpb $0x20, -0x1(%rcx)
je 0x310f7
movq %rcx, %rax
jmp 0x311a4
cmpl $0x8, %ecx
jne 0x31216
cmpl $0x100, %r8d # imm = 0x100
movl %r13d, -0x3c(%rbp)
movq %rdx, -0x38(%rbp)
ja 0x31260
movq %r8, %r14
movzbl (%r12), %eax
movb %al, (%rbx)
incq %rbx
movl $0x1, %esi
jmp 0x31288
movl -0x2c(%rbp), %eax
orl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rdx
movq %r14, %r8
jmp 0x31165
movl -0x2c(%rbp), %eax
orl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
addq $0x18, %rdx
movl -0x30(%rbp), %eax
addl %eax, %eax
movl %eax, -0x30(%rbp)
cmpl $0xff, %eax
ja 0x312b1
addq %r8, %r12
addq $0x30, %r15
testl %r13d, %r13d
jne 0x31003
jmp 0x312de
movq %r12, %rsi
testq %r8, %r8
je 0x311a4
cmpb $0x20, (%rsi)
jne 0x311a7
incq %rsi
cmpq %rax, %rsi
jb 0x31195
jmp 0x311a7
movq %r12, %rsi
subq %rsi, %rax
cmpl $0x100, %r8d # imm = 0x100
setae %dl
cmpl $0x7f, %eax
seta %cl
andb %dl, %cl
movzbl %cl, %edx
addl %eax, %edx
incl %edx
cmpl %r8d, %edx
jae 0x31240
movq %rbx, %rdi
movl $0x1, %ebx
testb %cl, %cl
movq %r8, -0x60(%rbp)
movl %eax, %ecx
je 0x311ea
orb $-0x80, %cl
movl %eax, %edx
shrl $0x7, %edx
movb %dl, 0x1(%rdi)
movl $0x2, %ebx
addq %rdi, %rbx
movb %cl, (%rdi)
movl %eax, %r14d
movq %rbx, %rdi
movq %r14, %rdx
callq 0x282c0
addq %r14, %rbx
movl -0x2c(%rbp), %eax
orl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rdx
movq -0x60(%rbp), %r8
jmp 0x31165
movq %rbx, %rdi
movq %r12, %rsi
movq %rbx, -0x68(%rbp)
movq %rdx, %rbx
movq %r8, %rdx
movq %r8, %r14
callq 0x282c0
movq %r14, %r8
movq %rbx, %rdx
movq -0x68(%rbp), %rbx
addq %r14, %rbx
jmp 0x31178
movq %rbx, %rdi
movq %r12, %rsi
movq %r8, %rdx
movq %r8, %r14
callq 0x282c0
movq %r14, %r8
addq %r14, %rbx
movq -0x38(%rbp), %rdx
jmp 0x31165
movzwl (%r12), %eax
movq %r8, %r14
cmpl $0xfe, %eax
ja 0x31276
movb %al, (%rbx)
incq %rbx
jmp 0x31283
movb $-0x1, (%rbx)
movb %al, 0x2(%rbx)
movb %ah, 0x1(%rbx)
addq $0x3, %rbx
movl $0x2, %esi
movq %rbx, %r13
addq %r12, %rsi
movl %eax, %ebx
movq %r13, %rdi
movq %rbx, %rdx
callq 0x282c0
addq %rbx, %r13
movq %r13, %rbx
movl -0x3c(%rbp), %r13d
movq -0x38(%rbp), %rdx
movq %r14, %r8
jmp 0x31178
movq -0x58(%rbp), %rax
movl -0x2c(%rbp), %ecx
movb %cl, (%rax)
incq %rax
movq %rax, -0x58(%rbp)
movl %r8d, %eax
addq %rax, %r12
addq $0x30, %r15
testl %r13d, %r13d
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdi
jne 0x30ff5
jmp 0x312f5
cmpl $0x1, -0x30(%rbp)
je 0x312ed
movq -0x58(%rbp), %rax
movl -0x2c(%rbp), %ecx
movb %cl, (%rax)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
cmpq $0x0, 0x2c8(%rax)
je 0x3130d
movb 0x1a8(%rdi), %al
movb %al, (%rbx)
incq %rbx
subl %esi, %ebx
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _mi_rec_pack:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov rax, [rdi]
mov r13d, [rax+168h]
mov ebx, [rax+18Ch]
add rbx, rsi
test r13d, r13d
jz loc_312F5
mov r12, rdx
mov r15, [rax+230h]
mov rdx, [rdi+48h]
mov [rbp+var_58], rsi
mov [rbp+var_50], rsi
mov [rbp+var_48], rdi
loc_30FF5:
mov [rbp+var_30], 1
mov [rbp+var_2C], 0
loc_31003:
dec r13d
movzx r8d, word ptr [r15+4]
mov ecx, [r15]
test ecx, ecx
jz loc_310B1
cmp ecx, 3
jz short loc_3107A
cmp ecx, 4
jnz loc_310E1
cmp qword ptr [rdx+10h], 0
jz loc_31158
mov [rbp+var_3C], r13d
mov r13, rbx
lea ebx, [r8-8]
mov rdi, r13
mov rsi, r12
mov r14, rdx
mov rdx, rbx
mov [rbp+var_60], r8
call _memcpy
mov rsi, [r12+rbx]
lea rdi, [rbx+r13]
mov rdx, [r14+10h]
call _memcpy
mov r8, [rbp+var_60]
mov rdx, r14
add rbx, [r14+10h]
add r13, rbx
mov rbx, r13
mov r13d, [rbp+var_3C]
jmp loc_31161
loc_3107A:
mov [rbp+var_38], rdx
mov rdi, r12
lea rsi, zero_string
mov rdx, r8
mov r14, r8
call _bcmp
test eax, eax
jz loc_31146
mov rdi, rbx
mov rsi, r12
mov rdx, r14
call _memcpy
add rbx, r14
jmp loc_3114F
loc_310B1:
mov rdi, rbx
mov rsi, r12
mov [rbp+var_68], rbx
mov rbx, rdx
mov rdx, r8
mov r14d, r13d
mov r13, r8
call _memcpy
mov r8, r13
mov r13d, r14d
mov rdx, rbx
mov rbx, [rbp+var_68]
add rbx, r8
jmp loc_31178
loc_310E1:
cmp ecx, 2
ja short loc_31111
lea rax, [r12+r8]
cmp ecx, 1
mov [rbp+var_38], rdx
jnz loc_3118D
loc_310F7:
mov rcx, rax
cmp rax, r12
jbe short loc_31109
lea rax, [rcx-1]
cmp byte ptr [rcx-1], 20h ; ' '
jz short loc_310F7
loc_31109:
mov rax, rcx
jmp loc_311A4
loc_31111:
cmp ecx, 8
jnz loc_31216
cmp r8d, 100h
mov [rbp+var_3C], r13d
mov [rbp+var_38], rdx
ja loc_31260
mov r14, r8
movzx eax, byte ptr [r12]
mov [rbx], al
inc rbx
mov esi, 1
jmp loc_31288
loc_31146:
mov eax, [rbp+var_2C]
or eax, [rbp+var_30]
mov [rbp+var_2C], eax
loc_3114F:
mov rdx, [rbp+var_38]
mov r8, r14
jmp short loc_31165
loc_31158:
mov eax, [rbp+var_2C]
or eax, [rbp+var_30]
mov [rbp+var_2C], eax
loc_31161:
add rdx, 18h
loc_31165:
mov eax, [rbp+var_30]
add eax, eax
mov [rbp+var_30], eax
cmp eax, 0FFh
ja loc_312B1
loc_31178:
add r12, r8
add r15, 30h ; '0'
test r13d, r13d
jnz loc_31003
jmp loc_312DE
loc_3118D:
mov rsi, r12
test r8, r8
jz short loc_311A4
loc_31195:
cmp byte ptr [rsi], 20h ; ' '
jnz short loc_311A7
inc rsi
cmp rsi, rax
jb short loc_31195
jmp short loc_311A7
loc_311A4:
mov rsi, r12
loc_311A7:
sub rax, rsi
cmp r8d, 100h
setnb dl
cmp eax, 7Fh
setnbe cl
and cl, dl
movzx edx, cl
add edx, eax
inc edx
cmp edx, r8d
jnb short loc_31240
mov rdi, rbx
mov ebx, 1
test cl, cl
mov [rbp+var_60], r8
mov ecx, eax
jz short loc_311EA
or cl, 80h
mov edx, eax
shr edx, 7
mov [rdi+1], dl
mov ebx, 2
loc_311EA:
add rbx, rdi
mov [rdi], cl
mov r14d, eax
mov rdi, rbx
mov rdx, r14
call _memcpy
add rbx, r14
mov eax, [rbp+var_2C]
or eax, [rbp+var_30]
mov [rbp+var_2C], eax
mov rdx, [rbp+var_38]
mov r8, [rbp+var_60]
jmp loc_31165
loc_31216:
mov rdi, rbx
mov rsi, r12
mov [rbp+var_68], rbx
mov rbx, rdx
mov rdx, r8
mov r14, r8
call _memcpy
mov r8, r14
mov rdx, rbx
mov rbx, [rbp+var_68]
add rbx, r14
jmp loc_31178
loc_31240:
mov rdi, rbx
mov rsi, r12
mov rdx, r8
mov r14, r8
call _memcpy
mov r8, r14
add rbx, r14
mov rdx, [rbp+var_38]
jmp loc_31165
loc_31260:
movzx eax, word ptr [r12]
mov r14, r8
cmp eax, 0FEh
ja short loc_31276
mov [rbx], al
inc rbx
jmp short loc_31283
loc_31276:
mov byte ptr [rbx], 0FFh
mov [rbx+2], al
mov [rbx+1], ah
add rbx, 3
loc_31283:
mov esi, 2
loc_31288:
mov r13, rbx
add rsi, r12
mov ebx, eax
mov rdi, r13
mov rdx, rbx
call _memcpy
add r13, rbx
mov rbx, r13
mov r13d, [rbp+var_3C]
mov rdx, [rbp+var_38]
mov r8, r14
jmp loc_31178
loc_312B1:
mov rax, [rbp+var_58]
mov ecx, [rbp+var_2C]
mov [rax], cl
inc rax
mov [rbp+var_58], rax
mov eax, r8d
add r12, rax
add r15, 30h ; '0'
test r13d, r13d
mov rsi, [rbp+var_50]
mov rdi, [rbp+var_48]
jnz loc_30FF5
jmp short loc_312F5
loc_312DE:
cmp [rbp+var_30], 1
jz short loc_312ED
mov rax, [rbp+var_58]
mov ecx, [rbp+var_2C]
mov [rax], cl
loc_312ED:
mov rsi, [rbp+var_50]
mov rdi, [rbp+var_48]
loc_312F5:
mov rax, [rdi]
cmp qword ptr [rax+2C8h], 0
jz short loc_3130D
mov al, [rdi+1A8h]
mov [rbx], al
inc rbx
loc_3130D:
sub ebx, esi
mov eax, ebx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long mi_rec_pack(long long a1, _BYTE *a2, char *a3)
{
int v3; // r13d
_BYTE *v4; // rbx
long long v6; // r15
long long v7; // rdx
long long v8; // r8
unsigned int v9; // ecx
_BYTE *v10; // r13
long long v11; // rbx
long long v12; // r14
long long v13; // r14
_BYTE *v14; // rdi
long long v15; // rbx
int v16; // r14d
long long v17; // r13
char *v18; // rax
char *v19; // rcx
long long v20; // r14
unsigned int v21; // eax
_BYTE *v22; // rbx
long long v23; // rsi
char *v24; // rsi
unsigned int v25; // eax
bool v26; // cl
_BYTE *v27; // rdi
long long v28; // rbx
bool v29; // zf
char v30; // cl
_BYTE *v31; // rbx
long long v32; // r14
_BYTE *v33; // rdi
long long v34; // rbx
long long v35; // r14
long long v36; // r14
_BYTE *v37; // r13
long long v38; // rbx
_BYTE *v40; // [rsp+8h] [rbp-68h]
_BYTE *v41; // [rsp+8h] [rbp-68h]
long long v42; // [rsp+10h] [rbp-60h]
long long v43; // [rsp+10h] [rbp-60h]
_BYTE *v44; // [rsp+18h] [rbp-58h]
int v45; // [rsp+20h] [rbp-50h]
long long v46; // [rsp+28h] [rbp-48h]
int v47; // [rsp+34h] [rbp-3Ch]
int v48; // [rsp+34h] [rbp-3Ch]
long long v49; // [rsp+38h] [rbp-38h]
long long v50; // [rsp+38h] [rbp-38h]
long long v51; // [rsp+38h] [rbp-38h]
unsigned int v52; // [rsp+40h] [rbp-30h]
int v53; // [rsp+44h] [rbp-2Ch]
v3 = *(_DWORD *)(*(_QWORD *)a1 + 360LL);
v4 = &a2[*(unsigned int *)(*(_QWORD *)a1 + 396LL)];
if ( !v3 )
goto LABEL_48;
v6 = *(_QWORD *)(*(_QWORD *)a1 + 560LL);
v7 = *(_QWORD *)(a1 + 72);
v44 = a2;
v45 = (int)a2;
v46 = a1;
while ( 2 )
{
v52 = 1;
v53 = 0;
while ( 1 )
{
--v3;
v8 = *(unsigned __int16 *)(v6 + 4);
v9 = *(_DWORD *)v6;
if ( *(_DWORD *)v6 )
break;
v14 = v4;
v40 = v4;
v15 = v7;
v16 = v3;
v17 = *(unsigned __int16 *)(v6 + 4);
memcpy(v14, a3, v8);
v8 = v17;
v3 = v16;
v7 = v15;
v4 = &v40[v8];
LABEL_25:
a3 += v8;
v6 += 48LL;
if ( !v3 )
{
if ( v52 != 1 )
*v44 = v53;
LODWORD(a2) = v45;
a1 = v46;
goto LABEL_48;
}
}
if ( v9 == 3 )
{
v49 = v7;
v13 = *(unsigned __int16 *)(v6 + 4);
if ( (unsigned int)bcmp(a3, &zero_string, v8) )
{
memcpy(v4, a3, v13);
v4 += v13;
}
else
{
v53 |= v52;
}
v7 = v49;
v8 = v13;
goto LABEL_24;
}
if ( v9 == 4 )
{
if ( *(_QWORD *)(v7 + 16) )
{
v47 = v3;
v10 = v4;
v11 = (unsigned int)(v8 - 8);
v12 = v7;
v42 = *(unsigned __int16 *)(v6 + 4);
memcpy(v10, a3, v11);
memcpy(&v10[v11], *(_QWORD *)&a3[v11], *(_QWORD *)(v12 + 16));
v8 = v42;
v7 = v12;
v4 = &v10[*(_QWORD *)(v12 + 16) + v11];
v3 = v47;
}
else
{
v53 |= v52;
}
v7 += 24LL;
goto LABEL_24;
}
if ( v9 > 2 )
{
if ( v9 == 8 )
{
v48 = v3;
v51 = v7;
if ( (unsigned int)v8 > 0x100 )
{
v21 = *(unsigned __int16 *)a3;
v20 = *(unsigned __int16 *)(v6 + 4);
if ( v21 > 0xFE )
{
*v4 = -1;
v4[2] = v21;
v4[1] = BYTE1(v21);
v22 = v4 + 3;
}
else
{
*v4 = v21;
v22 = v4 + 1;
}
v23 = 2LL;
}
else
{
v20 = *(unsigned __int16 *)(v6 + 4);
v21 = (unsigned __int8)*a3;
*v4 = v21;
v22 = v4 + 1;
v23 = 1LL;
}
v37 = v22;
v38 = v21;
memcpy(v37, &a3[v23], v21);
v4 = &v37[v38];
v3 = v48;
v7 = v51;
v8 = v20;
}
else
{
v33 = v4;
v41 = v4;
v34 = v7;
v35 = *(unsigned __int16 *)(v6 + 4);
memcpy(v33, a3, v8);
v8 = v35;
v7 = v34;
v4 = &v41[v35];
}
goto LABEL_25;
}
v18 = &a3[v8];
v50 = v7;
if ( v9 == 1 )
{
do
{
v19 = v18;
if ( v18 <= a3 )
break;
--v18;
}
while ( *(v19 - 1) == 32 );
LODWORD(v18) = (_DWORD)v19;
goto LABEL_31;
}
v24 = a3;
if ( !*(_WORD *)(v6 + 4) )
{
LABEL_31:
v24 = a3;
goto LABEL_32;
}
do
{
if ( *v24 != 32 )
break;
++v24;
}
while ( v24 < v18 );
LABEL_32:
v25 = (_DWORD)v18 - (_DWORD)v24;
v26 = (unsigned int)v8 >= 0x100 && v25 > 0x7F;
if ( v25 + v26 + 1 >= (unsigned int)v8 )
{
v36 = *(unsigned __int16 *)(v6 + 4);
memcpy(v4, a3, v8);
v8 = v36;
v4 += v36;
v7 = v50;
}
else
{
v27 = v4;
v28 = 1LL;
v29 = !v26;
v43 = *(unsigned __int16 *)(v6 + 4);
v30 = v25;
if ( !v29 )
{
v30 = v25 | 0x80;
v27[1] = v25 >> 7;
v28 = 2LL;
}
v31 = &v27[v28];
*v27 = v30;
v32 = v25;
memcpy(v31, v24, v25);
v4 = &v31[v32];
v53 |= v52;
v7 = v50;
v8 = v43;
}
LABEL_24:
v52 *= 2;
if ( v52 <= 0xFF )
goto LABEL_25;
*v44++ = v53;
a3 += (unsigned int)v8;
v6 += 48LL;
LODWORD(a2) = v45;
a1 = v46;
if ( v3 )
continue;
break;
}
LABEL_48:
if ( *(_QWORD *)(*(_QWORD *)a1 + 712LL) )
{
*v4 = *(_BYTE *)(a1 + 424);
LODWORD(v4) = (_DWORD)v4 + 1;
}
return (unsigned int)((_DWORD)v4 - (_DWORD)a2);
}
| _mi_rec_pack:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV RAX,qword ptr [RDI]
MOV R13D,dword ptr [RAX + 0x168]
MOV EBX,dword ptr [RAX + 0x18c]
ADD RBX,RSI
TEST R13D,R13D
JZ 0x001312f5
MOV R12,RDX
MOV R15,qword ptr [RAX + 0x230]
MOV RDX,qword ptr [RDI + 0x48]
MOV qword ptr [RBP + -0x58],RSI
MOV qword ptr [RBP + -0x50],RSI
MOV qword ptr [RBP + -0x48],RDI
LAB_00130ff5:
MOV dword ptr [RBP + -0x30],0x1
MOV dword ptr [RBP + -0x2c],0x0
LAB_00131003:
DEC R13D
MOVZX R8D,word ptr [R15 + 0x4]
MOV ECX,dword ptr [R15]
TEST ECX,ECX
JZ 0x001310b1
CMP ECX,0x3
JZ 0x0013107a
CMP ECX,0x4
JNZ 0x001310e1
CMP qword ptr [RDX + 0x10],0x0
JZ 0x00131158
MOV dword ptr [RBP + -0x3c],R13D
MOV R13,RBX
LEA EBX,[R8 + -0x8]
MOV RDI,R13
MOV RSI,R12
MOV R14,RDX
MOV RDX,RBX
MOV qword ptr [RBP + -0x60],R8
CALL 0x001282c0
MOV RSI,qword ptr [R12 + RBX*0x1]
LEA RDI,[RBX + R13*0x1]
MOV RDX,qword ptr [R14 + 0x10]
CALL 0x001282c0
MOV R8,qword ptr [RBP + -0x60]
MOV RDX,R14
ADD RBX,qword ptr [R14 + 0x10]
ADD R13,RBX
MOV RBX,R13
MOV R13D,dword ptr [RBP + -0x3c]
JMP 0x00131161
LAB_0013107a:
MOV qword ptr [RBP + -0x38],RDX
MOV RDI,R12
LEA RSI,[0x4ade90]
MOV RDX,R8
MOV R14,R8
CALL 0x001283b0
TEST EAX,EAX
JZ 0x00131146
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R14
CALL 0x001282c0
ADD RBX,R14
JMP 0x0013114f
LAB_001310b1:
MOV RDI,RBX
MOV RSI,R12
MOV qword ptr [RBP + -0x68],RBX
MOV RBX,RDX
MOV RDX,R8
MOV R14D,R13D
MOV R13,R8
CALL 0x001282c0
MOV R8,R13
MOV R13D,R14D
MOV RDX,RBX
MOV RBX,qword ptr [RBP + -0x68]
ADD RBX,R8
JMP 0x00131178
LAB_001310e1:
CMP ECX,0x2
JA 0x00131111
LEA RAX,[R12 + R8*0x1]
CMP ECX,0x1
MOV qword ptr [RBP + -0x38],RDX
JNZ 0x0013118d
LAB_001310f7:
MOV RCX,RAX
CMP RAX,R12
JBE 0x00131109
LEA RAX,[RCX + -0x1]
CMP byte ptr [RCX + -0x1],0x20
JZ 0x001310f7
LAB_00131109:
MOV RAX,RCX
JMP 0x001311a4
LAB_00131111:
CMP ECX,0x8
JNZ 0x00131216
CMP R8D,0x100
MOV dword ptr [RBP + -0x3c],R13D
MOV qword ptr [RBP + -0x38],RDX
JA 0x00131260
MOV R14,R8
MOVZX EAX,byte ptr [R12]
MOV byte ptr [RBX],AL
INC RBX
MOV ESI,0x1
JMP 0x00131288
LAB_00131146:
MOV EAX,dword ptr [RBP + -0x2c]
OR EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x2c],EAX
LAB_0013114f:
MOV RDX,qword ptr [RBP + -0x38]
MOV R8,R14
JMP 0x00131165
LAB_00131158:
MOV EAX,dword ptr [RBP + -0x2c]
OR EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x2c],EAX
LAB_00131161:
ADD RDX,0x18
LAB_00131165:
MOV EAX,dword ptr [RBP + -0x30]
ADD EAX,EAX
MOV dword ptr [RBP + -0x30],EAX
CMP EAX,0xff
JA 0x001312b1
LAB_00131178:
ADD R12,R8
ADD R15,0x30
TEST R13D,R13D
JNZ 0x00131003
JMP 0x001312de
LAB_0013118d:
MOV RSI,R12
TEST R8,R8
JZ 0x001311a4
LAB_00131195:
CMP byte ptr [RSI],0x20
JNZ 0x001311a7
INC RSI
CMP RSI,RAX
JC 0x00131195
JMP 0x001311a7
LAB_001311a4:
MOV RSI,R12
LAB_001311a7:
SUB RAX,RSI
CMP R8D,0x100
SETNC DL
CMP EAX,0x7f
SETA CL
AND CL,DL
MOVZX EDX,CL
ADD EDX,EAX
INC EDX
CMP EDX,R8D
JNC 0x00131240
MOV RDI,RBX
MOV EBX,0x1
TEST CL,CL
MOV qword ptr [RBP + -0x60],R8
MOV ECX,EAX
JZ 0x001311ea
OR CL,0x80
MOV EDX,EAX
SHR EDX,0x7
MOV byte ptr [RDI + 0x1],DL
MOV EBX,0x2
LAB_001311ea:
ADD RBX,RDI
MOV byte ptr [RDI],CL
MOV R14D,EAX
MOV RDI,RBX
MOV RDX,R14
CALL 0x001282c0
ADD RBX,R14
MOV EAX,dword ptr [RBP + -0x2c]
OR EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x2c],EAX
MOV RDX,qword ptr [RBP + -0x38]
MOV R8,qword ptr [RBP + -0x60]
JMP 0x00131165
LAB_00131216:
MOV RDI,RBX
MOV RSI,R12
MOV qword ptr [RBP + -0x68],RBX
MOV RBX,RDX
MOV RDX,R8
MOV R14,R8
CALL 0x001282c0
MOV R8,R14
MOV RDX,RBX
MOV RBX,qword ptr [RBP + -0x68]
ADD RBX,R14
JMP 0x00131178
LAB_00131240:
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R8
MOV R14,R8
CALL 0x001282c0
MOV R8,R14
ADD RBX,R14
MOV RDX,qword ptr [RBP + -0x38]
JMP 0x00131165
LAB_00131260:
MOVZX EAX,word ptr [R12]
MOV R14,R8
CMP EAX,0xfe
JA 0x00131276
MOV byte ptr [RBX],AL
INC RBX
JMP 0x00131283
LAB_00131276:
MOV byte ptr [RBX],0xff
MOV byte ptr [RBX + 0x2],AL
MOV byte ptr [RBX + 0x1],AH
ADD RBX,0x3
LAB_00131283:
MOV ESI,0x2
LAB_00131288:
MOV R13,RBX
ADD RSI,R12
MOV EBX,EAX
MOV RDI,R13
MOV RDX,RBX
CALL 0x001282c0
ADD R13,RBX
MOV RBX,R13
MOV R13D,dword ptr [RBP + -0x3c]
MOV RDX,qword ptr [RBP + -0x38]
MOV R8,R14
JMP 0x00131178
LAB_001312b1:
MOV RAX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RBP + -0x2c]
MOV byte ptr [RAX],CL
INC RAX
MOV qword ptr [RBP + -0x58],RAX
MOV EAX,R8D
ADD R12,RAX
ADD R15,0x30
TEST R13D,R13D
MOV RSI,qword ptr [RBP + -0x50]
MOV RDI,qword ptr [RBP + -0x48]
JNZ 0x00130ff5
JMP 0x001312f5
LAB_001312de:
CMP dword ptr [RBP + -0x30],0x1
JZ 0x001312ed
MOV RAX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RBP + -0x2c]
MOV byte ptr [RAX],CL
LAB_001312ed:
MOV RSI,qword ptr [RBP + -0x50]
MOV RDI,qword ptr [RBP + -0x48]
LAB_001312f5:
MOV RAX,qword ptr [RDI]
CMP qword ptr [RAX + 0x2c8],0x0
JZ 0x0013130d
MOV AL,byte ptr [RDI + 0x1a8]
MOV byte ptr [RBX],AL
INC RBX
LAB_0013130d:
SUB EBX,ESI
MOV EAX,EBX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int _mi_rec_pack(long *param_1,int1 *param_2,ushort *param_3)
{
ushort uVar1;
ushort *puVar2;
int iVar3;
uint uVar4;
ulong uVar5;
byte bVar7;
long lVar8;
byte *pbVar9;
long lVar10;
ushort *puVar11;
uint uVar12;
ulong __n;
int iVar13;
uint *puVar14;
int1 *local_60;
uint local_38;
uint local_34;
ushort *puVar6;
lVar8 = *param_1;
iVar13 = *(int *)(lVar8 + 0x168);
pbVar9 = param_2 + *(uint *)(lVar8 + 0x18c);
if (iVar13 == 0) {
LAB_001312f5:
if (*(long *)(*param_1 + 0x2c8) != 0) {
*pbVar9 = *(byte *)(param_1 + 0x35);
pbVar9 = pbVar9 + 1;
}
return (int)pbVar9 - (int)param_2;
}
puVar14 = *(uint **)(lVar8 + 0x230);
lVar8 = param_1[9];
local_60 = param_2;
LAB_00130ff5:
local_38 = 1;
local_34 = 0;
do {
iVar13 = iVar13 + -1;
uVar1 = (ushort)puVar14[1];
__n = (ulong)uVar1;
uVar4 = *puVar14;
if (uVar4 == 0) {
memcpy(pbVar9,param_3,__n);
pbVar9 = pbVar9 + __n;
}
else {
if (uVar4 == 3) {
iVar3 = bcmp(param_3,zero_string,__n);
if (iVar3 == 0) {
local_34 = local_34 | local_38;
}
else {
memcpy(pbVar9,param_3,__n);
pbVar9 = pbVar9 + __n;
}
}
else if (uVar4 == 4) {
if (*(long *)(lVar8 + 0x10) == 0) {
local_34 = local_34 | local_38;
}
else {
uVar5 = (ulong)(uVar1 - 8);
memcpy(pbVar9,param_3,uVar5);
memcpy(pbVar9 + uVar5,*(void **)((long)param_3 + uVar5),*(size_t *)(lVar8 + 0x10));
pbVar9 = pbVar9 + uVar5 + *(long *)(lVar8 + 0x10);
}
lVar8 = lVar8 + 0x18;
}
else {
uVar12 = (uint)uVar1;
if (2 < uVar4) {
if (uVar4 == 8) {
if (uVar12 < 0x101) {
uVar4 = (uint)(byte)*param_3;
*pbVar9 = (byte)*param_3;
pbVar9 = pbVar9 + 1;
lVar10 = 1;
}
else {
uVar1 = *param_3;
uVar4 = (uint)uVar1;
if (uVar1 < 0xff) {
*pbVar9 = (byte)uVar1;
pbVar9 = pbVar9 + 1;
}
else {
*pbVar9 = 0xff;
pbVar9[2] = (byte)uVar1;
pbVar9[1] = (byte)(uVar1 >> 8);
pbVar9 = pbVar9 + 3;
}
lVar10 = 2;
}
memcpy(pbVar9,(byte *)(lVar10 + (long)param_3),(ulong)uVar4);
pbVar9 = pbVar9 + uVar4;
}
else {
memcpy(pbVar9,param_3,__n);
pbVar9 = pbVar9 + __n;
}
goto LAB_00131178;
}
puVar6 = (ushort *)((long)param_3 + __n);
puVar2 = puVar6;
puVar11 = param_3;
if (uVar4 == 1) {
do {
puVar6 = puVar2;
if (puVar6 <= param_3) break;
puVar2 = (ushort *)((long)puVar6 + -1);
} while (*(byte *)((long)puVar6 + -1) == 0x20);
}
else if (__n != 0) {
do {
if ((byte)*puVar11 != 0x20) break;
puVar11 = (ushort *)((long)puVar11 + 1);
} while (puVar11 < puVar6);
}
uVar5 = (long)puVar6 - (long)puVar11;
uVar4 = (uint)uVar5;
if ((0x7f < uVar4 && 0xff < uVar12) + uVar4 + 1 < uVar12) {
lVar10 = 1;
bVar7 = (byte)uVar5;
if (0x7f < uVar4 && 0xff < uVar12) {
bVar7 = bVar7 | 0x80;
pbVar9[1] = (byte)(uVar5 >> 7);
lVar10 = 2;
}
*pbVar9 = bVar7;
memcpy(pbVar9 + lVar10,puVar11,uVar5 & 0xffffffff);
pbVar9 = pbVar9 + lVar10 + (uVar5 & 0xffffffff);
local_34 = local_34 | local_38;
}
else {
memcpy(pbVar9,param_3,__n);
pbVar9 = pbVar9 + __n;
}
}
local_38 = local_38 * 2;
if (0xff < local_38) break;
}
LAB_00131178:
param_3 = (ushort *)((long)param_3 + __n);
puVar14 = puVar14 + 0xc;
if (iVar13 == 0) {
if (local_38 != 1) {
*local_60 = (char)local_34;
}
goto LAB_001312f5;
}
} while( true );
*local_60 = (char)local_34;
local_60 = local_60 + 1;
param_3 = (ushort *)((long)param_3 + __n);
puVar14 = puVar14 + 0xc;
if (iVar13 == 0) goto LAB_001312f5;
goto LAB_00130ff5;
}
| |
41,527 | mysql_close | eloqsql/libmariadb/libmariadb/mariadb_lib.c | void STDCALL
mysql_close(MYSQL *mysql)
{
if (mysql) /* Some simple safety */
{
if (mysql->extension && mysql->extension->conn_hdlr)
{
MA_CONNECTION_HANDLER *p= mysql->extension->conn_hdlr;
if (p->plugin->close)
p->plugin->close(mysql);
free(p);
/* Fix for CONC-294: Since we already called plugin->close function
we need to prevent that mysql_close_slow_part (which sends COM_QUIT
to the server) will be handled by plugin again. */
mysql->extension->conn_hdlr= NULL;
}
if (mysql->methods)
mysql->methods->db_close(mysql);
/* reset the connection in all active statements */
ma_invalidate_stmts(mysql, "mysql_close()");
mysql_close_memory(mysql);
mysql_close_options(mysql);
ma_clear_session_state(mysql);
if (mysql->net.extension)
{
if (compression_plugin(&mysql->net))
compression_plugin(&mysql->net)->free_ctx(compression_ctx(&mysql->net));
free(mysql->net.extension);
}
mysql->host_info=mysql->user=mysql->passwd=mysql->db=0;
/* Clear pointers for better safety */
memset((char*) &mysql->options, 0, sizeof(mysql->options));
if (mysql->extension)
free(mysql->extension);
/* Clear pointers for better safety */
mysql->net.extension = NULL;
mysql->extension = NULL;
mysql->net.pvio= 0;
if (mysql->free_me)
free(mysql);
}
return;
} | O0 | c | mysql_close:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x25ab6
movq -0x8(%rbp), %rax
cmpq $0x0, 0x4f0(%rax)
je 0x25962
movq -0x8(%rbp), %rax
movq 0x4f0(%rax), %rax
cmpq $0x0, (%rax)
je 0x25962
movq -0x8(%rbp), %rax
movq 0x4f0(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x60(%rax)
je 0x25947
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x60(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x10(%rbp), %rdi
callq 0x13520
movq -0x8(%rbp), %rax
movq 0x4f0(%rax), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x4d0(%rax)
je 0x25985
movq -0x8(%rbp), %rax
movq 0x4d0(%rax), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x8(%rbp), %rdi
leaq 0x305ea(%rip), %rsi # 0x55f7a
callq 0x25ac0
movq -0x8(%rbp), %rdi
callq 0x252d0
movq -0x8(%rbp), %rdi
callq 0x253d0
movq -0x8(%rbp), %rdi
callq 0x260e0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x2a0(%rax)
je 0x25a04
movq -0x8(%rbp), %rax
movq 0x2a0(%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x259f4
movq -0x8(%rbp), %rax
movq 0x2a0(%rax), %rax
movq 0x10(%rax), %rax
movq 0x60(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x2a0(%rcx), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq 0x2a0(%rax), %rdi
callq 0x13520
movq -0x8(%rbp), %rax
movq $0x0, 0x2e8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x2c0(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x2b8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x2d8(%rax)
movq -0x8(%rbp), %rdi
addq $0x390, %rdi # imm = 0x390
xorl %esi, %esi
movl $0xf8, %edx
callq 0x13250
movq -0x8(%rbp), %rax
cmpq $0x0, 0x4f0(%rax)
je 0x25a75
movq -0x8(%rbp), %rax
movq 0x4f0(%rax), %rdi
callq 0x13520
movq -0x8(%rbp), %rax
movq $0x0, 0x2a0(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x4f0(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x48c(%rax)
je 0x25ab4
movq -0x8(%rbp), %rdi
callq 0x13520
jmp 0x25ab6
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| mysql_close:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
cmp [rbp+var_8], 0
jz loc_25AB6
mov rax, [rbp+var_8]
cmp qword ptr [rax+4F0h], 0
jz short loc_25962
mov rax, [rbp+var_8]
mov rax, [rax+4F0h]
cmp qword ptr [rax], 0
jz short loc_25962
mov rax, [rbp+var_8]
mov rax, [rax+4F0h]
mov rax, [rax]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rax, [rax]
cmp qword ptr [rax+60h], 0
jz short loc_25947
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+60h]
mov rdi, [rbp+var_8]
call rax
loc_25947:
mov rdi, [rbp+var_10]
call _free
mov rax, [rbp+var_8]
mov rax, [rax+4F0h]
mov qword ptr [rax], 0
loc_25962:
mov rax, [rbp+var_8]
cmp qword ptr [rax+4D0h], 0
jz short loc_25985
mov rax, [rbp+var_8]
mov rax, [rax+4D0h]
mov rax, [rax+8]
mov rdi, [rbp+var_8]
call rax
loc_25985:
mov rdi, [rbp+var_8]
lea rsi, aMysqlClose; "mysql_close()"
call ma_invalidate_stmts
mov rdi, [rbp+var_8]
call mysql_close_memory
mov rdi, [rbp+var_8]
call mysql_close_options
mov rdi, [rbp+var_8]
call ma_clear_session_state
mov rax, [rbp+var_8]
cmp qword ptr [rax+2A0h], 0
jz short loc_25A04
mov rax, [rbp+var_8]
mov rax, [rax+2A0h]
cmp qword ptr [rax+10h], 0
jz short loc_259F4
mov rax, [rbp+var_8]
mov rax, [rax+2A0h]
mov rax, [rax+10h]
mov rax, [rax+60h]
mov rcx, [rbp+var_8]
mov rcx, [rcx+2A0h]
mov rdi, [rcx+8]
call rax
loc_259F4:
mov rax, [rbp+var_8]
mov rdi, [rax+2A0h]
call _free
loc_25A04:
mov rax, [rbp+var_8]
mov qword ptr [rax+2E8h], 0
mov rax, [rbp+var_8]
mov qword ptr [rax+2C0h], 0
mov rax, [rbp+var_8]
mov qword ptr [rax+2B8h], 0
mov rax, [rbp+var_8]
mov qword ptr [rax+2D8h], 0
mov rdi, [rbp+var_8]
add rdi, 390h
xor esi, esi
mov edx, 0F8h
call _memset
mov rax, [rbp+var_8]
cmp qword ptr [rax+4F0h], 0
jz short loc_25A75
mov rax, [rbp+var_8]
mov rdi, [rax+4F0h]
call _free
loc_25A75:
mov rax, [rbp+var_8]
mov qword ptr [rax+2A0h], 0
mov rax, [rbp+var_8]
mov qword ptr [rax+4F0h], 0
mov rax, [rbp+var_8]
mov qword ptr [rax], 0
mov rax, [rbp+var_8]
cmp byte ptr [rax+48Ch], 0
jz short loc_25AB4
mov rdi, [rbp+var_8]
call _free
loc_25AB4:
jmp short $+2
loc_25AB6:
add rsp, 10h
pop rbp
retn
| long long mysql_close(long long a1)
{
long long result; // rax
long long v2; // [rsp+0h] [rbp-10h]
if ( a1 )
{
if ( *(_QWORD *)(a1 + 1264) && **(_QWORD **)(a1 + 1264) )
{
v2 = **(_QWORD **)(a1 + 1264);
if ( *(_QWORD *)(*(_QWORD *)v2 + 96LL) )
(*(void ( **)(long long))(*(_QWORD *)v2 + 96LL))(a1);
free(v2);
**(_QWORD **)(a1 + 1264) = 0LL;
}
if ( *(_QWORD *)(a1 + 1232) )
(*(void ( **)(long long))(*(_QWORD *)(a1 + 1232) + 8LL))(a1);
ma_invalidate_stmts(a1, "mysql_close()");
mysql_close_memory((_QWORD *)a1);
mysql_close_options(a1);
ma_clear_session_state(a1);
if ( *(_QWORD *)(a1 + 672) )
{
if ( *(_QWORD *)(*(_QWORD *)(a1 + 672) + 16LL) )
(*(void ( **)(_QWORD))(*(_QWORD *)(*(_QWORD *)(a1 + 672) + 16LL) + 96LL))(*(_QWORD *)(*(_QWORD *)(a1 + 672) + 8LL));
free(*(_QWORD *)(a1 + 672));
}
*(_QWORD *)(a1 + 744) = 0LL;
*(_QWORD *)(a1 + 704) = 0LL;
*(_QWORD *)(a1 + 696) = 0LL;
*(_QWORD *)(a1 + 728) = 0LL;
memset(a1 + 912, 0LL, 248LL);
if ( *(_QWORD *)(a1 + 1264) )
free(*(_QWORD *)(a1 + 1264));
*(_QWORD *)(a1 + 672) = 0LL;
*(_QWORD *)(a1 + 1264) = 0LL;
*(_QWORD *)a1 = 0LL;
result = a1;
if ( *(_BYTE *)(a1 + 1164) )
return free(a1);
}
return result;
}
| mysql_close:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
CMP qword ptr [RBP + -0x8],0x0
JZ 0x00125ab6
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x4f0],0x0
JZ 0x00125962
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x4f0]
CMP qword ptr [RAX],0x0
JZ 0x00125962
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x4f0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
CMP qword ptr [RAX + 0x60],0x0
JZ 0x00125947
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x60]
MOV RDI,qword ptr [RBP + -0x8]
CALL RAX
LAB_00125947:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00113520
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x4f0]
MOV qword ptr [RAX],0x0
LAB_00125962:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x4d0],0x0
JZ 0x00125985
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x4d0]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RBP + -0x8]
CALL RAX
LAB_00125985:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x155f7a]
CALL 0x00125ac0
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001252d0
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001253d0
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001260e0
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x2a0],0x0
JZ 0x00125a04
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x2a0]
CMP qword ptr [RAX + 0x10],0x0
JZ 0x001259f4
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x2a0]
MOV RAX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RAX + 0x60]
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX + 0x2a0]
MOV RDI,qword ptr [RCX + 0x8]
CALL RAX
LAB_001259f4:
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x2a0]
CALL 0x00113520
LAB_00125a04:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x2e8],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x2c0],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x2b8],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x2d8],0x0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x390
XOR ESI,ESI
MOV EDX,0xf8
CALL 0x00113250
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x4f0],0x0
JZ 0x00125a75
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x4f0]
CALL 0x00113520
LAB_00125a75:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x2a0],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x4f0],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX + 0x48c],0x0
JZ 0x00125ab4
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00113520
LAB_00125ab4:
JMP 0x00125ab6
LAB_00125ab6:
ADD RSP,0x10
POP RBP
RET
|
void mysql_close(int8 *param_1)
{
long *__ptr;
if (param_1 != (int8 *)0x0) {
if ((param_1[0x9e] != 0) && (*(long *)param_1[0x9e] != 0)) {
__ptr = *(long **)param_1[0x9e];
if (*(long *)(*__ptr + 0x60) != 0) {
(**(code **)(*__ptr + 0x60))(param_1);
}
free(__ptr);
*(int8 *)param_1[0x9e] = 0;
}
if (param_1[0x9a] != 0) {
(**(code **)(param_1[0x9a] + 8))(param_1);
}
ma_invalidate_stmts(param_1);
mysql_close_memory(param_1);
mysql_close_options(param_1);
ma_clear_session_state(param_1);
if (param_1[0x54] != 0) {
if (*(long *)(param_1[0x54] + 0x10) != 0) {
(**(code **)(*(long *)(param_1[0x54] + 0x10) + 0x60))(*(int8 *)(param_1[0x54] + 8));
}
free((void *)param_1[0x54]);
}
param_1[0x5d] = 0;
param_1[0x58] = 0;
param_1[0x57] = 0;
param_1[0x5b] = 0;
memset(param_1 + 0x72,0,0xf8);
if (param_1[0x9e] != 0) {
free((void *)param_1[0x9e]);
}
param_1[0x54] = 0;
param_1[0x9e] = 0;
*param_1 = 0;
if (*(char *)((long)param_1 + 0x48c) != '\0') {
free(param_1);
}
}
return;
}
| |
41,528 | nglog::GetExistingTempDirectories(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>>>>&) | ng-log[P]ng-log/src/logging.cc | NGLOG_NO_EXPORT
void GetExistingTempDirectories(vector<string>& list) {
GetTempDirectories(list);
auto i_dir = list.begin();
while (i_dir != list.end()) {
// zero arg to access means test for existence; no constant
// defined on windows
if (access(i_dir->c_str(), 0)) {
i_dir = list.erase(i_dir);
} else {
++i_dir;
}
}
} | O3 | cpp | nglog::GetExistingTempDirectories(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>>>>&):
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xcea9
movq (%rbx), %r14
cmpq 0x8(%rbx), %r14
je 0xd034
movq (%r14), %rdi
xorl %esi, %esi
callq 0x78a0
testl %eax, %eax
je 0xd02e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1f39e
movq %rax, %r14
jmp 0xd00a
addq $0x20, %r14
jmp 0xd00a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _ZN5nglog26GetExistingTempDirectoriesERSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS6_EE:
push r14
push rbx
push rax
mov rbx, rdi
call _ZN5nglogL18GetTempDirectoriesERSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS6_EE; nglog::GetTempDirectories(std::vector<std::string> &)
mov r14, [rbx]
loc_D00A:
cmp r14, [rbx+8]
jz short loc_D034
mov rdi, [r14]
xor esi, esi
call _access
test eax, eax
jz short loc_D02E
mov rdi, rbx
mov rsi, r14
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE8_M_eraseEN9__gnu_cxx17__normal_iteratorIPS5_S7_EE; std::vector<std::string>::_M_erase(__gnu_cxx::__normal_iterator<std::string*,std::vector<std::string>>)
mov r14, rax
jmp short loc_D00A
loc_D02E:
add r14, 20h ; ' '
jmp short loc_D00A
loc_D034:
add rsp, 8
pop rbx
pop r14
retn
| char nglog::GetExistingTempDirectories(_QWORD *a1)
{
long long v1; // rax
_QWORD *v2; // r14
LOBYTE(v1) = nglog::GetTempDirectories(a1);
v2 = (_QWORD *)*a1;
while ( v2 != (_QWORD *)a1[1] )
{
LODWORD(v1) = access(*v2, 0LL);
if ( (_DWORD)v1 )
{
v1 = std::vector<std::string>::_M_erase(a1, v2);
v2 = (_QWORD *)v1;
}
else
{
v2 += 4;
}
}
return v1;
}
| GetExistingTempDirectories:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
CALL 0x0010cea9
MOV R14,qword ptr [RBX]
LAB_0010d00a:
CMP R14,qword ptr [RBX + 0x8]
JZ 0x0010d034
MOV RDI,qword ptr [R14]
XOR ESI,ESI
CALL 0x001078a0
TEST EAX,EAX
JZ 0x0010d02e
MOV RDI,RBX
MOV RSI,R14
CALL 0x0011f39e
MOV R14,RAX
JMP 0x0010d00a
LAB_0010d02e:
ADD R14,0x20
JMP 0x0010d00a
LAB_0010d034:
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* nglog::GetExistingTempDirectories(std::vector<std::__cxx11::string,
std::allocator<std::__cxx11::string > >&) */
void nglog::GetExistingTempDirectories(vector *param_1)
{
int iVar1;
int8 *puVar2;
GetTempDirectories(param_1);
puVar2 = *(int8 **)param_1;
while (puVar2 != *(int8 **)(param_1 + 8)) {
iVar1 = access((char *)*puVar2,0);
if (iVar1 == 0) {
puVar2 = puVar2 + 4;
}
else {
puVar2 = (int8 *)
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::_M_erase
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)
param_1);
}
}
return;
}
| |
41,529 | wengine_handler | navaro[P]qoraal-tictactoe/src/services/www/html/wengine.c | int32_t
wengine_handler (HTTP_USER_T *user, uint32_t method, char* endpoint)
{
int32_t res = HTTP_SERVER_WSERVER_E_OK ;
char* cmd[5] = {0} ;
int i ;
uint16_t event = 0 ;
uint16_t parm = 0 ;
cmd[0] = strchr (endpoint, '/') ;
for (i=0; i<5; i++) {
if (cmd[i]) *(cmd[i])++ = 0 ;
if (cmd[i]) cmd[i+1] = strchr (cmd[i], '/') ;
if (cmd[i+1] == 0) break ;
}
if (method == HTTP_HEADER_METHOD_GET) {
if (html_emit_lock (&_wengine_emit, 4000) != EOK) {
return httpserver_write_response (user, WSERVER_RESP_CODE_500, HTTP_SERVER_CONTENT_TYPE_HTML,
0, 0, WSERVER_RESP_CONTENT_500, strlen(WSERVER_RESP_CONTENT_500)) ;
}
if (cmd[1]) event = (uint16_t)atoi(cmd[1]) ;
if (cmd[2]) parm = (uint16_t)atoi(cmd[2]) ;
res = html_emit_wait (cmd[0], event, parm, user, 120000) ;
html_emit_unlock (&_wengine_emit) ;
if (res == E_NOTFOUND) {
res = httpserver_write_response (user, WSERVER_RESP_CODE_404, HTTP_SERVER_CONTENT_TYPE_HTML,
0, 0, WSERVER_RESP_CONTENT_404, strlen(WSERVER_RESP_CONTENT_404)) ;
} else if (res != EOK) {
res = httpserver_write_response (user, WSERVER_RESP_CODE_404, HTTP_SERVER_CONTENT_TYPE_HTML,
0, 0, WSERVER_RESP_CONTENT_500, strlen(WSERVER_RESP_CONTENT_500)) ;
}
return res ;
} else {
return HTTP_SERVER_WSERVER_E_METHOD ;
}
return HTTP_SERVER_WSERVER_E_OK ;
} | O3 | c | wengine_handler:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %esi, %r14d
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x20(%rbp)
movq %rdx, %rdi
movl $0x2f, %esi
callq 0x61d0
movq %rax, -0x40(%rbp)
xorl %r15d, %r15d
cmpq $0x5, %r15
je 0x12a4a
testq %rax, %rax
je 0x12a3d
leaq 0x1(%rax), %rdi
movq %rdi, -0x40(%rbp,%r15,8)
movb $0x0, (%rax)
movl $0x2f, %esi
callq 0x61d0
movq %rax, -0x38(%rbp,%r15,8)
jmp 0x12a42
movq -0x38(%rbp,%r15,8), %rax
incq %r15
testq %rax, %rax
jne 0x12a15
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
cmpl $0x1, %r14d
jne 0x12b06
leaq 0x2deaf(%rip), %rdi # 0x40910
movl $0xfa0, %esi # imm = 0xFA0
callq 0x13d99
testl %eax, %eax
je 0x12a91
movl $0x2cf, (%rsp) # imm = 0x2CF
leaq 0x14d18(%rip), %rdx # 0x27795
leaq 0x169b2(%rip), %r9 # 0x29436
movq %rbx, %rdi
movl $0x1f4, %esi # imm = 0x1F4
jmp 0x12b28
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x12aa4
callq 0x64d0
movl %eax, %r14d
jmp 0x12aa7
xorl %r14d, %r14d
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x12ab7
callq 0x64d0
jmp 0x12ab9
xorl %eax, %eax
movq -0x40(%rbp), %rdi
movzwl %r14w, %esi
movzwl %ax, %edx
movq %rbx, %rcx
movl $0x1d4c0, %r8d # imm = 0x1D4C0
callq 0x13e03
movl %eax, %r15d
leaq 0x2de34(%rip), %rdi # 0x40910
callq 0x13dea
testl %r15d, %r15d
je 0x12b06
cmpl $0xfffff6fc, %r15d # imm = 0xFFFFF6FC
jne 0x12b0b
movl $0x3af, (%rsp) # imm = 0x3AF
leaq 0x14c98(%rip), %rdx # 0x27795
leaq 0x16c02(%rip), %r9 # 0x29706
jmp 0x12b20
movl %r15d, %eax
jmp 0x12b32
movl $0x2cf, (%rsp) # imm = 0x2CF
leaq 0x14c7c(%rip), %rdx # 0x27795
leaq 0x16916(%rip), %r9 # 0x29436
movq %rbx, %rdi
movl $0x194, %esi # imm = 0x194
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x1d7ed
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
| wengine_handler:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 38h
mov r14d, esi
mov rbx, rdi
xorps xmm0, xmm0
movaps [rbp+var_30], xmm0
movaps [rbp+var_40], xmm0
mov [rbp+var_20], 0
mov rdi, rdx
mov esi, 2Fh ; '/'
call _strchr
mov qword ptr [rbp+var_40], rax
xor r15d, r15d
loc_12A15:
cmp r15, 5
jz short loc_12A4A
test rax, rax
jz short loc_12A3D
lea rdi, [rax+1]
mov qword ptr [rbp+r15*8+var_40], rdi
mov byte ptr [rax], 0
mov esi, 2Fh ; '/'
call _strchr
mov qword ptr [rbp+r15*8+var_40+8], rax
jmp short loc_12A42
loc_12A3D:
mov rax, qword ptr [rbp+r15*8+var_40+8]
loc_12A42:
inc r15
test rax, rax
jnz short loc_12A15
loc_12A4A:
mov r15d, 0FFFFFFFFh
cmp r14d, 1
jnz loc_12B06
lea rdi, _wengine_emit
mov esi, 0FA0h
call html_emit_lock
test eax, eax
jz short loc_12A91
mov [rsp+50h+var_50], 2CFh
lea rdx, aTextHtml; "text/html"
lea r9, unk_29436
mov rdi, rbx
mov esi, 1F4h
jmp loc_12B28
loc_12A91:
mov rdi, qword ptr [rbp+var_40+8]
test rdi, rdi
jz short loc_12AA4
call _atoi
mov r14d, eax
jmp short loc_12AA7
loc_12AA4:
xor r14d, r14d
loc_12AA7:
mov rdi, qword ptr [rbp+var_30]
test rdi, rdi
jz short loc_12AB7
call _atoi
jmp short loc_12AB9
loc_12AB7:
xor eax, eax
loc_12AB9:
mov rdi, qword ptr [rbp+var_40]
movzx esi, r14w
movzx edx, ax
mov rcx, rbx
mov r8d, 1D4C0h
call html_emit_wait
mov r15d, eax
lea rdi, _wengine_emit
call html_emit_unlock
test r15d, r15d
jz short loc_12B06
cmp r15d, 0FFFFF6FCh
jnz short loc_12B0B
mov [rsp+50h+var_50], 3AFh
lea rdx, aTextHtml; "text/html"
lea r9, unk_29706
jmp short loc_12B20
loc_12B06:
mov eax, r15d
jmp short loc_12B32
loc_12B0B:
mov [rsp+50h+var_50], 2CFh
lea rdx, aTextHtml; "text/html"
lea r9, unk_29436
loc_12B20:
mov rdi, rbx
mov esi, 194h
loc_12B28:
xor ecx, ecx
xor r8d, r8d
call httpserver_write_response
loc_12B32:
add rsp, 38h
pop rbx
pop r14
pop r15
pop rbp
retn
| long long wengine_handler(long long a1, int a2, long long a3)
{
_BYTE *v3; // rax
long long v4; // r15
unsigned int v5; // r15d
unsigned __int16 v7; // r14
unsigned __int16 v8; // ax
void *v9; // r9
int v10; // [rsp+0h] [rbp-50h]
__int128 v11; // [rsp+10h] [rbp-40h]
__int128 v12; // [rsp+20h] [rbp-30h]
long long v13; // [rsp+30h] [rbp-20h]
v12 = 0LL;
v11 = 0LL;
v13 = 0LL;
v3 = (_BYTE *)strchr(a3, 47LL);
*(_QWORD *)&v11 = v3;
v4 = 0LL;
do
{
if ( v4 == 5 )
break;
if ( v3 )
{
*((_QWORD *)&v11 + v4) = v3 + 1;
*v3 = 0;
v3 = (_BYTE *)strchr(v3 + 1, 47LL);
*((_QWORD *)&v11 + v4 + 1) = v3;
}
else
{
v3 = (_BYTE *)*((_QWORD *)&v11 + v4 + 1);
}
++v4;
}
while ( v3 );
v5 = -1;
if ( a2 != 1 )
return v5;
if ( (unsigned int)html_emit_lock(&wengine_emit, 4000LL) )
return httpserver_write_response(a1, 500, (unsigned int)aTextHtml, 0, 0, (unsigned int)&unk_29436, 719);
v7 = *((_QWORD *)&v11 + 1) ? atoi() : 0;
v8 = (_QWORD)v12 ? atoi() : 0;
v5 = html_emit_wait(v11, v7, v8, a1, 120000LL);
html_emit_unlock(&wengine_emit);
if ( !v5 )
return v5;
if ( v5 == -2308 )
{
v10 = 943;
v9 = &unk_29706;
}
else
{
v10 = 719;
v9 = &unk_29436;
}
return httpserver_write_response(a1, 404, (unsigned int)aTextHtml, 0, 0, (_DWORD)v9, v10);
}
| wengine_handler:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x38
MOV R14D,ESI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RBP + -0x30],XMM0
MOVAPS xmmword ptr [RBP + -0x40],XMM0
MOV qword ptr [RBP + -0x20],0x0
MOV RDI,RDX
MOV ESI,0x2f
CALL 0x001061d0
MOV qword ptr [RBP + -0x40],RAX
XOR R15D,R15D
LAB_00112a15:
CMP R15,0x5
JZ 0x00112a4a
TEST RAX,RAX
JZ 0x00112a3d
LEA RDI,[RAX + 0x1]
MOV qword ptr [RBP + R15*0x8 + -0x40],RDI
MOV byte ptr [RAX],0x0
MOV ESI,0x2f
CALL 0x001061d0
MOV qword ptr [RBP + R15*0x8 + -0x38],RAX
JMP 0x00112a42
LAB_00112a3d:
MOV RAX,qword ptr [RBP + R15*0x8 + -0x38]
LAB_00112a42:
INC R15
TEST RAX,RAX
JNZ 0x00112a15
LAB_00112a4a:
MOV R15D,0xffffffff
CMP R14D,0x1
JNZ 0x00112b06
LEA RDI,[0x140910]
MOV ESI,0xfa0
CALL 0x00113d99
TEST EAX,EAX
JZ 0x00112a91
MOV dword ptr [RSP],0x2cf
LEA RDX,[0x127795]
LEA R9,[0x129436]
MOV RDI,RBX
MOV ESI,0x1f4
JMP 0x00112b28
LAB_00112a91:
MOV RDI,qword ptr [RBP + -0x38]
TEST RDI,RDI
JZ 0x00112aa4
CALL 0x001064d0
MOV R14D,EAX
JMP 0x00112aa7
LAB_00112aa4:
XOR R14D,R14D
LAB_00112aa7:
MOV RDI,qword ptr [RBP + -0x30]
TEST RDI,RDI
JZ 0x00112ab7
CALL 0x001064d0
JMP 0x00112ab9
LAB_00112ab7:
XOR EAX,EAX
LAB_00112ab9:
MOV RDI,qword ptr [RBP + -0x40]
MOVZX ESI,R14W
MOVZX EDX,AX
MOV RCX,RBX
MOV R8D,0x1d4c0
CALL 0x00113e03
MOV R15D,EAX
LEA RDI,[0x140910]
CALL 0x00113dea
TEST R15D,R15D
JZ 0x00112b06
CMP R15D,0xfffff6fc
JNZ 0x00112b0b
MOV dword ptr [RSP],0x3af
LEA RDX,[0x127795]
LEA R9,[0x129706]
JMP 0x00112b20
LAB_00112b06:
MOV EAX,R15D
JMP 0x00112b32
LAB_00112b0b:
MOV dword ptr [RSP],0x2cf
LEA RDX,[0x127795]
LEA R9,[0x129436]
LAB_00112b20:
MOV RDI,RBX
MOV ESI,0x194
LAB_00112b28:
XOR ECX,ECX
XOR R8D,R8D
CALL 0x0011d7ed
LAB_00112b32:
ADD RSP,0x38
POP RBX
POP R14
POP R15
POP RBP
RET
|
ulong wengine_handler(int8 param_1,int param_2,char *param_3)
{
int iVar1;
uint uVar2;
uint uVar3;
char *pcVar4;
int8 uVar5;
int *puVar6;
long lVar7;
ulong uVar8;
int4 uVar9;
char *local_48 [5];
local_48[2] = (char *)0x0;
local_48[3] = (char *)0x0;
local_48[0] = (char *)0x0;
local_48[1] = (char *)0x0;
local_48[4] = (char *)0x0;
pcVar4 = strchr(param_3,0x2f);
lVar7 = 0;
local_48[0] = pcVar4;
do {
if (lVar7 == 5) break;
if (pcVar4 == (char *)0x0) {
pcVar4 = local_48[lVar7 + 1];
}
else {
local_48[lVar7] = pcVar4 + 1;
*pcVar4 = '\0';
pcVar4 = strchr(pcVar4 + 1,0x2f);
local_48[lVar7 + 1] = pcVar4;
}
lVar7 = lVar7 + 1;
} while (pcVar4 != (char *)0x0);
uVar8 = 0xffffffff;
if (param_2 == 1) {
iVar1 = html_emit_lock(_wengine_emit,4000);
if (iVar1 == 0) {
if (local_48[1] == (char *)0x0) {
uVar2 = 0;
}
else {
uVar2 = atoi(local_48[1]);
}
if (local_48[2] == (char *)0x0) {
uVar3 = 0;
}
else {
uVar3 = atoi(local_48[2]);
}
uVar2 = html_emit_wait(local_48[0],uVar2 & 0xffff,uVar3 & 0xffff,param_1,120000);
html_emit_unlock(_wengine_emit);
if (uVar2 == 0) {
return (ulong)uVar2;
}
if (uVar2 == 0xfffff6fc) {
uVar9 = 0x3af;
puVar6 = &DAT_00129706;
}
else {
uVar9 = 0x2cf;
puVar6 = &DAT_00129436;
}
uVar5 = 0x194;
}
else {
uVar9 = 0x2cf;
puVar6 = &DAT_00129436;
uVar5 = 500;
}
uVar8 = httpserver_write_response(param_1,uVar5,s_text_html_00127795,0,0,puVar6,uVar9);
}
return uVar8;
}
| |
41,530 | my_wc_mb_bin | eloqsql/strings/ctype-bin.c | int my_wc_mb_bin(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
if (s >= e)
return MY_CS_TOOSMALL;
if (wc < 256)
{
s[0]= (char) wc;
return 1;
}
return MY_CS_ILUNI;
} | O3 | c | my_wc_mb_bin:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x331f3
xorl %eax, %eax
cmpq $0xff, %rsi
ja 0x331f3
movb %sil, (%rdx)
movl $0x1, %eax
popq %rbp
retq
| my_wc_mb_bin:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short loc_331F3
xor eax, eax
cmp rsi, 0FFh
ja short loc_331F3
mov [rdx], sil
mov eax, 1
loc_331F3:
pop rbp
retn
| long long my_wc_mb_bin(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
long long result; // rax
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
result = 0LL;
if ( a2 <= 0xFF )
{
*a3 = a2;
return 1LL;
}
}
return result;
}
| my_wc_mb_bin:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x001331f3
XOR EAX,EAX
CMP RSI,0xff
JA 0x001331f3
MOV byte ptr [RDX],SIL
MOV EAX,0x1
LAB_001331f3:
POP RBP
RET
|
int8 my_wc_mb_bin(int8 param_1,ulong param_2,int1 *param_3,int1 *param_4)
{
int8 uVar1;
uVar1 = 0xffffff9b;
if ((param_3 < param_4) && (uVar1 = 0, param_2 < 0x100)) {
*param_3 = (char)param_2;
uVar1 = 1;
}
return uVar1;
}
| |
41,531 | testing::internal::PrintTestPartResult(testing::TestPartResult const&) | seiftnesse[P]memoryallocator/build_O0/_deps/googletest-src/googletest/src/gtest.cc | static void PrintTestPartResult(const TestPartResult& test_part_result) {
const std::string& result = PrintTestPartResultToString(test_part_result);
printf("%s\n", result.c_str());
fflush(stdout);
// If the test program runs in Visual Studio or a debugger, the
// following statements add the test part result message to the Output
// window such that the user can double-click on it to jump to the
// corresponding source code location; otherwise they do nothing.
#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
// We don't call OutputDebugString*() on Windows Mobile, as printing
// to stdout is done by OutputDebugString() there already - we don't
// want the same message printed twice.
::OutputDebugStringA(result.c_str());
::OutputDebugStringA("\n");
#endif
} | O0 | cpp | testing::internal::PrintTestPartResult(testing::TestPartResult const&):
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x33170
movq -0x48(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb280
movq %rax, %rsi
leaq 0x3f04c(%rip), %rdi # 0x74b14
xorl %eax, %eax
callq 0xb090
jmp 0x35ad1
movq 0x6e4c8(%rip), %rax # 0xa3fa0
movq (%rax), %rdi
callq 0xb860
jmp 0x35ae2
leaq -0x30(%rbp), %rdi
callq 0xbe58
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xbe58
movq -0x38(%rbp), %rdi
callq 0xbcd0
nop
| _ZN7testing8internalL19PrintTestPartResultERKNS_14TestPartResultE:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov rsi, [rbp+var_8]
lea rdi, [rbp+var_30]
mov [rbp+var_48], rdi
call _ZN7testing8internalL27PrintTestPartResultToStringB5cxx11ERKNS_14TestPartResultE; testing::internal::PrintTestPartResultToString(testing::TestPartResult const&)
mov rax, [rbp+var_48]
mov [rbp+var_10], rax
mov rdi, [rbp+var_10]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rsi, rax
lea rdi, aNoteSFilterS+12h; "%s\n"
xor eax, eax
call _printf
jmp short $+2
loc_35AD1:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
jmp short $+2
loc_35AE2:
lea rdi, [rbp+var_30]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
add rsp, 50h
pop rbp
retn
mov rcx, rax
mov eax, edx
mov [rbp+var_38], rcx
mov [rbp+var_3C], eax
lea rdi, [rbp+var_30]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov rdi, [rbp+var_38]
call __Unwind_Resume
| void testing::internal::PrintTestPartResult(testing::internal *this, const testing::TestPartResult *a2)
{
const char *v2; // rax
_BYTE v3[32]; // [rsp+20h] [rbp-30h] BYREF
_BYTE *v4; // [rsp+40h] [rbp-10h]
testing::internal *v5; // [rsp+48h] [rbp-8h]
v5 = this;
testing::internal::PrintTestPartResultToString[abi:cxx11]((long long)v3, this);
v4 = v3;
v2 = (const char *)std::string::c_str(v3);
printf("%s\n", v2);
fflush(stdout);
std::string::~string(v3);
}
| PrintTestPartResult:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV RSI,qword ptr [RBP + -0x8]
LEA RDI,[RBP + -0x30]
MOV qword ptr [RBP + -0x48],RDI
CALL 0x00133170
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x10],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0010b280
MOV RSI,RAX
LAB_00135ac1:
LEA RDI,[0x174b14]
XOR EAX,EAX
CALL 0x0010b090
JMP 0x00135ad1
LAB_00135ad1:
MOV RAX,qword ptr [0x001a3fa0]
MOV RDI,qword ptr [RAX]
CALL 0x0010b860
LAB_00135ae0:
JMP 0x00135ae2
LAB_00135ae2:
LEA RDI,[RBP + -0x30]
CALL 0x0010be58
ADD RSP,0x50
POP RBP
RET
|
/* testing::internal::PrintTestPartResult(testing::TestPartResult const&) */
void testing::internal::PrintTestPartResult(TestPartResult *param_1)
{
int8 uVar1;
internal local_38 [32];
internal *local_18;
TestPartResult *local_10;
local_10 = param_1;
PrintTestPartResultToString_abi_cxx11_(local_38,param_1);
local_18 = local_38;
uVar1 = std::__cxx11::string::c_str();
/* try { // try from 00135ac1 to 00135adf has its CatchHandler @ 00135af1 */
printf("%s\n",uVar1);
fflush(*(FILE **)PTR_stdout_001a3fa0);
std::__cxx11::string::~string((string *)local_38);
return;
}
| |
41,532 | mysql_stmt_execute_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_stmt_execute_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_stmt_execute,
(parms->stmt),
parms->stmt->mysql,
int,
r_int)
} | O0 | c | mysql_stmt_execute_start_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x29020
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| mysql_stmt_execute_start_internal:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+38h]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rdi, [rax]
call mysql_stmt_execute
mov [rbp+var_14], eax
mov ecx, [rbp+var_14]
mov rax, [rbp+var_20]
mov [rax+8], ecx
mov rax, [rbp+var_20]
mov dword ptr [rax], 0
add rsp, 20h
pop rbp
retn
| _DWORD * mysql_stmt_execute_start_internal(long long *a1)
{
_DWORD *result; // rax
_DWORD *v2; // [rsp+0h] [rbp-20h]
v2 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(*a1 + 56) + 1152LL) + 40LL);
v2[2] = mysql_stmt_execute(*a1);
result = v2;
*v2 = 0;
return result;
}
| mysql_stmt_execute_start_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
CALL 0x00129020
MOV dword ptr [RBP + -0x14],EAX
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x8],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0x0
ADD RSP,0x20
POP RBP
RET
|
void mysql_stmt_execute_start_internal(long *param_1)
{
int4 *puVar1;
int4 uVar2;
puVar1 = *(int4 **)(*(long *)(*(long *)(*param_1 + 0x38) + 0x480) + 0x28);
uVar2 = mysql_stmt_execute(*param_1);
puVar1[2] = uVar2;
*puVar1 = 0;
return;
}
| |
41,533 | hi0bits | eloqsql/strings/dtoa.c | static int hi0bits(register ULong x)
{
register int k= 0;
if (!(x & 0xffff0000))
{
k= 16;
x<<= 16;
}
if (!(x & 0xff000000))
{
k+= 8;
x<<= 8;
}
if (!(x & 0xf0000000))
{
k+= 4;
x<<= 4;
}
if (!(x & 0xc0000000))
{
k+= 2;
x<<= 2;
}
if (!(x & 0x80000000))
{
k++;
if (!(x & 0x40000000))
return 32;
}
return k;
} | O0 | c | hi0bits:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0x8(%rbp), %eax
andl $0xffff0000, %eax # imm = 0xFFFF0000
cmpl $0x0, %eax
jne 0x733fb
movl $0x10, -0xc(%rbp)
movl -0x8(%rbp), %eax
shll $0x10, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0xff000000, %eax # imm = 0xFF000000
cmpl $0x0, %eax
jne 0x7341a
movl -0xc(%rbp), %eax
addl $0x8, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
shll $0x8, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0xf0000000, %eax # imm = 0xF0000000
cmpl $0x0, %eax
jne 0x73439
movl -0xc(%rbp), %eax
addl $0x4, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
shll $0x4, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0xc0000000, %eax # imm = 0xC0000000
cmpl $0x0, %eax
jne 0x73458
movl -0xc(%rbp), %eax
addl $0x2, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x0, %eax
jne 0x73486
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
andl $0x40000000, %eax # imm = 0x40000000
cmpl $0x0, %eax
jne 0x73484
movl $0x20, -0x4(%rbp)
jmp 0x7348c
jmp 0x73486
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| hi0bits:
push rbp
mov rbp, rsp
mov [rbp+var_8], edi
mov [rbp+var_C], 0
mov eax, [rbp+var_8]
and eax, 0FFFF0000h
cmp eax, 0
jnz short loc_733FB
mov [rbp+var_C], 10h
mov eax, [rbp+var_8]
shl eax, 10h
mov [rbp+var_8], eax
loc_733FB:
mov eax, [rbp+var_8]
and eax, 0FF000000h
cmp eax, 0
jnz short loc_7341A
mov eax, [rbp+var_C]
add eax, 8
mov [rbp+var_C], eax
mov eax, [rbp+var_8]
shl eax, 8
mov [rbp+var_8], eax
loc_7341A:
mov eax, [rbp+var_8]
and eax, 0F0000000h
cmp eax, 0
jnz short loc_73439
mov eax, [rbp+var_C]
add eax, 4
mov [rbp+var_C], eax
mov eax, [rbp+var_8]
shl eax, 4
mov [rbp+var_8], eax
loc_73439:
mov eax, [rbp+var_8]
and eax, 0C0000000h
cmp eax, 0
jnz short loc_73458
mov eax, [rbp+var_C]
add eax, 2
mov [rbp+var_C], eax
mov eax, [rbp+var_8]
shl eax, 2
mov [rbp+var_8], eax
loc_73458:
mov eax, [rbp+var_8]
and eax, 80000000h
cmp eax, 0
jnz short loc_73486
mov eax, [rbp+var_C]
add eax, 1
mov [rbp+var_C], eax
mov eax, [rbp+var_8]
and eax, 40000000h
cmp eax, 0
jnz short loc_73484
mov [rbp+var_4], 20h ; ' '
jmp short loc_7348C
loc_73484:
jmp short $+2
loc_73486:
mov eax, [rbp+var_C]
mov [rbp+var_4], eax
loc_7348C:
mov eax, [rbp+var_4]
pop rbp
retn
| long long hi0bits(int a1)
{
unsigned int v2; // [rsp+0h] [rbp-Ch]
int v3; // [rsp+4h] [rbp-8h]
v3 = a1;
v2 = 0;
if ( (a1 & 0xFFFF0000) == 0 )
{
v2 = 16;
v3 = a1 << 16;
}
if ( (v3 & 0xFF000000) == 0 )
{
v2 += 8;
v3 <<= 8;
}
if ( (v3 & 0xF0000000) == 0 )
{
v2 += 4;
v3 *= 16;
}
if ( (v3 & 0xC0000000) == 0 )
{
v2 += 2;
v3 *= 4;
}
if ( v3 < 0 )
return v2;
++v2;
if ( (v3 & 0x40000000) != 0 )
return v2;
else
return 32;
}
| hi0bits:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x8],EDI
MOV dword ptr [RBP + -0xc],0x0
MOV EAX,dword ptr [RBP + -0x8]
AND EAX,0xffff0000
CMP EAX,0x0
JNZ 0x001733fb
MOV dword ptr [RBP + -0xc],0x10
MOV EAX,dword ptr [RBP + -0x8]
SHL EAX,0x10
MOV dword ptr [RBP + -0x8],EAX
LAB_001733fb:
MOV EAX,dword ptr [RBP + -0x8]
AND EAX,0xff000000
CMP EAX,0x0
JNZ 0x0017341a
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x8
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x8]
SHL EAX,0x8
MOV dword ptr [RBP + -0x8],EAX
LAB_0017341a:
MOV EAX,dword ptr [RBP + -0x8]
AND EAX,0xf0000000
CMP EAX,0x0
JNZ 0x00173439
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x4
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x8]
SHL EAX,0x4
MOV dword ptr [RBP + -0x8],EAX
LAB_00173439:
MOV EAX,dword ptr [RBP + -0x8]
AND EAX,0xc0000000
CMP EAX,0x0
JNZ 0x00173458
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x2
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x8]
SHL EAX,0x2
MOV dword ptr [RBP + -0x8],EAX
LAB_00173458:
MOV EAX,dword ptr [RBP + -0x8]
AND EAX,0x80000000
CMP EAX,0x0
JNZ 0x00173486
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x8]
AND EAX,0x40000000
CMP EAX,0x0
JNZ 0x00173484
MOV dword ptr [RBP + -0x4],0x20
JMP 0x0017348c
LAB_00173484:
JMP 0x00173486
LAB_00173486:
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x4],EAX
LAB_0017348c:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int hi0bits(uint param_1)
{
int local_14;
uint local_10;
int local_c;
local_14 = 0;
local_10 = param_1;
if ((param_1 & 0xffff0000) == 0) {
local_14 = 0x10;
local_10 = param_1 << 0x10;
}
if ((local_10 & 0xff000000) == 0) {
local_14 = local_14 + 8;
local_10 = local_10 << 8;
}
if ((local_10 & 0xf0000000) == 0) {
local_14 = local_14 + 4;
local_10 = local_10 << 4;
}
if ((local_10 & 0xc0000000) == 0) {
local_14 = local_14 + 2;
local_10 = local_10 << 2;
}
if (((local_10 & 0x80000000) == 0) && (local_14 = local_14 + 1, (local_10 & 0x40000000) == 0)) {
local_c = 0x20;
}
else {
local_c = local_14;
}
return local_c;
}
| |
41,534 | nlohmann::json_abi_v3_11_3::detail::iteration_proxy<nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>>::begin() const | monkey531[P]llama/common/./json.hpp | iteration_proxy_value<IteratorType> begin() const noexcept
{
return iteration_proxy_value<IteratorType>(container->begin());
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::iteration_proxy<nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>>::begin() const:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, (%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsp)
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
movq %rcx, 0x18(%rsp)
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0xe44fb
cmpl $0x2, %ecx
je 0xe44ed
cmpl $0x1, %ecx
jne 0xe4506
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xe450f
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0xe450f
movq $0x1, 0x18(%rsp)
jmp 0xe450f
movq $0x0, 0x18(%rsp)
movq %rsp, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xadb5c
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
nop
| _ZNK8nlohmann16json_abi_v3_11_36detail15iteration_proxyINS1_9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEE5beginEv:
push rbx
sub rsp, 20h
mov rbx, rdi
mov rax, [rsi]
mov [rsp+28h+var_28], rax
xorps xmm0, xmm0
movups [rsp+28h+var_20], xmm0
mov rcx, 8000000000000000h
mov [rsp+28h+var_10], rcx
movzx ecx, byte ptr [rax]
test ecx, ecx
jz short loc_E44FB
cmp ecx, 2
jz short loc_E44ED
cmp ecx, 1
jnz short loc_E4506
mov rax, [rax+8]
mov rax, [rax]
mov qword ptr [rsp+28h+var_20], rax
jmp short loc_E450F
loc_E44ED:
mov rax, [rax+8]
mov rax, [rax]
mov qword ptr [rsp+28h+var_20+8], rax
jmp short loc_E450F
loc_E44FB:
mov [rsp+28h+var_10], 1
jmp short loc_E450F
loc_E4506:
mov [rsp+28h+var_10], 0
loc_E450F:
mov rsi, rsp
mov rdi, rbx
xor edx, edx
call _ZN8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEEC2ESH_m; nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>>::iteration_proxy_value(nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>,ulong)
mov rax, rbx
add rsp, 20h
pop rbx
retn
| long long nlohmann::json_abi_v3_11_3::detail::iteration_proxy<nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>>::begin(
long long a1,
unsigned __int8 **a2)
{
unsigned __int8 *v2; // rax
int v3; // ecx
unsigned __int8 *v5; // [rsp+0h] [rbp-28h] BYREF
__int128 v6; // [rsp+8h] [rbp-20h]
long long v7; // [rsp+18h] [rbp-10h]
v2 = *a2;
v5 = v2;
v6 = 0LL;
v7 = 0x8000000000000000LL;
v3 = *v2;
if ( *v2 )
{
if ( v3 == 2 )
{
*((_QWORD *)&v6 + 1) = **((_QWORD **)v2 + 1);
}
else if ( v3 == 1 )
{
*(_QWORD *)&v6 = **((_QWORD **)v2 + 1);
}
else
{
v7 = 0LL;
}
}
else
{
v7 = 1LL;
}
nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>>::iteration_proxy_value(
a1,
(__int128 *)&v5,
0LL);
return a1;
}
| begin:
PUSH RBX
SUB RSP,0x20
MOV RBX,RDI
MOV RAX,qword ptr [RSI]
MOV qword ptr [RSP],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSP + 0x8],XMM0
MOV RCX,-0x8000000000000000
MOV qword ptr [RSP + 0x18],RCX
MOVZX ECX,byte ptr [RAX]
TEST ECX,ECX
JZ 0x001e44fb
CMP ECX,0x2
JZ 0x001e44ed
CMP ECX,0x1
JNZ 0x001e4506
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0x8],RAX
JMP 0x001e450f
LAB_001e44ed:
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0x10],RAX
JMP 0x001e450f
LAB_001e44fb:
MOV qword ptr [RSP + 0x18],0x1
JMP 0x001e450f
LAB_001e4506:
MOV qword ptr [RSP + 0x18],0x0
LAB_001e450f:
MOV RSI,RSP
MOV RDI,RBX
XOR EDX,EDX
CALL 0x001adb5c
MOV RAX,RBX
ADD RSP,0x20
POP RBX
RET
|
/* nlohmann::json_abi_v3_11_3::detail::iteration_proxy<nlohmann::json_abi_v3_11_3::detail::iter_impl<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> > >::begin() const */
void nlohmann::json_abi_v3_11_3::detail::
iteration_proxy<nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>>
::begin(void)
{
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>>
::iteration_proxy_value();
return;
}
| |
41,535 | gc_free_cycles | bluesky950520[P]quickjs/quickjs.c | static void gc_free_cycles(JSRuntime *rt)
{
struct list_head *el, *el1;
JSGCObjectHeader *p;
#ifdef DUMP_GC_FREE
BOOL header_done = FALSE;
#endif
rt->gc_phase = JS_GC_PHASE_REMOVE_CYCLES;
for(;;) {
el = rt->tmp_obj_list.next;
if (el == &rt->tmp_obj_list)
break;
p = list_entry(el, JSGCObjectHeader, link);
/* Only need to free the GC object associated with JS
values. The rest will be automatically removed because they
must be referenced by them. */
switch(p->gc_obj_type) {
case JS_GC_OBJ_TYPE_JS_OBJECT:
case JS_GC_OBJ_TYPE_FUNCTION_BYTECODE:
#ifdef DUMP_GC_FREE
if (check_dump_flag(rt, DUMP_GC_FREE)) {
if (!header_done) {
printf("Freeing cycles:\n");
JS_DumpObjectHeader(rt);
header_done = TRUE;
}
JS_DumpGCObject(rt, p);
}
#endif
free_gc_object(rt, p);
break;
default:
list_del(&p->link);
list_add_tail(&p->link, &rt->gc_zero_ref_count_list);
break;
}
}
rt->gc_phase = JS_GC_PHASE_NONE;
list_for_each_safe(el, el1, &rt->gc_zero_ref_count_list) {
p = list_entry(el, JSGCObjectHeader, link);
assert(p->gc_obj_type == JS_GC_OBJ_TYPE_JS_OBJECT ||
p->gc_obj_type == JS_GC_OBJ_TYPE_FUNCTION_BYTECODE);
js_free_rt(rt, p);
}
init_list_head(&rt->gc_zero_ref_count_list);
} | O0 | c | gc_free_cycles:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movb $0x2, 0xc8(%rax)
movq 0x20(%rsp), %rax
movq 0xc0(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
addq $0xb8, %rcx
cmpq %rcx, %rax
jne 0x2ae1e
jmp 0x2ae7a
movq 0x18(%rsp), %rax
addq $-0x8, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movb 0x4(%rax), %al
andb $0xf, %al
subb $0x1, %al
ja 0x2ae4d
jmp 0x2ae3c
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x5e970
jmp 0x2ae75
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x23c30
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movq 0x20(%rsp), %rsi
addq $0xa8, %rsi
callq 0x23a50
jmp 0x2adf5
movq 0x20(%rsp), %rax
movb $0x0, 0xc8(%rax)
movq 0x20(%rsp), %rax
movq 0xb0(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
addq $0xa8, %rcx
cmpq %rcx, %rax
je 0x2aef2
movq 0x18(%rsp), %rax
addq $-0x8, %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x21960
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x2aea5
movq 0x20(%rsp), %rdi
addq $0xa8, %rdi
callq 0x22390
addq $0x28, %rsp
retq
nopl (%rax,%rax)
| gc_free_cycles:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov rax, [rsp+28h+var_8]
mov byte ptr [rax+0C8h], 2
loc_2ADF5:
mov rax, [rsp+28h+var_8]
mov rax, [rax+0C0h]
mov [rsp+28h+var_10], rax
mov rax, [rsp+28h+var_10]
mov rcx, [rsp+28h+var_8]
add rcx, 0B8h
cmp rax, rcx
jnz short loc_2AE1E
jmp short loc_2AE7A
loc_2AE1E:
mov rax, [rsp+28h+var_10]
add rax, 0FFFFFFFFFFFFFFF8h
mov [rsp+28h+var_20], rax
mov rax, [rsp+28h+var_20]
mov al, [rax+4]
and al, 0Fh
sub al, 1
ja short loc_2AE4D
jmp short $+2
loc_2AE3C:
mov rdi, [rsp+28h+var_8]
mov rsi, [rsp+28h+var_20]
call free_gc_object
jmp short loc_2AE75
loc_2AE4D:
mov rdi, [rsp+28h+var_20]
add rdi, 8
call list_del_0
mov rdi, [rsp+28h+var_20]
add rdi, 8
mov rsi, [rsp+28h+var_8]
add rsi, 0A8h
call list_add_tail_0
loc_2AE75:
jmp loc_2ADF5
loc_2AE7A:
mov rax, [rsp+28h+var_8]
mov byte ptr [rax+0C8h], 0
mov rax, [rsp+28h+var_8]
mov rax, [rax+0B0h]
mov [rsp+28h+var_10], rax
mov rax, [rsp+28h+var_10]
mov rax, [rax+8]
mov [rsp+28h+var_18], rax
loc_2AEA5:
mov rax, [rsp+28h+var_10]
mov rcx, [rsp+28h+var_8]
add rcx, 0A8h
cmp rax, rcx
jz short loc_2AEF2
mov rax, [rsp+28h+var_10]
add rax, 0FFFFFFFFFFFFFFF8h
mov [rsp+28h+var_20], rax
mov rdi, [rsp+28h+var_8]
mov rsi, [rsp+28h+var_20]
call js_free_rt
mov rax, [rsp+28h+var_18]
mov [rsp+28h+var_10], rax
mov rax, [rsp+28h+var_10]
mov rax, [rax+8]
mov [rsp+28h+var_18], rax
jmp short loc_2AEA5
loc_2AEF2:
mov rdi, [rsp+28h+var_8]
add rdi, 0A8h
call init_list_head_0
add rsp, 28h
retn
| _QWORD * gc_free_cycles(long long a1)
{
long long v2; // [rsp+10h] [rbp-18h]
_QWORD *v3; // [rsp+18h] [rbp-10h]
long long v4; // [rsp+18h] [rbp-10h]
*(_BYTE *)(a1 + 200) = 2;
while ( 1 )
{
v3 = *(_QWORD **)(a1 + 192);
if ( v3 == (_QWORD *)(a1 + 184) )
break;
if ( (*((_BYTE *)v3 - 4) & 0xFu) > 1 )
{
list_del_0(v3);
list_add_tail_0((long long)v3, (_QWORD *)(a1 + 168));
}
else
{
free_gc_object(a1, v3 - 1);
}
}
*(_BYTE *)(a1 + 200) = 0;
v4 = *(_QWORD *)(a1 + 176);
v2 = *(_QWORD *)(v4 + 8);
while ( v4 != a1 + 168 )
{
js_free_rt(a1, v4 - 8);
v4 = v2;
v2 = *(_QWORD *)(v2 + 8);
}
return init_list_head_0((_QWORD *)(a1 + 168));
}
| gc_free_cycles:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV RAX,qword ptr [RSP + 0x20]
MOV byte ptr [RAX + 0xc8],0x2
LAB_0012adf5:
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + 0xc0]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x20]
ADD RCX,0xb8
CMP RAX,RCX
JNZ 0x0012ae1e
JMP 0x0012ae7a
LAB_0012ae1e:
MOV RAX,qword ptr [RSP + 0x18]
ADD RAX,-0x8
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV AL,byte ptr [RAX + 0x4]
AND AL,0xf
SUB AL,0x1
JA 0x0012ae4d
JMP 0x0012ae3c
LAB_0012ae3c:
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x0015e970
JMP 0x0012ae75
LAB_0012ae4d:
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x8
CALL 0x00123c30
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x8
MOV RSI,qword ptr [RSP + 0x20]
ADD RSI,0xa8
CALL 0x00123a50
LAB_0012ae75:
JMP 0x0012adf5
LAB_0012ae7a:
MOV RAX,qword ptr [RSP + 0x20]
MOV byte ptr [RAX + 0xc8],0x0
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + 0xb0]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x10],RAX
LAB_0012aea5:
MOV RAX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x20]
ADD RCX,0xa8
CMP RAX,RCX
JZ 0x0012aef2
MOV RAX,qword ptr [RSP + 0x18]
ADD RAX,-0x8
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x00121960
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x10],RAX
JMP 0x0012aea5
LAB_0012aef2:
MOV RDI,qword ptr [RSP + 0x20]
ADD RDI,0xa8
CALL 0x00122390
ADD RSP,0x28
RET
|
void gc_free_cycles(long param_1)
{
long lVar1;
long local_18;
long local_10;
*(int1 *)(param_1 + 200) = 2;
while (lVar1 = *(long *)(param_1 + 0xc0), lVar1 != param_1 + 0xb8) {
if ((*(byte *)(lVar1 + -4) & 0xf) < 2) {
free_gc_object(param_1,lVar1 + -8);
}
else {
list_del(lVar1);
list_add_tail(lVar1,param_1 + 0xa8);
}
}
*(int1 *)(param_1 + 200) = 0;
local_10 = *(long *)(param_1 + 0xb0);
local_18 = *(long *)(local_10 + 8);
while (local_10 != param_1 + 0xa8) {
js_free_rt(param_1,local_10 + -8);
local_10 = local_18;
local_18 = *(long *)(local_18 + 8);
}
init_list_head(param_1 + 0xa8);
return;
}
| |
41,536 | bf_pow_ui_ui | bluesky950520[P]quickjs/libbf.c | static int bf_pow_ui_ui(bf_t *r, limb_t a1, limb_t b,
limb_t prec, bf_flags_t flags)
{
bf_t a;
int ret;
if (a1 == 10 && b <= LIMB_DIGITS) {
/* use precomputed powers. We do not round at this point
because we expect the caller to do it */
ret = bf_set_ui(r, mp_pow_dec[b]);
} else {
bf_init(r->ctx, &a);
ret = bf_set_ui(&a, a1);
ret |= bf_pow_ui(r, &a, b, prec, flags);
bf_delete(&a);
}
return ret;
} | O2 | c | bf_pow_ui_ui:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %r12
cmpq $0xa, %rsi
setne %al
cmpq $0x14, %rdx
setae %cl
orb %al, %cl
jne 0x76619
leaq 0x16841(%rip), %rax # 0x8ce40
movq (%rax,%r14,8), %rsi
movq %r12, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x73106
movl %r8d, %ebx
movq (%r12), %rax
movq %rsp, %r13
movq %rax, (%r13)
andl $0x0, 0x8(%r13)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x10(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r13)
movq %r13, %rdi
callq 0x73106
movl %eax, %ebp
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %r15, %rcx
movl %ebx, %r8d
callq 0x78f8d
movl %eax, %ebx
orl %ebp, %ebx
movq %r13, %rdi
callq 0x7500e
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| bf_pow_ui_ui:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r15, rcx
mov r14, rdx
mov r12, rdi
cmp rsi, 0Ah
setnz al
cmp rdx, 14h
setnb cl
or cl, al
jnz short loc_76619
lea rax, mp_pow_dec
mov rsi, [rax+r14*8]
mov rdi, r12
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp bf_set_ui
loc_76619:
mov ebx, r8d
mov rax, [r12]
mov r13, rsp
mov [r13+0], rax
and dword ptr [r13+8], 0
mov rax, 8000000000000000h
mov [r13+10h], rax
xorps xmm0, xmm0
movups xmmword ptr [r13+18h], xmm0
mov rdi, r13
call bf_set_ui
mov ebp, eax
mov rdi, r12
mov rsi, r13
mov rdx, r14
mov rcx, r15
mov r8d, ebx
call bf_pow_ui
mov ebx, eax
or ebx, ebp
mov rdi, r13
call bf_delete_0
mov eax, ebx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long bf_pow_ui_ui(long long *a1, unsigned long long a2, unsigned long long a3, long long a4, unsigned int a5)
{
int v9; // ebp
unsigned int v10; // ebx
long long v11; // [rsp+0h] [rbp-58h] BYREF
int v12; // [rsp+8h] [rbp-50h]
unsigned long long v13; // [rsp+10h] [rbp-48h]
__int128 v14; // [rsp+18h] [rbp-40h]
if ( a2 == 10 && a3 < 0x14 )
return bf_set_ui((long long)a1, mp_pow_dec[a3]);
v11 = *a1;
v12 = 0;
v13 = 0x8000000000000000LL;
v14 = 0LL;
v9 = bf_set_ui((long long)&v11, a2);
v10 = v9 | bf_pow_ui(a1, &v11, a3, a4, a5);
bf_delete_0(&v11);
return v10;
}
| bf_pow_ui_ui:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R15,RCX
MOV R14,RDX
MOV R12,RDI
CMP RSI,0xa
SETNZ AL
CMP RDX,0x14
SETNC CL
OR CL,AL
JNZ 0x00176619
LEA RAX,[0x18ce40]
MOV RSI,qword ptr [RAX + R14*0x8]
MOV RDI,R12
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00173106
LAB_00176619:
MOV EBX,R8D
MOV RAX,qword ptr [R12]
MOV R13,RSP
MOV qword ptr [R13],RAX
AND dword ptr [R13 + 0x8],0x0
MOV RAX,-0x8000000000000000
MOV qword ptr [R13 + 0x10],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R13 + 0x18],XMM0
MOV RDI,R13
CALL 0x00173106
MOV EBP,EAX
MOV RDI,R12
MOV RSI,R13
MOV RDX,R14
MOV RCX,R15
MOV R8D,EBX
CALL 0x00178f8d
MOV EBX,EAX
OR EBX,EBP
MOV RDI,R13
CALL 0x0017500e
MOV EAX,EBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong bf_pow_ui_ui(int8 *param_1,long param_2,ulong param_3,int8 param_4,
int4 param_5)
{
uint uVar1;
uint uVar2;
ulong uVar3;
int8 local_58;
int4 local_50;
int8 local_48;
int8 local_40;
int8 uStack_38;
if (param_3 < 0x14 && param_2 == 10) {
uVar3 = bf_set_ui(param_1,*(int8 *)(mp_pow_dec + param_3 * 8));
return uVar3;
}
local_58 = *param_1;
local_50 = 0;
local_48 = 0x8000000000000000;
local_40 = 0;
uStack_38 = 0;
uVar1 = bf_set_ui(&local_58);
uVar2 = bf_pow_ui(param_1,&local_58,param_3,param_4,param_5);
bf_delete(&local_58);
return (ulong)(uVar2 | uVar1);
}
| |
41,537 | my_filename | eloqsql/mysys/my_div.c | char * my_filename(File fd)
{
DBUG_ENTER("my_filename");
if ((uint) fd >= (uint) my_file_limit || !my_file_info[fd].name)
DBUG_RETURN((char*) "UNKNOWN");
if (fd >= 0 && my_file_info[fd].type != UNOPEN)
{
DBUG_RETURN(my_file_info[fd].name);
}
else
DBUG_RETURN((char*) "UNOPENED"); /* Debug message */
} | O0 | c | my_filename:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x19b64f(%rip), %rcx # 0x1d6400
cmpl (%rcx), %eax
jae 0x3add0
leaq 0x19b64c(%rip), %rax # 0x1d6408
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0x3addf
jmp 0x3add2
leaq 0x46463(%rip), %rax # 0x8123c
movq %rax, -0x8(%rbp)
jmp 0x3ae2d
cmpl $0x0, -0xc(%rbp)
jl 0x3ae20
leaq 0x19b61c(%rip), %rax # 0x1d6408
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
je 0x3ae20
jmp 0x3ae02
leaq 0x19b5ff(%rip), %rax # 0x1d6408
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3ae2d
jmp 0x3ae22
leaq 0x4641b(%rip), %rax # 0x81244
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| my_filename:
push rbp
mov rbp, rsp
mov [rbp+var_C], edi
mov eax, [rbp+var_C]
lea rcx, my_file_limit
cmp eax, [rcx]
jnb short loc_3ADD0
lea rax, my_file_info
mov rax, [rax]
movsxd rcx, [rbp+var_C]
shl rcx, 4
add rax, rcx
cmp qword ptr [rax], 0
jnz short loc_3ADDF
loc_3ADD0:
jmp short $+2
loc_3ADD2:
lea rax, aUnknown_0; "UNKNOWN"
mov [rbp+var_8], rax
jmp short loc_3AE2D
loc_3ADDF:
cmp [rbp+var_C], 0
jl short loc_3AE20
lea rax, my_file_info
mov rax, [rax]
movsxd rcx, [rbp+var_C]
shl rcx, 4
add rax, rcx
cmp dword ptr [rax+8], 0
jz short loc_3AE20
jmp short $+2
loc_3AE02:
lea rax, my_file_info
mov rax, [rax]
movsxd rcx, [rbp+var_C]
shl rcx, 4
add rax, rcx
mov rax, [rax]
mov [rbp+var_8], rax
jmp short loc_3AE2D
loc_3AE20:
jmp short $+2
loc_3AE22:
lea rax, aUnopened; "UNOPENED"
mov [rbp+var_8], rax
loc_3AE2D:
mov rax, [rbp+var_8]
pop rbp
retn
| const char * my_filename(int a1)
{
if ( (unsigned int)a1 >= my_file_limit || !*((_QWORD *)my_file_info + 2 * a1) )
return "UNKNOWN";
if ( a1 >= 0 && *((_DWORD *)my_file_info + 4 * a1 + 2) )
return (const char *)*((_QWORD *)my_file_info + 2 * a1);
return "UNOPENED";
}
| my_filename:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0xc],EDI
MOV EAX,dword ptr [RBP + -0xc]
LEA RCX,[0x2d6400]
CMP EAX,dword ptr [RCX]
JNC 0x0013add0
LEA RAX,[0x2d6408]
MOV RAX,qword ptr [RAX]
MOVSXD RCX,dword ptr [RBP + -0xc]
SHL RCX,0x4
ADD RAX,RCX
CMP qword ptr [RAX],0x0
JNZ 0x0013addf
LAB_0013add0:
JMP 0x0013add2
LAB_0013add2:
LEA RAX,[0x18123c]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0013ae2d
LAB_0013addf:
CMP dword ptr [RBP + -0xc],0x0
JL 0x0013ae20
LEA RAX,[0x2d6408]
MOV RAX,qword ptr [RAX]
MOVSXD RCX,dword ptr [RBP + -0xc]
SHL RCX,0x4
ADD RAX,RCX
CMP dword ptr [RAX + 0x8],0x0
JZ 0x0013ae20
JMP 0x0013ae02
LAB_0013ae02:
LEA RAX,[0x2d6408]
MOV RAX,qword ptr [RAX]
MOVSXD RCX,dword ptr [RBP + -0xc]
SHL RCX,0x4
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0013ae2d
LAB_0013ae20:
JMP 0x0013ae22
LAB_0013ae22:
LEA RAX,[0x181244]
MOV qword ptr [RBP + -0x8],RAX
LAB_0013ae2d:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
char * my_filename(uint param_1)
{
char *local_10;
if ((param_1 < my_file_limit) && (*(long *)(my_file_info + (long)(int)param_1 * 0x10) != 0)) {
if (((int)param_1 < 0) || (*(int *)(my_file_info + (long)(int)param_1 * 0x10 + 8) == 0)) {
local_10 = "UNOPENED";
}
else {
local_10 = *(char **)(my_file_info + (long)(int)param_1 * 0x10);
}
}
else {
local_10 = "UNKNOWN";
}
return local_10;
}
| |
41,538 | ma_remove_not_visible_states_with_lock | eloqsql/storage/maria/ma_state.c | void _ma_remove_not_visible_states_with_lock(MARIA_SHARE *share,
my_bool all)
{
my_bool is_lock_trman;
if ((is_lock_trman= trman_is_inited()))
trnman_lock();
mysql_mutex_lock(&share->intern_lock);
share->state_history= _ma_remove_not_visible_states(share->state_history,
all, 1);
mysql_mutex_unlock(&share->intern_lock);
if (is_lock_trman)
trnman_unlock();
} | O0 | c | ma_remove_not_visible_states_with_lock:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movb $0x0, %al
callq 0x75130
movb %al, -0xa(%rbp)
cmpb $0x0, %al
je 0x43987
movb $0x0, %al
callq 0x750f0
movq -0x8(%rbp), %rdi
addq $0x8f0, %rdi # imm = 0x8F0
leaq 0x10eacf(%rip), %rsi # 0x152468
movl $0xe1, %edx
callq 0x43780
movq -0x8(%rbp), %rax
movq 0x450(%rax), %rdi
movl $0x1, %edx
movsbl -0x9(%rbp), %esi
callq 0x43850
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x450(%rax)
movq -0x8(%rbp), %rdi
addq $0x8f0, %rdi # imm = 0x8F0
callq 0x437f0
cmpb $0x0, -0xa(%rbp)
je 0x439e7
movb $0x0, %al
callq 0x75110
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| _ma_remove_not_visible_states_with_lock:
push rbp
mov rbp, rsp
sub rsp, 10h
mov al, sil
mov [rbp+var_8], rdi
mov [rbp+var_9], al
mov al, 0
call trman_is_inited
mov [rbp+var_A], al
cmp al, 0
jz short loc_43987
mov al, 0
call trnman_lock
loc_43987:
mov rdi, [rbp+var_8]
add rdi, 8F0h
lea rsi, aWorkspaceLlm4b_6; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0E1h
call inline_mysql_mutex_lock_5
mov rax, [rbp+var_8]
mov rdi, [rax+450h]
mov edx, 1
movsx esi, [rbp+var_9]
call _ma_remove_not_visible_states
mov rcx, rax
mov rax, [rbp+var_8]
mov [rax+450h], rcx
mov rdi, [rbp+var_8]
add rdi, 8F0h
call inline_mysql_mutex_unlock_5
cmp [rbp+var_A], 0
jz short loc_439E7
mov al, 0
call trnman_unlock
loc_439E7:
add rsp, 10h
pop rbp
retn
| long long ma_remove_not_visible_states_with_lock(long long a1, char a2)
{
long long result; // rax
char is_inited; // [rsp+6h] [rbp-Ah]
is_inited = trman_is_inited();
if ( is_inited )
trnman_lock();
inline_mysql_mutex_lock_5(
a1 + 2288,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_state.c",
0xE1u);
*(_QWORD *)(a1 + 1104) = ma_remove_not_visible_states(*(_QWORD **)(a1 + 1104), a2, 1);
result = inline_mysql_mutex_unlock_5(a1 + 2288);
if ( is_inited )
return trnman_unlock();
return result;
}
| _ma_remove_not_visible_states_with_lock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV AL,SIL
MOV qword ptr [RBP + -0x8],RDI
MOV byte ptr [RBP + -0x9],AL
MOV AL,0x0
CALL 0x00175130
MOV byte ptr [RBP + -0xa],AL
CMP AL,0x0
JZ 0x00143987
MOV AL,0x0
CALL 0x001750f0
LAB_00143987:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x8f0
LEA RSI,[0x252468]
MOV EDX,0xe1
CALL 0x00143780
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x450]
MOV EDX,0x1
MOVSX ESI,byte ptr [RBP + -0x9]
CALL 0x00143850
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x450],RCX
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x8f0
CALL 0x001437f0
CMP byte ptr [RBP + -0xa],0x0
JZ 0x001439e7
MOV AL,0x0
CALL 0x00175110
LAB_001439e7:
ADD RSP,0x10
POP RBP
RET
|
void _ma_remove_not_visible_states_with_lock(long param_1,char param_2)
{
char cVar1;
int8 uVar2;
cVar1 = trman_is_inited();
if (cVar1 != '\0') {
trnman_lock();
}
inline_mysql_mutex_lock
(param_1 + 0x8f0,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_state.c",
0xe1);
uVar2 = _ma_remove_not_visible_states(*(int8 *)(param_1 + 0x450),(int)param_2,1);
*(int8 *)(param_1 + 0x450) = uVar2;
inline_mysql_mutex_unlock(param_1 + 0x8f0);
if (cVar1 != '\0') {
trnman_unlock();
}
return;
}
| |
41,539 | my_setwd | eloqsql/mysys/my_getwd.c | int my_setwd(const char *dir, myf MyFlags)
{
int res;
size_t length;
char *start, *pos;
DBUG_ENTER("my_setwd");
DBUG_PRINT("my",("dir: '%s' MyFlags %lu", dir, MyFlags));
start=(char *) dir;
if (! dir[0] || (dir[0] == FN_LIBCHAR && dir[1] == 0))
dir=FN_ROOTDIR;
if ((res=chdir((char*) dir)) != 0)
{
my_errno=errno;
if (MyFlags & MY_WME)
my_error(EE_SETWD,MYF(ME_BELL),start,errno);
}
else
{
if (test_if_hard_path(start))
{ /* Hard pathname */
pos= strmake(&curr_dir[0],start,(size_t) FN_REFLEN-1);
if (pos[-1] != FN_LIBCHAR)
{
length=(uint) (pos-(char*) curr_dir);
curr_dir[length]=FN_LIBCHAR; /* must end with '/' */
curr_dir[length+1]='\0';
}
}
else
curr_dir[0]='\0'; /* Don't save name */
}
DBUG_RETURN(res);
} | O3 | c | my_setwd:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
je 0xc241f
movq %r14, %rdi
cmpl $0x2f, %eax
jne 0xc2426
cmpb $0x0, 0x1(%r14)
movq %r14, %rdi
jne 0xc2426
leaq 0x486df(%rip), %rdi # 0x10ab05
callq 0x2bb40
movl %eax, %ebx
testl %eax, %eax
je 0xc2464
callq 0x2b950
movq %rax, %r12
movl (%rax), %r13d
callq 0xc5c9a
movl %r13d, (%rax)
testb $0x10, %r15b
je 0xc24c1
movl (%r12), %ecx
movl $0x4, %esi
movl $0x11, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0xbf527
jmp 0xc24c1
leaq 0xb9916d(%rip), %rax # 0xc5b5d8
movq (%rax), %rax
movq %r14, %rcx
movzbl (%rcx), %edx
cmpl $0x7e, %edx
jne 0xc2489
cmpb $0x2f, 0x1(%rcx)
jne 0xc24b7
movq %rax, %rcx
testq %rax, %rax
jne 0xc2471
jmp 0xc24b7
cmpl $0x2f, %edx
jne 0xc24b7
leaq 0xb9915b(%rip), %r15 # 0xc5b5f0
movl $0x1ff, %edx # imm = 0x1FF
movq %r15, %rdi
movq %r14, %rsi
callq 0xfbd9c
cmpb $0x2f, -0x1(%rax)
je 0xc24c1
subl %r15d, %eax
movw $0x2f, (%r15,%rax)
jmp 0xc24c1
leaq 0xb99132(%rip), %rax # 0xc5b5f0
movb $0x0, (%rax)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_setwd:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rsi
mov r14, rdi
movzx eax, byte ptr [rdi]
test eax, eax
jz short loc_C241F
mov rdi, r14
cmp eax, 2Fh ; '/'
jnz short loc_C2426
cmp byte ptr [r14+1], 0
mov rdi, r14
jnz short loc_C2426
loc_C241F:
lea rdi, unk_10AB05
loc_C2426:
call _chdir
mov ebx, eax
test eax, eax
jz short loc_C2464
call ___errno_location
mov r12, rax
mov r13d, [rax]
call _my_thread_var
mov [rax], r13d
test r15b, 10h
jz short loc_C24C1
mov ecx, [r12]
mov esi, 4
mov edi, 11h
mov rdx, r14
xor eax, eax
call my_error
jmp short loc_C24C1
loc_C2464:
lea rax, home_dir
mov rax, [rax]
mov rcx, r14
loc_C2471:
movzx edx, byte ptr [rcx]
cmp edx, 7Eh ; '~'
jnz short loc_C2489
cmp byte ptr [rcx+1], 2Fh ; '/'
jnz short loc_C24B7
mov rcx, rax
test rax, rax
jnz short loc_C2471
jmp short loc_C24B7
loc_C2489:
cmp edx, 2Fh ; '/'
jnz short loc_C24B7
lea r15, curr_dir
mov edx, 1FFh
mov rdi, r15
mov rsi, r14
call strmake
cmp byte ptr [rax-1], 2Fh ; '/'
jz short loc_C24C1
sub eax, r15d
mov word ptr [r15+rax], 2Fh ; '/'
jmp short loc_C24C1
loc_C24B7:
lea rax, curr_dir
mov byte ptr [rax], 0
loc_C24C1:
mov eax, ebx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_setwd(unsigned __int8 *a1, char a2)
{
unsigned __int8 *v2; // r14
unsigned int v3; // ebx
unsigned int *v4; // r12
unsigned int v5; // r13d
unsigned __int8 *v6; // rcx
int v7; // edx
long long v8; // rax
v2 = a1;
if ( !*a1 || *a1 == 47 && !a1[1] )
a1 = (unsigned __int8 *)&unk_10AB05;
v3 = chdir(a1);
if ( v3 )
{
v4 = (unsigned int *)__errno_location(a1);
v5 = *v4;
*(_DWORD *)my_thread_var(a1) = v5;
if ( (a2 & 0x10) != 0 )
my_error(0x11u, 4LL, v2, *v4);
}
else
{
v6 = v2;
while ( 1 )
{
v7 = *v6;
if ( v7 != 126 )
break;
if ( v6[1] == 47 )
{
v6 = (unsigned __int8 *)home_dir;
if ( home_dir )
continue;
}
goto LABEL_16;
}
if ( v7 != 47 )
{
LABEL_16:
curr_dir[0] = 0;
return v3;
}
v8 = strmake(curr_dir, v2, 511LL);
if ( *(_BYTE *)(v8 - 1) != 47 )
*(_WORD *)&curr_dir[(unsigned int)v8 - (unsigned int)curr_dir] = 47;
}
return v3;
}
| my_setwd:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RSI
MOV R14,RDI
MOVZX EAX,byte ptr [RDI]
TEST EAX,EAX
JZ 0x001c241f
MOV RDI,R14
CMP EAX,0x2f
JNZ 0x001c2426
CMP byte ptr [R14 + 0x1],0x0
MOV RDI,R14
JNZ 0x001c2426
LAB_001c241f:
LEA RDI,[0x20ab05]
LAB_001c2426:
CALL 0x0012bb40
MOV EBX,EAX
TEST EAX,EAX
JZ 0x001c2464
CALL 0x0012b950
MOV R12,RAX
MOV R13D,dword ptr [RAX]
CALL 0x001c5c9a
MOV dword ptr [RAX],R13D
TEST R15B,0x10
JZ 0x001c24c1
MOV ECX,dword ptr [R12]
MOV ESI,0x4
MOV EDI,0x11
MOV RDX,R14
XOR EAX,EAX
CALL 0x001bf527
JMP 0x001c24c1
LAB_001c2464:
LEA RAX,[0xd5b5d8]
MOV RAX,qword ptr [RAX]
MOV RCX,R14
LAB_001c2471:
MOVZX EDX,byte ptr [RCX]
CMP EDX,0x7e
JNZ 0x001c2489
CMP byte ptr [RCX + 0x1],0x2f
JNZ 0x001c24b7
MOV RCX,RAX
TEST RAX,RAX
JNZ 0x001c2471
JMP 0x001c24b7
LAB_001c2489:
CMP EDX,0x2f
JNZ 0x001c24b7
LEA R15,[0xd5b5f0]
MOV EDX,0x1ff
MOV RDI,R15
MOV RSI,R14
CALL 0x001fbd9c
CMP byte ptr [RAX + -0x1],0x2f
JZ 0x001c24c1
SUB EAX,R15D
MOV word ptr [R15 + RAX*0x1],0x2f
JMP 0x001c24c1
LAB_001c24b7:
LEA RAX,[0xd5b5f0]
MOV byte ptr [RAX],0x0
LAB_001c24c1:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int my_setwd(char *param_1,ulong param_2)
{
int iVar1;
int iVar2;
int *piVar3;
int *piVar4;
long lVar5;
char *pcVar6;
if ((*param_1 == '\0') || ((pcVar6 = param_1, *param_1 == '/' && (param_1[1] == '\0')))) {
pcVar6 = "/";
}
iVar2 = chdir(pcVar6);
pcVar6 = param_1;
if (iVar2 == 0) {
while (*pcVar6 == '~') {
if ((pcVar6[1] != '/') || (pcVar6 = home_dir, home_dir == (char *)0x0)) goto LAB_001c24b7;
}
if (*pcVar6 == '/') {
lVar5 = strmake(&curr_dir,param_1,0x1ff);
if (*(char *)(lVar5 + -1) == '/') {
return 0;
}
*(int2 *)(&curr_dir + ((int)lVar5 - 0xd5b5f0)) = 0x2f;
return 0;
}
LAB_001c24b7:
curr_dir = 0;
}
else {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar4 = (int *)_my_thread_var();
*piVar4 = iVar1;
if ((param_2 & 0x10) != 0) {
my_error(0x11,4,param_1,*piVar3);
}
}
return iVar2;
}
| |
41,540 | my_large_malloc | eloqsql/mysys/my_largepage.c | uchar *my_large_malloc(size_t *size, myf my_flags)
{
uchar *ptr= NULL;
#ifdef _WIN32
DWORD alloc_type= MEM_COMMIT | MEM_RESERVE;
size_t orig_size= *size;
DBUG_ENTER("my_large_malloc");
if (my_use_large_pages)
{
alloc_type|= MEM_LARGE_PAGES;
/* Align block size to my_large_page_size */
*size= MY_ALIGN(*size, (size_t) my_large_page_size);
}
ptr= VirtualAlloc(NULL, *size, alloc_type, PAGE_READWRITE);
if (!ptr)
{
if (my_flags & MY_WME)
{
if (my_use_large_pages)
{
my_printf_error(EE_OUTOFMEMORY,
"Couldn't allocate %zu bytes (MEM_LARGE_PAGES page "
"size %zu); Windows error %lu",
MYF(ME_WARNING | ME_ERROR_LOG_ONLY), *size,
my_large_page_size, GetLastError());
}
else
{
my_error(EE_OUTOFMEMORY, MYF(ME_BELL+ME_ERROR_LOG), *size);
}
}
if (my_use_large_pages)
{
*size= orig_size;
ptr= VirtualAlloc(NULL, *size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
if (!ptr && my_flags & MY_WME)
{
my_error(EE_OUTOFMEMORY, MYF(ME_BELL+ME_ERROR_LOG), *size);
}
}
}
#elif defined(HAVE_MMAP)
int mapflag;
int page_i= 0;
size_t large_page_size= 0;
size_t aligned_size= *size;
DBUG_ENTER("my_large_malloc");
while (1)
{
mapflag= MAP_PRIVATE | OS_MAP_ANON;
if (my_use_large_pages)
{
large_page_size= my_next_large_page_size(*size, &page_i);
/* this might be 0, in which case we do a standard mmap */
if (large_page_size)
{
#if defined(MAP_HUGETLB) /* linux 2.6.32 */
mapflag|= MAP_HUGETLB;
#if defined(MAP_HUGE_SHIFT) /* Linux-3.8+ */
mapflag|= my_bit_log2_size_t(large_page_size) << MAP_HUGE_SHIFT;
#else
# warning "No explicit large page (HUGETLB pages) support in Linux < 3.8"
#endif
#elif defined(MAP_ALIGNED)
mapflag|= MAP_ALIGNED(my_bit_log2_size_t(large_page_size));
#if defined(MAP_ALIGNED_SUPER)
mapflag|= MAP_ALIGNED_SUPER;
#endif
#endif
aligned_size= MY_ALIGN(*size, (size_t) large_page_size);
}
else
{
aligned_size= *size;
}
}
ptr= mmap(NULL, aligned_size, PROT_READ | PROT_WRITE, mapflag, -1, 0);
if (ptr == (void*) -1)
{
ptr= NULL;
if (my_flags & MY_WME)
{
if (large_page_size)
{
my_printf_error(EE_OUTOFMEMORY,
"Couldn't allocate %zu bytes (Large/HugeTLB memory "
"page size %zu); errno %u; continuing to smaller size",
MYF(ME_WARNING | ME_ERROR_LOG_ONLY),
aligned_size, large_page_size, errno);
}
else
{
my_error(EE_OUTOFMEMORY, MYF(ME_BELL+ME_ERROR_LOG), aligned_size);
}
}
/* try next smaller memory size */
if (large_page_size && errno == ENOMEM)
continue;
/* other errors are more serious */
break;
}
else /* success */
{
if (large_page_size)
{
/*
we do need to record the adjustment so that munmap gets called with
the right size. This is only the case for HUGETLB pages.
*/
*size= aligned_size;
}
break;
}
if (large_page_size == 0)
{
break; /* no more options to try */
}
}
#else
DBUG_RETURN(my_malloc_lock(*size, my_flags));
#endif /* defined(HAVE_MMAP) */
if (ptr != NULL)
{
MEM_MAKE_DEFINED(ptr, *size);
}
DBUG_RETURN(ptr);
} | O3 | c | my_large_malloc:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
movq (%rdi), %rbx
xorl %r14d, %r14d
xorl %r13d, %r13d
movl $0x22, %ecx
cmpb $0x1, 0xb62676(%rip) # 0xc0b0a0
jne 0xa8a81
movq -0x30(%rbp), %rax
movq (%rax), %rbx
cmpl $0x9, %r14d
movl $0x8, %edx
cmovgel %r14d, %edx
cmpl $0x7, %r14d
jg 0xa8a7e
movslq %r14d, %rsi
leaq 0xb62660(%rip), %rax # 0xc0b0b0
leaq (%rax,%rsi,8), %rdi
subq %rdx, %rsi
xorl %eax, %eax
movq (%rdi), %r13
testq %r13, %r13
je 0xa8a7b
cmpq %rbx, %r13
jbe 0xa8afe
decq %rax
addq $0x8, %rdi
cmpq %rax, %rsi
jne 0xa8a59
movl %edx, %r14d
jmp 0xa8a7e
subl %eax, %r14d
xorl %r13d, %r13d
xorl %edi, %edi
movq %rbx, %rsi
movl $0x3, %edx
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
xorl %r9d, %r9d
callq 0x295f0
cmpq $-0x1, %rax
jne 0xa8e75
testb $0x10, %r15b
jne 0xa8abc
testq %r13, %r13
je 0xa8e70
callq 0x297b0
movq %rax, %r12
jmp 0xa8aee
testq %r13, %r13
je 0xa8e86
callq 0x297b0
movq %rax, %r12
movl (%rax), %r9d
movl $0x880, %edx # imm = 0x880
movl $0x5, %edi
leaq 0x351f9(%rip), %rsi # 0xddcda
movq %rbx, %rcx
movq %r13, %r8
xorl %eax, %eax
callq 0x9f21d
cmpl $0xc, (%r12)
je 0xa8a1e
jmp 0xa8e70
movq %r13, %rcx
shrq $0x20, %rcx
jne 0xa8b3b
cmpq $0x10000, %r13 # imm = 0x10000
jae 0xa8b72
cmpq $0x100, %r13 # imm = 0x100
jae 0xa8bd3
cmpq $0x10, %r13
jae 0xa8c61
cmpq $0x4, %r13
jae 0xa8d9b
movl %r13d, %ecx
shrl %ecx
jmp 0xa8e49
movq %r13, %rdx
shrq $0x30, %rdx
jne 0xa8ba4
movq %r13, %rdx
shrq $0x28, %rdx
jne 0xa8bf8
movq %r13, %rdx
shrq $0x24, %rdx
jne 0xa8c85
movq %r13, %rdx
shrq $0x22, %rdx
jne 0xa8dac
shrl %ecx
jmp 0xa8e46
cmpq $0x1000000, %r13 # imm = 0x1000000
jae 0xa8c1a
cmpq $0x100000, %r13 # imm = 0x100000
jae 0xa8cb0
cmpq $0x40000, %r13 # imm = 0x40000
jae 0xa8dc4
movl %r13d, %ecx
shrl $0x11, %ecx
jmp 0xa8e28
movq %r13, %rdx
shrq $0x38, %rdx
jne 0xa8c3f
movq %r13, %rdx
shrq $0x34, %rdx
jne 0xa8cd7
movq %r13, %rdx
shrq $0x32, %rdx
jne 0xa8dd5
shrl $0x11, %ecx
jmp 0xa8e43
cmpq $0x1000, %r13 # imm = 0x1000
jae 0xa8d02
cmpq $0x400, %r13 # imm = 0x400
jae 0xa8dea
movl %r13d, %ecx
shrl $0x9, %ecx
jmp 0xa8df9
movq %r13, %rdx
shrq $0x2c, %rdx
jne 0xa8d29
movq %r13, %rdx
shrq $0x2a, %rdx
jne 0xa8dfe
shrl $0x9, %ecx
jmp 0xa8e11
cmpq $0x10000000, %r13 # imm = 0x10000000
jae 0xa8d54
cmpq $0x4000000, %r13 # imm = 0x4000000
jae 0xa8e16
movl %r13d, %ecx
shrl $0x19, %ecx
jmp 0xa8e25
movq %r13, %rdx
shrq $0x3c, %rdx
jne 0xa8d77
movq %r13, %rdx
shrq $0x3a, %rdx
jne 0xa8e2d
shrl $0x19, %ecx
jmp 0xa8e40
cmpq $0x80, %r13
movl $0x3, %edx
sbbl $0x0, %edx
movl %r13d, %ecx
shrl $0x5, %ecx
cmpq $0x40, %r13
cmovael %edx, %ecx
orl $0x4, %ecx
jmp 0xa8e49
movq %r13, %rdx
shrq $0x26, %rdx
movq %r13, %rsi
shrq $0x27, %rsi
cmpq $0x1, %rsi
movl $0x3, %esi
sbbl $0x0, %esi
shrl $0x5, %ecx
testq %rdx, %rdx
cmovnel %esi, %ecx
orl $0x4, %ecx
jmp 0xa8e46
cmpq $0x800000, %r13 # imm = 0x800000
movl $0x3, %edx
sbbl $0x0, %edx
movl %r13d, %ecx
shrl $0x15, %ecx
cmpq $0x400000, %r13 # imm = 0x400000
cmovael %edx, %ecx
orl $0x4, %ecx
jmp 0xa8e28
movq %r13, %rdx
shrq $0x36, %rdx
movq %r13, %rsi
shrq $0x37, %rsi
cmpq $0x1, %rsi
movl $0x3, %esi
sbbl $0x0, %esi
shrl $0x15, %ecx
testq %rdx, %rdx
cmovnel %esi, %ecx
orl $0x4, %ecx
jmp 0xa8e43
cmpq $0x8000, %r13 # imm = 0x8000
movl $0x3, %edx
sbbl $0x0, %edx
movl %r13d, %ecx
shrl $0xd, %ecx
cmpq $0x4000, %r13 # imm = 0x4000
cmovael %edx, %ecx
orl $0x4, %ecx
jmp 0xa8df9
movq %r13, %rdx
shrq $0x2e, %rdx
movq %r13, %rsi
shrq $0x2f, %rsi
cmpq $0x1, %rsi
movl $0x3, %esi
sbbl $0x0, %esi
shrl $0xd, %ecx
testq %rdx, %rdx
cmovnel %esi, %ecx
orl $0x4, %ecx
jmp 0xa8e11
movl %r13d, %edx
notl %edx
shrl $0x1f, %edx
xorl $0x3, %edx
movl %r13d, %ecx
shrl $0x1d, %ecx
cmpq $0x40000000, %r13 # imm = 0x40000000
cmovael %edx, %ecx
orl $0x4, %ecx
jmp 0xa8e25
movq %r13, %rdx
shrq $0x3e, %rdx
xorl %esi, %esi
testq %r13, %r13
setns %sil
xorl $0x3, %esi
shrl $0x1d, %ecx
testq %rdx, %rdx
cmovnel %esi, %ecx
orl $0x4, %ecx
jmp 0xa8e40
cmpq $0x8, %r13
movl $0x3, %ecx
sbbl $0x0, %ecx
jmp 0xa8e49
movq %r13, %rcx
shrq $0x23, %rcx
cmpq $0x1, %rcx
movl $0x3, %ecx
sbbl $0x0, %ecx
jmp 0xa8e46
cmpq $0x80000, %r13 # imm = 0x80000
movl $0x3, %ecx
sbbl $0x0, %ecx
jmp 0xa8e28
movq %r13, %rcx
shrq $0x33, %rcx
cmpq $0x1, %rcx
movl $0x3, %ecx
sbbl $0x0, %ecx
jmp 0xa8e43
cmpq $0x800, %r13 # imm = 0x800
movl $0x3, %ecx
sbbl $0x0, %ecx
addl $0x8, %ecx
jmp 0xa8e49
movq %r13, %rcx
shrq $0x2b, %rcx
cmpq $0x1, %rcx
movl $0x3, %ecx
sbbl $0x0, %ecx
addl $0x8, %ecx
jmp 0xa8e46
cmpq $0x8000000, %r13 # imm = 0x8000000
movl $0x3, %ecx
sbbl $0x0, %ecx
addl $0x8, %ecx
addl $0x10, %ecx
jmp 0xa8e49
movq %r13, %rcx
shrq $0x3b, %rcx
cmpq $0x1, %rcx
movl $0x3, %ecx
sbbl $0x0, %ecx
addl $0x8, %ecx
addl $0x10, %ecx
addl $0x20, %ecx
movl %r14d, %r14d
subq %rax, %r14
incq %r14
shll $0x1a, %ecx
orl $0x40022, %ecx # imm = 0x40022
leaq (%rbx,%r13), %rax
decq %rax
movq %r13, %rbx
negq %rbx
andq %rax, %rbx
jmp 0xa8a81
xorl %r12d, %r12d
jmp 0xa8e9d
movq %rax, %r12
testq %r13, %r13
je 0xa8e9d
movq -0x30(%rbp), %rax
movq %rbx, (%rax)
jmp 0xa8e9d
xorl %r12d, %r12d
movl $0x44, %esi
movl $0x5, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x9f103
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_large_malloc:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rsi
mov [rbp+var_30], rdi
mov rbx, [rdi]
xor r14d, r14d
xor r13d, r13d
loc_A8A1E:
mov ecx, 22h ; '"'
cmp cs:my_use_large_pages, 1
jnz short loc_A8A81
mov rax, [rbp+var_30]
mov rbx, [rax]
cmp r14d, 9
mov edx, 8
cmovge edx, r14d
cmp r14d, 7
jg short loc_A8A7E
movsxd rsi, r14d
lea rax, my_large_page_sizes
lea rdi, [rax+rsi*8]
sub rsi, rdx
xor eax, eax
loc_A8A59:
mov r13, [rdi]
test r13, r13
jz short loc_A8A7B
cmp r13, rbx
jbe loc_A8AFE
dec rax
add rdi, 8
cmp rsi, rax
jnz short loc_A8A59
mov r14d, edx
jmp short loc_A8A7E
loc_A8A7B:
sub r14d, eax
loc_A8A7E:
xor r13d, r13d
loc_A8A81:
xor edi, edi
mov rsi, rbx
mov edx, 3
mov r8d, 0FFFFFFFFh
xor r9d, r9d
call _mmap64
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz loc_A8E75
test r15b, 10h
jnz short loc_A8ABC
test r13, r13
jz loc_A8E70
call ___errno_location
mov r12, rax
jmp short loc_A8AEE
loc_A8ABC:
test r13, r13
jz loc_A8E86
call ___errno_location
mov r12, rax
mov r9d, [rax]
mov edx, 880h
mov edi, 5
lea rsi, aCouldnTAllocat; "Couldn't allocate %zu bytes (Large/Huge"...
mov rcx, rbx
mov r8, r13
xor eax, eax
call my_printf_error
loc_A8AEE:
cmp dword ptr [r12], 0Ch
jz loc_A8A1E
jmp loc_A8E70
loc_A8AFE:
mov rcx, r13
shr rcx, 20h
jnz short loc_A8B3B
cmp r13, offset stru_10000
jnb short loc_A8B72
cmp r13, 100h
jnb loc_A8BD3
cmp r13, 10h
jnb loc_A8C61
cmp r13, 4
jnb loc_A8D9B
mov ecx, r13d
shr ecx, 1
jmp loc_A8E49
loc_A8B3B:
mov rdx, r13
shr rdx, 30h
jnz short loc_A8BA4
mov rdx, r13
shr rdx, 28h
jnz loc_A8BF8
mov rdx, r13
shr rdx, 24h
jnz loc_A8C85
mov rdx, r13
shr rdx, 22h
jnz loc_A8DAC
shr ecx, 1
jmp loc_A8E46
loc_A8B72:
cmp r13, 1000000h
jnb loc_A8C1A
cmp r13, offset xmmword_100000
jnb loc_A8CB0
cmp r13, 40000h
jnb loc_A8DC4
mov ecx, r13d
shr ecx, 11h
jmp loc_A8E28
loc_A8BA4:
mov rdx, r13
shr rdx, 38h
jnz loc_A8C3F
mov rdx, r13
shr rdx, 34h
jnz loc_A8CD7
mov rdx, r13
shr rdx, 32h
jnz loc_A8DD5
shr ecx, 11h
jmp loc_A8E43
loc_A8BD3:
cmp r13, 1000h
jnb loc_A8D02
cmp r13, 400h
jnb loc_A8DEA
mov ecx, r13d
shr ecx, 9
jmp loc_A8DF9
loc_A8BF8:
mov rdx, r13
shr rdx, 2Ch
jnz loc_A8D29
mov rdx, r13
shr rdx, 2Ah
jnz loc_A8DFE
shr ecx, 9
jmp loc_A8E11
loc_A8C1A:
cmp r13, 10000000h
jnb loc_A8D54
cmp r13, 4000000h
jnb loc_A8E16
mov ecx, r13d
shr ecx, 19h
jmp loc_A8E25
loc_A8C3F:
mov rdx, r13
shr rdx, 3Ch
jnz loc_A8D77
mov rdx, r13
shr rdx, 3Ah
jnz loc_A8E2D
shr ecx, 19h
jmp loc_A8E40
loc_A8C61:
cmp r13, 80h
mov edx, 3
sbb edx, 0
mov ecx, r13d
shr ecx, 5
cmp r13, 40h ; '@'
cmovnb ecx, edx
or ecx, 4
jmp loc_A8E49
loc_A8C85:
mov rdx, r13
shr rdx, 26h
mov rsi, r13
shr rsi, 27h
cmp rsi, 1
mov esi, 3
sbb esi, 0
shr ecx, 5
test rdx, rdx
cmovnz ecx, esi
or ecx, 4
jmp loc_A8E46
loc_A8CB0:
cmp r13, offset unk_800000
mov edx, 3
sbb edx, 0
mov ecx, r13d
shr ecx, 15h
cmp r13, offset unk_400000
cmovnb ecx, edx
or ecx, 4
jmp loc_A8E28
loc_A8CD7:
mov rdx, r13
shr rdx, 36h
mov rsi, r13
shr rsi, 37h
cmp rsi, 1
mov esi, 3
sbb esi, 0
shr ecx, 15h
test rdx, rdx
cmovnz ecx, esi
or ecx, 4
jmp loc_A8E43
loc_A8D02:
cmp r13, 8000h
mov edx, 3
sbb edx, 0
mov ecx, r13d
shr ecx, 0Dh
cmp r13, 4000h
cmovnb ecx, edx
or ecx, 4
jmp loc_A8DF9
loc_A8D29:
mov rdx, r13
shr rdx, 2Eh
mov rsi, r13
shr rsi, 2Fh
cmp rsi, 1
mov esi, 3
sbb esi, 0
shr ecx, 0Dh
test rdx, rdx
cmovnz ecx, esi
or ecx, 4
jmp loc_A8E11
loc_A8D54:
mov edx, r13d
not edx
shr edx, 1Fh
xor edx, 3
mov ecx, r13d
shr ecx, 1Dh
cmp r13, 40000000h
cmovnb ecx, edx
or ecx, 4
jmp loc_A8E25
loc_A8D77:
mov rdx, r13
shr rdx, 3Eh
xor esi, esi
test r13, r13
setns sil
xor esi, 3
shr ecx, 1Dh
test rdx, rdx
cmovnz ecx, esi
or ecx, 4
jmp loc_A8E40
loc_A8D9B:
cmp r13, 8
mov ecx, 3
sbb ecx, 0
jmp loc_A8E49
loc_A8DAC:
mov rcx, r13
shr rcx, 23h
cmp rcx, 1
mov ecx, 3
sbb ecx, 0
jmp loc_A8E46
loc_A8DC4:
cmp r13, 80000h
mov ecx, 3
sbb ecx, 0
jmp short loc_A8E28
loc_A8DD5:
mov rcx, r13
shr rcx, 33h
cmp rcx, 1
mov ecx, 3
sbb ecx, 0
jmp short loc_A8E43
loc_A8DEA:
cmp r13, 800h
mov ecx, 3
sbb ecx, 0
loc_A8DF9:
add ecx, 8
jmp short loc_A8E49
loc_A8DFE:
mov rcx, r13
shr rcx, 2Bh
cmp rcx, 1
mov ecx, 3
sbb ecx, 0
loc_A8E11:
add ecx, 8
jmp short loc_A8E46
loc_A8E16:
cmp r13, 8000000h
mov ecx, 3
sbb ecx, 0
loc_A8E25:
add ecx, 8
loc_A8E28:
add ecx, 10h
jmp short loc_A8E49
loc_A8E2D:
mov rcx, r13
shr rcx, 3Bh
cmp rcx, 1
mov ecx, 3
sbb ecx, 0
loc_A8E40:
add ecx, 8
loc_A8E43:
add ecx, 10h
loc_A8E46:
add ecx, 20h ; ' '
loc_A8E49:
mov r14d, r14d
sub r14, rax
inc r14
shl ecx, 1Ah
or ecx, 40022h
lea rax, [rbx+r13]
dec rax
mov rbx, r13
neg rbx
and rbx, rax
jmp loc_A8A81
loc_A8E70:
xor r12d, r12d
jmp short loc_A8E9D
loc_A8E75:
mov r12, rax
test r13, r13
jz short loc_A8E9D
mov rax, [rbp+var_30]
mov [rax], rbx
jmp short loc_A8E9D
loc_A8E86:
xor r12d, r12d
mov esi, 44h ; 'D'
mov edi, 5
mov rdx, rbx
xor eax, eax
call my_error
loc_A8E9D:
mov rax, r12
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_large_malloc(
unsigned long long *a1,
char a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
unsigned long long v10; // rbx
int v11; // r14d
unsigned long long v12; // r13
long long v13; // rcx
long long v14; // rdx
unsigned long long *v15; // rdi
long long v16; // rax
long long v17; // rax
_DWORD *v18; // r12
__m128 v19; // xmm4
__m128 v20; // xmm5
int v21; // ecx
int v22; // ecx
int v23; // ecx
int v24; // ecx
int v25; // ecx
int v26; // ecx
int v27; // ecx
int v28; // ecx
unsigned int v29; // ecx
int v30; // ecx
unsigned int v31; // ecx
int v32; // ecx
unsigned int v33; // ecx
int v34; // ecx
unsigned int v35; // ecx
int v36; // ecx
long long v37; // r12
unsigned long long *v39; // [rsp+0h] [rbp-30h]
v39 = a1;
v10 = *a1;
v11 = 0;
v12 = 0LL;
while ( 1 )
{
v13 = 34LL;
if ( my_use_large_pages == 1 )
{
v10 = *v39;
v14 = 8LL;
if ( v11 >= 9 )
v14 = (unsigned int)v11;
if ( v11 > 7 )
{
LABEL_12:
v12 = 0LL;
}
else
{
v15 = &my_large_page_sizes[v11];
v16 = 0LL;
while ( 1 )
{
v12 = *v15;
if ( !*v15 )
{
v11 -= v16;
goto LABEL_12;
}
if ( v12 <= v10 )
break;
--v16;
++v15;
if ( v11 - v14 == v16 )
{
v11 = v14;
goto LABEL_12;
}
}
if ( HIDWORD(v12) )
{
if ( HIWORD(v12) )
{
if ( HIBYTE(v12) )
{
if ( v12 >> 60 )
{
v36 = HIDWORD(v12) >> 29;
if ( v12 >> 62 )
v36 = ((v12 & 0x8000000000000000LL) == 0LL) ^ 3;
v28 = v36 | 4;
}
else if ( v12 >> 58 )
{
v28 = 3 - (v12 >> 59 == 0);
}
else
{
v28 = HIDWORD(v12) >> 25;
}
v24 = v28 + 8;
}
else if ( v12 >> 52 )
{
v32 = HIDWORD(v12) >> 21;
if ( v12 >> 54 )
v32 = 3 - (v12 >> 55 == 0);
v24 = v32 | 4;
}
else if ( v12 >> 50 )
{
v24 = 3 - (v12 >> 51 == 0);
}
else
{
v24 = HIDWORD(v12) >> 17;
}
v22 = v24 + 16;
}
else if ( v12 >> 40 )
{
if ( v12 >> 44 )
{
v34 = HIDWORD(v12) >> 13;
if ( v12 >> 46 )
v34 = 3 - (v12 >> 47 == 0);
v26 = v34 | 4;
}
else if ( v12 >> 42 )
{
v26 = 3 - (v12 >> 43 == 0);
}
else
{
v26 = HIDWORD(v12) >> 9;
}
v22 = v26 + 8;
}
else if ( v12 >> 36 )
{
v30 = HIDWORD(v12) >> 5;
if ( v12 >> 38 )
v30 = 3 - (v12 >> 39 == 0);
v22 = v30 | 4;
}
else if ( v12 >> 34 )
{
v22 = 3 - (v12 >> 35 == 0);
}
else
{
v22 = HIDWORD(v12) >> 1;
}
v21 = v22 + 32;
}
else if ( v12 >= (unsigned long long)&stru_10000 )
{
if ( v12 >= 0x1000000 )
{
if ( v12 >= 0x10000000 )
{
v35 = (unsigned int)v12 >> 29;
if ( v12 >= 0x40000000 )
v35 = ((v12 & 0x80000000) == 0LL) ^ 3;
v27 = v35 | 4;
}
else if ( v12 >= 0x4000000 )
{
v27 = 3 - (v12 < 0x8000000);
}
else
{
v27 = (unsigned int)v12 >> 25;
}
v23 = v27 + 8;
}
else if ( v12 >= (unsigned long long)&xmmword_100000 )
{
v31 = (unsigned int)v12 >> 21;
if ( v12 >= (unsigned long long)&unk_400000 )
v31 = 3 - (v12 < (unsigned long long)&unk_800000);
v23 = v31 | 4;
}
else if ( v12 >= 0x40000 )
{
v23 = 3 - (v12 < 0x80000);
}
else
{
v23 = (unsigned int)v12 >> 17;
}
v21 = v23 + 16;
}
else if ( v12 >= 0x100 )
{
if ( v12 >= 0x1000 )
{
v33 = (unsigned int)v12 >> 13;
if ( v12 >= 0x4000 )
v33 = 3 - (v12 < 0x8000);
v25 = v33 | 4;
}
else if ( v12 >= 0x400 )
{
v25 = 3 - (v12 < 0x800);
}
else
{
v25 = (unsigned int)v12 >> 9;
}
v21 = v25 + 8;
}
else if ( v12 >= 0x10 )
{
v29 = (unsigned int)v12 >> 5;
if ( v12 >= 0x40 )
v29 = 3 - (v12 < 0x80);
v21 = v29 | 4;
}
else if ( v12 >= 4 )
{
v21 = 3 - (v12 < 8);
}
else
{
v21 = (unsigned int)v12 >> 1;
}
v11 = v11 - v16 + 1;
v13 = (v21 << 26) | 0x40022u;
v10 = (v10 + v12 - 1) & -(long long)v12;
}
}
v17 = mmap64(0LL, v10, 3LL, v13, 0xFFFFFFFFLL, 0LL, v39);
if ( v17 != -1 )
break;
if ( (a2 & 0x10) != 0 )
{
if ( !v12 )
{
v37 = 0LL;
my_error(5u, 68LL, v10);
return v37;
}
v18 = (_DWORD *)__errno_location(0LL);
my_printf_error(
5,
(long long)"Couldn't allocate %zu bytes (Large/HugeTLB memory page size %zu); errno %u; continuing to smaller size",
2176,
v10,
v12,
(unsigned int)*v18,
a3,
a4,
a5,
a6,
v19,
v20,
a9,
a10,
(char)v39);
}
else
{
if ( !v12 )
return 0LL;
v18 = (_DWORD *)__errno_location(0LL);
}
if ( *v18 != 12 )
return 0LL;
}
v37 = v17;
if ( v12 )
*v39 = v10;
return v37;
}
| my_large_malloc:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RSI
MOV qword ptr [RBP + -0x30],RDI
MOV RBX,qword ptr [RDI]
XOR R14D,R14D
XOR R13D,R13D
LAB_001a8a1e:
MOV ECX,0x22
CMP byte ptr [0x00d0b0a0],0x1
JNZ 0x001a8a81
MOV RAX,qword ptr [RBP + -0x30]
MOV RBX,qword ptr [RAX]
CMP R14D,0x9
MOV EDX,0x8
CMOVGE EDX,R14D
CMP R14D,0x7
JG 0x001a8a7e
MOVSXD RSI,R14D
LEA RAX,[0xd0b0b0]
LEA RDI,[RAX + RSI*0x8]
SUB RSI,RDX
XOR EAX,EAX
LAB_001a8a59:
MOV R13,qword ptr [RDI]
TEST R13,R13
JZ 0x001a8a7b
CMP R13,RBX
JBE 0x001a8afe
DEC RAX
ADD RDI,0x8
CMP RSI,RAX
JNZ 0x001a8a59
MOV R14D,EDX
JMP 0x001a8a7e
LAB_001a8a7b:
SUB R14D,EAX
LAB_001a8a7e:
XOR R13D,R13D
LAB_001a8a81:
XOR EDI,EDI
MOV RSI,RBX
MOV EDX,0x3
MOV R8D,0xffffffff
XOR R9D,R9D
CALL 0x001295f0
CMP RAX,-0x1
JNZ 0x001a8e75
TEST R15B,0x10
JNZ 0x001a8abc
TEST R13,R13
JZ 0x001a8e70
CALL 0x001297b0
MOV R12,RAX
JMP 0x001a8aee
LAB_001a8abc:
TEST R13,R13
JZ 0x001a8e86
CALL 0x001297b0
MOV R12,RAX
MOV R9D,dword ptr [RAX]
MOV EDX,0x880
MOV EDI,0x5
LEA RSI,[0x1ddcda]
MOV RCX,RBX
MOV R8,R13
XOR EAX,EAX
CALL 0x0019f21d
LAB_001a8aee:
CMP dword ptr [R12],0xc
JZ 0x001a8a1e
JMP 0x001a8e70
LAB_001a8afe:
MOV RCX,R13
SHR RCX,0x20
JNZ 0x001a8b3b
CMP R13,0x10000
JNC 0x001a8b72
CMP R13,0x100
JNC 0x001a8bd3
CMP R13,0x10
JNC 0x001a8c61
CMP R13,0x4
JNC 0x001a8d9b
MOV ECX,R13D
SHR ECX,0x1
JMP 0x001a8e49
LAB_001a8b3b:
MOV RDX,R13
SHR RDX,0x30
JNZ 0x001a8ba4
MOV RDX,R13
SHR RDX,0x28
JNZ 0x001a8bf8
MOV RDX,R13
SHR RDX,0x24
JNZ 0x001a8c85
MOV RDX,R13
SHR RDX,0x22
JNZ 0x001a8dac
SHR ECX,0x1
JMP 0x001a8e46
LAB_001a8b72:
CMP R13,0x1000000
JNC 0x001a8c1a
CMP R13,0x100000
JNC 0x001a8cb0
CMP R13,0x40000
JNC 0x001a8dc4
MOV ECX,R13D
SHR ECX,0x11
JMP 0x001a8e28
LAB_001a8ba4:
MOV RDX,R13
SHR RDX,0x38
JNZ 0x001a8c3f
MOV RDX,R13
SHR RDX,0x34
JNZ 0x001a8cd7
MOV RDX,R13
SHR RDX,0x32
JNZ 0x001a8dd5
SHR ECX,0x11
JMP 0x001a8e43
LAB_001a8bd3:
CMP R13,0x1000
JNC 0x001a8d02
CMP R13,0x400
JNC 0x001a8dea
MOV ECX,R13D
SHR ECX,0x9
JMP 0x001a8df9
LAB_001a8bf8:
MOV RDX,R13
SHR RDX,0x2c
JNZ 0x001a8d29
MOV RDX,R13
SHR RDX,0x2a
JNZ 0x001a8dfe
SHR ECX,0x9
JMP 0x001a8e11
LAB_001a8c1a:
CMP R13,0x10000000
JNC 0x001a8d54
CMP R13,0x4000000
JNC 0x001a8e16
MOV ECX,R13D
SHR ECX,0x19
JMP 0x001a8e25
LAB_001a8c3f:
MOV RDX,R13
SHR RDX,0x3c
JNZ 0x001a8d77
MOV RDX,R13
SHR RDX,0x3a
JNZ 0x001a8e2d
SHR ECX,0x19
JMP 0x001a8e40
LAB_001a8c61:
CMP R13,0x80
MOV EDX,0x3
SBB EDX,0x0
MOV ECX,R13D
SHR ECX,0x5
CMP R13,0x40
CMOVNC ECX,EDX
OR ECX,0x4
JMP 0x001a8e49
LAB_001a8c85:
MOV RDX,R13
SHR RDX,0x26
MOV RSI,R13
SHR RSI,0x27
CMP RSI,0x1
MOV ESI,0x3
SBB ESI,0x0
SHR ECX,0x5
TEST RDX,RDX
CMOVNZ ECX,ESI
OR ECX,0x4
JMP 0x001a8e46
LAB_001a8cb0:
CMP R13,0x800000
MOV EDX,0x3
SBB EDX,0x0
MOV ECX,R13D
SHR ECX,0x15
CMP R13,0x400000
CMOVNC ECX,EDX
OR ECX,0x4
JMP 0x001a8e28
LAB_001a8cd7:
MOV RDX,R13
SHR RDX,0x36
MOV RSI,R13
SHR RSI,0x37
CMP RSI,0x1
MOV ESI,0x3
SBB ESI,0x0
SHR ECX,0x15
TEST RDX,RDX
CMOVNZ ECX,ESI
OR ECX,0x4
JMP 0x001a8e43
LAB_001a8d02:
CMP R13,0x8000
MOV EDX,0x3
SBB EDX,0x0
MOV ECX,R13D
SHR ECX,0xd
CMP R13,0x4000
CMOVNC ECX,EDX
OR ECX,0x4
JMP 0x001a8df9
LAB_001a8d29:
MOV RDX,R13
SHR RDX,0x2e
MOV RSI,R13
SHR RSI,0x2f
CMP RSI,0x1
MOV ESI,0x3
SBB ESI,0x0
SHR ECX,0xd
TEST RDX,RDX
CMOVNZ ECX,ESI
OR ECX,0x4
JMP 0x001a8e11
LAB_001a8d54:
MOV EDX,R13D
NOT EDX
SHR EDX,0x1f
XOR EDX,0x3
MOV ECX,R13D
SHR ECX,0x1d
CMP R13,0x40000000
CMOVNC ECX,EDX
OR ECX,0x4
JMP 0x001a8e25
LAB_001a8d77:
MOV RDX,R13
SHR RDX,0x3e
XOR ESI,ESI
TEST R13,R13
SETNS SIL
XOR ESI,0x3
SHR ECX,0x1d
TEST RDX,RDX
CMOVNZ ECX,ESI
OR ECX,0x4
JMP 0x001a8e40
LAB_001a8d9b:
CMP R13,0x8
MOV ECX,0x3
SBB ECX,0x0
JMP 0x001a8e49
LAB_001a8dac:
MOV RCX,R13
SHR RCX,0x23
CMP RCX,0x1
MOV ECX,0x3
SBB ECX,0x0
JMP 0x001a8e46
LAB_001a8dc4:
CMP R13,0x80000
MOV ECX,0x3
SBB ECX,0x0
JMP 0x001a8e28
LAB_001a8dd5:
MOV RCX,R13
SHR RCX,0x33
CMP RCX,0x1
MOV ECX,0x3
SBB ECX,0x0
JMP 0x001a8e43
LAB_001a8dea:
CMP R13,0x800
MOV ECX,0x3
SBB ECX,0x0
LAB_001a8df9:
ADD ECX,0x8
JMP 0x001a8e49
LAB_001a8dfe:
MOV RCX,R13
SHR RCX,0x2b
CMP RCX,0x1
MOV ECX,0x3
SBB ECX,0x0
LAB_001a8e11:
ADD ECX,0x8
JMP 0x001a8e46
LAB_001a8e16:
CMP R13,0x8000000
MOV ECX,0x3
SBB ECX,0x0
LAB_001a8e25:
ADD ECX,0x8
LAB_001a8e28:
ADD ECX,0x10
JMP 0x001a8e49
LAB_001a8e2d:
MOV RCX,R13
SHR RCX,0x3b
CMP RCX,0x1
MOV ECX,0x3
SBB ECX,0x0
LAB_001a8e40:
ADD ECX,0x8
LAB_001a8e43:
ADD ECX,0x10
LAB_001a8e46:
ADD ECX,0x20
LAB_001a8e49:
MOV R14D,R14D
SUB R14,RAX
INC R14
SHL ECX,0x1a
OR ECX,0x40022
LEA RAX,[RBX + R13*0x1]
DEC RAX
MOV RBX,R13
NEG RBX
AND RBX,RAX
JMP 0x001a8a81
LAB_001a8e70:
XOR R12D,R12D
JMP 0x001a8e9d
LAB_001a8e75:
MOV R12,RAX
TEST R13,R13
JZ 0x001a8e9d
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RBX
JMP 0x001a8e9d
LAB_001a8e86:
XOR R12D,R12D
MOV ESI,0x44
MOV EDI,0x5
MOV RDX,RBX
XOR EAX,EAX
CALL 0x0019f103
LAB_001a8e9d:
MOV RAX,R12
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void * my_large_malloc(ulong *param_1,ulong param_2)
{
long lVar1;
void *pvVar2;
int *piVar3;
uint uVar4;
ulong uVar5;
ulong __len;
ulong *puVar6;
ulong uVar7;
int iVar8;
ulong uVar9;
__len = *param_1;
uVar9 = 0;
uVar7 = 0;
do {
uVar4 = 0x22;
if (my_use_large_pages == '\x01') {
__len = *param_1;
iVar8 = (int)uVar9;
uVar5 = 8;
if (8 < iVar8) {
uVar5 = uVar9 & 0xffffffff;
}
uVar7 = uVar9;
if (iVar8 < 8) {
puVar6 = &my_large_page_sizes + iVar8;
lVar1 = 0;
do {
uVar7 = *puVar6;
if (uVar7 == 0) {
uVar7 = (ulong)(uint)(iVar8 - (int)lVar1);
break;
}
if (uVar7 <= __len) {
if (uVar7 >> 0x20 == 0) {
if (uVar7 < 0x10000) {
if (uVar7 < 0x100) {
if (uVar7 < 0x10) {
if (uVar7 < 4) {
uVar4 = (uint)(uVar7 >> 1) & 0x7fffffff;
}
else {
uVar4 = 3 - (uVar7 < 8);
}
}
else {
uVar4 = (uint)(uVar7 >> 5) & 0x7ffffff;
if (0x3f < uVar7) {
uVar4 = 3 - (uVar7 < 0x80);
}
uVar4 = uVar4 | 4;
}
}
else {
if (uVar7 < 0x1000) {
if (uVar7 < 0x400) {
uVar4 = (uint)(uVar7 >> 9) & 0x7fffff;
}
else {
uVar4 = 3 - (uVar7 < 0x800);
}
}
else {
uVar4 = (uint)(uVar7 >> 0xd) & 0x7ffff;
if (0x3fff < uVar7) {
uVar4 = 3 - (uVar7 < 0x8000);
}
uVar4 = uVar4 | 4;
}
uVar4 = uVar4 + 8;
}
}
else {
if (uVar7 < 0x1000000) {
if (uVar7 < 0x100000) {
if (uVar7 < 0x40000) {
uVar4 = (uint)(uVar7 >> 0x11) & 0x7fff;
}
else {
uVar4 = 3 - (uVar7 < 0x80000);
}
}
else {
uVar4 = (uint)(uVar7 >> 0x15) & 0x7ff;
if (0x3fffff < uVar7) {
uVar4 = 3 - (uVar7 < 0x800000);
}
uVar4 = uVar4 | 4;
}
}
else {
if (uVar7 < 0x10000000) {
if (uVar7 < 0x4000000) {
uVar4 = (uint)(uVar7 >> 0x19) & 0x7f;
}
else {
uVar4 = 3 - (uVar7 < 0x8000000);
}
}
else {
uVar4 = (uint)(uVar7 >> 0x1d) & 7;
if (0x3fffffff < uVar7) {
uVar4 = ~(uint)uVar7 >> 0x1f ^ 3;
}
uVar4 = uVar4 | 4;
}
uVar4 = uVar4 + 8;
}
uVar4 = uVar4 + 0x10;
}
}
else {
uVar4 = (uint)(uVar7 >> 0x20);
if (uVar7 >> 0x30 == 0) {
if (uVar7 >> 0x28 == 0) {
if (uVar7 >> 0x24 == 0) {
if (uVar7 >> 0x22 == 0) {
uVar4 = uVar4 >> 1;
}
else {
uVar4 = 3 - (uVar7 >> 0x23 == 0);
}
}
else {
uVar4 = uVar4 >> 5;
if (uVar7 >> 0x26 != 0) {
uVar4 = 3 - (uVar7 >> 0x27 == 0);
}
uVar4 = uVar4 | 4;
}
}
else {
if (uVar7 >> 0x2c == 0) {
if (uVar7 >> 0x2a == 0) {
uVar4 = uVar4 >> 9;
}
else {
uVar4 = 3 - (uVar7 >> 0x2b == 0);
}
}
else {
uVar4 = uVar4 >> 0xd;
if (uVar7 >> 0x2e != 0) {
uVar4 = 3 - (uVar7 >> 0x2f == 0);
}
uVar4 = uVar4 | 4;
}
uVar4 = uVar4 + 8;
}
}
else {
if (uVar7 >> 0x38 == 0) {
if (uVar7 >> 0x34 == 0) {
if (uVar7 >> 0x32 == 0) {
uVar4 = uVar4 >> 0x11;
}
else {
uVar4 = 3 - (uVar7 >> 0x33 == 0);
}
}
else {
uVar4 = uVar4 >> 0x15;
if (uVar7 >> 0x36 != 0) {
uVar4 = 3 - (uVar7 >> 0x37 == 0);
}
uVar4 = uVar4 | 4;
}
}
else {
if (uVar7 >> 0x3c == 0) {
if (uVar7 >> 0x3a == 0) {
uVar4 = uVar4 >> 0x19;
}
else {
uVar4 = 3 - (uVar7 >> 0x3b == 0);
}
}
else {
uVar4 = uVar4 >> 0x1d;
if (uVar7 >> 0x3e != 0) {
uVar4 = -1 < (long)uVar7 ^ 3;
}
uVar4 = uVar4 | 4;
}
uVar4 = uVar4 + 8;
}
uVar4 = uVar4 + 0x10;
}
uVar4 = uVar4 + 0x20;
}
uVar9 = ((uVar9 & 0xffffffff) - lVar1) + 1;
uVar4 = uVar4 << 0x1a | 0x40022;
__len = -uVar7 & (__len + uVar7) - 1;
goto LAB_001a8a81;
}
lVar1 = lVar1 + -1;
puVar6 = puVar6 + 1;
uVar7 = uVar5;
} while ((long)iVar8 - uVar5 != lVar1);
}
uVar9 = uVar7;
uVar7 = 0;
}
LAB_001a8a81:
pvVar2 = mmap64((void *)0x0,__len,3,uVar4,-1,0);
if (pvVar2 != (void *)0xffffffffffffffff) {
if (uVar7 != 0) {
*param_1 = __len;
return pvVar2;
}
return pvVar2;
}
if ((param_2 & 0x10) == 0) {
if (uVar7 == 0) {
return (void *)0x0;
}
piVar3 = __errno_location();
}
else {
if (uVar7 == 0) {
my_error(5,0x44,__len);
return (void *)0x0;
}
piVar3 = __errno_location();
my_printf_error(5,
"Couldn\'t allocate %zu bytes (Large/HugeTLB memory page size %zu); errno %u; continuing to smaller size"
,0x880,__len,uVar7);
}
if (*piVar3 != 0xc) {
return (void *)0x0;
}
} while( true );
}
| |
41,541 | release_whole_queue | eloqsql/mysys/mf_keycache.c | static void release_whole_queue(KEYCACHE_WQUEUE *wqueue)
{
struct st_my_thread_var *last;
struct st_my_thread_var *next;
struct st_my_thread_var *thread;
/* Queue may be empty. */
if (!(last= wqueue->last_thread))
return;
next= last->next; /* First (oldest) element */
do
{
thread=next;
DBUG_ASSERT(thread && thread->init == 1);
KEYCACHE_DBUG_PRINT("release_whole_queue: signal",
("thread %ld", (ulong) thread->id));
/* Take thread from queue. */
next= thread->next;
thread->next= NULL;
/* Signal the thread. */
keycache_pthread_cond_signal(&thread->suspend);
}
while (thread != last);
/* Now queue is definitely empty. */
wqueue->last_thread= NULL;
} | O3 | c | release_whole_queue:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x989fc
movq %rdi, %rbx
movq 0x88(%r14), %r12
leaq 0x2ed658(%rip), %r15 # 0x386010
movq 0x38(%r12), %rdi
movq 0x88(%r12), %r13
movq $0x0, 0x88(%r12)
testq %rdi, %rdi
jne 0x989ea
leaq 0x8(%r12), %rdi
callq 0x295c0
cmpq %r14, %r12
movq %r13, %r12
jne 0x989b8
jmp 0x989f5
movq (%r15), %rax
callq *0x170(%rax)
jmp 0x989d6
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| release_whole_queue:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, [rdi]
test r14, r14
jz short loc_989FC
mov rbx, rdi
mov r12, [r14+88h]
lea r15, PSI_server
loc_989B8:
mov rdi, [r12+38h]
mov r13, [r12+88h]
mov qword ptr [r12+88h], 0
test rdi, rdi
jnz short loc_989EA
loc_989D6:
lea rdi, [r12+8]
call _pthread_cond_signal
cmp r12, r14
mov r12, r13
jnz short loc_989B8
jmp short loc_989F5
loc_989EA:
mov rax, [r15]
call qword ptr [rax+170h]
jmp short loc_989D6
loc_989F5:
mov qword ptr [rbx], 0
loc_989FC:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long release_whole_queue(long long *a1)
{
long long v1; // r14
long long v3; // r12
long long v4; // rdi
long long v5; // r13
long long result; // rax
bool v7; // zf
v1 = *a1;
if ( *a1 )
{
v3 = *(_QWORD *)(v1 + 136);
do
{
v4 = *(_QWORD *)(v3 + 56);
v5 = *(_QWORD *)(v3 + 136);
*(_QWORD *)(v3 + 136) = 0LL;
if ( v4 )
((void ( *)(long long))PSI_server[46])(v4);
result = pthread_cond_signal(v3 + 8);
v7 = v3 == v1;
v3 = v5;
}
while ( !v7 );
*a1 = 0LL;
}
return result;
}
| release_whole_queue:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,qword ptr [RDI]
TEST R14,R14
JZ 0x001989fc
MOV RBX,RDI
MOV R12,qword ptr [R14 + 0x88]
LEA R15,[0x486010]
LAB_001989b8:
MOV RDI,qword ptr [R12 + 0x38]
MOV R13,qword ptr [R12 + 0x88]
MOV qword ptr [R12 + 0x88],0x0
TEST RDI,RDI
JNZ 0x001989ea
LAB_001989d6:
LEA RDI,[R12 + 0x8]
CALL 0x001295c0
CMP R12,R14
MOV R12,R13
JNZ 0x001989b8
JMP 0x001989f5
LAB_001989ea:
MOV RAX,qword ptr [R15]
CALL qword ptr [RAX + 0x170]
JMP 0x001989d6
LAB_001989f5:
MOV qword ptr [RBX],0x0
LAB_001989fc:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void release_whole_queue(long *param_1)
{
long lVar1;
long lVar2;
long lVar3;
bool bVar4;
lVar1 = *param_1;
if (lVar1 != 0) {
lVar3 = *(long *)(lVar1 + 0x88);
do {
lVar2 = *(long *)(lVar3 + 0x88);
*(int8 *)(lVar3 + 0x88) = 0;
if (*(long *)(lVar3 + 0x38) != 0) {
(**(code **)(PSI_server + 0x170))();
}
pthread_cond_signal((pthread_cond_t *)(lVar3 + 8));
bVar4 = lVar3 != lVar1;
lVar3 = lVar2;
} while (bVar4);
*param_1 = 0;
}
return;
}
| |
41,542 | gguf_kv_to_str[abi:cxx11](gguf_context const*, int) | monkey531[P]llama/src/llama-impl.cpp | std::string gguf_kv_to_str(const struct gguf_context * ctx_gguf, int i) {
const enum gguf_type type = gguf_get_kv_type(ctx_gguf, i);
switch (type) {
case GGUF_TYPE_STRING:
return gguf_get_val_str(ctx_gguf, i);
case GGUF_TYPE_ARRAY:
{
const enum gguf_type arr_type = gguf_get_arr_type(ctx_gguf, i);
int arr_n = gguf_get_arr_n(ctx_gguf, i);
const void * data = arr_type == GGUF_TYPE_STRING ? nullptr : gguf_get_arr_data(ctx_gguf, i);
std::stringstream ss;
ss << "[";
for (int j = 0; j < arr_n; j++) {
if (arr_type == GGUF_TYPE_STRING) {
std::string val = gguf_get_arr_str(ctx_gguf, i, j);
// escape quotes
replace_all(val, "\\", "\\\\");
replace_all(val, "\"", "\\\"");
ss << '"' << val << '"';
} else if (arr_type == GGUF_TYPE_ARRAY) {
ss << "???";
} else {
ss << gguf_data_to_str(arr_type, data, j);
}
if (j < arr_n - 1) {
ss << ", ";
}
}
ss << "]";
return ss.str();
}
default:
return gguf_data_to_str(type, gguf_get_val_data(ctx_gguf, i), 0);
}
} | O1 | cpp | gguf_kv_to_str[abi:cxx11](gguf_context const*, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rsi, %r15
movq %rdi, %r14
movslq %edx, %r13
movq %rsi, %rdi
movq %r13, %rsi
callq 0x6cf60
cmpl $0x9, %eax
je 0xac1ec
movl %eax, %ebx
movq %r15, %rdi
movq %r13, %rsi
cmpl $0x8, %eax
jne 0xac217
callq 0x67830
leaq 0x80(%rsp), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x6c230
jmp 0xac4eb
movq %r15, %rdi
movq %r13, %rsi
callq 0x65ef0
movl %eax, %ebp
movq %r15, %rdi
movq %r13, %rsi
callq 0x68040
movq %rax, %r12
cmpl $0x8, %ebp
jne 0xac230
movq $0x0, 0x60(%rsp)
jmp 0xac240
callq 0x69ff0
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xac5a0
jmp 0xac4eb
movq %r15, %rdi
movq %r13, %rsi
callq 0x6be20
movq %rax, 0x60(%rsp)
movq %r13, 0x70(%rsp)
movq %r15, 0x78(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x67d30
leaq 0x90(%rsp), %rdi
leaq 0x6d988(%rip), %rsi # 0x119bee
movl $0x1, %edx
callq 0x69a40
movq %r14, 0x68(%rsp)
testl %r12d, %r12d
jle 0xac49c
leal -0x1(%r12), %eax
movslq %eax, %r13
andl $0x7fffffff, %r12d # imm = 0x7FFFFFFF
xorl %ebx, %ebx
leaq 0x20(%rsp), %r14
leaq 0x40(%rsp), %r15
cmpl $0x8, %ebp
jne 0xac410
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rsi
movq %rbx, %rdx
callq 0x68e00
movq %rsp, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x6c230
leaq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %r14, %rdi
leaq 0x6d91b(%rip), %rsi # 0x119bf1
leaq 0x6d915(%rip), %rdx # 0x119bf2
callq 0x666b0
leaq 0x50(%rsp), %rax
movq %rax, 0x40(%rsp)
movq %r15, %rdi
leaq 0x6d8fa(%rip), %rsi # 0x119bf0
leaq 0x6d8f5(%rip), %rdx # 0x119bf2
callq 0x666b0
movq %rsp, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6d3e0
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0xac32c
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x69220
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0xac348
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x69220
leaq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %r14, %rdi
leaq 0x72dd6(%rip), %rsi # 0x11f132
leaq 0x72dd0(%rip), %rdx # 0x11f133
callq 0x666b0
leaq 0x50(%rsp), %rax
movq %rax, 0x40(%rsp)
movq %r15, %rdi
leaq 0x6d877(%rip), %rsi # 0x119bf3
leaq 0x6d872(%rip), %rdx # 0x119bf5
callq 0x666b0
movq %rsp, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6d3e0
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0xac3b2
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x69220
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0xac3ce
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x69220
movb $0x22, 0x20(%rsp)
movl $0x1, %edx
leaq 0x90(%rsp), %rdi
movq %r14, %rsi
callq 0x69a40
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rax, %rdi
callq 0x69a40
movb $0x22, 0x20(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x69a40
jmp 0xac457
cmpl $0x9, %ebp
jne 0xac430
movl $0x3, %edx
leaq 0x90(%rsp), %rdi
leaq 0x6d7cd(%rip), %rsi # 0x119bf6
callq 0x69a40
jmp 0xac472
movq %rsp, %rdi
movl %ebp, %esi
movq 0x60(%rsp), %rdx
movl %ebx, %ecx
callq 0xac5a0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x90(%rsp), %rdi
callq 0x69a40
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xac472
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x69220
cmpq %r13, %rbx
jge 0xac490
movl $0x2, %edx
leaq 0x90(%rsp), %rdi
leaq 0x717fc(%rip), %rsi # 0x11dc87
callq 0x69a40
incq %rbx
cmpq %rbx, %r12
jne 0xac299
leaq 0x73390(%rip), %rsi # 0x11f833
movl $0x1, %edx
leaq 0x90(%rsp), %rdi
callq 0x69a40
movq 0x68(%rsp), %r14
leaq 0x98(%rsp), %rsi
movq %r14, %rdi
callq 0x6b850
movq 0xb4597(%rip), %rsi # 0x160a68
leaq 0x80(%rsp), %rdi
callq 0x67e80
leaq 0x100(%rsp), %rdi
callq 0x661c0
movq %r14, %rax
addq $0x208, %rsp # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xac554
jmp 0xac559
jmp 0xac554
jmp 0xac554
jmp 0xac533
jmp 0xac559
jmp 0xac512
jmp 0xac554
jmp 0xac559
movq %rax, %rbx
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0xac536
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x69220
jmp 0xac536
movq %rax, %rbx
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0xac55c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x69220
jmp 0xac55c
movq %rax, %rbx
jmp 0xac577
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xac577
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x69220
movq 0xb44ea(%rip), %rsi # 0x160a68
leaq 0x80(%rsp), %rdi
callq 0x67e80
leaq 0x100(%rsp), %rdi
callq 0x661c0
movq %rbx, %rdi
callq 0x6c640
| _Z14gguf_kv_to_strB5cxx11PK12gguf_contexti:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 208h
mov r15, rsi
mov r14, rdi
movsxd r13, edx
mov rdi, rsi
mov rsi, r13
call _gguf_get_kv_type
cmp eax, 9
jz short loc_AC1EC
mov ebx, eax
mov rdi, r15
mov rsi, r13
cmp eax, 8
jnz short loc_AC217
call _gguf_get_val_str
lea rdx, [rsp+238h+var_1B8]
mov rdi, r14
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp loc_AC4EB
loc_AC1EC:
mov rdi, r15
mov rsi, r13
call _gguf_get_arr_type
mov ebp, eax
mov rdi, r15
mov rsi, r13
call _gguf_get_arr_n
mov r12, rax
cmp ebp, 8
jnz short loc_AC230
mov [rsp+238h+var_1D8], 0
jmp short loc_AC240
loc_AC217:
call _gguf_get_val_data
mov rdi, r14
mov esi, ebx
mov rdx, rax
xor ecx, ecx
call _ZL16gguf_data_to_strB5cxx119gguf_typePKvi; gguf_data_to_str(gguf_type,void const*,int)
jmp loc_AC4EB
loc_AC230:
mov rdi, r15
mov rsi, r13
call _gguf_get_arr_data
mov [rsp+238h+var_1D8], rax
loc_AC240:
mov [rsp+238h+var_1C8], r13
mov [rsp+238h+var_1C0], r15
lea rdi, [rsp+238h+var_1B8]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(void)
lea rdi, [rsp+238h+var_1A8]
lea rsi, asc_119BEE; "["
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)
mov [rsp+238h+var_1D0], r14
test r12d, r12d
jle loc_AC49C
lea eax, [r12-1]
movsxd r13, eax
and r12d, 7FFFFFFFh
xor ebx, ebx
lea r14, [rsp+238h+var_218]
lea r15, [rsp+238h+var_1F8]
loc_AC299:
cmp ebp, 8
jnz loc_AC410
mov rdi, [rsp+238h+var_1C0]
mov rsi, [rsp+238h+var_1C8]
mov rdx, rbx
call _gguf_get_arr_str
mov rdi, rsp
mov rsi, rax
mov rdx, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rax, [rsp+238h+var_208]
mov [rsp+238h+var_218], rax
mov rdi, r14
lea rsi, asc_119BF0+1; "\\"
lea rdx, asc_119BF0+2; ""
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rax, [rsp+238h+var_1E8]
mov [rsp+238h+var_1F8], rax
mov rdi, r15
lea rsi, asc_119BF0; "\\\\"
lea rdx, asc_119BF0+2; ""
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rdi, rsp; int
mov rsi, r14; int
mov rdx, r15; int
call __Z11replace_allRNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS4_S7_; replace_all(std::string &,std::string const&,std::string const&)
mov rdi, [rsp+238h+var_1F8]; void *
lea rax, [rsp+238h+var_1E8]
cmp rdi, rax
jz short loc_AC32C
mov rsi, [rsp+238h+var_1E8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_AC32C:
mov rdi, [rsp+238h+var_218]; void *
lea rax, [rsp+238h+var_208]
cmp rdi, rax
jz short loc_AC348
mov rsi, [rsp+238h+var_208]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_AC348:
lea rax, [rsp+238h+var_208]
mov [rsp+238h+var_218], rax
mov rdi, r14
lea rsi, aTokenizerToken+52h; "\""
lea rdx, aTokenizerToken+53h; ""
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rax, [rsp+238h+var_1E8]
mov [rsp+238h+var_1F8], rax
mov rdi, r15
lea rsi, asc_119BF3; "\\\""
lea rdx, asc_119BF3+2; ""
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rdi, rsp; int
mov rsi, r14; int
mov rdx, r15; int
call __Z11replace_allRNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS4_S7_; replace_all(std::string &,std::string const&,std::string const&)
mov rdi, [rsp+238h+var_1F8]; void *
lea rax, [rsp+238h+var_1E8]
cmp rdi, rax
jz short loc_AC3B2
mov rsi, [rsp+238h+var_1E8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_AC3B2:
mov rdi, [rsp+238h+var_218]; void *
lea rax, [rsp+238h+var_208]
cmp rdi, rax
jz short loc_AC3CE
mov rsi, [rsp+238h+var_208]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_AC3CE:
mov byte ptr [rsp+238h+var_218], 22h ; '"'
mov edx, 1
lea rdi, [rsp+238h+var_1A8]
mov rsi, 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 rsi, [rsp+238h+var_238]
mov rdx, [rsp+238h+var_230]
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov byte ptr [rsp+238h+var_218], 22h ; '"'
mov edx, 1
mov rdi, rax
mov rsi, r14
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
jmp short loc_AC457
loc_AC410:
cmp ebp, 9
jnz short loc_AC430
mov edx, 3
lea rdi, [rsp+238h+var_1A8]
lea rsi, asc_119BF6; "???"
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
jmp short loc_AC472
loc_AC430:
mov rdi, rsp
mov esi, ebp
mov rdx, [rsp+238h+var_1D8]
mov ecx, ebx
call _ZL16gguf_data_to_strB5cxx119gguf_typePKvi; gguf_data_to_str(gguf_type,void const*,int)
mov rsi, [rsp+238h+var_238]
mov rdx, [rsp+238h+var_230]
lea rdi, [rsp+238h+var_1A8]
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_AC457:
mov rdi, [rsp+238h+var_238]; void *
lea rax, [rsp+238h+var_228]
cmp rdi, rax
jz short loc_AC472
mov rsi, [rsp+238h+var_228]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_AC472:
cmp rbx, r13
jge short loc_AC490
mov edx, 2
lea rdi, [rsp+238h+var_1A8]
lea rsi, a4d4d36sSType6s+21h; ", "
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_AC490:
inc rbx
cmp r12, rbx
jnz loc_AC299
loc_AC49C:
lea rsi, asc_11F830+3; "]"
mov edx, 1
lea rdi, [rsp+238h+var_1A8]
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov r14, [rsp+238h+var_1D0]
lea rsi, [rsp+238h+var_1A0]
mov rdi, r14
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
mov rsi, cs:_ZTTNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+238h+var_1B8]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED2Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
lea rdi, [rsp+238h+var_138]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
loc_AC4EB:
mov rax, r14
add rsp, 208h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_AC554
jmp short loc_AC559
jmp short loc_AC554
jmp short loc_AC554
jmp short loc_AC533
jmp short loc_AC559
jmp short loc_AC512
jmp short loc_AC554
jmp short loc_AC559
loc_AC512:
mov rbx, rax
mov rdi, [rsp+arg_38]; void *
lea rax, [rsp+arg_48]
cmp rdi, rax
jz short loc_AC536
mov rsi, [rsp+arg_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_AC536
loc_AC533:
mov rbx, rax
loc_AC536:
mov rdi, [rsp+arg_18]; void *
lea rax, [rsp+arg_28]
cmp rdi, rax
jz short loc_AC55C
mov rsi, [rsp+arg_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_AC55C
loc_AC554:
mov rbx, rax
jmp short loc_AC577
loc_AC559:
mov rbx, rax
loc_AC55C:
mov rdi, [rsp+0]; void *
lea rax, [rsp+arg_8]
cmp rdi, rax
jz short loc_AC577
mov rsi, [rsp+arg_8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_AC577:
mov rsi, cs:_ZTTNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+arg_78]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED2Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
lea rdi, [rsp+arg_F8]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rdi, rbx
call __Unwind_Resume
| long long gguf_kv_to_str[abi:cxx11](long long a1, long long a2, int a3)
{
long long v3; // r14
long long v4; // r13
unsigned int kv_type; // eax
unsigned int v6; // ebx
long long val_str; // rax
unsigned int arr_type; // ebp
int arr_n; // r12d
long long val_data; // rax
long long v11; // r13
long long v12; // r12
long long v13; // rbx
long long arr_str; // rax
int v15; // ecx
int v16; // r8d
int v17; // r9d
int v18; // ecx
int v19; // r8d
int v20; // r9d
long long v21; // rax
long long v22; // rax
long long v23; // rdx
long long v24; // rcx
void *v26; // [rsp+0h] [rbp-238h] BYREF
long long v27; // [rsp+8h] [rbp-230h]
long long v28; // [rsp+10h] [rbp-228h] BYREF
void *v29[2]; // [rsp+20h] [rbp-218h] BYREF
_QWORD v30[2]; // [rsp+30h] [rbp-208h] BYREF
void *v31[2]; // [rsp+40h] [rbp-1F8h] BYREF
_QWORD v32[2]; // [rsp+50h] [rbp-1E8h] BYREF
long long arr_data; // [rsp+60h] [rbp-1D8h]
long long v34; // [rsp+68h] [rbp-1D0h]
long long v35; // [rsp+70h] [rbp-1C8h]
long long v36; // [rsp+78h] [rbp-1C0h]
_BYTE v37[16]; // [rsp+80h] [rbp-1B8h] BYREF
_BYTE v38[8]; // [rsp+90h] [rbp-1A8h] BYREF
_BYTE v39[104]; // [rsp+98h] [rbp-1A0h] BYREF
_BYTE v40[312]; // [rsp+100h] [rbp-138h] BYREF
v3 = a1;
v4 = a3;
kv_type = gguf_get_kv_type(a2, a3);
if ( kv_type == 9 )
{
arr_type = gguf_get_arr_type(a2, v4);
arr_n = gguf_get_arr_n(a2, v4);
if ( arr_type == 8 )
arr_data = 0LL;
else
arr_data = gguf_get_arr_data(a2, v4);
v35 = v4;
v36 = a2;
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(v37);
std::__ostream_insert<char,std::char_traits<char>>(v38, "[", 1LL);
v34 = a1;
if ( arr_n <= 0 )
{
LABEL_28:
std::__ostream_insert<char,std::char_traits<char>>(v38, "]", 1LL);
v3 = v34;
std::stringbuf::str(v34, v39);
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream(
v37,
&`VTT for'std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>,
v23,
v24);
std::ios_base::~ios_base((std::ios_base *)v40);
return v3;
}
v11 = arr_n - 1;
v12 = arr_n & 0x7FFFFFFF;
v13 = 0LL;
while ( arr_type != 8 )
{
if ( arr_type != 9 )
{
gguf_data_to_str[abi:cxx11](&v26, arr_type, arr_data, (unsigned int)v13);
std::__ostream_insert<char,std::char_traits<char>>(v38, v26, v27);
LABEL_23:
if ( v26 != &v28 )
operator delete(v26, v28 + 1);
goto LABEL_25;
}
std::__ostream_insert<char,std::char_traits<char>>(v38, "???", 3LL);
LABEL_25:
if ( v13 < v11 )
std::__ostream_insert<char,std::char_traits<char>>(v38, ", ", 2LL);
if ( v12 == ++v13 )
goto LABEL_28;
}
arr_str = gguf_get_arr_str(v36, v35, v13);
std::string::basic_string<std::allocator<char>>(&v26, arr_str, v29);
v29[0] = v30;
std::string::_M_construct<char const*>(v29, "\\", "");
v31[0] = v32;
std::string::_M_construct<char const*>(v31, "\\\\", "");
replace_all((int)&v26, (int)v29, (int)v31, v15, v16, v17, v26, v27, v28);
if ( v31[0] != v32 )
operator delete(v31[0], v32[0] + 1LL);
if ( v29[0] != v30 )
operator delete(v29[0], v30[0] + 1LL);
v29[0] = v30;
std::string::_M_construct<char const*>(v29, "\"", "");
v31[0] = v32;
std::string::_M_construct<char const*>(v31, "\\\"", "");
replace_all((int)&v26, (int)v29, (int)v31, v18, v19, v20, v26, v27, v28);
if ( v31[0] != v32 )
operator delete(v31[0], v32[0] + 1LL);
if ( v29[0] != v30 )
operator delete(v29[0], v30[0] + 1LL);
LOBYTE(v29[0]) = 34;
v21 = std::__ostream_insert<char,std::char_traits<char>>(v38, v29, 1LL);
v22 = std::__ostream_insert<char,std::char_traits<char>>(v21, v26, v27);
LOBYTE(v29[0]) = 34;
std::__ostream_insert<char,std::char_traits<char>>(v22, v29, 1LL);
goto LABEL_23;
}
v6 = kv_type;
if ( kv_type == 8 )
{
val_str = gguf_get_val_str(a2, v4);
std::string::basic_string<std::allocator<char>>(a1, val_str, v37);
}
else
{
val_data = gguf_get_val_data(a2, v4);
gguf_data_to_str[abi:cxx11](a1, v6, val_data, 0LL);
}
return v3;
}
| gguf_kv_to_str[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x208
MOV R15,RSI
MOV R14,RDI
MOVSXD R13,EDX
MOV RDI,RSI
MOV RSI,R13
CALL 0x0016cf60
CMP EAX,0x9
JZ 0x001ac1ec
MOV EBX,EAX
MOV RDI,R15
MOV RSI,R13
CMP EAX,0x8
JNZ 0x001ac217
CALL 0x00167830
LEA RDX,[RSP + 0x80]
MOV RDI,R14
MOV RSI,RAX
CALL 0x0016c230
JMP 0x001ac4eb
LAB_001ac1ec:
MOV RDI,R15
MOV RSI,R13
CALL 0x00165ef0
MOV EBP,EAX
MOV RDI,R15
MOV RSI,R13
CALL 0x00168040
MOV R12,RAX
CMP EBP,0x8
JNZ 0x001ac230
MOV qword ptr [RSP + 0x60],0x0
JMP 0x001ac240
LAB_001ac217:
CALL 0x00169ff0
MOV RDI,R14
MOV ESI,EBX
MOV RDX,RAX
XOR ECX,ECX
CALL 0x001ac5a0
JMP 0x001ac4eb
LAB_001ac230:
MOV RDI,R15
MOV RSI,R13
CALL 0x0016be20
MOV qword ptr [RSP + 0x60],RAX
LAB_001ac240:
MOV qword ptr [RSP + 0x70],R13
MOV qword ptr [RSP + 0x78],R15
LEA RDI,[RSP + 0x80]
CALL 0x00167d30
LEA RDI,[RSP + 0x90]
LAB_001ac25f:
LEA RSI,[0x219bee]
MOV EDX,0x1
CALL 0x00169a40
MOV qword ptr [RSP + 0x68],R14
TEST R12D,R12D
JLE 0x001ac49c
LEA EAX,[R12 + -0x1]
MOVSXD R13,EAX
AND R12D,0x7fffffff
XOR EBX,EBX
LEA R14,[RSP + 0x20]
LEA R15,[RSP + 0x40]
LAB_001ac299:
CMP EBP,0x8
JNZ 0x001ac410
LAB_001ac2a2:
MOV RDI,qword ptr [RSP + 0x78]
MOV RSI,qword ptr [RSP + 0x70]
MOV RDX,RBX
CALL 0x00168e00
LAB_001ac2b4:
MOV RDI,RSP
MOV RSI,RAX
MOV RDX,R14
CALL 0x0016c230
LEA RAX,[RSP + 0x30]
MOV qword ptr [RSP + 0x20],RAX
LAB_001ac2cc:
MOV RDI,R14
LEA RSI,[0x219bf1]
LEA RDX,[0x219bf2]
CALL 0x001666b0
LEA RAX,[RSP + 0x50]
MOV qword ptr [RSP + 0x40],RAX
LAB_001ac2ec:
MOV RDI,R15
LEA RSI,[0x219bf0]
LEA RDX,[0x219bf2]
CALL 0x001666b0
LAB_001ac302:
MOV RDI,RSP
MOV RSI,R14
MOV RDX,R15
CALL 0x0016d3e0
MOV RDI,qword ptr [RSP + 0x40]
LEA RAX,[RSP + 0x50]
CMP RDI,RAX
JZ 0x001ac32c
MOV RSI,qword ptr [RSP + 0x50]
INC RSI
CALL 0x00169220
LAB_001ac32c:
MOV RDI,qword ptr [RSP + 0x20]
LEA RAX,[RSP + 0x30]
CMP RDI,RAX
JZ 0x001ac348
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x00169220
LAB_001ac348:
LEA RAX,[RSP + 0x30]
MOV qword ptr [RSP + 0x20],RAX
LAB_001ac352:
MOV RDI,R14
LEA RSI,[0x21f132]
LEA RDX,[0x21f133]
CALL 0x001666b0
LEA RAX,[RSP + 0x50]
MOV qword ptr [RSP + 0x40],RAX
LAB_001ac372:
MOV RDI,R15
LEA RSI,[0x219bf3]
LEA RDX,[0x219bf5]
CALL 0x001666b0
LAB_001ac388:
MOV RDI,RSP
MOV RSI,R14
MOV RDX,R15
CALL 0x0016d3e0
MOV RDI,qword ptr [RSP + 0x40]
LEA RAX,[RSP + 0x50]
CMP RDI,RAX
JZ 0x001ac3b2
MOV RSI,qword ptr [RSP + 0x50]
INC RSI
CALL 0x00169220
LAB_001ac3b2:
MOV RDI,qword ptr [RSP + 0x20]
LEA RAX,[RSP + 0x30]
CMP RDI,RAX
JZ 0x001ac3ce
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x00169220
LAB_001ac3ce:
MOV byte ptr [RSP + 0x20],0x22
LAB_001ac3d3:
MOV EDX,0x1
LEA RDI,[RSP + 0x90]
MOV RSI,R14
CALL 0x00169a40
MOV RSI,qword ptr [RSP]
MOV RDX,qword ptr [RSP + 0x8]
MOV RDI,RAX
CALL 0x00169a40
MOV byte ptr [RSP + 0x20],0x22
MOV EDX,0x1
MOV RDI,RAX
MOV RSI,R14
CALL 0x00169a40
JMP 0x001ac457
LAB_001ac410:
CMP EBP,0x9
JNZ 0x001ac430
LAB_001ac415:
MOV EDX,0x3
LEA RDI,[RSP + 0x90]
LEA RSI,[0x219bf6]
CALL 0x00169a40
JMP 0x001ac472
LAB_001ac430:
MOV RDI,RSP
MOV ESI,EBP
MOV RDX,qword ptr [RSP + 0x60]
MOV ECX,EBX
CALL 0x001ac5a0
MOV RSI,qword ptr [RSP]
MOV RDX,qword ptr [RSP + 0x8]
LAB_001ac44a:
LEA RDI,[RSP + 0x90]
CALL 0x00169a40
LAB_001ac457:
MOV RDI,qword ptr [RSP]
LEA RAX,[RSP + 0x10]
CMP RDI,RAX
JZ 0x001ac472
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x00169220
LAB_001ac472:
CMP RBX,R13
JGE 0x001ac490
LAB_001ac477:
MOV EDX,0x2
LEA RDI,[RSP + 0x90]
LEA RSI,[0x21dc87]
CALL 0x00169a40
LAB_001ac490:
INC RBX
CMP R12,RBX
JNZ 0x001ac299
LAB_001ac49c:
LEA RSI,[0x21f833]
MOV EDX,0x1
LEA RDI,[RSP + 0x90]
CALL 0x00169a40
MOV R14,qword ptr [RSP + 0x68]
LEA RSI,[RSP + 0x98]
MOV RDI,R14
CALL 0x0016b850
LAB_001ac4ca:
MOV RSI,qword ptr [0x00260a68]
LEA RDI,[RSP + 0x80]
CALL 0x00167e80
LEA RDI,[RSP + 0x100]
CALL 0x001661c0
LAB_001ac4eb:
MOV RAX,R14
ADD RSP,0x208
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* gguf_kv_to_str[abi:cxx11](gguf_context const*, int) */
gguf_context * gguf_kv_to_str_abi_cxx11_(gguf_context *param_1,int param_2)
{
int iVar1;
uint uVar2;
char *pcVar3;
int8 uVar4;
ostream *poVar5;
int in_EDX;
ulong uVar6;
int4 in_register_00000034;
long lVar7;
long *local_238;
long local_230;
long local_228 [2];
long *local_218 [2];
long local_208 [2];
long *local_1f8 [2];
long local_1e8 [2];
int8 local_1d8;
gguf_context *local_1d0;
long local_1c8;
int8 local_1c0;
allocator local_1b8 [16];
ostream local_1a8 [112];
ios_base local_138 [264];
uVar4 = CONCAT44(in_register_00000034,param_2);
lVar7 = (long)in_EDX;
iVar1 = gguf_get_kv_type(uVar4,lVar7);
if (iVar1 == 9) {
iVar1 = gguf_get_arr_type(uVar4,lVar7);
uVar2 = gguf_get_arr_n(uVar4,lVar7);
if (iVar1 == 8) {
local_1d8 = 0;
}
else {
local_1d8 = gguf_get_arr_data(uVar4,lVar7);
}
local_1c8 = lVar7;
local_1c0 = uVar4;
std::__cxx11::stringstream::stringstream((stringstream *)local_1b8);
/* try { // try from 001ac25f to 001ac26f has its CatchHandler @ 001ac500 */
std::__ostream_insert<char,std::char_traits<char>>(local_1a8,"[",1);
local_1d0 = param_1;
if (0 < (int)uVar2) {
uVar6 = 0;
do {
if (iVar1 == 8) {
/* try { // try from 001ac2a2 to 001ac2b3 has its CatchHandler @ 001ac50e */
pcVar3 = (char *)gguf_get_arr_str(local_1c0,local_1c8,uVar6);
/* try { // try from 001ac2b4 to 001ac2c1 has its CatchHandler @ 001ac506 */
std::__cxx11::string::string<std::allocator<char>>
((string *)&local_238,pcVar3,(allocator *)local_218);
local_218[0] = local_208;
/* try { // try from 001ac2cc to 001ac2e1 has its CatchHandler @ 001ac510 */
std::__cxx11::string::_M_construct<char_const*>
((string *)local_218,&DAT_00219bf1,&DAT_00219bf2);
local_1f8[0] = local_1e8;
/* try { // try from 001ac2ec to 001ac301 has its CatchHandler @ 001ac508 */
std::__cxx11::string::_M_construct<char_const*>
((string *)local_1f8,&DAT_00219bf0,&DAT_00219bf2);
/* try { // try from 001ac302 to 001ac30f has its CatchHandler @ 001ac512 */
replace_all((string *)&local_238,(string *)local_218,(string *)local_1f8);
if (local_1f8[0] != local_1e8) {
operator_delete(local_1f8[0],local_1e8[0] + 1);
}
if (local_218[0] != local_208) {
operator_delete(local_218[0],local_208[0] + 1);
}
local_218[0] = local_208;
/* try { // try from 001ac352 to 001ac367 has its CatchHandler @ 001ac50a */
std::__cxx11::string::_M_construct<char_const*>((string *)local_218,"\"","");
local_1f8[0] = local_1e8;
/* try { // try from 001ac372 to 001ac387 has its CatchHandler @ 001ac533 */
std::__cxx11::string::_M_construct<char_const*>
((string *)local_1f8,&DAT_00219bf3,&DAT_00219bf5);
/* try { // try from 001ac388 to 001ac395 has its CatchHandler @ 001ac50c */
replace_all((string *)&local_238,(string *)local_218,(string *)local_1f8);
if (local_1f8[0] != local_1e8) {
operator_delete(local_1f8[0],local_1e8[0] + 1);
}
if (local_218[0] != local_208) {
operator_delete(local_218[0],local_208[0] + 1);
}
local_218[0]._0_1_ = (string)0x22;
/* try { // try from 001ac3d3 to 001ac40d has its CatchHandler @ 001ac559 */
poVar5 = std::__ostream_insert<char,std::char_traits<char>>(local_1a8,(char *)local_218,1)
;
poVar5 = std::__ostream_insert<char,std::char_traits<char>>
(poVar5,(char *)local_238,local_230);
local_218[0] = (long *)CONCAT71(local_218[0]._1_7_,0x22);
std::__ostream_insert<char,std::char_traits<char>>(poVar5,(char *)local_218,1);
LAB_001ac457:
if (local_238 != local_228) {
operator_delete(local_238,local_228[0] + 1);
}
}
else {
if (iVar1 != 9) {
/* try { // try from 001ac430 to 001ac440 has its CatchHandler @ 001ac504 */
gguf_data_to_str_abi_cxx11_(&local_238,iVar1,local_1d8,uVar6 & 0xffffffff);
/* try { // try from 001ac44a to 001ac456 has its CatchHandler @ 001ac502 */
std::__ostream_insert<char,std::char_traits<char>>
(local_1a8,(char *)local_238,local_230);
goto LAB_001ac457;
}
/* try { // try from 001ac415 to 001ac42d has its CatchHandler @ 001ac554 */
std::__ostream_insert<char,std::char_traits<char>>(local_1a8,"???",3);
}
if ((long)uVar6 < (long)(int)(uVar2 - 1)) {
/* try { // try from 001ac477 to 001ac48f has its CatchHandler @ 001ac554 */
std::__ostream_insert<char,std::char_traits<char>>(local_1a8,", ",2);
}
uVar6 = uVar6 + 1;
} while ((uVar2 & 0x7fffffff) != uVar6);
}
/* try { // try from 001ac49c to 001ac4c9 has its CatchHandler @ 001ac500 */
std::__ostream_insert<char,std::char_traits<char>>(local_1a8,"]",1);
param_1 = local_1d0;
std::__cxx11::stringbuf::str();
std::__cxx11::stringstream::~stringstream((stringstream *)local_1b8);
std::ios_base::~ios_base(local_138);
}
else if (iVar1 == 8) {
pcVar3 = (char *)gguf_get_val_str();
std::__cxx11::string::string<std::allocator<char>>((string *)param_1,pcVar3,local_1b8);
}
else {
uVar4 = gguf_get_val_data(uVar4,lVar7);
gguf_data_to_str_abi_cxx11_(param_1,iVar1,uVar4,0);
}
return param_1;
}
| |
41,543 | make_type | eloqsql/mysys/typelib.c | void make_type(register char * to, register uint nr,
register TYPELIB *typelib)
{
DBUG_ENTER("make_type");
if (!nr)
to[0]=0;
else
(void) strmov(to,get_type(typelib,nr-1));
DBUG_VOID_RETURN;
} | O0 | c | make_type:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x2d762
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
jmp 0x2d785
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
subl $0x1, %esi
callq 0x2d790
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x252d0
jmp 0x2d787
jmp 0x2d789
addq $0x20, %rsp
popq %rbp
retq
nop
| make_type:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
cmp [rbp+var_C], 0
jnz short loc_2D762
mov rax, [rbp+var_8]
mov byte ptr [rax], 0
jmp short loc_2D785
loc_2D762:
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
mov rdi, [rbp+var_18]
mov esi, [rbp+var_C]
sub esi, 1
call get_type
mov rdi, [rbp+var_20]
mov rsi, rax
call _stpcpy
loc_2D785:
jmp short $+2
loc_2D787:
jmp short $+2
loc_2D789:
add rsp, 20h
pop rbp
retn
| long long make_type(_BYTE *a1, int a2, long long a3)
{
long long result; // rax
long long type; // rax
if ( a2 )
{
type = get_type(a3, (unsigned int)(a2 - 1));
return stpcpy(a1, type);
}
else
{
result = (long long)a1;
*a1 = 0;
}
return result;
}
| make_type:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
CMP dword ptr [RBP + -0xc],0x0
JNZ 0x0012d762
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX],0x0
JMP 0x0012d785
LAB_0012d762:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,dword ptr [RBP + -0xc]
SUB ESI,0x1
CALL 0x0012d790
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,RAX
CALL 0x001252d0
LAB_0012d785:
JMP 0x0012d787
LAB_0012d787:
JMP 0x0012d789
LAB_0012d789:
ADD RSP,0x20
POP RBP
RET
|
void make_type(char *param_1,int param_2,int8 param_3)
{
char *__src;
if (param_2 == 0) {
*param_1 = '\0';
}
else {
__src = (char *)get_type(param_3,param_2 + -1);
stpcpy(param_1,__src);
}
return;
}
| |
41,544 | check_define_prop_flags | bluesky950520[P]quickjs/quickjs.c | static BOOL check_define_prop_flags(int prop_flags, int flags)
{
BOOL has_accessor, is_getset;
if (!(prop_flags & JS_PROP_CONFIGURABLE)) {
if ((flags & (JS_PROP_HAS_CONFIGURABLE | JS_PROP_CONFIGURABLE)) ==
(JS_PROP_HAS_CONFIGURABLE | JS_PROP_CONFIGURABLE)) {
return FALSE;
}
if ((flags & JS_PROP_HAS_ENUMERABLE) &&
(flags & JS_PROP_ENUMERABLE) != (prop_flags & JS_PROP_ENUMERABLE))
return FALSE;
}
if (flags & (JS_PROP_HAS_VALUE | JS_PROP_HAS_WRITABLE |
JS_PROP_HAS_GET | JS_PROP_HAS_SET)) {
if (!(prop_flags & JS_PROP_CONFIGURABLE)) {
has_accessor = ((flags & (JS_PROP_HAS_GET | JS_PROP_HAS_SET)) != 0);
is_getset = ((prop_flags & JS_PROP_TMASK) == JS_PROP_GETSET);
if (has_accessor != is_getset)
return FALSE;
if (!has_accessor && !is_getset && !(prop_flags & JS_PROP_WRITABLE)) {
/* not writable: cannot set the writable bit */
if ((flags & (JS_PROP_HAS_WRITABLE | JS_PROP_WRITABLE)) ==
(JS_PROP_HAS_WRITABLE | JS_PROP_WRITABLE))
return FALSE;
}
}
}
return TRUE;
} | O0 | c | check_define_prop_flags:
movl %edi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl -0x8(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x34380
movl -0xc(%rsp), %eax
andl $0x101, %eax # imm = 0x101
cmpl $0x101, %eax # imm = 0x101
jne 0x34351
movl $0x0, -0x4(%rsp)
jmp 0x34422
movl -0xc(%rsp), %eax
andl $0x400, %eax # imm = 0x400
cmpl $0x0, %eax
je 0x3437e
movl -0xc(%rsp), %eax
andl $0x4, %eax
movl -0x8(%rsp), %ecx
andl $0x4, %ecx
cmpl %ecx, %eax
je 0x3437e
movl $0x0, -0x4(%rsp)
jmp 0x34422
jmp 0x34380
movl -0xc(%rsp), %eax
andl $0x3a00, %eax # imm = 0x3A00
cmpl $0x0, %eax
je 0x3441a
movl -0x8(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x34418
movl -0xc(%rsp), %eax
andl $0x1800, %eax # imm = 0x1800
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x10(%rsp)
movl -0x8(%rsp), %eax
andl $0x30, %eax
cmpl $0x10, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rsp)
movl -0x10(%rsp), %eax
cmpl -0x14(%rsp), %eax
je 0x343e0
movl $0x0, -0x4(%rsp)
jmp 0x34422
cmpl $0x0, -0x10(%rsp)
jne 0x34416
cmpl $0x0, -0x14(%rsp)
jne 0x34416
movl -0x8(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x34416
movl -0xc(%rsp), %eax
andl $0x202, %eax # imm = 0x202
cmpl $0x202, %eax # imm = 0x202
jne 0x34414
movl $0x0, -0x4(%rsp)
jmp 0x34422
jmp 0x34416
jmp 0x34418
jmp 0x3441a
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
| check_define_prop_flags:
mov [rsp+var_8], edi
mov [rsp+var_C], esi
mov eax, [rsp+var_8]
and eax, 1
cmp eax, 0
jnz short loc_34380
mov eax, [rsp+var_C]
and eax, 101h
cmp eax, 101h
jnz short loc_34351
mov [rsp+var_4], 0
jmp loc_34422
loc_34351:
mov eax, [rsp+var_C]
and eax, 400h
cmp eax, 0
jz short loc_3437E
mov eax, [rsp+var_C]
and eax, 4
mov ecx, [rsp+var_8]
and ecx, 4
cmp eax, ecx
jz short loc_3437E
mov [rsp+var_4], 0
jmp loc_34422
loc_3437E:
jmp short $+2
loc_34380:
mov eax, [rsp+var_C]
and eax, 3A00h
cmp eax, 0
jz loc_3441A
mov eax, [rsp+var_8]
and eax, 1
cmp eax, 0
jnz short loc_34418
mov eax, [rsp+var_C]
and eax, 1800h
cmp eax, 0
setnz al
and al, 1
movzx eax, al
mov [rsp+var_10], eax
mov eax, [rsp+var_8]
and eax, 30h
cmp eax, 10h
setz al
and al, 1
movzx eax, al
mov [rsp+var_14], eax
mov eax, [rsp+var_10]
cmp eax, [rsp+var_14]
jz short loc_343E0
mov [rsp+var_4], 0
jmp short loc_34422
loc_343E0:
cmp [rsp+var_10], 0
jnz short loc_34416
cmp [rsp+var_14], 0
jnz short loc_34416
mov eax, [rsp+var_8]
and eax, 2
cmp eax, 0
jnz short loc_34416
mov eax, [rsp+var_C]
and eax, 202h
cmp eax, 202h
jnz short loc_34414
mov [rsp+var_4], 0
jmp short loc_34422
loc_34414:
jmp short $+2
loc_34416:
jmp short $+2
loc_34418:
jmp short $+2
loc_3441A:
mov [rsp+var_4], 1
loc_34422:
mov eax, [rsp+var_4]
retn
| long long check_define_prop_flags(char a1, __int16 a2)
{
if ( (a1 & 1) != 0 )
goto LABEL_7;
if ( (a2 & 0x101) != 0x101 )
{
if ( (a2 & 0x400) != 0 && (a2 & 4) != (a1 & 4) )
return 0;
LABEL_7:
if ( (a2 & 0x3A00) != 0 && (a1 & 1) == 0 )
{
if ( ((a2 & 0x1800) != 0) != ((a1 & 0x30) == 16) )
return 0;
if ( (a2 & 0x1800) == 0 && (a1 & 0x30) != 0x10 && (a1 & 2) == 0 && (a2 & 0x202) == 0x202 )
return 0;
}
return 1;
}
return 0;
}
| check_define_prop_flags:
MOV dword ptr [RSP + -0x8],EDI
MOV dword ptr [RSP + -0xc],ESI
MOV EAX,dword ptr [RSP + -0x8]
AND EAX,0x1
CMP EAX,0x0
JNZ 0x00134380
MOV EAX,dword ptr [RSP + -0xc]
AND EAX,0x101
CMP EAX,0x101
JNZ 0x00134351
MOV dword ptr [RSP + -0x4],0x0
JMP 0x00134422
LAB_00134351:
MOV EAX,dword ptr [RSP + -0xc]
AND EAX,0x400
CMP EAX,0x0
JZ 0x0013437e
MOV EAX,dword ptr [RSP + -0xc]
AND EAX,0x4
MOV ECX,dword ptr [RSP + -0x8]
AND ECX,0x4
CMP EAX,ECX
JZ 0x0013437e
MOV dword ptr [RSP + -0x4],0x0
JMP 0x00134422
LAB_0013437e:
JMP 0x00134380
LAB_00134380:
MOV EAX,dword ptr [RSP + -0xc]
AND EAX,0x3a00
CMP EAX,0x0
JZ 0x0013441a
MOV EAX,dword ptr [RSP + -0x8]
AND EAX,0x1
CMP EAX,0x0
JNZ 0x00134418
MOV EAX,dword ptr [RSP + -0xc]
AND EAX,0x1800
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RSP + -0x10],EAX
MOV EAX,dword ptr [RSP + -0x8]
AND EAX,0x30
CMP EAX,0x10
SETZ AL
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RSP + -0x14],EAX
MOV EAX,dword ptr [RSP + -0x10]
CMP EAX,dword ptr [RSP + -0x14]
JZ 0x001343e0
MOV dword ptr [RSP + -0x4],0x0
JMP 0x00134422
LAB_001343e0:
CMP dword ptr [RSP + -0x10],0x0
JNZ 0x00134416
CMP dword ptr [RSP + -0x14],0x0
JNZ 0x00134416
MOV EAX,dword ptr [RSP + -0x8]
AND EAX,0x2
CMP EAX,0x0
JNZ 0x00134416
MOV EAX,dword ptr [RSP + -0xc]
AND EAX,0x202
CMP EAX,0x202
JNZ 0x00134414
MOV dword ptr [RSP + -0x4],0x0
JMP 0x00134422
LAB_00134414:
JMP 0x00134416
LAB_00134416:
JMP 0x00134418
LAB_00134418:
JMP 0x0013441a
LAB_0013441a:
MOV dword ptr [RSP + -0x4],0x1
LAB_00134422:
MOV EAX,dword ptr [RSP + -0x4]
RET
|
int4 check_define_prop_flags(uint param_1,uint param_2)
{
bool bVar1;
bool bVar2;
if ((param_1 & 1) == 0) {
if ((param_2 & 0x101) == 0x101) {
return 0;
}
if (((param_2 & 0x400) != 0) && ((param_2 & 4) != (param_1 & 4))) {
return 0;
}
}
if (((param_2 & 0x3a00) != 0) && ((param_1 & 1) == 0)) {
bVar1 = (param_2 & 0x1800) != 0;
bVar2 = (param_1 & 0x30) == 0x10;
if (bVar1 != bVar2) {
return 0;
}
if ((((!bVar1) && (!bVar2)) && ((param_1 & 2) == 0)) && ((param_2 & 0x202) == 0x202)) {
return 0;
}
}
return 1;
}
| |
41,545 | check_define_prop_flags | bluesky950520[P]quickjs/quickjs.c | static BOOL check_define_prop_flags(int prop_flags, int flags)
{
BOOL has_accessor, is_getset;
if (!(prop_flags & JS_PROP_CONFIGURABLE)) {
if ((flags & (JS_PROP_HAS_CONFIGURABLE | JS_PROP_CONFIGURABLE)) ==
(JS_PROP_HAS_CONFIGURABLE | JS_PROP_CONFIGURABLE)) {
return FALSE;
}
if ((flags & JS_PROP_HAS_ENUMERABLE) &&
(flags & JS_PROP_ENUMERABLE) != (prop_flags & JS_PROP_ENUMERABLE))
return FALSE;
}
if (flags & (JS_PROP_HAS_VALUE | JS_PROP_HAS_WRITABLE |
JS_PROP_HAS_GET | JS_PROP_HAS_SET)) {
if (!(prop_flags & JS_PROP_CONFIGURABLE)) {
has_accessor = ((flags & (JS_PROP_HAS_GET | JS_PROP_HAS_SET)) != 0);
is_getset = ((prop_flags & JS_PROP_TMASK) == JS_PROP_GETSET);
if (has_accessor != is_getset)
return FALSE;
if (!has_accessor && !is_getset && !(prop_flags & JS_PROP_WRITABLE)) {
/* not writable: cannot set the writable bit */
if ((flags & (JS_PROP_HAS_WRITABLE | JS_PROP_WRITABLE)) ==
(JS_PROP_HAS_WRITABLE | JS_PROP_WRITABLE))
return FALSE;
}
}
}
return TRUE;
} | O2 | c | check_define_prop_flags:
testb $0x1, %dil
je 0x1f128
pushq $0x1
popq %rax
retq
movl %esi, %ecx
notl %ecx
xorl %eax, %eax
testw $0x101, %cx # imm = 0x101
jne 0x1f136
retq
btl $0xa, %esi
jae 0x1f145
movl %esi, %edx
xorl %edi, %edx
testb $0x4, %dl
jne 0x1f135
testw $0x3a00, %si # imm = 0x3A00
sete %dl
orb %dil, %dl
testb $0x1, %dl
jne 0x1f124
testw $0x1800, %si # imm = 0x1800
setne %r8b
movl %edi, %edx
andl $0x30, %edx
cmpl $0x10, %edx
sete %r9b
xorb %r8b, %r9b
jne 0x1f135
testw $0x202, %cx # imm = 0x202
jne 0x1f124
andl $0x2, %edi
jne 0x1f124
cmpl $0x10, %edx
je 0x1f124
andl $0x1800, %esi # imm = 0x1800
je 0x1f135
jmp 0x1f124
| check_define_prop_flags:
test dil, 1
jz short loc_1F128
loc_1F124:
push 1
pop rax
retn
loc_1F128:
mov ecx, esi
not ecx
xor eax, eax
test cx, 101h
jnz short loc_1F136
locret_1F135:
retn
loc_1F136:
bt esi, 0Ah
jnb short loc_1F145
mov edx, esi
xor edx, edi
test dl, 4
jnz short locret_1F135
loc_1F145:
test si, 3A00h
setz dl
or dl, dil
test dl, 1
jnz short loc_1F124
test si, 1800h
setnz r8b
mov edx, edi
and edx, 30h
cmp edx, 10h
setz r9b
xor r9b, r8b
jnz short locret_1F135
test cx, 202h
jnz short loc_1F124
and edi, 2
jnz short loc_1F124
cmp edx, 10h
jz short loc_1F124
and esi, 1800h
jz short locret_1F135
jmp short loc_1F124
| long long check_define_prop_flags(unsigned __int8 a1, __int16 a2)
{
long long result; // rax
int v3; // edx
if ( (a1 & 1) != 0 )
return 1LL;
result = 0LL;
if ( (~a2 & 0x101) != 0 && ((a2 & 0x400) == 0 || ((a1 ^ (unsigned __int8)a2) & 4) == 0) )
{
if ( a1 & 1 | ((a2 & 0x3A00) == 0) )
return 1LL;
v3 = a1 & 0x30;
if ( ((a2 & 0x1800) != 0) == (v3 == 16) && ((~a2 & 0x202) != 0 || (a1 & 2) != 0 || v3 == 16 || (a2 & 0x1800) != 0) )
return 1LL;
}
return result;
}
| check_define_prop_flags:
TEST DIL,0x1
JZ 0x0011f128
LAB_0011f124:
PUSH 0x1
POP RAX
RET
LAB_0011f128:
MOV ECX,ESI
NOT ECX
XOR EAX,EAX
TEST CX,0x101
JNZ 0x0011f136
LAB_0011f135:
RET
LAB_0011f136:
BT ESI,0xa
JNC 0x0011f145
MOV EDX,ESI
XOR EDX,EDI
TEST DL,0x4
JNZ 0x0011f135
LAB_0011f145:
TEST SI,0x3a00
SETZ DL
OR DL,DIL
TEST DL,0x1
JNZ 0x0011f124
TEST SI,0x1800
SETNZ R8B
MOV EDX,EDI
AND EDX,0x30
CMP EDX,0x10
SETZ R9B
XOR R9B,R8B
JNZ 0x0011f135
TEST CX,0x202
JNZ 0x0011f124
AND EDI,0x2
JNZ 0x0011f124
CMP EDX,0x10
JZ 0x0011f124
AND ESI,0x1800
JZ 0x0011f135
JMP 0x0011f124
|
int8 check_define_prop_flags(uint param_1,uint param_2)
{
if ((param_1 & 1) == 0) {
if ((((~param_2 & 0x101) == 0) ||
(((param_2 >> 10 & 1) != 0 && (((param_2 ^ param_1) & 4) != 0)))) ||
(((param_2 & 0x3a00) != 0 && (param_1 & 1) == 0 &&
((((param_1 & 0x30) == 0x10) != ((param_2 & 0x1800) != 0) ||
(((((~param_2 & 0x202) == 0 && ((param_1 & 2) == 0)) && ((param_1 & 0x30) != 0x10)) &&
((param_2 & 0x1800) == 0)))))))) {
return 0;
}
}
return 1;
}
| |
41,546 | check_define_prop_flags | bluesky950520[P]quickjs/quickjs.c | static BOOL check_define_prop_flags(int prop_flags, int flags)
{
BOOL has_accessor, is_getset;
if (!(prop_flags & JS_PROP_CONFIGURABLE)) {
if ((flags & (JS_PROP_HAS_CONFIGURABLE | JS_PROP_CONFIGURABLE)) ==
(JS_PROP_HAS_CONFIGURABLE | JS_PROP_CONFIGURABLE)) {
return FALSE;
}
if ((flags & JS_PROP_HAS_ENUMERABLE) &&
(flags & JS_PROP_ENUMERABLE) != (prop_flags & JS_PROP_ENUMERABLE))
return FALSE;
}
if (flags & (JS_PROP_HAS_VALUE | JS_PROP_HAS_WRITABLE |
JS_PROP_HAS_GET | JS_PROP_HAS_SET)) {
if (!(prop_flags & JS_PROP_CONFIGURABLE)) {
has_accessor = ((flags & (JS_PROP_HAS_GET | JS_PROP_HAS_SET)) != 0);
is_getset = ((prop_flags & JS_PROP_TMASK) == JS_PROP_GETSET);
if (has_accessor != is_getset)
return FALSE;
if (!has_accessor && !is_getset && !(prop_flags & JS_PROP_WRITABLE)) {
/* not writable: cannot set the writable bit */
if ((flags & (JS_PROP_HAS_WRITABLE | JS_PROP_WRITABLE)) ==
(JS_PROP_HAS_WRITABLE | JS_PROP_WRITABLE))
return FALSE;
}
}
}
return TRUE;
} | O3 | c | check_define_prop_flags:
testb $0x1, %dil
jne 0x25c13
movl %esi, %ecx
notl %ecx
xorl %eax, %eax
testl $0x101, %ecx # imm = 0x101
je 0x25c12
btl $0xa, %esi
jae 0x25bd5
movl %esi, %edx
xorl %edi, %edx
testb $0x4, %dl
jne 0x25c12
testl $0x3a00, %esi # imm = 0x3A00
je 0x25c13
testl $0x1800, %esi # imm = 0x1800
setne %r8b
movl %edi, %edx
andl $0x30, %edx
cmpl $0x10, %edx
sete %r9b
xorb %r8b, %r9b
jne 0x25c12
testl $0x202, %ecx # imm = 0x202
jne 0x25c13
andl $0x2, %edi
jne 0x25c13
cmpl $0x10, %edx
je 0x25c13
andl $0x1800, %esi # imm = 0x1800
jne 0x25c13
retq
movl $0x1, %eax
retq
| check_define_prop_flags:
test dil, 1
jnz short loc_25C13
mov ecx, esi
not ecx
xor eax, eax
test ecx, 101h
jz short locret_25C12
bt esi, 0Ah
jnb short loc_25BD5
mov edx, esi
xor edx, edi
test dl, 4
jnz short locret_25C12
loc_25BD5:
test esi, 3A00h
jz short loc_25C13
test esi, 1800h
setnz r8b
mov edx, edi
and edx, 30h
cmp edx, 10h
setz r9b
xor r9b, r8b
jnz short locret_25C12
test ecx, 202h
jnz short loc_25C13
and edi, 2
jnz short loc_25C13
cmp edx, 10h
jz short loc_25C13
and esi, 1800h
jnz short loc_25C13
locret_25C12:
retn
loc_25C13:
mov eax, 1
retn
| long long check_define_prop_flags(unsigned __int8 a1, __int16 a2)
{
long long result; // rax
int v3; // edx
if ( (a1 & 1) != 0 )
return 1LL;
result = 0LL;
if ( (~a2 & 0x101) != 0 && ((a2 & 0x400) == 0 || ((a1 ^ (unsigned __int8)a2) & 4) == 0) )
{
if ( (a2 & 0x3A00) == 0 )
return 1LL;
v3 = a1 & 0x30;
if ( ((a2 & 0x1800) != 0) == (v3 == 16) && ((~a2 & 0x202) != 0 || (a1 & 2) != 0 || v3 == 16 || (a2 & 0x1800) != 0) )
return 1LL;
}
return result;
}
| check_define_prop_flags:
TEST DIL,0x1
JNZ 0x00125c13
MOV ECX,ESI
NOT ECX
XOR EAX,EAX
TEST ECX,0x101
JZ 0x00125c12
BT ESI,0xa
JNC 0x00125bd5
MOV EDX,ESI
XOR EDX,EDI
TEST DL,0x4
JNZ 0x00125c12
LAB_00125bd5:
TEST ESI,0x3a00
JZ 0x00125c13
TEST ESI,0x1800
SETNZ R8B
MOV EDX,EDI
AND EDX,0x30
CMP EDX,0x10
SETZ R9B
XOR R9B,R8B
JNZ 0x00125c12
TEST ECX,0x202
JNZ 0x00125c13
AND EDI,0x2
JNZ 0x00125c13
CMP EDX,0x10
JZ 0x00125c13
AND ESI,0x1800
JNZ 0x00125c13
LAB_00125c12:
RET
LAB_00125c13:
MOV EAX,0x1
RET
|
int8 check_define_prop_flags(uint param_1,uint param_2)
{
if ((param_1 & 1) == 0) {
if ((((~param_2 & 0x101) == 0) ||
(((param_2 >> 10 & 1) != 0 && (((param_2 ^ param_1) & 4) != 0)))) ||
(((param_2 & 0x3a00) != 0 &&
((((param_1 & 0x30) == 0x10) != ((param_2 & 0x1800) != 0) ||
(((((~param_2 & 0x202) == 0 && ((param_1 & 2) == 0)) && ((param_1 & 0x30) != 0x10)) &&
((param_2 & 0x1800) == 0)))))))) {
return 0;
}
}
return 1;
}
| |
41,547 | 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>::insert(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&) | monkey531[P]llama/common/json.hpp | iterator insert(const_iterator pos, const basic_json& val)
{
// insert only works for arrays
if (JSON_HEDLEY_LIKELY(is_array()))
{
// check if iterator pos fits to this JSON value
if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
{
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
}
// insert to array and return iterator
return insert_iterator(pos, val);
}
JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
} | O2 | 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>::insert(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
cmpb $0x2, (%rsi)
jne 0x73060
movq (%rdx), %rsi
cmpq %r14, %rsi
jne 0x730be
movq %rdi, %rbx
leaq 0x30(%rsp), %rax
movq %rsi, (%rax)
movups 0x8(%rdx), %xmm0
movups %xmm0, 0x8(%rax)
movq 0x18(%rdx), %rdx
movq %rdx, 0x18(%rax)
movq %r14, %rsi
movq %rax, %rdx
callq 0x7313a
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x203a0
movq %rax, %rbx
movq %r14, %rdi
callq 0x36e28
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x295fa(%rip), %rsi # 0x9c67c
leaq 0x10(%rsp), %rdi
callq 0x731ab
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x135, %esi # imm = 0x135
movq %r14, %rcx
callq 0x36cdc
xorl %ebp, %ebp
leaq 0x640eb(%rip), %rsi # 0xd7198
leaq -0x3f6c0(%rip), %rdx # 0x339f4
movq %rbx, %rdi
callq 0x20b90
jmp 0x7310f
pushq $0x20
popq %rdi
callq 0x203a0
movq %rax, %rbx
leaq 0x24120(%rip), %rsi # 0x971f0
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x2499e
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0xca, %esi
movq %r14, %rcx
callq 0x36b4c
xorl %ebp, %ebp
leaq 0x64058(%rip), %rsi # 0xd7158
leaq -0x3f713(%rip), %rdx # 0x339f4
movq %rbx, %rdi
callq 0x20b90
jmp 0x73113
jmp 0x73127
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x20de8
testb %bpl, %bpl
jne 0x7312a
jmp 0x73132
movq %rax, %r14
movq %rbx, %rdi
callq 0x20530
movq %r14, %rdi
callq 0x20bf0
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6insertENS0_6detail9iter_implIKSD_EERSG_:
push rbp; char
push r14; int
push rbx; int
sub rsp, 50h
mov r14, rsi
cmp byte ptr [rsi], 2
jnz short loc_73060
mov rsi, [rdx]
cmp rsi, r14
jnz loc_730BE
mov rbx, rdi
lea rax, [rsp+68h+var_38]
mov [rax], rsi
movups xmm0, xmmword ptr [rdx+8]
movups xmmword ptr [rax+8], xmm0
mov rdx, [rdx+18h]
mov [rax+18h], rdx
mov rsi, r14
mov rdx, rax
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE15insert_iteratorIJRKSD_EEENS0_6detail9iter_implISD_EENSI_ISF_EEDpOT_; 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>::insert_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&>(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rax, rbx
add rsp, 50h
pop rbx
pop r14
pop rbp
retn
loc_73060:
push 20h ; ' '
pop rdi; 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+68h+var_60]
mov [rdx], rax
lea rsi, aCannotUseInser; "cannot use insert() with "
lea rdi, [rsp+68h+var_58]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA26_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[26],char const*>(char const(&)[26],char const* &&)
mov bpl, 1
lea rdx, [rsp+68h+var_58]
mov rdi, rbx; this
mov esi, 135h; 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
jmp short loc_7310F
loc_730BE:
push 20h ; ' '
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aIteratorDoesNo; "iterator does not fit current value"
lea rdi, [rsp+68h+var_58]
lea rdx, [rsp+68h+var_60]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov bpl, 1
lea rdx, [rsp+68h+var_58]
mov rdi, rbx; this
mov esi, 0CAh; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_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_36detail16invalid_iteratorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_7310F:
jmp short loc_73113
jmp short loc_73127
loc_73113:
mov r14, rax
lea rdi, [rsp+68h+var_58]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_7312A
jmp short loc_73132
loc_73127:
mov r14, rax
loc_7312A:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_73132:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::insert(
long long a1,
unsigned __int8 *a2,
long long a3)
{
nlohmann::json_abi_v3_11_3::detail::type_error *exception; // rbx
nlohmann::json_abi_v3_11_3::detail::invalid_iterator *v5; // rbx
_QWORD v6[4]; // [rsp+10h] [rbp-58h] BYREF
unsigned __int8 *v7; // [rsp+30h] [rbp-38h] BYREF
__int128 v8; // [rsp+38h] [rbp-30h]
long long v9; // [rsp+48h] [rbp-20h]
if ( *a2 != 2 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::type_error *)__cxa_allocate_exception(0x20uLL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name(a2);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[26],char const*>(
v6,
"cannot use insert() with ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
309,
(long long)v6);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
if ( *(unsigned __int8 **)a3 != a2 )
{
v5 = (nlohmann::json_abi_v3_11_3::detail::invalid_iterator *)__cxa_allocate_exception(0x20uLL);
std::string::basic_string<std::allocator<char>>(v6, (long long)"iterator does not fit current value");
ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
v5,
202,
(long long)v6);
__cxa_throw(
v5,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::invalid_iterator,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
v7 = *(unsigned __int8 **)a3;
v8 = *(_OWORD *)(a3 + 8);
v9 = *(_QWORD *)(a3 + 24);
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>::insert_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const&>(
a1,
a2,
&v7);
return a1;
}
| insert:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV R14,RSI
CMP byte ptr [RSI],0x2
JNZ 0x00173060
MOV RSI,qword ptr [RDX]
CMP RSI,R14
JNZ 0x001730be
MOV RBX,RDI
LEA RAX,[RSP + 0x30]
MOV qword ptr [RAX],RSI
MOVUPS XMM0,xmmword ptr [RDX + 0x8]
MOVUPS xmmword ptr [RAX + 0x8],XMM0
MOV RDX,qword ptr [RDX + 0x18]
MOV qword ptr [RAX + 0x18],RDX
MOV RSI,R14
MOV RDX,RAX
CALL 0x0017313a
MOV RAX,RBX
ADD RSP,0x50
POP RBX
POP R14
POP RBP
RET
LAB_00173060:
PUSH 0x20
POP RDI
CALL 0x001203a0
MOV RBX,RAX
MOV RDI,R14
CALL 0x00136e28
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_0017307b:
LEA RSI,[0x19c67c]
LEA RDI,[RSP + 0x10]
CALL 0x001731ab
MOV BPL,0x1
LAB_0017308f:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x135
MOV RCX,R14
CALL 0x00136cdc
XOR EBP,EBP
LEA RSI,[0x1d7198]
LEA RDX,[0x1339f4]
MOV RDI,RBX
CALL 0x00120b90
LAB_001730be:
PUSH 0x20
POP RDI
CALL 0x001203a0
MOV RBX,RAX
LAB_001730c9:
LEA RSI,[0x1971f0]
LEA RDI,[RSP + 0x10]
LEA RDX,[RSP + 0x8]
CALL 0x0012499e
MOV BPL,0x1
LAB_001730e2:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0xca
MOV RCX,R14
CALL 0x00136b4c
XOR EBP,EBP
LEA RSI,[0x1d7158]
LEA RDX,[0x1339f4]
MOV RDI,RBX
CALL 0x00120b90
|
/* 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>::insert(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const>,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&) */
basic_json<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>
* __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>
::insert(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>
*param_2,long *param_3)
{
int8 uVar1;
char *local_60;
detail local_58 [32];
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_38;
int4 local_30;
int4 uStack_2c;
int4 uStack_28;
int4 uStack_24;
long local_20;
if (*param_2 !=
(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) {
uVar1 = __cxa_allocate_exception(0x20);
local_60 = (char *)type_name(param_2);
/* try { // try from 0017307b to 0017308b has its CatchHandler @ 00173127 */
detail::concat<std::__cxx11::string,char_const(&)[26],char_const*>
(local_58,"cannot use insert() with ",&local_60);
/* try { // try from 0017308f to 001730bb has its CatchHandler @ 00173113 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar1,0x135,local_58,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::type_error::typeinfo,detail::exception::~exception);
}
local_38 = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)*param_3;
if (local_38 == param_2) {
local_30 = (int4)param_3[1];
uStack_2c = *(int4 *)((long)param_3 + 0xc);
uStack_28 = (int4)param_3[2];
uStack_24 = *(int4 *)((long)param_3 + 0x14);
local_20 = param_3[3];
insert_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const&>
(this,param_2,&local_38);
return this;
}
uVar1 = __cxa_allocate_exception(0x20);
/* try { // try from 001730c9 to 001730de has its CatchHandler @ 00173111 */
std::__cxx11::string::string<std::allocator<char>>
((string *)local_58,"iterator does not fit current value",(allocator *)&local_60);
/* try { // try from 001730e2 to 0017310e has its CatchHandler @ 0017310f */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar1,0xca,local_58,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::invalid_iterator::typeinfo,detail::exception::~exception);
}
| |
41,548 | ma_net_flush | eloqsql/libmariadb/libmariadb/ma_net.c | int ma_net_flush(NET *net)
{
int error=0;
/* don't flush if pipelined query is in progress */
if (net->extension->multi_status > COM_MULTI_OFF)
return 0;
if (net->buff != net->write_pos)
{
error=ma_net_real_write(net,(char*) net->buff,
(size_t) (net->write_pos - net->buff));
net->write_pos=net->buff;
}
if (net->compress)
net->pkt_nr= net->compress_pkt_nr;
return(error);
} | O3 | c | ma_net_flush:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x2a0(%rdi), %rcx
xorl %eax, %eax
cmpl $0x0, (%rcx)
jne 0x31bd4
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movq 0x18(%rdi), %rdx
cmpq %rdx, %rsi
je 0x31bc3
subq %rsi, %rdx
movq %rbx, %rdi
callq 0x31bdb
movq 0x8(%rbx), %rcx
movq %rcx, 0x18(%rbx)
jmp 0x31bc5
xorl %eax, %eax
cmpb $0x0, 0x84(%rbx)
je 0x31bd4
movl 0x64(%rbx), %ecx
movl %ecx, 0x60(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| ma_net_flush:
push rbp
mov rbp, rsp
push rbx
push rax
mov rcx, [rdi+2A0h]
xor eax, eax
cmp dword ptr [rcx], 0
jnz short loc_31BD4
mov rbx, rdi
mov rsi, [rdi+8]
mov rdx, [rdi+18h]
cmp rsi, rdx
jz short loc_31BC3
sub rdx, rsi
mov rdi, rbx
call ma_net_real_write
mov rcx, [rbx+8]
mov [rbx+18h], rcx
jmp short loc_31BC5
loc_31BC3:
xor eax, eax
loc_31BC5:
cmp byte ptr [rbx+84h], 0
jz short loc_31BD4
mov ecx, [rbx+64h]
mov [rbx+60h], ecx
loc_31BD4:
add rsp, 8
pop rbx
pop rbp
retn
| long long ma_net_flush(long long a1)
{
long long result; // rax
long long v2; // rsi
long long v3; // rdx
result = 0LL;
if ( !**(_DWORD **)(a1 + 672) )
{
v2 = *(_QWORD *)(a1 + 8);
v3 = *(_QWORD *)(a1 + 24);
if ( v2 == v3 )
{
result = 0LL;
}
else
{
result = ma_net_real_write(a1, v2, v3 - v2);
*(_QWORD *)(a1 + 24) = *(_QWORD *)(a1 + 8);
}
if ( *(_BYTE *)(a1 + 132) )
*(_DWORD *)(a1 + 96) = *(_DWORD *)(a1 + 100);
}
return result;
}
| ma_net_flush:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RCX,qword ptr [RDI + 0x2a0]
XOR EAX,EAX
CMP dword ptr [RCX],0x0
JNZ 0x00131bd4
MOV RBX,RDI
MOV RSI,qword ptr [RDI + 0x8]
MOV RDX,qword ptr [RDI + 0x18]
CMP RSI,RDX
JZ 0x00131bc3
SUB RDX,RSI
MOV RDI,RBX
CALL 0x00131bdb
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [RBX + 0x18],RCX
JMP 0x00131bc5
LAB_00131bc3:
XOR EAX,EAX
LAB_00131bc5:
CMP byte ptr [RBX + 0x84],0x0
JZ 0x00131bd4
MOV ECX,dword ptr [RBX + 0x64]
MOV dword ptr [RBX + 0x60],ECX
LAB_00131bd4:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
int8 ma_net_flush(long param_1)
{
long lVar1;
int8 uVar2;
uVar2 = 0;
if (**(int **)(param_1 + 0x2a0) == 0) {
lVar1 = *(long *)(param_1 + 8);
if (lVar1 == *(long *)(param_1 + 0x18)) {
uVar2 = 0;
}
else {
uVar2 = ma_net_real_write(param_1,lVar1,*(long *)(param_1 + 0x18) - lVar1);
*(int8 *)(param_1 + 0x18) = *(int8 *)(param_1 + 8);
}
if (*(char *)(param_1 + 0x84) != '\0') {
*(int4 *)(param_1 + 0x60) = *(int4 *)(param_1 + 100);
}
}
return uVar2;
}
| |
41,549 | js_bigint_toString | bluesky950520[P]quickjs/quickjs.c | static JSValue js_bigint_toString(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue val;
int base;
JSValue ret;
val = js_thisBigIntValue(ctx, this_val);
if (JS_IsException(val))
return val;
if (argc == 0 || JS_IsUndefined(argv[0])) {
base = 10;
} else {
base = js_get_radix(ctx, argv[0]);
if (base < 0)
goto fail;
}
ret = js_bigint_to_string1(ctx, val, base);
JS_FreeValue(ctx, val);
return ret;
fail:
JS_FreeValue(ctx, val);
return JS_EXCEPTION;
} | O0 | c | js_bigint_toString:
subq $0x88, %rsp
movq %rsi, 0x68(%rsp)
movq %rdx, 0x70(%rsp)
movq %rdi, 0x60(%rsp)
movl %ecx, 0x5c(%rsp)
movq %r8, 0x50(%rsp)
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
callq 0xc37b0
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0xc3671
movq 0x40(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x80(%rsp)
jmp 0xc3748
cmpl $0x0, 0x5c(%rsp)
je 0xc368e
movq 0x50(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x34550
cmpl $0x0, %eax
je 0xc3698
movl $0xa, 0x3c(%rsp)
jmp 0xc36bd
movq 0x60(%rsp), %rdi
movq 0x50(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0xc3890
movl %eax, 0x3c(%rsp)
cmpl $0x0, 0x3c(%rsp)
jge 0xc36bb
jmp 0xc3720
jmp 0xc36bd
movq 0x60(%rsp), %rdi
movl 0x3c(%rsp), %ecx
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x68bb0
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x60(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x29f80
movq 0x28(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x80(%rsp)
jmp 0xc3748
movq 0x60(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x29f80
movl $0x0, 0x78(%rsp)
movq $0x6, 0x80(%rsp)
movq 0x78(%rsp), %rax
movq 0x80(%rsp), %rdx
addq $0x88, %rsp
retq
nopl (%rax)
| js_bigint_toString:
sub rsp, 88h
mov [rsp+88h+var_20], rsi
mov [rsp+88h+var_18], rdx
mov [rsp+88h+var_28], rdi
mov [rsp+88h+var_2C], ecx
mov [rsp+88h+var_38], r8
mov rdi, [rsp+88h+var_28]
mov rsi, [rsp+88h+var_20]
mov rdx, [rsp+88h+var_18]
call js_thisBigIntValue
mov [rsp+88h+var_70], rax
mov [rsp+88h+var_68], rdx
mov rax, [rsp+88h+var_70]
mov [rsp+88h+var_48], rax
mov rax, [rsp+88h+var_68]
mov [rsp+88h+var_40], rax
mov rdi, [rsp+88h+var_48]
mov rsi, [rsp+88h+var_40]
call JS_IsException_1
cmp eax, 0
jz short loc_C3671
mov rax, [rsp+88h+var_48]
mov [rsp+88h+var_10], rax
mov rax, [rsp+88h+var_40]
mov [rsp+88h+var_8], rax
jmp loc_C3748
loc_C3671:
cmp [rsp+88h+var_2C], 0
jz short loc_C368E
mov rax, [rsp+88h+var_38]
mov rdi, [rax]
mov rsi, [rax+8]
call JS_IsUndefined_1
cmp eax, 0
jz short loc_C3698
loc_C368E:
mov [rsp+88h+var_4C], 0Ah
jmp short loc_C36BD
loc_C3698:
mov rdi, [rsp+88h+var_28]
mov rax, [rsp+88h+var_38]
mov rsi, [rax]
mov rdx, [rax+8]
call js_get_radix
mov [rsp+88h+var_4C], eax
cmp [rsp+88h+var_4C], 0
jge short loc_C36BB
jmp short loc_C3720
loc_C36BB:
jmp short $+2
loc_C36BD:
mov rdi, [rsp+88h+var_28]
mov ecx, [rsp+88h+var_4C]
mov rsi, [rsp+88h+var_48]
mov rdx, [rsp+88h+var_40]
call js_bigint_to_string1
mov [rsp+88h+var_80], rax
mov [rsp+88h+var_78], rdx
mov rax, [rsp+88h+var_80]
mov [rsp+88h+var_60], rax
mov rax, [rsp+88h+var_78]
mov [rsp+88h+var_58], rax
mov rdi, [rsp+88h+var_28]
mov rsi, [rsp+88h+var_48]
mov rdx, [rsp+88h+var_40]
call JS_FreeValue
mov rax, [rsp+88h+var_60]
mov [rsp+88h+var_10], rax
mov rax, [rsp+88h+var_58]
mov [rsp+88h+var_8], rax
jmp short loc_C3748
loc_C3720:
mov rdi, [rsp+88h+var_28]
mov rsi, [rsp+88h+var_48]
mov rdx, [rsp+88h+var_40]
call JS_FreeValue
mov dword ptr [rsp+88h+var_10], 0
mov [rsp+88h+var_8], 6
loc_C3748:
mov rax, [rsp+88h+var_10]
mov rdx, [rsp+88h+var_8]
add rsp, 88h
retn
| long long js_bigint_toString(long long a1, long long a2, long long a3, int a4, long long *a5)
{
long long v5; // rdx
long long v6; // rax
long long v8; // [rsp+18h] [rbp-70h]
long long v9; // [rsp+28h] [rbp-60h]
signed int radix; // [rsp+3Ch] [rbp-4Ch]
long long v11; // [rsp+48h] [rbp-40h]
long long v14; // [rsp+78h] [rbp-10h]
v8 = js_thisBigIntValue(a1, a2, a3);
v11 = v5;
if ( JS_IsException_1(v8, v5) )
return v8;
if ( a4 && !JS_IsUndefined_1(*a5, a5[1]) )
{
radix = js_get_radix(a1, *a5, a5[1]);
if ( radix < 0 )
{
JS_FreeValue(a1, v8, v11);
LODWORD(v14) = 0;
return v14;
}
v6 = js_bigint_to_string1(a1, v8, v11, radix);
}
else
{
v6 = js_bigint_to_string1(a1, v8, v11, 0xAu);
}
v9 = v6;
JS_FreeValue(a1, v8, v11);
return v9;
}
| js_bigint_toString:
SUB RSP,0x88
MOV qword ptr [RSP + 0x68],RSI
MOV qword ptr [RSP + 0x70],RDX
MOV qword ptr [RSP + 0x60],RDI
MOV dword ptr [RSP + 0x5c],ECX
MOV qword ptr [RSP + 0x50],R8
MOV RDI,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0x68]
MOV RDX,qword ptr [RSP + 0x70]
CALL 0x001c37b0
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],RDX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x48],RAX
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x48]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x001c3671
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x78],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x80],RAX
JMP 0x001c3748
LAB_001c3671:
CMP dword ptr [RSP + 0x5c],0x0
JZ 0x001c368e
MOV RAX,qword ptr [RSP + 0x50]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x8]
CALL 0x00134550
CMP EAX,0x0
JZ 0x001c3698
LAB_001c368e:
MOV dword ptr [RSP + 0x3c],0xa
JMP 0x001c36bd
LAB_001c3698:
MOV RDI,qword ptr [RSP + 0x60]
MOV RAX,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x001c3890
MOV dword ptr [RSP + 0x3c],EAX
CMP dword ptr [RSP + 0x3c],0x0
JGE 0x001c36bb
JMP 0x001c3720
LAB_001c36bb:
JMP 0x001c36bd
LAB_001c36bd:
MOV RDI,qword ptr [RSP + 0x60]
MOV ECX,dword ptr [RSP + 0x3c]
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x48]
CALL 0x00168bb0
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RDX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x30],RAX
MOV RDI,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x48]
CALL 0x00129f80
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x78],RAX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x80],RAX
JMP 0x001c3748
LAB_001c3720:
MOV RDI,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x48]
CALL 0x00129f80
MOV dword ptr [RSP + 0x78],0x0
MOV qword ptr [RSP + 0x80],0x6
LAB_001c3748:
MOV RAX,qword ptr [RSP + 0x78]
MOV RDX,qword ptr [RSP + 0x80]
ADD RSP,0x88
RET
|
int1 [16]
js_bigint_toString(int8 param_1,int8 param_2,int8 param_3,int param_4,
int8 *param_5)
{
int iVar1;
int1 auVar3 [16];
int local_4c;
int4 local_10;
int4 uStack_c;
int8 local_8;
int8 uVar2;
auVar3 = js_thisBigIntValue(param_1,param_2,param_3);
uVar2 = auVar3._8_8_;
auVar3._0_8_ = auVar3._0_8_;
iVar1 = JS_IsException(auVar3._0_8_,uVar2);
if (iVar1 == 0) {
if ((param_4 == 0) || (iVar1 = JS_IsUndefined(*param_5,param_5[1]), iVar1 != 0)) {
local_4c = 10;
}
else {
local_4c = js_get_radix(param_1,*param_5,param_5[1]);
if (local_4c < 0) {
JS_FreeValue(param_1,auVar3._0_8_,uVar2);
local_10 = 0;
local_8 = 6;
goto LAB_001c3748;
}
}
auVar3 = js_bigint_to_string1(param_1,auVar3._0_8_,uVar2,local_4c);
local_8 = auVar3._8_8_;
JS_FreeValue(param_1,auVar3._0_8_,uVar2);
local_10 = auVar3._0_4_;
uStack_c = auVar3._4_4_;
}
else {
local_10 = auVar3._0_4_;
uStack_c = auVar3._4_4_;
local_8 = uVar2;
}
LAB_001c3748:
auVar3._4_4_ = uStack_c;
auVar3._0_4_ = local_10;
auVar3._8_8_ = local_8;
return auVar3;
}
| |
41,550 | js_bigint_toString | bluesky950520[P]quickjs/quickjs.c | static JSValue js_bigint_toString(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue val;
int base;
JSValue ret;
val = js_thisBigIntValue(ctx, this_val);
if (JS_IsException(val))
return val;
if (argc == 0 || JS_IsUndefined(argv[0])) {
base = 10;
} else {
base = js_get_radix(ctx, argv[0]);
if (base < 0)
goto fail;
}
ret = js_bigint_to_string1(ctx, val, base);
JS_FreeValue(ctx, val);
return ret;
fail:
JS_FreeValue(ctx, val);
return JS_EXCEPTION;
} | O2 | c | js_bigint_toString:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movl %ecx, %ebp
movq %rdi, %r15
callq 0x6192b
movq %rax, %r14
movq %rdx, %rbx
cmpl $0x6, %ebx
jne 0x618a1
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %r14, %rcx
andq %rax, %rcx
jmp 0x618f9
pushq $0xa
popq %rcx
testl %ebp, %ebp
je 0x618c4
movq 0x8(%r12), %rdx
cmpl $0x3, %edx
je 0x618c4
movq (%r12), %rsi
movq %r15, %rdi
callq 0x6196b
movl %eax, %ecx
testl %eax, %eax
js 0x61911
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3a52c
movq %rax, %r12
movq %rdx, %r13
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1bbce
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %r12, %rcx
movq %r12, %r14
movq %r13, %rbx
movl %r14d, %eax
orq %rcx, %rax
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1bbce
pushq $0x6
popq %rbx
xorl %r14d, %r14d
xorl %ecx, %ecx
jmp 0x618f9
| js_bigint_toString:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r12, r8
mov ebp, ecx
mov r15, rdi
call js_thisBigIntValue
mov r14, rax
mov rbx, rdx
cmp ebx, 6
jnz short loc_618A1
mov rax, 0FFFFFFFF00000000h
mov rcx, r14
and rcx, rax
jmp short loc_618F9
loc_618A1:
push 0Ah
pop rcx
test ebp, ebp
jz short loc_618C4
mov rdx, [r12+8]
cmp edx, 3
jz short loc_618C4
mov rsi, [r12]
mov rdi, r15
call js_get_radix
mov ecx, eax
test eax, eax
js short loc_61911
loc_618C4:
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call js_bigint_to_string1
mov r12, rax
mov r13, rdx
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call JS_FreeValue
mov rcx, 0FFFFFFFF00000000h
and rcx, r12
mov r14, r12
mov rbx, r13
loc_618F9:
mov eax, r14d
or rax, rcx
mov rdx, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_61911:
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call JS_FreeValue
push 6
pop rbx
xor r14d, r14d
xor ecx, ecx
jmp short loc_618F9
| unsigned long long js_bigint_toString(long long a1, long long a2, long long a3, int a4, _QWORD *a5)
{
long long v7; // r14
long long v8; // rdx
long long v9; // rbx
unsigned long long v10; // rcx
signed int radix; // ecx
long long v12; // rdx
unsigned long long v13; // r12
v7 = js_thisBigIntValue(a1);
v9 = v8;
if ( (_DWORD)v8 == 6 )
{
v10 = v7 & 0xFFFFFFFF00000000LL;
}
else
{
radix = 10;
if ( a4 && (v12 = a5[1], (_DWORD)v12 != 3) && (radix = js_get_radix(a1, *a5, v12, 10LL), radix < 0) )
{
JS_FreeValue(a1, v7, v9);
LODWORD(v7) = 0;
v10 = 0LL;
}
else
{
v13 = js_bigint_to_string1(a1, v7, v9, radix);
JS_FreeValue(a1, v7, v9);
v10 = v13 & 0xFFFFFFFF00000000LL;
LODWORD(v7) = v13;
}
}
return v10 | (unsigned int)v7;
}
| js_bigint_toString:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R12,R8
MOV EBP,ECX
MOV R15,RDI
CALL 0x0016192b
MOV R14,RAX
MOV RBX,RDX
CMP EBX,0x6
JNZ 0x001618a1
MOV RAX,-0x100000000
MOV RCX,R14
AND RCX,RAX
JMP 0x001618f9
LAB_001618a1:
PUSH 0xa
POP RCX
TEST EBP,EBP
JZ 0x001618c4
MOV RDX,qword ptr [R12 + 0x8]
CMP EDX,0x3
JZ 0x001618c4
MOV RSI,qword ptr [R12]
MOV RDI,R15
CALL 0x0016196b
MOV ECX,EAX
TEST EAX,EAX
JS 0x00161911
LAB_001618c4:
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x0013a52c
MOV R12,RAX
MOV R13,RDX
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x0011bbce
MOV RCX,-0x100000000
AND RCX,R12
MOV R14,R12
MOV RBX,R13
LAB_001618f9:
MOV EAX,R14D
OR RAX,RCX
MOV RDX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00161911:
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x0011bbce
PUSH 0x6
POP RBX
XOR R14D,R14D
XOR ECX,ECX
JMP 0x001618f9
|
int1 [16]
js_bigint_toString(int8 param_1,int8 param_2,int8 param_3,int param_4,
int8 *param_5)
{
int iVar1;
ulong uVar2;
int8 uVar3;
int1 auVar4 [16];
int1 auVar5 [16];
auVar4 = js_thisBigIntValue();
uVar3 = auVar4._8_8_;
uVar2 = auVar4._0_8_;
if (auVar4._8_4_ == 6) {
uVar2 = uVar2 & 0xffffffff00000000;
}
else {
if ((param_4 != 0) && ((int)param_5[1] != 3)) {
iVar1 = js_get_radix(param_1,*param_5,param_5[1],10);
if (iVar1 < 0) {
JS_FreeValue(param_1,uVar2,uVar3,iVar1);
auVar4 = ZEXT816(6) << 0x40;
uVar2 = 0;
goto LAB_001618f9;
}
}
auVar4 = js_bigint_to_string1(param_1,uVar2,uVar3);
JS_FreeValue(param_1,uVar2,uVar3);
uVar2 = auVar4._0_8_ & 0xffffffff00000000;
}
LAB_001618f9:
auVar5._0_8_ = auVar4._0_8_ & 0xffffffff | uVar2;
auVar5._8_8_ = auVar4._8_8_;
return auVar5;
}
| |
41,551 | js_bigint_toString | bluesky950520[P]quickjs/quickjs.c | static JSValue js_bigint_toString(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue val;
int base;
JSValue ret;
val = js_thisBigIntValue(ctx, this_val);
if (JS_IsException(val))
return val;
if (argc == 0 || JS_IsUndefined(argv[0])) {
base = 10;
} else {
base = js_get_radix(ctx, argv[0]);
if (base < 0)
goto fail;
}
ret = js_bigint_to_string1(ctx, val, base);
JS_FreeValue(ctx, val);
return ret;
fail:
JS_FreeValue(ctx, val);
return JS_EXCEPTION;
} | O3 | c | js_bigint_toString:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movl %ecx, %ebp
movq %rdi, %r15
callq 0x75c2a
movq %rax, %rbx
movq %rdx, %r14
cmpl $0x6, %r14d
jne 0x75b77
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %rbx, %rcx
andq %rax, %rcx
jmp 0x75be4
movl $0xa, %ecx
testl %ebp, %ebp
je 0x75b9c
movq 0x8(%r12), %rdx
cmpl $0x3, %edx
je 0x75b9c
movq (%r12), %rsi
movq %r15, %rdi
callq 0x75c6c
movl %eax, %ecx
testl %eax, %eax
js 0x75bfb
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x43a83
movq %rax, %r13
movq %rdx, %r12
cmpl $-0x9, %r14d
jb 0x75bd1
movq 0x18(%r15), %rdi
movl (%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rbx)
cmpl $0x1, %eax
jg 0x75bd1
movq %rbx, %rsi
movq %r14, %rdx
callq 0x259d8
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %r13, %rcx
movq %r13, %rbx
movq %r12, %r14
movl %ebx, %eax
orq %rcx, %rax
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $-0x9, %r14d
jb 0x75c1c
movq 0x18(%r15), %rdi
movl (%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rbx)
cmpl $0x1, %eax
jg 0x75c1c
movq %rbx, %rsi
movq %r14, %rdx
callq 0x259d8
xorl %ebx, %ebx
xorl %ecx, %ecx
movl $0x6, %r14d
jmp 0x75be4
| js_bigint_toString:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r12, r8
mov ebp, ecx
mov r15, rdi
call js_thisBigIntValue
mov rbx, rax
mov r14, rdx
cmp r14d, 6
jnz short loc_75B77
mov rax, 0FFFFFFFF00000000h
mov rcx, rbx
and rcx, rax
jmp short loc_75BE4
loc_75B77:
mov ecx, 0Ah
test ebp, ebp
jz short loc_75B9C
mov rdx, [r12+8]
cmp edx, 3
jz short loc_75B9C
mov rsi, [r12]
mov rdi, r15
call js_get_radix
mov ecx, eax
test eax, eax
js short loc_75BFB
loc_75B9C:
mov rdi, r15
mov rsi, rbx
mov rdx, r14
call js_bigint_to_string1
mov r13, rax
mov r12, rdx
cmp r14d, 0FFFFFFF7h
jb short loc_75BD1
mov rdi, [r15+18h]
mov eax, [rbx]
lea ecx, [rax-1]
mov [rbx], ecx
cmp eax, 1
jg short loc_75BD1
mov rsi, rbx
mov rdx, r14
call js_free_value_rt
loc_75BD1:
mov rcx, 0FFFFFFFF00000000h
and rcx, r13
mov rbx, r13
mov r14, r12
loc_75BE4:
mov eax, ebx
or rax, rcx
mov rdx, r14
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_75BFB:
cmp r14d, 0FFFFFFF7h
jb short loc_75C1C
mov rdi, [r15+18h]
mov eax, [rbx]
lea ecx, [rax-1]
mov [rbx], ecx
cmp eax, 1
jg short loc_75C1C
mov rsi, rbx
mov rdx, r14
call js_free_value_rt
loc_75C1C:
xor ebx, ebx
xor ecx, ecx
mov r14d, 6
jmp short loc_75BE4
| unsigned long long js_bigint_toString(long long a1, long long a2, long long a3, int a4, _QWORD *a5)
{
long long v7; // rbx
long long v8; // rdx
long long v9; // r14
unsigned long long v10; // rcx
signed int radix; // ecx
long long v12; // rdx
long long v13; // r8
long long v14; // r9
long long v15; // r8
long long v16; // r9
unsigned long long v17; // r13
long long v18; // rdi
int v19; // eax
long long v20; // rcx
long long v22; // rdi
int v23; // eax
long long v24; // rcx
v7 = js_thisBigIntValue(a1);
v9 = v8;
if ( (_DWORD)v8 == 6 )
{
v10 = v7 & 0xFFFFFFFF00000000LL;
}
else
{
radix = 10;
if ( a4 && (v12 = a5[1], (_DWORD)v12 != 3) && (radix = js_get_radix(a1, *a5, v12, 10LL), radix < 0) )
{
if ( (unsigned int)v9 >= 0xFFFFFFF7 )
{
v22 = *(_QWORD *)(a1 + 24);
v23 = *(_DWORD *)v7;
v24 = (unsigned int)(*(_DWORD *)v7 - 1);
*(_DWORD *)v7 = v24;
if ( v23 <= 1 )
js_free_value_rt(v22, (_QWORD *)v7, v9, v24, v13, v14);
}
LODWORD(v7) = 0;
v10 = 0LL;
}
else
{
v17 = js_bigint_to_string1(a1, (_DWORD *)v7, v9, radix);
if ( (unsigned int)v9 >= 0xFFFFFFF7 )
{
v18 = *(_QWORD *)(a1 + 24);
v19 = *(_DWORD *)v7;
v20 = (unsigned int)(*(_DWORD *)v7 - 1);
*(_DWORD *)v7 = v20;
if ( v19 <= 1 )
js_free_value_rt(v18, (_QWORD *)v7, v9, v20, v15, v16);
}
v10 = v17 & 0xFFFFFFFF00000000LL;
LODWORD(v7) = v17;
}
}
return v10 | (unsigned int)v7;
}
| js_bigint_toString:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R12,R8
MOV EBP,ECX
MOV R15,RDI
CALL 0x00175c2a
MOV RBX,RAX
MOV R14,RDX
CMP R14D,0x6
JNZ 0x00175b77
MOV RAX,-0x100000000
MOV RCX,RBX
AND RCX,RAX
JMP 0x00175be4
LAB_00175b77:
MOV ECX,0xa
TEST EBP,EBP
JZ 0x00175b9c
MOV RDX,qword ptr [R12 + 0x8]
CMP EDX,0x3
JZ 0x00175b9c
MOV RSI,qword ptr [R12]
MOV RDI,R15
CALL 0x00175c6c
MOV ECX,EAX
TEST EAX,EAX
JS 0x00175bfb
LAB_00175b9c:
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R14
CALL 0x00143a83
MOV R13,RAX
MOV R12,RDX
CMP R14D,-0x9
JC 0x00175bd1
MOV RDI,qword ptr [R15 + 0x18]
MOV EAX,dword ptr [RBX]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RBX],ECX
CMP EAX,0x1
JG 0x00175bd1
MOV RSI,RBX
MOV RDX,R14
CALL 0x001259d8
LAB_00175bd1:
MOV RCX,-0x100000000
AND RCX,R13
MOV RBX,R13
MOV R14,R12
LAB_00175be4:
MOV EAX,EBX
OR RAX,RCX
MOV RDX,R14
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00175bfb:
CMP R14D,-0x9
JC 0x00175c1c
MOV RDI,qword ptr [R15 + 0x18]
MOV EAX,dword ptr [RBX]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RBX],ECX
CMP EAX,0x1
JG 0x00175c1c
MOV RSI,RBX
MOV RDX,R14
CALL 0x001259d8
LAB_00175c1c:
XOR EBX,EBX
XOR ECX,ECX
MOV R14D,0x6
JMP 0x00175be4
|
int1 [16]
js_bigint_toString(long param_1,int8 param_2,int8 param_3,int param_4,
int8 *param_5)
{
int8 uVar1;
int iVar2;
int *piVar3;
ulong uVar4;
int8 uVar5;
uint uVar6;
int1 auVar7 [16];
int1 auVar8 [16];
auVar7 = js_thisBigIntValue();
uVar5 = auVar7._8_8_;
piVar3 = auVar7._0_8_;
uVar6 = auVar7._8_4_;
if (uVar6 == 6) {
uVar4 = (ulong)piVar3 & 0xffffffff00000000;
}
else {
if ((param_4 != 0) && ((int)param_5[1] != 3)) {
iVar2 = js_get_radix(param_1,*param_5,param_5[1],10);
if (iVar2 < 0) {
if (0xfffffff6 < uVar6) {
uVar1 = *(int8 *)(param_1 + 0x18);
iVar2 = *piVar3;
*piVar3 = iVar2 + -1;
if (iVar2 < 2) {
js_free_value_rt(uVar1,piVar3,uVar5);
}
}
uVar4 = 0;
auVar7 = ZEXT816(6) << 0x40;
goto LAB_00175be4;
}
}
auVar7 = js_bigint_to_string1(param_1,piVar3,uVar5);
if (0xfffffff6 < uVar6) {
uVar1 = *(int8 *)(param_1 + 0x18);
iVar2 = *piVar3;
*piVar3 = iVar2 + -1;
if (iVar2 < 2) {
js_free_value_rt(uVar1,piVar3,uVar5);
}
}
uVar4 = auVar7._0_8_ & 0xffffffff00000000;
}
LAB_00175be4:
auVar8._0_8_ = auVar7._0_8_ & 0xffffffff | uVar4;
auVar8._8_8_ = auVar7._8_8_;
return auVar8;
}
| |
41,552 | my_hash_first | eloqsql/mysys/hash.c | uchar* my_hash_first(const HASH *hash, const uchar *key, size_t length,
HASH_SEARCH_STATE *current_record)
{
uchar *res;
DBUG_ASSERT(my_hash_inited(hash));
res= my_hash_first_from_hash_value(hash,
hash->hash_function(hash->charset, key,
length ? length :
hash->key_length),
key, length, current_record);
return res;
} | O0 | c | my_hash_first:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0x2b58a
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2b5c3
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x2b5cf
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rdx
callq *%rax
movq -0x48(%rbp), %rdi
movl %eax, %esi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0x2b650
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_hash_first:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
jmp short $+2
loc_2B58A:
mov rax, [rbp+var_8]
mov [rbp+var_48], rax
mov rax, [rbp+var_8]
mov rax, [rax+58h]
mov [rbp+var_40], rax
mov rax, [rbp+var_8]
mov rax, [rax+68h]
mov [rbp+var_38], rax
mov rax, [rbp+var_10]
mov [rbp+var_30], rax
cmp [rbp+var_18], 0
jz short loc_2B5C3
mov rax, [rbp+var_18]
mov [rbp+var_50], rax
jmp short loc_2B5CF
loc_2B5C3:
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov [rbp+var_50], rax
loc_2B5CF:
mov rax, [rbp+var_40]
mov rsi, [rbp+var_30]
mov rdi, [rbp+var_38]
mov rdx, [rbp+var_50]
call rax
mov rdi, [rbp+var_48]
mov esi, eax
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_18]
mov r8, [rbp+var_20]
call my_hash_first_from_hash_value
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
add rsp, 50h
pop rbp
retn
| long long my_hash_first(_QWORD *a1, long long a2, long long a3, long long a4)
{
unsigned int v4; // eax
long long ( *v6)(long long, long long, long long); // [rsp+10h] [rbp-40h]
long long v7; // [rsp+18h] [rbp-38h]
v6 = (long long ( *)(long long, long long, long long))a1[11];
v7 = a1[13];
if ( a3 )
v4 = v6(v7, a2, a3);
else
v4 = v6(v7, a2, a1[1]);
return my_hash_first_from_hash_value(a1, v4, a2, a3, a4);
}
| my_hash_first:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
JMP 0x0012b58a
LAB_0012b58a:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x58]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x68]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x0012b5c3
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x0012b5cf
LAB_0012b5c3:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x50],RAX
LAB_0012b5cf:
MOV RAX,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x50]
CALL RAX
MOV RDI,qword ptr [RBP + -0x48]
MOV ESI,EAX
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x18]
MOV R8,qword ptr [RBP + -0x20]
CALL 0x0012b650
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RSP,0x50
POP RBP
RET
|
int8 my_hash_first(long param_1,int8 param_2,long param_3,int8 param_4)
{
int4 uVar1;
int8 uVar2;
int8 local_58;
local_58 = param_3;
if (param_3 == 0) {
local_58 = *(long *)(param_1 + 8);
}
uVar1 = (**(code **)(param_1 + 0x58))(*(int8 *)(param_1 + 0x68),param_2,local_58);
uVar2 = my_hash_first_from_hash_value(param_1,uVar1,param_2,param_3,param_4);
return uVar2;
}
| |
41,553 | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::scan() | llama.cpp/common/./json.hpp | token_type scan()
{
// initially, skip the BOM
if (position.chars_read_total == 0 && !skip_bom())
{
error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
return token_type::parse_error;
}
// read next character and ignore whitespace
skip_whitespace();
// ignore comments
while (ignore_comments && current == '/')
{
if (!scan_comment())
{
return token_type::parse_error;
}
// skip following whitespace
skip_whitespace();
}
switch (current)
{
// structural characters
case '[':
return token_type::begin_array;
case ']':
return token_type::end_array;
case '{':
return token_type::begin_object;
case '}':
return token_type::end_object;
case ':':
return token_type::name_separator;
case ',':
return token_type::value_separator;
// literals
case 't':
{
std::array<char_type, 4> true_literal = {{static_cast<char_type>('t'), static_cast<char_type>('r'), static_cast<char_type>('u'), static_cast<char_type>('e')}};
return scan_literal(true_literal.data(), true_literal.size(), token_type::literal_true);
}
case 'f':
{
std::array<char_type, 5> false_literal = {{static_cast<char_type>('f'), static_cast<char_type>('a'), static_cast<char_type>('l'), static_cast<char_type>('s'), static_cast<char_type>('e')}};
return scan_literal(false_literal.data(), false_literal.size(), token_type::literal_false);
}
case 'n':
{
std::array<char_type, 4> null_literal = {{static_cast<char_type>('n'), static_cast<char_type>('u'), static_cast<char_type>('l'), static_cast<char_type>('l')}};
return scan_literal(null_literal.data(), null_literal.size(), token_type::literal_null);
}
// string
case '\"':
return scan_string();
// number
case '-':
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
return scan_number();
// end of input (the null byte is needed when parsing from
// string literals)
case '\0':
case char_traits<char_type>::eof():
return token_type::end_of_input;
// error
default:
error_message = "invalid literal";
return token_type::parse_error;
}
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::scan():
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
jne 0x26427
movq %rbx, %rdi
callq 0x265be
testb %al, %al
je 0x264e9
movabsq $0x100002600, %r14 # imm = 0x100002600
movq %rbx, %rdi
callq 0x17cf0
movl 0x14(%rbx), %eax
cmpq $0x20, %rax
ja 0x26471
btq %rax, %r14
jb 0x26431
jmp 0x26471
movq %rbx, %rdi
callq 0x26600
testb %al, %al
je 0x264f4
movq %rbx, %rdi
callq 0x17cf0
movl 0x14(%rbx), %eax
cmpq $0x20, %rax
ja 0x26471
btq %rax, %r14
jb 0x2645a
cmpl $0x2f, %eax
jne 0x2647c
cmpb $0x0, 0x10(%rbx)
jne 0x2644a
cmpl $0x5a, %eax
jg 0x264ac
leal -0x22(%rax), %ecx
cmpl $0x18, %ecx
ja 0x26536
leaq 0x34b94(%rip), %rax # 0x5b028
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x26b6a
cmpl $0x6d, %eax
jle 0x26501
cmpl $0x7a, %eax
jg 0x26544
cmpl $0x6e, %eax
je 0x2657e
cmpl $0x74, %eax
jne 0x26555
leaq 0xc(%rsp), %rsi
movl $0x65757274, (%rsi) # imm = 0x65757274
movl $0x4, %edx
movq %rbx, %rdi
movl $0x1, %ecx
jmp 0x26596
leaq 0x359eb(%rip), %rax # 0x5bedb
movq %rax, 0x70(%rbx)
movl $0xe, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
cmpl $0x5b, %eax
je 0x265aa
cmpl $0x5d, %eax
je 0x265b4
cmpl $0x66, %eax
jne 0x26555
leaq 0x10(%rsp), %rsi
movb $0x65, 0x4(%rsi)
movl $0x736c6166, (%rsi) # imm = 0x736C6166
movl $0x5, %edx
movq %rbx, %rdi
movl $0x2, %ecx
jmp 0x26596
incl %eax
cmpl $0x2, %eax
jae 0x26555
movl $0xf, %eax
jmp 0x264f9
cmpl $0x7b, %eax
je 0x265a0
cmpl $0x7d, %eax
jne 0x26555
movl $0xb, %eax
jmp 0x264f9
leaq 0x359ac(%rip), %rax # 0x5bf08
jmp 0x264f0
movl $0xc, %eax
jmp 0x264f9
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x266f8
movl $0xd, %eax
jmp 0x264f9
leaq 0x8(%rsp), %rsi
movl $0x6c6c756e, (%rsi) # imm = 0x6C6C756E
movl $0x4, %edx
movq %rbx, %rdi
movl $0x3, %ecx
callq 0x2667c
jmp 0x264f9
movl $0x9, %eax
jmp 0x264f9
movl $0x8, %eax
jmp 0x264f9
movl $0xa, %eax
jmp 0x264f9
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE4scanEv:
push r14
push rbx
sub rsp, 18h
mov rbx, rdi
cmp qword ptr [rdi+20h], 0
jnz short loc_26427
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE8skip_bomEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::skip_bom(void)
test al, al
jz loc_264E9
loc_26427:
mov r14, 100002600h
loc_26431:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
mov eax, [rbx+14h]
cmp rax, 20h ; ' '
ja short loc_26471
bt r14, rax
jb short loc_26431
jmp short loc_26471
loc_2644A:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE12scan_commentEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::scan_comment(void)
test al, al
jz loc_264F4
loc_2645A:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
mov eax, [rbx+14h]
cmp rax, 20h ; ' '
ja short loc_26471
bt r14, rax
jb short loc_2645A
loc_26471:
cmp eax, 2Fh ; '/'
jnz short loc_2647C
cmp byte ptr [rbx+10h], 0
jnz short loc_2644A
loc_2647C:
cmp eax, 5Ah ; 'Z'
jg short loc_264AC
lea ecx, [rax-22h]; switch 25 cases
cmp ecx, 18h
ja def_2649B; jumptable 000000000002649B default case
lea rax, jpt_2649B
movsxd rcx, ds:(jpt_2649B - 5B028h)[rax+rcx*4]
add rcx, rax
jmp rcx; switch jump
loc_2649D:
mov rdi, rbx; jumptable 000000000002649B cases 45,48-57
add rsp, 18h
pop rbx
pop r14
jmp _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE11scan_numberEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::scan_number(void)
loc_264AC:
cmp eax, 6Dh ; 'm'
jle short loc_26501
cmp eax, 7Ah ; 'z'
jg loc_26544
cmp eax, 6Eh ; 'n'
jz loc_2657E
cmp eax, 74h ; 't'
jnz loc_26555; jumptable 000000000002649B cases 35-43,46,47
lea rsi, [rsp+28h+var_1C]
mov dword ptr [rsi], 65757274h
mov edx, 4
mov rdi, rbx
mov ecx, 1
jmp loc_26596
loc_264E9:
lea rax, aInvalidBomMust; "invalid BOM; must be 0xEF 0xBB 0xBF if "...
loc_264F0:
mov [rbx+70h], rax
loc_264F4:
mov eax, 0Eh
loc_264F9:
add rsp, 18h
pop rbx
pop r14
retn
loc_26501:
cmp eax, 5Bh ; '['
jz loc_265AA
cmp eax, 5Dh ; ']'
jz loc_265B4
cmp eax, 66h ; 'f'
jnz short loc_26555; jumptable 000000000002649B cases 35-43,46,47
lea rsi, [rsp+28h+var_18]
mov byte ptr [rsi+4], 65h ; 'e'
mov dword ptr [rsi], 736C6166h
mov edx, 5
mov rdi, rbx
mov ecx, 2
jmp short loc_26596
def_2649B:
inc eax; jumptable 000000000002649B default case
cmp eax, 2
jnb short loc_26555; jumptable 000000000002649B cases 35-43,46,47
mov eax, 0Fh
jmp short loc_264F9
loc_26544:
cmp eax, 7Bh ; '{'
jz short loc_265A0
cmp eax, 7Dh ; '}'
jnz short loc_26555; jumptable 000000000002649B cases 35-43,46,47
mov eax, 0Bh
jmp short loc_264F9
loc_26555:
lea rax, aInvalidLiteral; jumptable 000000000002649B cases 35-43,46,47
jmp short loc_264F0
loc_2655E:
mov eax, 0Ch; jumptable 000000000002649B case 58
jmp short loc_264F9
loc_26565:
mov rdi, rbx; jumptable 000000000002649B case 34
add rsp, 18h
pop rbx
pop r14
jmp _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE11scan_stringEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::scan_string(void)
loc_26574:
mov eax, 0Dh; jumptable 000000000002649B case 44
jmp loc_264F9
loc_2657E:
lea rsi, [rsp+28h+var_20]
mov dword ptr [rsi], 6C6C756Eh
mov edx, 4
mov rdi, rbx
mov ecx, 3
loc_26596:
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE12scan_literalESK_mNS1_10lexer_baseISF_E10token_typeE; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::scan_literal(char const*,ulong,nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type)
jmp loc_264F9
loc_265A0:
mov eax, 9
jmp loc_264F9
loc_265AA:
mov eax, 8
jmp loc_264F9
loc_265B4:
mov eax, 0Ah
jmp loc_264F9
| long long nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::scan(
__m128i *a1)
{
long long v1; // r14
unsigned long long v2; // rax
long long result; // rax
int *v4; // rsi
long long v5; // rdx
long long v6; // rcx
const char *v7; // rax
int v8; // [rsp+8h] [rbp-20h] BYREF
int v9; // [rsp+Ch] [rbp-1Ch] BYREF
_BYTE v10[24]; // [rsp+10h] [rbp-18h] BYREF
if ( a1[2].m128i_i64[0]
|| (unsigned __int8)nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::skip_bom(a1) )
{
v1 = 0x100002600LL;
do
{
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1);
v2 = a1[1].m128i_u32[1];
}
while ( v2 <= 0x20 && _bittest64(&v1, v2) );
while ( (_DWORD)v2 == 47 && a1[1].m128i_i8[0] )
{
if ( !(unsigned __int8)nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::scan_comment(a1) )
return 14LL;
do
{
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1);
v2 = a1[1].m128i_u32[1];
}
while ( v2 <= 0x20 && _bittest64(&v1, v2) );
}
if ( (int)v2 <= 90 )
{
switch ( (int)v2 )
{
case '"':
result = nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::scan_string(a1);
break;
case '#':
case '$':
case '%':
case '&':
case '\'':
case '(':
case ')':
case '*':
case '+':
case '.':
case '/':
goto LABEL_33;
case ',':
result = 13LL;
break;
case '-':
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
result = nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::scan_number(a1);
break;
case ':':
result = 12LL;
break;
default:
if ( (unsigned int)(v2 + 1) >= 2 )
goto LABEL_33;
result = 15LL;
break;
}
return result;
}
if ( (int)v2 <= 109 )
{
switch ( (_DWORD)v2 )
{
case '[':
return 8LL;
case ']':
return 10LL;
case 'f':
v4 = (int *)v10;
qmemcpy(v10, "false", 5);
v5 = 5LL;
v6 = 2LL;
return nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::scan_literal(
a1,
v4,
v5,
v6);
}
}
else if ( (int)v2 > 122 )
{
if ( (_DWORD)v2 == 123 )
return 9LL;
if ( (_DWORD)v2 == 125 )
return 11LL;
}
else
{
if ( (_DWORD)v2 == 110 )
{
v4 = &v8;
v8 = 1819047278;
v5 = 4LL;
v6 = 3LL;
return nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::scan_literal(
a1,
v4,
v5,
v6);
}
if ( (_DWORD)v2 == 116 )
{
v4 = &v9;
v9 = 1702195828;
v5 = 4LL;
v6 = 1LL;
return nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::scan_literal(
a1,
v4,
v5,
v6);
}
}
LABEL_33:
v7 = "invalid literal";
}
else
{
v7 = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
}
a1[7].m128i_i64[0] = (long long)v7;
return 14LL;
}
| scan:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
CMP qword ptr [RDI + 0x20],0x0
JNZ 0x00126427
MOV RDI,RBX
CALL 0x001265be
TEST AL,AL
JZ 0x001264e9
LAB_00126427:
MOV R14,0x100002600
LAB_00126431:
MOV RDI,RBX
CALL 0x00117cf0
MOV EAX,dword ptr [RBX + 0x14]
CMP RAX,0x20
JA 0x00126471
BT R14,RAX
JC 0x00126431
JMP 0x00126471
LAB_0012644a:
MOV RDI,RBX
CALL 0x00126600
TEST AL,AL
JZ 0x001264f4
LAB_0012645a:
MOV RDI,RBX
CALL 0x00117cf0
MOV EAX,dword ptr [RBX + 0x14]
CMP RAX,0x20
JA 0x00126471
BT R14,RAX
JC 0x0012645a
LAB_00126471:
CMP EAX,0x2f
JNZ 0x0012647c
CMP byte ptr [RBX + 0x10],0x0
JNZ 0x0012644a
LAB_0012647c:
CMP EAX,0x5a
JG 0x001264ac
LEA ECX,[RAX + -0x22]
CMP ECX,0x18
JA 0x00126536
LEA RAX,[0x15b028]
MOVSXD RCX,dword ptr [RAX + RCX*0x4]
ADD RCX,RAX
switchD:
JMP RCX
caseD_2d:
MOV RDI,RBX
ADD RSP,0x18
POP RBX
POP R14
JMP 0x00126b6a
LAB_001264ac:
CMP EAX,0x6d
JLE 0x00126501
CMP EAX,0x7a
JG 0x00126544
CMP EAX,0x6e
JZ 0x0012657e
CMP EAX,0x74
JNZ 0x00126555
LEA RSI,[RSP + 0xc]
MOV dword ptr [RSI],0x65757274
MOV EDX,0x4
MOV RDI,RBX
MOV ECX,0x1
JMP 0x00126596
LAB_001264e9:
LEA RAX,[0x15bedb]
LAB_001264f0:
MOV qword ptr [RBX + 0x70],RAX
LAB_001264f4:
MOV EAX,0xe
LAB_001264f9:
ADD RSP,0x18
POP RBX
POP R14
RET
LAB_00126501:
CMP EAX,0x5b
JZ 0x001265aa
CMP EAX,0x5d
JZ 0x001265b4
CMP EAX,0x66
JNZ 0x00126555
LEA RSI,[RSP + 0x10]
MOV byte ptr [RSI + 0x4],0x65
MOV dword ptr [RSI],0x736c6166
MOV EDX,0x5
MOV RDI,RBX
MOV ECX,0x2
JMP 0x00126596
default:
INC EAX
CMP EAX,0x2
JNC 0x00126555
MOV EAX,0xf
JMP 0x001264f9
LAB_00126544:
CMP EAX,0x7b
JZ 0x001265a0
CMP EAX,0x7d
JNZ 0x00126555
MOV EAX,0xb
JMP 0x001264f9
caseD_23:
LEA RAX,[0x15bf08]
JMP 0x001264f0
caseD_3a:
MOV EAX,0xc
JMP 0x001264f9
caseD_22:
MOV RDI,RBX
ADD RSP,0x18
POP RBX
POP R14
JMP 0x001266f8
caseD_2c:
MOV EAX,0xd
JMP 0x001264f9
LAB_0012657e:
LEA RSI,[RSP + 0x8]
MOV dword ptr [RSI],0x6c6c756e
MOV EDX,0x4
MOV RDI,RBX
MOV ECX,0x3
LAB_00126596:
CALL 0x0012667c
JMP 0x001264f9
LAB_001265a0:
MOV EAX,0x9
JMP 0x001264f9
LAB_001265aa:
MOV EAX,0x8
JMP 0x001264f9
LAB_001265b4:
MOV EAX,0xa
JMP 0x001264f9
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::scan() */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::scan(lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this)
{
char cVar1;
int iVar2;
ulong uVar3;
int8 uVar4;
char *pcVar5;
int8 uVar6;
int4 *puVar7;
int4 local_20;
int4 local_1c;
int4 local_18;
int1 local_14;
if ((*(long *)(this + 0x20) != 0) || (cVar1 = skip_bom(this), cVar1 != '\0')) {
do {
get(this);
uVar3 = (ulong)*(uint *)(this + 0x14);
if (0x20 < uVar3) break;
} while ((0x100002600U >> (uVar3 & 0x3f) & 1) != 0);
do {
iVar2 = (int)uVar3;
if ((iVar2 != 0x2f) ||
(this[0x10] ==
(lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
)0x0)) goto LAB_0012647c;
cVar1 = scan_comment(this);
if (cVar1 == '\0') goto LAB_001264f4;
do {
get(this);
uVar3 = (ulong)*(uint *)(this + 0x14);
if (0x20 < uVar3) break;
} while ((0x100002600U >> (uVar3 & 0x3f) & 1) != 0);
} while( true );
}
pcVar5 = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
goto LAB_001264f0;
LAB_0012647c:
if (0x5a < iVar2) {
if (iVar2 < 0x6e) {
if (iVar2 == 0x5b) {
return 8;
}
if (iVar2 == 0x5d) {
return 10;
}
if (iVar2 == 0x66) {
puVar7 = &local_18;
local_14 = 0x65;
local_18 = 0x736c6166;
uVar6 = 5;
uVar4 = 2;
goto LAB_00126596;
}
}
else if (iVar2 < 0x7b) {
if (iVar2 == 0x6e) {
puVar7 = &local_20;
local_20 = 0x6c6c756e;
uVar6 = 4;
uVar4 = 3;
LAB_00126596:
uVar4 = scan_literal(this,puVar7,uVar6,uVar4);
return uVar4;
}
if (iVar2 == 0x74) {
puVar7 = &local_1c;
local_1c = 0x65757274;
uVar6 = 4;
uVar4 = 1;
goto LAB_00126596;
}
}
else {
if (iVar2 == 0x7b) {
return 9;
}
if (iVar2 == 0x7d) {
return 0xb;
}
}
goto switchD_0012649b_caseD_23;
}
switch(iVar2) {
case 0x22:
uVar4 = scan_string(this);
return uVar4;
case 0x2c:
uVar4 = 0xd;
break;
case 0x2d:
case 0x30:
case 0x31:
case 0x32:
case 0x33:
case 0x34:
case 0x35:
case 0x36:
case 0x37:
case 0x38:
case 0x39:
uVar4 = scan_number(this);
return uVar4;
case 0x3a:
uVar4 = 0xc;
break;
default:
if (iVar2 + 1U < 2) {
return 0xf;
}
case 0x23:
case 0x24:
case 0x25:
case 0x26:
case 0x27:
case 0x28:
case 0x29:
case 0x2a:
case 0x2b:
case 0x2e:
case 0x2f:
switchD_0012649b_caseD_23:
pcVar5 = "invalid literal";
LAB_001264f0:
*(char **)(this + 0x70) = pcVar5;
LAB_001264f4:
uVar4 = 0xe;
}
return uVar4;
}
| |
41,554 | minja::Value& nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::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>, minja::Value, std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>>>::at<unsigned long&, 0>(unsigned long&) | monkey531[P]llama/common/json.hpp | T & at(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
return it->second;
}
}
JSON_THROW(std::out_of_range("key not found"));
} | O2 | cpp | minja::Value& nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::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>, minja::Value, std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>>>::at<unsigned long&, 0>(unsigned long&):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rbx
cmpq 0x8(%r15), %rbx
je 0x6b470
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x6b4db
testb %al, %al
jne 0x6b463
addq $0x60, %rbx
jmp 0x6b448
addq $0x10, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x24460
movq %rax, %rbx
leaq 0x4ae34(%rip), %rsi # 0xb62b6
movq %rax, %rdi
callq 0x24100
movq 0x94b27(%rip), %rsi # 0xfffb8
movq 0x94b00(%rip), %rdx # 0xfff98
movq %rbx, %rdi
callq 0x24ee0
movq %rax, %r14
movq %rbx, %rdi
callq 0x24670
movq %r14, %rdi
callq 0x24f60
nop
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE2atIRmTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OSS_:
push r15
push r14
push rbx
mov r14, rsi
mov r15, rdi
mov rbx, [rdi]
loc_6B448:
cmp rbx, [r15+8]
jz short loc_6B470
mov rsi, [r14]
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_3eqImTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES3_
test al, al
jnz short loc_6B463
add rbx, 60h ; '`'
jmp short loc_6B448
loc_6B463:
add rbx, 10h
mov rax, rbx
pop rbx
pop r14
pop r15
retn
loc_6B470:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aKeyNotFound; "key not found"
mov rdi, rax; this
call __ZNSt12out_of_rangeC1EPKc; std::out_of_range::out_of_range(char const*)
mov rsi, cs:_ZTISt12out_of_range_ptr; lptinfo
mov rdx, cs:_ZNSt12out_of_rangeD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
mov rdi, r14
call __Unwind_Resume
| long long ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE2atIRmTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OSS_(
long long *a1,
_QWORD *a2)
{
long long i; // rbx
std::out_of_range *exception; // rbx
for ( i = *a1; ; i += 96LL )
{
if ( i == a1[1] )
{
exception = (std::out_of_range *)__cxa_allocate_exception(0x10uLL);
std::out_of_range::out_of_range(exception, "key not found");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::out_of_range,
(void (*)(void *))&std::out_of_range::~out_of_range);
}
if ( (unsigned __int8)ZN8nlohmann16json_abi_v3_11_3eqImTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES3_(
i,
*a2) )
break;
}
return i + 16;
}
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE2atIRmTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OSS_:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RSI
MOV R15,RDI
MOV RBX,qword ptr [RDI]
LAB_0016b448:
CMP RBX,qword ptr [R15 + 0x8]
JZ 0x0016b470
MOV RSI,qword ptr [R14]
MOV RDI,RBX
CALL 0x0016b4db
TEST AL,AL
JNZ 0x0016b463
ADD RBX,0x60
JMP 0x0016b448
LAB_0016b463:
ADD RBX,0x10
MOV RAX,RBX
POP RBX
POP R14
POP R15
RET
LAB_0016b470:
PUSH 0x10
POP RDI
CALL 0x00124460
MOV RBX,RAX
LAB_0016b47b:
LEA RSI,[0x1b62b6]
MOV RDI,RAX
CALL 0x00124100
LAB_0016b48a:
MOV RSI,qword ptr [0x001fffb8]
MOV RDX,qword ptr [0x001fff98]
MOV RDI,RBX
CALL 0x00124ee0
|
long _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE2atIRmTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OSS_
(long *param_1,int8 *param_2)
{
char cVar1;
out_of_range *this;
long lVar2;
lVar2 = *param_1;
while( true ) {
if (lVar2 == param_1[1]) {
this = (out_of_range *)__cxa_allocate_exception(0x10);
/* try { // try from 0016b47b to 0016b489 has its CatchHandler @ 0016b4a0 */
std::out_of_range::out_of_range(this,"key not found");
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_001fffb8,PTR__out_of_range_001fff98);
}
cVar1 = _ZN8nlohmann16json_abi_v3_11_3eqImTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES3_
(lVar2,*param_2);
if (cVar1 != '\0') break;
lVar2 = lVar2 + 0x60;
}
return lVar2 + 0x10;
}
| |
41,555 | init_available_charsets | eloqsql/mysys/charset.c | static void init_available_charsets(void)
{
char fname[FN_REFLEN + sizeof(MY_CHARSET_INDEX)];
struct charset_info_st **cs;
MY_CHARSET_LOADER loader;
DBUG_ENTER("init_available_charsets");
bzero((char*) &all_charsets,sizeof(all_charsets));
bzero((char*) &my_collation_statistics, sizeof(my_collation_statistics));
my_hash_init2(key_memory_charsets, &charset_name_hash, 16,
&my_charset_latin1, 64, 0, 0, get_charset_key,
0, 0, HASH_UNIQUE);
init_compiled_charsets(MYF(0));
/* Copy compiled charsets */
for (cs= (struct charset_info_st**) all_charsets;
cs < (struct charset_info_st**) all_charsets +
array_elements(all_charsets)-1 ;
cs++)
{
if (*cs)
{
DBUG_ASSERT(cs[0]->mbmaxlen <= MY_CS_MBMAXLEN);
if (cs[0]->m_ctype)
if (init_state_maps(*cs))
*cs= NULL;
}
}
my_charset_loader_init_mysys(&loader);
strmov(get_charsets_dir(fname), MY_CHARSET_INDEX);
my_read_charset_file(&loader, fname, MYF(0));
DBUG_VOID_RETURN;
} | O0 | c | init_available_charsets:
pushq %rbp
movq %rsp, %rbp
subq $0x300, %rsp # imm = 0x300
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
leaq 0x326ff1(%rip), %rdi # 0x386960
xorl %esi, %esi
movl $0x4000, %edx # imm = 0x4000
callq 0x24180
leaq 0x32b04e(%rip), %rdi # 0x38a9d0
xorl %esi, %esi
movl $0x4000, %edx # imm = 0x4000
callq 0x24180
leaq 0x326c37(%rip), %rax # 0x3865cc
movl (%rax), %edi
leaq 0x32afc2(%rip), %rsi # 0x38a960
movl $0x10, %edx
leaq 0x16e99e(%rip), %rcx # 0x1ce348
movl $0x40, %r8d
xorl %eax, %eax
movl %eax, %r9d
leaq 0x1ab4(%rip), %rax # 0x61470
movq $0x0, (%rsp)
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x1, 0x20(%rsp)
callq 0x61e90
xorl %eax, %eax
movl %eax, %edi
callq 0x663c0
leaq 0x326f68(%rip), %rax # 0x386960
movq %rax, -0x2d8(%rbp)
leaq 0x326f5a(%rip), %rax # 0x386960
addq $0x4000, %rax # imm = 0x4000
addq $-0x8, %rax
cmpq %rax, -0x2d8(%rbp)
jae 0x5fa76
movq -0x2d8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x5fa60
jmp 0x5fa28
jmp 0x5fa2a
movq -0x2d8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x40(%rax)
je 0x5fa5e
movq -0x2d8(%rbp), %rax
movq (%rax), %rdi
callq 0x60fd0
cmpb $0x0, %al
je 0x5fa5c
movq -0x2d8(%rbp), %rax
movq $0x0, (%rax)
jmp 0x5fa5e
jmp 0x5fa60
jmp 0x5fa62
movq -0x2d8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x2d8(%rbp)
jmp 0x5f9ff
leaq -0x2d0(%rbp), %rdi
callq 0x5ef70
leaq -0x220(%rbp), %rdi
callq 0x5f610
movq %rax, %rdi
leaq 0x1d609(%rip), %rsi # 0x7d0a1
callq 0x242a0
leaq -0x220(%rbp), %rsi
leaq -0x2d0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x614b0
jmp 0x5fab6
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x5fad1
addq $0x300, %rsp # imm = 0x300
popq %rbp
retq
callq 0x242d0
nopw %cs:(%rax,%rax)
| init_available_charsets:
push rbp
mov rbp, rsp
sub rsp, 300h
mov rax, fs:28h
mov [rbp+var_8], rax
lea rdi, all_charsets
xor esi, esi
mov edx, 4000h
call _memset
lea rdi, my_collation_statistics
xor esi, esi
mov edx, 4000h
call _memset
lea rax, key_memory_charsets
mov edi, [rax]
lea rsi, charset_name_hash
mov edx, 10h
lea rcx, my_charset_latin1
mov r8d, 40h ; '@'
xor eax, eax
mov r9d, eax
lea rax, get_charset_key
mov [rsp+300h+var_300], 0
mov [rsp+300h+var_2F8], rax
mov [rsp+300h+var_2F0], 0
mov [rsp+300h+var_2E8], 0
mov [rsp+300h+var_2E0], 1
call my_hash_init2
xor eax, eax
mov edi, eax
call init_compiled_charsets
lea rax, all_charsets
mov [rbp+var_2D8], rax
loc_5F9FF:
lea rax, all_charsets
add rax, 4000h
add rax, 0FFFFFFFFFFFFFFF8h
cmp [rbp+var_2D8], rax
jnb short loc_5FA76
mov rax, [rbp+var_2D8]
cmp qword ptr [rax], 0
jz short loc_5FA60
jmp short $+2
loc_5FA28:
jmp short $+2
loc_5FA2A:
mov rax, [rbp+var_2D8]
mov rax, [rax]
cmp qword ptr [rax+40h], 0
jz short loc_5FA5E
mov rax, [rbp+var_2D8]
mov rdi, [rax]
call init_state_maps
cmp al, 0
jz short loc_5FA5C
mov rax, [rbp+var_2D8]
mov qword ptr [rax], 0
loc_5FA5C:
jmp short $+2
loc_5FA5E:
jmp short $+2
loc_5FA60:
jmp short $+2
loc_5FA62:
mov rax, [rbp+var_2D8]
add rax, 8
mov [rbp+var_2D8], rax
jmp short loc_5F9FF
loc_5FA76:
lea rdi, [rbp+var_2D0]
call my_charset_loader_init_mysys
lea rdi, [rbp+var_220]
call get_charsets_dir
mov rdi, rax
lea rsi, aIndexXml; "Index.xml"
call _stpcpy
lea rsi, [rbp+var_220]
lea rdi, [rbp+var_2D0]
xor eax, eax
mov edx, eax
call my_read_charset_file
jmp short $+2
loc_5FAB6:
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_5FAD1
add rsp, 300h
pop rbp
retn
loc_5FAD1:
call ___stack_chk_fail
| unsigned long long init_available_charsets()
{
long long charsets_dir; // rax
_QWORD *i; // [rsp+28h] [rbp-2D8h]
_BYTE v3[176]; // [rsp+30h] [rbp-2D0h] BYREF
_BYTE v4[536]; // [rsp+E0h] [rbp-220h] BYREF
unsigned long long v5; // [rsp+2F8h] [rbp-8h]
v5 = __readfsqword(0x28u);
memset(all_charsets, 0LL, sizeof(all_charsets));
memset(my_collation_statistics, 0LL, sizeof(my_collation_statistics));
my_hash_init2(
key_memory_charsets,
(unsigned int)&charset_name_hash,
16,
(unsigned int)&my_charset_latin1,
64,
0,
0LL,
(long long)get_charset_key,
0LL,
0LL,
1);
init_compiled_charsets(0LL);
for ( i = all_charsets; i < &all_charsets[2047]; ++i )
{
if ( *i && *(_QWORD *)(*i + 64LL) )
{
if ( (unsigned __int8)init_state_maps(*i) )
*i = 0LL;
}
}
my_charset_loader_init_mysys((long long)v3);
charsets_dir = get_charsets_dir(v4);
stpcpy(charsets_dir, "Index.xml");
my_read_charset_file(v3, v4, 0LL);
return __readfsqword(0x28u);
}
| init_available_charsets:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x300
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
LEA RDI,[0x486960]
XOR ESI,ESI
MOV EDX,0x4000
CALL 0x00124180
LEA RDI,[0x48a9d0]
XOR ESI,ESI
MOV EDX,0x4000
CALL 0x00124180
LEA RAX,[0x4865cc]
MOV EDI,dword ptr [RAX]
LEA RSI,[0x48a960]
MOV EDX,0x10
LEA RCX,[0x2ce348]
MOV R8D,0x40
XOR EAX,EAX
MOV R9D,EAX
LEA RAX,[0x161470]
MOV qword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x0
MOV dword ptr [RSP + 0x20],0x1
CALL 0x00161e90
XOR EAX,EAX
MOV EDI,EAX
CALL 0x001663c0
LEA RAX,[0x486960]
MOV qword ptr [RBP + -0x2d8],RAX
LAB_0015f9ff:
LEA RAX,[0x486960]
ADD RAX,0x4000
ADD RAX,-0x8
CMP qword ptr [RBP + -0x2d8],RAX
JNC 0x0015fa76
MOV RAX,qword ptr [RBP + -0x2d8]
CMP qword ptr [RAX],0x0
JZ 0x0015fa60
JMP 0x0015fa28
LAB_0015fa28:
JMP 0x0015fa2a
LAB_0015fa2a:
MOV RAX,qword ptr [RBP + -0x2d8]
MOV RAX,qword ptr [RAX]
CMP qword ptr [RAX + 0x40],0x0
JZ 0x0015fa5e
MOV RAX,qword ptr [RBP + -0x2d8]
MOV RDI,qword ptr [RAX]
CALL 0x00160fd0
CMP AL,0x0
JZ 0x0015fa5c
MOV RAX,qword ptr [RBP + -0x2d8]
MOV qword ptr [RAX],0x0
LAB_0015fa5c:
JMP 0x0015fa5e
LAB_0015fa5e:
JMP 0x0015fa60
LAB_0015fa60:
JMP 0x0015fa62
LAB_0015fa62:
MOV RAX,qword ptr [RBP + -0x2d8]
ADD RAX,0x8
MOV qword ptr [RBP + -0x2d8],RAX
JMP 0x0015f9ff
LAB_0015fa76:
LEA RDI,[RBP + -0x2d0]
CALL 0x0015ef70
LEA RDI,[RBP + -0x220]
CALL 0x0015f610
MOV RDI,RAX
LEA RSI,[0x17d0a1]
CALL 0x001242a0
LEA RSI,[RBP + -0x220]
LEA RDI,[RBP + -0x2d0]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001614b0
JMP 0x0015fab6
LAB_0015fab6:
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0015fad1
ADD RSP,0x300
POP RBP
RET
LAB_0015fad1:
CALL 0x001242d0
|
void init_available_charsets(void)
{
char cVar1;
char *__dest;
long in_FS_OFFSET;
long *local_2e0;
int1 local_2d8 [176];
int1 local_228 [536];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
memset(&all_charsets,0,0x4000);
memset(my_collation_statistics,0,0x4000);
my_hash_init2(key_memory_charsets,charset_name_hash,0x10,&my_charset_latin1,0x40,0,0,
get_charset_key,0,0,1);
init_compiled_charsets(0);
for (local_2e0 = &all_charsets; local_2e0 < (long *)0x48a958; local_2e0 = local_2e0 + 1) {
if (((*local_2e0 != 0) && (*(long *)(*local_2e0 + 0x40) != 0)) &&
(cVar1 = init_state_maps(*local_2e0), cVar1 != '\0')) {
*local_2e0 = 0;
}
}
my_charset_loader_init_mysys(local_2d8);
__dest = (char *)get_charsets_dir(local_228);
stpcpy(__dest,"Index.xml");
my_read_charset_file(local_2d8,local_228,0);
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
}
| |
41,556 | YAML::detail::node& YAML::detail::node::get<char [7]>(char const (&) [7], std::shared_ptr<YAML::detail::memory_holder>) | aimrt_mujoco_sim/_deps/yaml-cpp-src/include/yaml-cpp/node/detail/node.h | node& get(const Key& key, shared_memory_holder pMemory) {
node& value = m_pRef->get(key, pMemory);
value.add_dependency(*this);
return value;
} | O3 | c | YAML::detail::node& YAML::detail::node::get<char [7]>(char const (&) [7], std::shared_ptr<YAML::detail::memory_holder>):
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
movq (%rdx), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rdx), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x5736c
movq 0x1b8bca(%rip), %rcx # 0x20ff28
cmpb $0x0, (%rcx)
je 0x57368
incl 0x8(%rax)
jmp 0x5736c
lock
incl 0x8(%rax)
leaq 0x8(%rsp), %rdx
callq 0x573b8
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x57388
callq 0x466d6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x51ba0
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x573b0
callq 0x466d6
movq %rbx, %rdi
callq 0x2e220
| _ZN4YAML6detail4node3getIA7_cEERS1_RKT_St10shared_ptrINS0_13memory_holderEE:
push r14
push rbx
sub rsp, 18h
mov rbx, rdi
mov rdi, [rdi]
mov rax, [rdx]
mov [rsp+28h+var_20], rax
mov rax, [rdx+8]
mov [rsp+28h+var_18], rax
test rax, rax
jz short loc_5736C
mov rcx, cs:__libc_single_threaded_ptr
cmp byte ptr [rcx], 0
jz short loc_57368
inc dword ptr [rax+8]
jmp short loc_5736C
loc_57368:
lock inc dword ptr [rax+8]
loc_5736C:
lea rdx, [rsp+28h+var_20]
call _ZN4YAML6detail8node_ref3getIA7_cEERNS0_4nodeERKT_St10shared_ptrINS0_13memory_holderEE; YAML::detail::node_ref::get<char [7]>(char [7] const&,std::shared_ptr<YAML::detail::memory_holder>)
mov r14, rax
mov rdi, [rsp+28h+var_18]
test rdi, rdi
jz short loc_57388
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_57388:
mov rdi, r14; this
mov rsi, rbx; YAML::detail::node *
call _ZN4YAML6detail4node14add_dependencyERS1_; YAML::detail::node::add_dependency(YAML::detail::node&)
mov rax, r14
add rsp, 18h
pop rbx
pop r14
retn
mov rbx, rax
mov rdi, [rsp+arg_8]
test rdi, rdi
jz short loc_573B0
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_573B0:
mov rdi, rbx
call __Unwind_Resume
| YAML::detail::node * YAML::detail::node::get<char [7]>(
YAML::detail::node *a1,
int a2,
long long *a3,
void *a4,
int a5,
int a6)
{
long long v7; // rdi
volatile signed __int32 *v8; // rax
YAML::detail::node *v9; // r14
long long v11; // [rsp+8h] [rbp-20h] BYREF
volatile signed __int32 *v12; // [rsp+10h] [rbp-18h]
v7 = *(_QWORD *)a1;
v11 = *a3;
v8 = (volatile signed __int32 *)a3[1];
v12 = v8;
if ( v8 )
{
a4 = &_libc_single_threaded;
if ( _libc_single_threaded )
++*((_DWORD *)v8 + 2);
else
_InterlockedIncrement(v8 + 2);
}
v9 = (YAML::detail::node *)YAML::detail::node_ref::get<char [7]>(v7, a2, (unsigned int)&v11, (_DWORD)a4, a5, a6);
if ( v12 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v12);
YAML::detail::node::add_dependency(v9, a1);
return v9;
}
| get<char[7]>:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV RDI,qword ptr [RDI]
MOV RAX,qword ptr [RDX]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RDX + 0x8]
MOV qword ptr [RSP + 0x10],RAX
TEST RAX,RAX
JZ 0x0015736c
MOV RCX,qword ptr [0x0030ff28]
CMP byte ptr [RCX],0x0
JZ 0x00157368
INC dword ptr [RAX + 0x8]
JMP 0x0015736c
LAB_00157368:
INC.LOCK dword ptr [RAX + 0x8]
LAB_0015736c:
LEA RDX,[RSP + 0x8]
CALL 0x001573b8
LAB_00157376:
MOV R14,RAX
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x00157388
CALL 0x001466d6
LAB_00157388:
MOV RDI,R14
MOV RSI,RBX
CALL 0x00151ba0
MOV RAX,R14
ADD RSP,0x18
POP RBX
POP R14
RET
|
/* YAML::detail::node& YAML::detail::node::get<char [7]>(char const (&) [7],
std::shared_ptr<YAML::detail::memory_holder>) */
node * __thiscall
YAML::detail::node::get<char[7]>(node *this,int8 param_1,int8 *param_3)
{
node_ref *pnVar1;
node *this_00;
int8 local_20;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_18;
pnVar1 = *(node_ref **)this;
local_20 = *param_3;
local_18 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)param_3[1];
if (local_18 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
if (*PTR___libc_single_threaded_0030ff28 == '\0') {
LOCK();
*(int *)(local_18 + 8) = *(int *)(local_18 + 8) + 1;
UNLOCK();
}
else {
*(int *)(local_18 + 8) = *(int *)(local_18 + 8) + 1;
}
}
/* try { // try from 0015736c to 00157375 has its CatchHandler @ 0015739e */
this_00 = node_ref::get<char[7]>(pnVar1,param_1,&local_20);
if (local_18 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_18);
}
add_dependency(this_00,this);
return this_00;
}
| |
41,557 | ggml_add1_impl | ngxson[P]ggml-easy/ggml/src/ggml.c | static struct ggml_tensor * ggml_add1_impl(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b,
bool inplace) {
GGML_ASSERT(ggml_is_scalar(b));
GGML_ASSERT(ggml_is_padded_1d(a));
struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);
result->op = GGML_OP_ADD1;
result->src[0] = a;
result->src[1] = b;
return result;
} | O1 | c | ggml_add1_impl:
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x1, 0x10(%rdx)
jne 0x1a57a
movq %rdx, %rbx
cmpq $0x1, 0x18(%rdx)
jne 0x1a57a
cmpq $0x1, 0x20(%rbx)
jne 0x1a57a
cmpq $0x1, 0x28(%rbx)
jne 0x1a57a
movq %rsi, %r14
movq 0x30(%rsi), %rax
movl (%rsi), %esi
imulq $0x38, %rsi, %rdx
leaq 0x4e8a9(%rip), %r8 # 0x68dc0
cmpq 0x18(%rdx,%r8), %rax
jne 0x1a596
movq 0x18(%r14), %rdx
movq 0x40(%r14), %rax
imulq 0x38(%r14), %rdx
cmpq %rdx, %rax
jne 0x1a596
imulq 0x20(%r14), %rax
cmpq %rax, 0x48(%r14)
jne 0x1a596
testb %cl, %cl
je 0x1a549
movq %r14, %rsi
callq 0x16260
jmp 0x1a55d
leaq 0x10(%r14), %rcx
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x19cd9
movl $0x3, 0x50(%rax)
movq %r14, 0x98(%rax)
movq %rbx, 0xa0(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3008e(%rip), %rdi # 0x4a60f
leaq 0x300d2(%rip), %rdx # 0x4a65a
leaq 0x321e2(%rip), %rcx # 0x4c771
movl $0x784, %esi # imm = 0x784
jmp 0x1a5b0
leaq 0x30072(%rip), %rdi # 0x4a60f
leaq 0x300b6(%rip), %rdx # 0x4a65a
leaq 0x321d8(%rip), %rcx # 0x4c783
movl $0x785, %esi # imm = 0x785
xorl %eax, %eax
callq 0x17c70
| ggml_add1_impl:
push r14
push rbx
push rax
cmp qword ptr [rdx+10h], 1
jnz loc_1A57A
mov rbx, rdx
cmp qword ptr [rdx+18h], 1
jnz loc_1A57A
cmp qword ptr [rbx+20h], 1
jnz short loc_1A57A
cmp qword ptr [rbx+28h], 1
jnz short loc_1A57A
mov r14, rsi
mov rax, [rsi+30h]
mov esi, [rsi]
imul rdx, rsi, 38h ; '8'
lea r8, type_traits
cmp rax, [rdx+r8+18h]
jnz short loc_1A596
mov rdx, [r14+18h]
mov rax, [r14+40h]
imul rdx, [r14+38h]
cmp rax, rdx
jnz short loc_1A596
imul rax, [r14+20h]
cmp [r14+48h], rax
jnz short loc_1A596
test cl, cl
jz short loc_1A549
mov rsi, r14
call _ggml_view_tensor
jmp short loc_1A55D
loc_1A549:
lea rcx, [r14+10h]
mov edx, 4
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
loc_1A55D:
mov dword ptr [rax+50h], 3
mov [rax+98h], r14
mov [rax+0A0h], rbx
add rsp, 8
pop rbx
pop r14
retn
loc_1A57A:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlIsScalarB; "ggml_is_scalar(b)"
mov esi, 784h
jmp short loc_1A5B0
loc_1A596:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlIsPadded1d; "ggml_is_padded_1d(a)"
mov esi, 785h
loc_1A5B0:
xor eax, eax
call _ggml_abort
| long long ggml_add1_impl(long long a1, _QWORD *a2, _QWORD *a3, char a4, char **a5, int a6)
{
char *v8; // rax
long long v9; // rsi
long long v10; // rax
long long result; // rax
const char *v12; // rcx
int v13; // esi
if ( a3[2] != 1LL || a3[3] != 1LL || a3[4] != 1LL || a3[5] != 1LL )
{
v12 = "ggml_is_scalar(b)";
v13 = 1924;
goto LABEL_14;
}
v8 = (char *)a2[6];
v9 = *(unsigned int *)a2;
a5 = &type_traits;
if ( v8 != (&type_traits)[7 * v9 + 3] || (v10 = a2[8], v10 != a2[7] * a2[3]) || a2[9] != a2[4] * v10 )
{
v12 = "ggml_is_padded_1d(a)";
v13 = 1925;
LABEL_14:
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c",
v13,
(unsigned int)"GGML_ASSERT(%s) failed",
(_DWORD)v12,
(_DWORD)a5,
a6);
}
if ( a4 )
result = ggml_view_tensor(a1, (long long)a2);
else
result = ggml_new_tensor_impl(a1, v9, 4, a2 + 2, 0LL, 0LL);
*(_DWORD *)(result + 80) = 3;
*(_QWORD *)(result + 152) = a2;
*(_QWORD *)(result + 160) = a3;
return result;
}
| ggml_add1_impl:
PUSH R14
PUSH RBX
PUSH RAX
CMP qword ptr [RDX + 0x10],0x1
JNZ 0x0011a57a
MOV RBX,RDX
CMP qword ptr [RDX + 0x18],0x1
JNZ 0x0011a57a
CMP qword ptr [RBX + 0x20],0x1
JNZ 0x0011a57a
CMP qword ptr [RBX + 0x28],0x1
JNZ 0x0011a57a
MOV R14,RSI
MOV RAX,qword ptr [RSI + 0x30]
MOV ESI,dword ptr [RSI]
IMUL RDX,RSI,0x38
LEA R8,[0x168dc0]
CMP RAX,qword ptr [RDX + R8*0x1 + 0x18]
JNZ 0x0011a596
MOV RDX,qword ptr [R14 + 0x18]
MOV RAX,qword ptr [R14 + 0x40]
IMUL RDX,qword ptr [R14 + 0x38]
CMP RAX,RDX
JNZ 0x0011a596
IMUL RAX,qword ptr [R14 + 0x20]
CMP qword ptr [R14 + 0x48],RAX
JNZ 0x0011a596
TEST CL,CL
JZ 0x0011a549
MOV RSI,R14
CALL 0x00116260
JMP 0x0011a55d
LAB_0011a549:
LEA RCX,[R14 + 0x10]
MOV EDX,0x4
XOR R8D,R8D
XOR R9D,R9D
CALL 0x00119cd9
LAB_0011a55d:
MOV dword ptr [RAX + 0x50],0x3
MOV qword ptr [RAX + 0x98],R14
MOV qword ptr [RAX + 0xa0],RBX
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_0011a57a:
LEA RDI,[0x14a60f]
LEA RDX,[0x14a65a]
LEA RCX,[0x14c771]
MOV ESI,0x784
JMP 0x0011a5b0
LAB_0011a596:
LEA RDI,[0x14a60f]
LEA RDX,[0x14a65a]
LEA RCX,[0x14c783]
MOV ESI,0x785
LAB_0011a5b0:
XOR EAX,EAX
CALL 0x00117c70
|
void ggml_add1_impl(int8 param_1,uint *param_2,long param_3,char param_4)
{
long lVar1;
char *pcVar2;
int8 uVar3;
if ((((*(long *)(param_3 + 0x10) == 1) && (*(long *)(param_3 + 0x18) == 1)) &&
(*(long *)(param_3 + 0x20) == 1)) && (*(long *)(param_3 + 0x28) == 1)) {
if (*(long *)(param_2 + 0xc) == *(long *)(type_traits + (ulong)*param_2 * 0x38 + 0x18)) {
if ((*(long *)(param_2 + 0x10) == *(long *)(param_2 + 6) * *(long *)(param_2 + 0xe)) &&
(*(long *)(param_2 + 0x12) == *(long *)(param_2 + 0x10) * *(long *)(param_2 + 8))) {
if (param_4 == '\0') {
lVar1 = ggml_new_tensor_impl(param_1,(ulong)*param_2,4,param_2 + 4,0,0);
}
else {
lVar1 = ggml_view_tensor(param_1,param_2);
}
*(int4 *)(lVar1 + 0x50) = 3;
*(uint **)(lVar1 + 0x98) = param_2;
*(long *)(lVar1 + 0xa0) = param_3;
return;
}
}
pcVar2 = "ggml_is_padded_1d(a)";
uVar3 = 0x785;
}
else {
pcVar2 = "ggml_is_scalar(b)";
uVar3 = 0x784;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c",uVar3,
"GGML_ASSERT(%s) failed",pcVar2);
}
| |
41,558 | ggml_add1_impl | ngxson[P]ggml-easy/ggml/src/ggml.c | static struct ggml_tensor * ggml_add1_impl(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b,
bool inplace) {
GGML_ASSERT(ggml_is_scalar(b));
GGML_ASSERT(ggml_is_padded_1d(a));
struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);
result->op = GGML_OP_ADD1;
result->src[0] = a;
result->src[1] = b;
return result;
} | O2 | c | ggml_add1_impl:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x1e7b0
testb %al, %al
je 0x2079f
movq %r14, %rdi
callq 0x28992
testb %al, %al
je 0x207bb
movq %r15, %rdi
movq %r14, %rsi
testb %bpl, %bpl
je 0x2077a
callq 0x1c3e0
jmp 0x2077f
callq 0x1d660
movl $0x3, 0x50(%rax)
movq %r14, 0x98(%rax)
movq %rbx, 0xa0(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2addd(%rip), %rdi # 0x4b583
leaq 0x2ae21(%rip), %rdx # 0x4b5ce
leaq 0x2cf31(%rip), %rcx # 0x4d6e5
movl $0x784, %esi # imm = 0x784
jmp 0x207d5
leaq 0x2adc1(%rip), %rdi # 0x4b583
leaq 0x2ae05(%rip), %rdx # 0x4b5ce
leaq 0x2cf27(%rip), %rcx # 0x4d6f7
movl $0x785, %esi # imm = 0x785
xorl %eax, %eax
callq 0x1e770
| ggml_add1_impl:
push rbp
push r15
push r14
push rbx
push rax
mov ebp, ecx
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov rdi, rdx
call _ggml_is_scalar
test al, al
jz short loc_2079F
mov rdi, r14
call ggml_is_padded_1d
test al, al
jz short loc_207BB
mov rdi, r15
mov rsi, r14
test bpl, bpl
jz short loc_2077A
call _ggml_view_tensor
jmp short loc_2077F
loc_2077A:
call _ggml_dup_tensor
loc_2077F:
mov dword ptr [rax+50h], 3
mov [rax+98h], r14
mov [rax+0A0h], rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_2079F:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlIsScalarB; "ggml_is_scalar(b)"
mov esi, 784h
jmp short loc_207D5
loc_207BB:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlIsPadded1d; "ggml_is_padded_1d(a)"
mov esi, 785h
loc_207D5:
xor eax, eax
call _ggml_abort
| long long ggml_add1_impl(
long long a1,
unsigned int *a2,
_QWORD *a3,
char a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
double a9,
double a10,
__m128 a11,
__m128 a12)
{
char v12; // al
long long v15; // r8
long long v16; // r9
__m128 v17; // xmm4
__m128 v18; // xmm5
long long result; // rax
const char *v20; // rcx
int v21; // esi
char v22; // [rsp-8h] [rbp-28h]
v22 = v12;
if ( !ggml_is_scalar(a3) )
{
v20 = "ggml_is_scalar(b)";
v21 = 1924;
goto LABEL_9;
}
if ( !(unsigned __int8)ggml_is_padded_1d(a2) )
{
v20 = "ggml_is_padded_1d(a)";
v21 = 1925;
LABEL_9:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c",
v21,
(long long)"GGML_ASSERT(%s) failed",
(long long)v20,
v15,
v16,
a5,
a6,
a7,
a8,
v17,
v18,
a11,
a12,
v22);
}
if ( a4 )
result = ggml_view_tensor(a1, (long long)a2, a5, a6, a7, a8, v17, v18, a11, a12);
else
result = ggml_dup_tensor(a1, a2);
*(_DWORD *)(result + 80) = 3;
*(_QWORD *)(result + 152) = a2;
*(_QWORD *)(result + 160) = a3;
return result;
}
| ggml_add1_impl:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EBP,ECX
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV RDI,RDX
CALL 0x0011e7b0
TEST AL,AL
JZ 0x0012079f
MOV RDI,R14
CALL 0x00128992
TEST AL,AL
JZ 0x001207bb
MOV RDI,R15
MOV RSI,R14
TEST BPL,BPL
JZ 0x0012077a
CALL 0x0011c3e0
JMP 0x0012077f
LAB_0012077a:
CALL 0x0011d660
LAB_0012077f:
MOV dword ptr [RAX + 0x50],0x3
MOV qword ptr [RAX + 0x98],R14
MOV qword ptr [RAX + 0xa0],RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0012079f:
LEA RDI,[0x14b583]
LEA RDX,[0x14b5ce]
LEA RCX,[0x14d6e5]
MOV ESI,0x784
JMP 0x001207d5
LAB_001207bb:
LEA RDI,[0x14b583]
LEA RDX,[0x14b5ce]
LEA RCX,[0x14d6f7]
MOV ESI,0x785
LAB_001207d5:
XOR EAX,EAX
CALL 0x0011e770
|
void ggml_add1_impl(int8 param_1,int8 param_2,int8 param_3,char param_4)
{
char cVar1;
long lVar2;
char *pcVar3;
int8 uVar4;
cVar1 = ggml_is_scalar(param_3);
if (cVar1 == '\0') {
pcVar3 = "ggml_is_scalar(b)";
uVar4 = 0x784;
}
else {
cVar1 = ggml_is_padded_1d(param_2);
if (cVar1 != '\0') {
if (param_4 == '\0') {
lVar2 = ggml_dup_tensor(param_1,param_2);
}
else {
lVar2 = ggml_view_tensor();
}
*(int4 *)(lVar2 + 0x50) = 3;
*(int8 *)(lVar2 + 0x98) = param_2;
*(int8 *)(lVar2 + 0xa0) = param_3;
return;
}
pcVar3 = "ggml_is_padded_1d(a)";
uVar4 = 0x785;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c",uVar4,
"GGML_ASSERT(%s) failed",pcVar3);
}
| |
41,559 | TensorFixtureTest_MatMulTestTwoDim_Test::~TensorFixtureTest_MatMulTestTwoDim_Test() | deependujha[P]DeepTensor/ctests/tensor_test.cc | TEST_F(TensorFixtureTest, MatMulTestTwoDim) {
// t4: [[140, 146], [320, 335]]
std::shared_ptr<Tensor> t4 = t1->matmul(t2);
EXPECT_EQ(t4->dims(), 2);
EXPECT_EQ(t4->shape[0], 2);
EXPECT_EQ(t4->shape[1], 2);
EXPECT_DOUBLE_EQ(t4->get(0)->data, double(140));
EXPECT_DOUBLE_EQ(t4->get(1)->data, double(146));
EXPECT_DOUBLE_EQ(t4->get(2)->data, double(320));
EXPECT_DOUBLE_EQ(t4->get(3)->data, double(335));
} | O0 | cpp | TensorFixtureTest_MatMulTestTwoDim_Test::~TensorFixtureTest_MatMulTestTwoDim_Test():
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30cd0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ZN39TensorFixtureTest_MatMulTestTwoDim_TestD2Ev:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]; this
call _ZN17TensorFixtureTestD2Ev; TensorFixtureTest::~TensorFixtureTest()
add rsp, 10h
pop rbp
retn
| void TensorFixtureTest_MatMulTestTwoDim_Test::~TensorFixtureTest_MatMulTestTwoDim_Test(
TensorFixtureTest_MatMulTestTwoDim_Test *this)
{
TensorFixtureTest::~TensorFixtureTest(this);
}
| ~TensorFixtureTest_MatMulTestTwoDim_Test:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00130cd0
ADD RSP,0x10
POP RBP
RET
|
/* TensorFixtureTest_MatMulTestTwoDim_Test::~TensorFixtureTest_MatMulTestTwoDim_Test() */
void __thiscall
TensorFixtureTest_MatMulTestTwoDim_Test::~TensorFixtureTest_MatMulTestTwoDim_Test
(TensorFixtureTest_MatMulTestTwoDim_Test *this)
{
TensorFixtureTest::~TensorFixtureTest((TensorFixtureTest *)this);
return;
}
| |
41,560 | minja::Context::at(minja::Value const&) | monkey531[P]llama/common/minja.hpp | virtual Value & at(const Value & key) {
if (values_.contains(key)) return values_.at(key);
if (parent_) return parent_->at(key);
throw std::runtime_error("Undefined variable: " + key.dump());
} | O0 | cpp | minja::Context::at(minja::Value const&):
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x18, %rdi
movq 0x60(%rsp), %rsi
callq 0x113f10
testb $0x1, %al
jne 0x130e7c
jmp 0x130e99
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movq 0x60(%rsp), %rsi
callq 0x113bd0
movq %rax, 0x70(%rsp)
jmp 0x130f9a
movq 0x8(%rsp), %rdi
addq $0x68, %rdi
callq 0x131100
testb $0x1, %al
jne 0x130ead
jmp 0x130ed3
movq 0x8(%rsp), %rdi
addq $0x68, %rdi
callq 0x10ddf0
movq %rax, %rdi
movq 0x60(%rsp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, 0x70(%rsp)
jmp 0x130f9a
movb $0x1, 0x13(%rsp)
movl $0x10, %edi
callq 0x565c0
movq %rax, (%rsp)
movq 0x60(%rsp), %rsi
leaq 0x20(%rsp), %rdi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0xdccf0
jmp 0x130efe
leaq 0xb8b3d(%rip), %rsi # 0x1e9a42
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0xa97b0
jmp 0x130f16
movq (%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x56410
jmp 0x130f26
movq (%rsp), %rdi
movb $0x0, 0x13(%rsp)
movq 0x13e072(%rip), %rsi # 0x26efa8
movq 0x13e033(%rip), %rdx # 0x26ef70
callq 0x569b0
jmp 0x130fae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x130f86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x130f7c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x572d0
leaq 0x20(%rsp), %rdi
callq 0x572d0
testb $0x1, 0x13(%rsp)
jne 0x130f8f
jmp 0x130f98
movq (%rsp), %rdi
callq 0x56dd0
jmp 0x130fa4
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x56a10
nop
| _ZN5minja7Context2atERKNS_5ValueE:
sub rsp, 78h
mov [rsp+78h+var_10], rdi
mov [rsp+78h+var_18], rsi
mov rdi, [rsp+78h+var_10]
mov [rsp+78h+var_70], rdi
add rdi, 18h; this
mov rsi, [rsp+78h+var_18]; minja::Value *
call _ZNK5minja5Value8containsERKS0_; minja::Value::contains(minja::Value const&)
test al, 1
jnz short loc_130E7C
jmp short loc_130E99
loc_130E7C:
mov rdi, [rsp+78h+var_70]
add rdi, 18h; this
mov rsi, [rsp+78h+var_18]; minja::Value *
call _ZN5minja5Value2atERKS0_; minja::Value::at(minja::Value const&)
mov [rsp+78h+var_8], rax
jmp loc_130F9A
loc_130E99:
mov rdi, [rsp+78h+var_70]
add rdi, 68h ; 'h'
call _ZNKSt12__shared_ptrIN5minja7ContextELN9__gnu_cxx12_Lock_policyE2EEcvbEv; std::__shared_ptr<minja::Context,(__gnu_cxx::_Lock_policy)2>::operator bool(void)
test al, 1
jnz short loc_130EAD
jmp short loc_130ED3
loc_130EAD:
mov rdi, [rsp+78h+var_70]
add rdi, 68h ; 'h'
call _ZNKSt19__shared_ptr_accessIN5minja7ContextELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<minja::Context,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rdi, rax
mov rsi, [rsp+78h+var_18]
mov rax, [rdi]
call qword ptr [rax+18h]
mov [rsp+78h+var_8], rax
jmp loc_130F9A
loc_130ED3:
mov [rsp+78h+var_65], 1
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov [rsp+78h+var_78], rax
mov rsi, [rsp+78h+var_18]
lea rdi, [rsp+78h+var_58]
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
jmp short $+2
loc_130EFE:
lea rsi, aUndefinedVaria; "Undefined variable: "
lea rdi, [rsp+78h+var_38]
lea rdx, [rsp+78h+var_58]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
jmp short $+2
loc_130F16:
mov rdi, [rsp+78h+var_78]
lea rsi, [rsp+78h+var_38]
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
jmp short $+2
loc_130F26:
mov rdi, [rsp+78h+var_78]; void *
mov [rsp+78h+var_65], 0
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp short loc_130FAE
mov rcx, rax
mov eax, edx
mov [rsp+arg_10], rcx
mov [rsp+arg_C], eax
jmp short loc_130F86
mov rcx, rax
mov eax, edx
mov [rsp+arg_10], rcx
mov [rsp+arg_C], eax
jmp short loc_130F7C
mov rcx, rax
mov eax, edx
mov [rsp+arg_10], rcx
mov [rsp+arg_C], eax
lea rdi, [rsp+arg_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_130F7C:
lea rdi, [rsp+arg_18]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_130F86:
test [rsp+arg_B], 1
jnz short loc_130F8F
jmp short loc_130F98
loc_130F8F:
mov rdi, [rsp+0]; void *
call ___cxa_free_exception
loc_130F98:
jmp short loc_130FA4
loc_130F9A:
mov rax, [rsp+78h+var_8]
add rsp, 78h
retn
loc_130FA4:
mov rdi, [rsp+arg_10]
call __Unwind_Resume
loc_130FAE:
xchg ax, ax
| long long minja::Context::at(minja::Context *this, const minja::Value *a2)
{
long long v2; // rax
void *exception; // [rsp+0h] [rbp-78h]
_BYTE v5[32]; // [rsp+20h] [rbp-58h] BYREF
_BYTE v6[32]; // [rsp+40h] [rbp-38h] BYREF
minja::Value *v7; // [rsp+60h] [rbp-18h]
minja::Context *v8; // [rsp+68h] [rbp-10h]
v8 = this;
v7 = a2;
if ( minja::Value::contains((minja::Context *)((char *)this + 24), a2) )
return minja::Value::at((minja::Context *)((char *)this + 24), v7);
if ( (std::__shared_ptr<minja::Context,(__gnu_cxx::_Lock_policy)2>::operator bool((char *)this + 104) & 1) == 0 )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v5, (long long)v7, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v6, (long long)"Undefined variable: ", (long long)v5);
std::runtime_error::runtime_error(exception, v6);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v2 = std::__shared_ptr_access<minja::Context,(__gnu_cxx::_Lock_policy)2,false,false>::operator->((long long)this + 104);
return (*(long long ( **)(long long, minja::Value *))(*(_QWORD *)v2 + 24LL))(v2, v7);
}
| |||
41,561 | minja::Context::at(minja::Value const&) | monkey531[P]llama/common/minja.hpp | virtual Value & at(const Value & key) {
if (values_.contains(key)) return values_.at(key);
if (parent_) return parent_->at(key);
throw std::runtime_error("Undefined variable: " + key.dump());
} | O3 | cpp | minja::Context::at(minja::Value const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rdi), %r15
movq %r15, %rdi
callq 0x6747c
testb %al, %al
je 0x70b93
movq %r15, %rdi
movq %r14, %rsi
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6726a
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x70bb2
movq (%rdi), %rax
movq 0x18(%rax), %rax
movq %r14, %rsi
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movl $0x10, %edi
callq 0x193b0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x50cd0
leaq 0x4c350(%rip), %rsi # 0xbcf2a
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x4320d
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x19c80
xorl %ebp, %ebp
movq 0x803ee(%rip), %rsi # 0xf0ff0
movq 0x80367(%rip), %rdx # 0xf0f70
movq %rbx, %rdi
callq 0x19d60
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x70c2f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x197f0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x70c4a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x197f0
testb %bpl, %bpl
jne 0x70c74
jmp 0x70c7c
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x70c74
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x197f0
jmp 0x70c74
movq %rax, %r14
movq %rbx, %rdi
callq 0x195a0
movq %r14, %rdi
callq 0x19dc0
| _ZN5minja7Context2atERKNS_5ValueE:
push rbp
push r15
push r14
push rbx
sub rsp, 48h
mov r14, rsi
mov rbx, rdi
lea r15, [rdi+18h]
mov rdi, r15; this
call _ZNK5minja5Value8containsERKS0_; minja::Value::contains(minja::Value const&)
test al, al
jz short loc_70B93
mov rdi, r15; this
mov rsi, r14; minja::Value *
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
jmp _ZN5minja5Value2atERKS0_; minja::Value::at(minja::Value const&)
loc_70B93:
mov rdi, [rbx+68h]
test rdi, rdi
jz short loc_70BB2
mov rax, [rdi]
mov rax, [rax+18h]
mov rsi, r14
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
jmp rax
loc_70BB2:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+68h+var_60]
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aUndefinedVaria; "Undefined variable: "
lea rdi, [rsp+68h+var_40]
lea rdx, [rsp+68h+var_60]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+68h+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:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+68h+var_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_70C2F
mov rsi, [rsp+68h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_70C2F:
lea rax, [rsp+68h+var_50]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_70C4A
mov rsi, [rsp+68h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_70C4A:
test bpl, bpl
jnz short loc_70C74
jmp short loc_70C7C
mov r14, rax
lea rax, [rsp+68h+var_50]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_70C74
mov rsi, [rsp+68h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_70C74
mov r14, rax
loc_70C74:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_70C7C:
mov rdi, r14
call __Unwind_Resume
| unsigned long long minja::Context::at(minja::Context *this, const minja::Value *a2, __m128d a3)
{
long long v4; // rdi
void *exception; // rbx
_BYTE v6[16]; // [rsp+8h] [rbp-60h] BYREF
_BYTE v7[16]; // [rsp+28h] [rbp-40h] BYREF
if ( minja::Value::contains((minja::Context *)((char *)this + 24), a2, a3) )
return minja::Value::at((minja::Context *)((char *)this + 24), a2);
v4 = *((_QWORD *)this + 13);
if ( !v4 )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v6, (long long)a2, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v7, (long long)"Undefined variable: ", (long long)v6);
std::runtime_error::runtime_error(exception, v7);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return (*(long long ( **)(long long, const minja::Value *))(*(_QWORD *)v4 + 24LL))(v4, a2);
}
| at:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV R14,RSI
MOV RBX,RDI
LEA R15,[RDI + 0x18]
MOV RDI,R15
CALL 0x0016747c
TEST AL,AL
JZ 0x00170b93
MOV RDI,R15
MOV RSI,R14
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
JMP 0x0016726a
LAB_00170b93:
MOV RDI,qword ptr [RBX + 0x68]
TEST RDI,RDI
JZ 0x00170bb2
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x18]
MOV RSI,R14
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
JMP RAX
LAB_00170bb2:
MOV EDI,0x10
CALL 0x001193b0
MOV RBX,RAX
LAB_00170bbf:
LEA RDI,[RSP + 0x8]
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x00150cd0
LAB_00170bd3:
LEA RSI,[0x1bcf2a]
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x8]
CALL 0x0014320d
MOV BPL,0x1
LAB_00170bec:
LEA RSI,[RSP + 0x28]
MOV RDI,RBX
CALL 0x00119c80
XOR EBP,EBP
MOV RSI,qword ptr [0x001f0ff0]
MOV RDX,qword ptr [0x001f0f70]
MOV RDI,RBX
CALL 0x00119d60
|
/* minja::Context::at(minja::Value const&) */
void __thiscall minja::Context::at(Context *this,Value *param_1)
{
long *plVar1;
char cVar2;
runtime_error *this_00;
int1 local_60 [32];
string local_40 [32];
cVar2 = Value::contains((Value *)(this + 0x18),param_1);
if (cVar2 != '\0') {
Value::at((Value *)(this + 0x18),param_1);
return;
}
plVar1 = *(long **)(this + 0x68);
if (plVar1 != (long *)0x0) {
/* WARNING: Could not recover jumptable at 0x00170bb0. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(*plVar1 + 0x18))(plVar1,param_1);
return;
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00170bbf to 00170bd2 has its CatchHandler @ 00170c71 */
Value::dump_abi_cxx11_((int)local_60,SUB81(param_1,0));
/* try { // try from 00170bd3 to 00170be8 has its CatchHandler @ 00170c51 */
std::operator+((char *)local_40,(string *)"Undefined variable: ");
/* try { // try from 00170bec to 00170c10 has its CatchHandler @ 00170c11 */
std::runtime_error::runtime_error(this_00,local_40);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_001f0ff0,PTR__runtime_error_001f0f70);
}
| |
41,562 | my_hash_sort_8bit_bin | eloqsql/strings/ctype-bin.c | void my_hash_sort_8bit_bin(CHARSET_INFO *cs __attribute__((unused)),
const uchar *key, size_t len,
ulong *nr1, ulong *nr2)
{
/*
Remove trailing spaces. We have to do this to be able to compare
'A ' and 'A' as identical
*/
const uchar *end= skip_trailing_space(key, len);
my_hash_sort_bin(cs, key, end - key, nr1, nr2);
} | O3 | c | my_hash_sort_8bit_bin:
pushq %rbp
movq %rsp, %rbp
leaq (%rsi,%rdx), %r9
cmpq $0x15, %rdx
jb 0x30024
movq %r9, %rdi
andq $-0x4, %rdi
cmpq %rsi, %rdi
jbe 0x30024
leaq 0x3(%rsi), %rdx
andq $-0x4, %rdx
movq %r9, %rax
movb -0x1(%r9), %r10b
cmpq %rdi, %r9
jbe 0x30084
leaq -0x1(%rax), %r9
cmpb $0x20, %r10b
je 0x3000c
jmp 0x30027
movq %r9, %rax
movq %rax, %rdi
subq %rsi, %rdi
movq %rax, %rdx
movq %rdi, %r9
cmpq %rsi, %rax
jbe 0x30046
leaq -0x1(%rdx), %rax
leaq -0x1(%r9), %rdi
cmpb $0x20, -0x1(%rdx)
je 0x3002d
movq (%rcx), %rax
movq (%r8), %rdi
testq %r9, %r9
jle 0x3007c
movl %eax, %r9d
andl $0x3f, %r9d
addq %rdi, %r9
movzbl (%rsi), %r10d
imulq %r9, %r10
movq %rax, %r9
shlq $0x8, %r9
addq %r10, %r9
xorq %r9, %rax
addq $0x3, %rdi
incq %rsi
cmpq %rdx, %rsi
jb 0x30051
movq %rax, (%rcx)
movq %rdi, (%r8)
popq %rbp
retq
cmpb $0x20, %r10b
setne %r9b
cmpq %rdi, %rdx
setae %dil
orb %r9b, %dil
jne 0x30027
movq %rax, %rdi
movq %rdi, %rax
cmpq %rdx, %rdi
jbe 0x30027
leaq -0x4(%rax), %rdi
cmpl $0x20202020, -0x4(%rax) # imm = 0x20202020
je 0x3009b
jmp 0x30027
| my_hash_sort_8bit_bin:
push rbp
mov rbp, rsp
lea r9, [rsi+rdx]
cmp rdx, 15h
jb short loc_30024
mov rdi, r9
and rdi, 0FFFFFFFFFFFFFFFCh
cmp rdi, rsi
jbe short loc_30024
lea rdx, [rsi+3]
and rdx, 0FFFFFFFFFFFFFFFCh
loc_3000C:
mov rax, r9
mov r10b, [r9-1]
cmp r9, rdi
jbe short loc_30084
lea r9, [rax-1]
cmp r10b, 20h ; ' '
jz short loc_3000C
jmp short loc_30027
loc_30024:
mov rax, r9
loc_30027:
mov rdi, rax
sub rdi, rsi
loc_3002D:
mov rdx, rax
mov r9, rdi
cmp rax, rsi
jbe short loc_30046
lea rax, [rdx-1]
lea rdi, [r9-1]
cmp byte ptr [rdx-1], 20h ; ' '
jz short loc_3002D
loc_30046:
mov rax, [rcx]
mov rdi, [r8]
test r9, r9
jle short loc_3007C
loc_30051:
mov r9d, eax
and r9d, 3Fh
add r9, rdi
movzx r10d, byte ptr [rsi]
imul r10, r9
mov r9, rax
shl r9, 8
add r9, r10
xor rax, r9
add rdi, 3
inc rsi
cmp rsi, rdx
jb short loc_30051
loc_3007C:
mov [rcx], rax
mov [r8], rdi
pop rbp
retn
loc_30084:
cmp r10b, 20h ; ' '
setnz r9b
cmp rdx, rdi
setnb dil
or dil, r9b
jnz short loc_30027
mov rdi, rax
loc_3009B:
mov rax, rdi
cmp rdi, rdx
jbe short loc_30027
lea rdi, [rax-4]
cmp dword ptr [rax-4], 20202020h
jz short loc_3009B
jmp loc_30027
| long long my_hash_sort_8bit_bin(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
long long *a4,
long long *a5)
{
unsigned long long v5; // r9
unsigned long long v6; // rdi
unsigned long long v7; // rdx
unsigned __int8 *v8; // rax
char v9; // r10
long long v10; // rdi
unsigned long long v11; // rdx
long long v12; // r9
long long result; // rax
long long v14; // rdi
unsigned long long v15; // rdi
v5 = (unsigned long long)&a2[a3];
if ( a3 < 0x15 || (v6 = v5 & 0xFFFFFFFFFFFFFFFCLL, (v5 & 0xFFFFFFFFFFFFFFFCLL) <= (unsigned long long)a2) )
{
v8 = &a2[a3];
}
else
{
v7 = (unsigned long long)(a2 + 3) & 0xFFFFFFFFFFFFFFFCLL;
while ( 1 )
{
v8 = (unsigned __int8 *)v5;
v9 = *(_BYTE *)(v5 - 1);
if ( v5 <= v6 )
break;
--v5;
if ( v9 != 32 )
goto LABEL_8;
}
if ( v9 == 32 && v7 < v6 )
{
v15 = v5;
do
{
v8 = (unsigned __int8 *)v15;
if ( v15 <= v7 )
break;
v15 -= 4LL;
}
while ( *((_DWORD *)v8 - 1) == 538976288 );
}
}
LABEL_8:
v10 = v8 - a2;
do
{
v11 = (unsigned long long)v8;
v12 = v10;
if ( v8 <= a2 )
break;
--v8;
--v10;
}
while ( *(_BYTE *)(v11 - 1) == 32 );
result = *a4;
v14 = *a5;
if ( v12 > 0 )
{
do
{
result ^= (v14 + (result & 0x3F)) * *a2 + (result << 8);
v14 += 3LL;
++a2;
}
while ( (unsigned long long)a2 < v11 );
}
*a4 = result;
*a5 = v14;
return result;
}
| my_hash_sort_8bit_bin:
PUSH RBP
MOV RBP,RSP
LEA R9,[RSI + RDX*0x1]
CMP RDX,0x15
JC 0x00130024
MOV RDI,R9
AND RDI,-0x4
CMP RDI,RSI
JBE 0x00130024
LEA RDX,[RSI + 0x3]
AND RDX,-0x4
LAB_0013000c:
MOV RAX,R9
MOV R10B,byte ptr [R9 + -0x1]
CMP R9,RDI
JBE 0x00130084
LEA R9,[RAX + -0x1]
CMP R10B,0x20
JZ 0x0013000c
JMP 0x00130027
LAB_00130024:
MOV RAX,R9
LAB_00130027:
MOV RDI,RAX
SUB RDI,RSI
LAB_0013002d:
MOV RDX,RAX
MOV R9,RDI
CMP RAX,RSI
JBE 0x00130046
LEA RAX,[RDX + -0x1]
LEA RDI,[R9 + -0x1]
CMP byte ptr [RDX + -0x1],0x20
JZ 0x0013002d
LAB_00130046:
MOV RAX,qword ptr [RCX]
MOV RDI,qword ptr [R8]
TEST R9,R9
JLE 0x0013007c
LAB_00130051:
MOV R9D,EAX
AND R9D,0x3f
ADD R9,RDI
MOVZX R10D,byte ptr [RSI]
IMUL R10,R9
MOV R9,RAX
SHL R9,0x8
ADD R9,R10
XOR RAX,R9
ADD RDI,0x3
INC RSI
CMP RSI,RDX
JC 0x00130051
LAB_0013007c:
MOV qword ptr [RCX],RAX
MOV qword ptr [R8],RDI
POP RBP
RET
LAB_00130084:
CMP R10B,0x20
SETNZ R9B
CMP RDX,RDI
SETNC DIL
OR DIL,R9B
JNZ 0x00130027
MOV RDI,RAX
LAB_0013009b:
MOV RAX,RDI
CMP RDI,RDX
JBE 0x00130027
LEA RDI,[RAX + -0x4]
CMP dword ptr [RAX + -0x4],0x20202020
JZ 0x0013009b
JMP 0x00130027
|
void my_hash_sort_8bit_bin
(int8 param_1,byte *param_2,ulong param_3,ulong *param_4,long *param_5)
{
byte *pbVar1;
byte *pbVar2;
ulong uVar3;
byte *pbVar4;
long lVar5;
long lVar6;
pbVar2 = param_2 + param_3;
if ((0x14 < param_3) && (pbVar4 = (byte *)((ulong)pbVar2 & 0xfffffffffffffffc), param_2 < pbVar4))
{
pbVar1 = pbVar2;
do {
pbVar2 = pbVar1;
if (pbVar2 <= pbVar4) {
pbVar1 = pbVar2;
if ((byte *)((ulong)(param_2 + 3) & 0xfffffffffffffffc) < pbVar4 && pbVar2[-1] == 0x20)
goto LAB_0013009b;
break;
}
pbVar1 = pbVar2 + -1;
} while (pbVar2[-1] == 0x20);
}
goto LAB_00130027;
while (pbVar1 = pbVar2 + -4, *(int *)(pbVar2 + -4) == 0x20202020) {
LAB_0013009b:
pbVar2 = pbVar1;
if (pbVar2 <= (byte *)((ulong)(param_2 + 3) & 0xfffffffffffffffc)) break;
}
LAB_00130027:
lVar6 = (long)pbVar2 - (long)param_2;
do {
lVar5 = lVar6;
pbVar4 = pbVar2;
if (pbVar4 <= param_2) break;
pbVar2 = pbVar4 + -1;
lVar6 = lVar5 + -1;
} while (pbVar4[-1] == 0x20);
uVar3 = *param_4;
lVar6 = *param_5;
if (0 < lVar5) {
do {
uVar3 = uVar3 ^ uVar3 * 0x100 + (ulong)*param_2 * ((ulong)((uint)uVar3 & 0x3f) + lVar6);
lVar6 = lVar6 + 3;
param_2 = param_2 + 1;
} while (param_2 < pbVar4);
}
*param_4 = uVar3;
*param_5 = lVar6;
return;
}
| |
41,563 | void nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2<double>(char*, int&, int&, double) | hkr04[P]cpp-mcp/common/json.hpp | JSON_HEDLEY_NON_NULL(1)
void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
{
static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
"internal error: not enough precision");
JSON_ASSERT(std::isfinite(value));
JSON_ASSERT(value > 0);
// If the neighbors (and boundaries) of 'value' are always computed for double-precision
// numbers, all float's can be recovered using strtod (and strtof). However, the resulting
// decimal representations are not exactly "short".
//
// The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars)
// says "value is converted to a string as if by std::sprintf in the default ("C") locale"
// and since sprintf promotes floats to doubles, I think this is exactly what 'std::to_chars'
// does.
// On the other hand, the documentation for 'std::to_chars' requires that "parsing the
// representation using the corresponding std::from_chars function recovers value exactly". That
// indicates that single precision floating-point numbers should be recovered using
// 'std::strtof'.
//
// NB: If the neighbors are computed for single-precision numbers, there is a single float
// (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision
// value is off by 1 ulp.
#if 0 // NOLINT(readability-avoid-unconditional-preprocessor-if)
const boundaries w = compute_boundaries(static_cast<double>(value));
#else
const boundaries w = compute_boundaries(value);
#endif
grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
} | O0 | cpp | void nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2<double>(char*, int&, int&, double):
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movsd %xmm0, 0x88(%rsp)
movsd 0x88(%rsp), %xmm0
leaq 0x58(%rsp), %rdi
callq 0x1a8b0
movq 0xa0(%rsp), %rdi
movq 0x98(%rsp), %rsi
movq 0x90(%rsp), %rdx
movq 0x68(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rcx
movl 0x50(%rsp), %r8d
leaq 0x38(%rsp), %r9
leaq 0x28(%rsp), %rax
movq (%r9), %r10
movq %r10, (%rsp)
movq 0x8(%r9), %r9
movq %r9, 0x8(%rsp)
movq (%rax), %r9
movq %r9, 0x10(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x1ab40
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl6grisu2IdEEvPcRiS5_T_:
sub rsp, 0A8h
mov [rsp+0A8h+var_8], rdi
mov [rsp+0A8h+var_10], rsi
mov [rsp+0A8h+var_18], rdx
movsd [rsp+0A8h+var_20], xmm0
movsd xmm0, [rsp+0A8h+var_20]
lea rdi, [rsp+0A8h+var_50]
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl18compute_boundariesIdEENS2_10boundariesET_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::compute_boundaries<double>(double)
mov rdi, [rsp+0A8h+var_8]
mov rsi, [rsp+0A8h+var_10]
mov rdx, [rsp+0A8h+var_18]
mov rax, [rsp+0A8h+var_40]
mov [rsp+0A8h+var_60], rax
mov rax, [rsp+0A8h+var_38]
mov [rsp+0A8h+var_58], rax
mov rax, [rsp+0A8h+var_50]
mov [rsp+0A8h+var_70], rax
mov rax, [rsp+0A8h+var_48]
mov [rsp+0A8h+var_68], rax
mov rax, [rsp+0A8h+var_30]
mov [rsp+0A8h+var_80], rax
mov rax, [rsp+0A8h+var_28]
mov [rsp+0A8h+var_78], rax
mov rcx, [rsp+0A8h+var_60]
mov r8d, dword ptr [rsp+0A8h+var_58]
lea r9, [rsp+0A8h+var_70]
lea rax, [rsp+0A8h+var_80]
mov r10, [r9]
mov [rsp+0A8h+var_A8], r10
mov r9, [r9+8]
mov [rsp+0A8h+var_A0], r9
mov r9, [rax]
mov [rsp+0A8h+var_98], r9
mov rax, [rax+8]
mov [rsp+0A8h+var_90], rax
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl6grisu2EPcRiS4_NS2_5diyfpES5_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(char *,int &,int &,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp)
add rsp, 0A8h
retn
| long long nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2<double>(
long long a1,
long long a2,
long long a3,
double a4)
{
_QWORD v5[3]; // [rsp+58h] [rbp-50h] BYREF
long long v6; // [rsp+70h] [rbp-38h]
long long v7; // [rsp+78h] [rbp-30h]
long long v8; // [rsp+80h] [rbp-28h]
double v9; // [rsp+88h] [rbp-20h]
long long v10; // [rsp+90h] [rbp-18h]
long long v11; // [rsp+98h] [rbp-10h]
long long v12; // [rsp+A0h] [rbp-8h]
v12 = a1;
v11 = a2;
v10 = a3;
v9 = a4;
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::compute_boundaries<double>(v5, a4);
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(
v12,
v11,
v10,
v5[2],
(unsigned int)v6,
v7,
v5[0],
v5[1],
v7,
v8);
}
| grisu2<double>:
SUB RSP,0xa8
MOV qword ptr [RSP + 0xa0],RDI
MOV qword ptr [RSP + 0x98],RSI
MOV qword ptr [RSP + 0x90],RDX
MOVSD qword ptr [RSP + 0x88],XMM0
MOVSD XMM0,qword ptr [RSP + 0x88]
LEA RDI,[RSP + 0x58]
CALL 0x0011a8b0
MOV RDI,qword ptr [RSP + 0xa0]
MOV RSI,qword ptr [RSP + 0x98]
MOV RDX,qword ptr [RSP + 0x90]
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0x48],RAX
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0x50],RAX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x38],RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0x30],RAX
MOV RCX,qword ptr [RSP + 0x48]
MOV R8D,dword ptr [RSP + 0x50]
LEA R9,[RSP + 0x38]
LEA RAX,[RSP + 0x28]
MOV R10,qword ptr [R9]
MOV qword ptr [RSP],R10
MOV R9,qword ptr [R9 + 0x8]
MOV qword ptr [RSP + 0x8],R9
MOV R9,qword ptr [RAX]
MOV qword ptr [RSP + 0x10],R9
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x18],RAX
CALL 0x0011ab40
ADD RSP,0xa8
RET
|
/* void nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2<double>(char*, int&, int&, double) */
void nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2<double>
(char *param_1,int *param_2,int *param_3,double param_4)
{
int8 local_50;
int8 local_48;
int8 local_40;
ulong local_38;
int8 local_30;
int8 local_28;
double local_20;
int *local_18;
int *local_10;
char *local_8;
local_20 = param_4;
local_18 = param_3;
local_10 = param_2;
local_8 = param_1;
compute_boundaries<double>((dtoa_impl *)&local_50,param_4);
grisu2(local_8,local_10,local_18,local_40,local_38 & 0xffffffff,local_30,local_50,local_48,
local_30,local_28);
return;
}
| |
41,564 | JS_ThrowReferenceErrorUninitialized2 | bluesky950520[P]quickjs/quickjs.c | static JSValue JS_ThrowReferenceErrorUninitialized2(JSContext *ctx,
JSFunctionBytecode *b,
int idx, BOOL is_ref)
{
JSAtom atom = JS_ATOM_NULL;
if (is_ref) {
atom = b->closure_var[idx].var_name;
} else {
/* not present if the function is stripped and contains no eval() */
if (b->vardefs)
atom = b->vardefs[b->arg_count + idx].var_name;
}
return JS_ThrowReferenceErrorUninitialized(ctx, atom);
} | O0 | c | JS_ThrowReferenceErrorUninitialized2:
subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x0, 0x10(%rsp)
je 0x670cd
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
movslq 0x14(%rsp), %rcx
movl 0x4(%rax,%rcx,8), %eax
movl %eax, 0xc(%rsp)
jmp 0x67101
movq 0x18(%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x670ff
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x18(%rsp), %rcx
movzwl 0x40(%rcx), %ecx
addl 0x14(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
jmp 0x67101
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x604d0
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rdx
addq $0x38, %rsp
retq
nopl (%rax,%rax)
| JS_ThrowReferenceErrorUninitialized2:
sub rsp, 38h
mov [rsp+38h+var_18], rdi
mov [rsp+38h+var_20], rsi
mov [rsp+38h+var_24], edx
mov [rsp+38h+var_28], ecx
mov [rsp+38h+var_2C], 0
cmp [rsp+38h+var_28], 0
jz short loc_670CD
mov rax, [rsp+38h+var_20]
mov rax, [rax+38h]
movsxd rcx, [rsp+38h+var_24]
mov eax, [rax+rcx*8+4]
mov [rsp+38h+var_2C], eax
jmp short loc_67101
loc_670CD:
mov rax, [rsp+38h+var_20]
cmp qword ptr [rax+30h], 0
jz short loc_670FF
mov rax, [rsp+38h+var_20]
mov rax, [rax+30h]
mov rcx, [rsp+38h+var_20]
movzx ecx, word ptr [rcx+40h]
add ecx, [rsp+38h+var_24]
movsxd rcx, ecx
shl rcx, 4
add rax, rcx
mov eax, [rax]
mov [rsp+38h+var_2C], eax
loc_670FF:
jmp short $+2
loc_67101:
mov rdi, [rsp+38h+var_18]
mov esi, [rsp+38h+var_2C]
call JS_ThrowReferenceErrorUninitialized
mov [rsp+38h+var_10], rax
mov [rsp+38h+var_8], rdx
mov rax, [rsp+38h+var_10]
mov rdx, [rsp+38h+var_8]
add rsp, 38h
retn
| long long JS_ThrowReferenceErrorUninitialized2(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
unsigned int v15; // [rsp+Ch] [rbp-2Ch]
v15 = 0;
if ( (_DWORD)a4 )
return JS_ThrowReferenceErrorUninitialized(
a1,
*(_DWORD *)(*(_QWORD *)(a2 + 56) + 8LL * (int)a3 + 4),
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
a3,
(int)a3,
a5,
a6);
if ( *(_QWORD *)(a2 + 48) )
{
a4 = 16LL * (int)(a3 + *(unsigned __int16 *)(a2 + 64));
v15 = *(_DWORD *)(a4 + *(_QWORD *)(a2 + 48));
}
return JS_ThrowReferenceErrorUninitialized(a1, v15, a7, a8, a9, a10, a11, a12, a13, a14, a3, a4, a5, a6);
}
| JS_ThrowReferenceErrorUninitialized2:
SUB RSP,0x38
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RSI
MOV dword ptr [RSP + 0x14],EDX
MOV dword ptr [RSP + 0x10],ECX
MOV dword ptr [RSP + 0xc],0x0
CMP dword ptr [RSP + 0x10],0x0
JZ 0x001670cd
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOVSXD RCX,dword ptr [RSP + 0x14]
MOV EAX,dword ptr [RAX + RCX*0x8 + 0x4]
MOV dword ptr [RSP + 0xc],EAX
JMP 0x00167101
LAB_001670cd:
MOV RAX,qword ptr [RSP + 0x18]
CMP qword ptr [RAX + 0x30],0x0
JZ 0x001670ff
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x30]
MOV RCX,qword ptr [RSP + 0x18]
MOVZX ECX,word ptr [RCX + 0x40]
ADD ECX,dword ptr [RSP + 0x14]
MOVSXD RCX,ECX
SHL RCX,0x4
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RSP + 0xc],EAX
LAB_001670ff:
JMP 0x00167101
LAB_00167101:
MOV RDI,qword ptr [RSP + 0x20]
MOV ESI,dword ptr [RSP + 0xc]
CALL 0x001604d0
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x30],RDX
MOV RAX,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
ADD RSP,0x38
RET
|
int1 [16]
JS_ThrowReferenceErrorUninitialized2(int8 param_1,long param_2,int param_3,int param_4)
{
int1 auVar1 [16];
int4 local_2c;
local_2c = 0;
if (param_4 == 0) {
if (*(long *)(param_2 + 0x30) != 0) {
local_2c = *(int4 *)
(*(long *)(param_2 + 0x30) +
(long)(int)((uint)*(ushort *)(param_2 + 0x40) + param_3) * 0x10);
}
}
else {
local_2c = *(int4 *)(*(long *)(param_2 + 0x38) + 4 + (long)param_3 * 8);
}
auVar1 = JS_ThrowReferenceErrorUninitialized(param_1,local_2c);
return auVar1;
}
| |
41,565 | JS_ThrowReferenceErrorUninitialized2 | bluesky950520[P]quickjs/quickjs.c | static JSValue JS_ThrowReferenceErrorUninitialized2(JSContext *ctx,
JSFunctionBytecode *b,
int idx, BOOL is_ref)
{
JSAtom atom = JS_ATOM_NULL;
if (is_ref) {
atom = b->closure_var[idx].var_name;
} else {
/* not present if the function is stripped and contains no eval() */
if (b->vardefs)
atom = b->vardefs[b->arg_count + idx].var_name;
}
return JS_ThrowReferenceErrorUninitialized(ctx, atom);
} | O2 | c | JS_ThrowReferenceErrorUninitialized2:
testl %ecx, %ecx
je 0x37be2
movq 0x38(%rsi), %rax
movl %edx, %ecx
leaq (%rax,%rcx,8), %rax
addq $0x4, %rax
jmp 0x37bf8
movq 0x30(%rsi), %rax
testq %rax, %rax
je 0x37bff
movzwl 0x40(%rsi), %ecx
addl %edx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %esi
jmp 0x35ece
xorl %esi, %esi
jmp 0x35ece
| JS_ThrowReferenceErrorUninitialized2:
test ecx, ecx
jz short loc_37BE2
mov rax, [rsi+38h]
mov ecx, edx
lea rax, [rax+rcx*8]
add rax, 4
jmp short loc_37BF8
loc_37BE2:
mov rax, [rsi+30h]
test rax, rax
jz short loc_37BFF
movzx ecx, word ptr [rsi+40h]
add ecx, edx
shl rcx, 4
add rax, rcx
loc_37BF8:
mov esi, [rax]
jmp JS_ThrowReferenceErrorUninitialized
loc_37BFF:
xor esi, esi
jmp JS_ThrowReferenceErrorUninitialized
| long long JS_ThrowReferenceErrorUninitialized2(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long v14; // rcx
int *v15; // rax
long long v16; // rax
if ( (_DWORD)a4 )
{
v14 = (unsigned int)a3;
v15 = (int *)(*(_QWORD *)(a2 + 56) + 8LL * (unsigned int)a3 + 4);
return JS_ThrowReferenceErrorUninitialized(a1, *v15, a7, a8, a9, a10, a11, a12, a13, a14, a3, v14, a5, a6);
}
v16 = *(_QWORD *)(a2 + 48);
if ( v16 )
{
v14 = 16LL * ((unsigned int)a3 + *(unsigned __int16 *)(a2 + 64));
v15 = (int *)(v14 + v16);
return JS_ThrowReferenceErrorUninitialized(a1, *v15, a7, a8, a9, a10, a11, a12, a13, a14, a3, v14, a5, a6);
}
return JS_ThrowReferenceErrorUninitialized(a1, 0, a7, a8, a9, a10, a11, a12, a13, a14, a3, a4, a5, a6);
}
| JS_ThrowReferenceErrorUninitialized2:
TEST ECX,ECX
JZ 0x00137be2
MOV RAX,qword ptr [RSI + 0x38]
MOV ECX,EDX
LEA RAX,[RAX + RCX*0x8]
ADD RAX,0x4
JMP 0x00137bf8
LAB_00137be2:
MOV RAX,qword ptr [RSI + 0x30]
TEST RAX,RAX
JZ 0x00137bff
MOVZX ECX,word ptr [RSI + 0x40]
ADD ECX,EDX
SHL RCX,0x4
ADD RAX,RCX
LAB_00137bf8:
MOV ESI,dword ptr [RAX]
JMP 0x00135ece
LAB_00137bff:
XOR ESI,ESI
JMP 0x00135ece
|
void JS_ThrowReferenceErrorUninitialized2(int8 param_1,long param_2,uint param_3,int param_4)
{
int4 *puVar1;
if (param_4 == 0) {
if (*(long *)(param_2 + 0x30) == 0) {
JS_ThrowReferenceErrorUninitialized(param_1,0);
return;
}
puVar1 = (int4 *)
(*(long *)(param_2 + 0x30) + (ulong)(*(ushort *)(param_2 + 0x40) + param_3) * 0x10);
}
else {
puVar1 = (int4 *)(*(long *)(param_2 + 0x38) + (ulong)param_3 * 8 + 4);
}
JS_ThrowReferenceErrorUninitialized(param_1,*puVar1);
return;
}
| |
41,566 | Shell::readMultiLineInput[abi:cxx11]() | isaiah76[P]linux-shell/src/Shell.cpp | std::string Shell::readMultiLineInput(){
std::string completeCommand;
char* input;
bool continueReading = true;
std::string prompt = curDir + "$ ";
while(continueReading) {
input = readline(prompt.c_str());
if(!input){
std::cout << "exit\n";
running = false;
return "";
}
std::string line = input;
free(input);
if(!line.empty() && line.back() == '\\'){
line.pop_back();
completeCommand += line;
prompt = "> ";
} else {
completeCommand += line;
continueReading = false;
}
}
return completeCommand;
} | O0 | cpp | Shell::readMultiLineInput[abi:cxx11]():
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3420
movq -0xa8(%rbp), %rsi
movb $0x1, -0x39(%rbp)
addq $0x8, %rsi
leaq 0x5108(%rip), %rdx # 0x9006
leaq -0x60(%rbp), %rdi
callq 0x4650
jmp 0x3f09
jmp 0x3f0b
testb $0x1, -0x39(%rbp)
je 0x40ec
leaq -0x60(%rbp), %rdi
callq 0x3140
movq %rax, %rdi
callq 0x3290
movq %rax, -0xc0(%rbp)
jmp 0x3f2f
movq -0xc0(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x3fe1
movq 0x9084(%rip), %rdi # 0xcfd0
leaq 0x50d9(%rip), %rsi # 0x902c
callq 0x32c0
jmp 0x3f5a
movq -0xa8(%rbp), %rax
movb $0x0, (%rax)
leaq -0x6d(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x3510
movq -0xb8(%rbp), %rdi
movq -0xc8(%rbp), %rdx
leaq 0x51b1(%rip), %rsi # 0x913a
callq 0x3410
jmp 0x3f90
leaq -0x6d(%rbp), %rdi
callq 0x3310
movl $0x1, -0x74(%rbp)
jmp 0x4103
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x412e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x4125
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x6d(%rbp), %rdi
callq 0x3310
jmp 0x4125
movq -0x38(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x99(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x3510
movq -0xd8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
leaq -0x98(%rbp), %rdi
callq 0x3410
jmp 0x401b
leaq -0x99(%rbp), %rdi
callq 0x3310
movq -0x38(%rbp), %rdi
callq 0x3340
leaq -0x98(%rbp), %rdi
callq 0x34e0
testb $0x1, %al
jne 0x40c5
leaq -0x98(%rbp), %rdi
callq 0x3220
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x40c5
leaq -0x98(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x3370
movq -0xe0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x33a0
jmp 0x407d
leaq 0x4fae(%rip), %rsi # 0x9032
leaq -0x60(%rbp), %rdi
callq 0x3400
jmp 0x408f
jmp 0x40db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x99(%rbp), %rdi
callq 0x3310
jmp 0x4125
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x31d0
jmp 0x4125
leaq -0x30(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x33a0
jmp 0x40d7
movb $0x0, -0x39(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x31d0
jmp 0x3f0b
movq -0xb8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x31b0
movl $0x1, -0x74(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x31d0
leaq -0x30(%rbp), %rdi
callq 0x31d0
movq -0xb0(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x60(%rbp), %rdi
callq 0x31d0
leaq -0x30(%rbp), %rdi
callq 0x31d0
movq -0x68(%rbp), %rdi
callq 0x3500
| _ZN5Shell18readMultiLineInputB5cxx11Ev:
push rbp
mov rbp, rsp
sub rsp, 0E0h
mov [rbp+var_B8], rdi
mov rax, rdi
mov [rbp+var_B0], rax
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov [rbp+var_A8], rax
lea rdi, [rbp+var_30]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
mov rsi, [rbp+var_A8]
mov [rbp+var_39], 1
add rsi, 8
lea rdx, unk_9006
lea rdi, [rbp+var_60]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EERKS8_PKS5_; std::operator+<char>(std::string const&,char const*)
jmp short $+2
loc_3F09:
jmp short $+2
loc_3F0B:
test [rbp+var_39], 1
jz loc_40EC
lea rdi, [rbp+var_60]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rdi, rax
call _readline
mov [rbp+var_C0], rax
jmp short $+2
loc_3F2F:
mov rax, [rbp+var_C0]
mov [rbp+var_38], rax
cmp [rbp+var_38], 0
jnz loc_3FE1
mov rdi, cs:_ZSt4cout_ptr
lea rsi, aExit; "exit\n"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short $+2
loc_3F5A:
mov rax, [rbp+var_A8]
mov byte ptr [rax], 0
lea rdi, [rbp+var_6D]
mov [rbp+var_C8], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdi, [rbp+var_B8]
mov rdx, [rbp+var_C8]
lea rsi, aForkFailed+0Ch; ""
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1EPKcRKS3_; std::string::basic_string(char const*,std::allocator<char> const&)
jmp short $+2
loc_3F90:
lea rdi, [rbp+var_6D]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
mov [rbp+var_74], 1
jmp loc_4103
mov rcx, rax
mov eax, edx
mov [rbp+var_68], rcx
mov [rbp+var_6C], eax
jmp loc_412E
mov rcx, rax
mov eax, edx
mov [rbp+var_68], rcx
mov [rbp+var_6C], eax
jmp loc_4125
mov rcx, rax
mov eax, edx
mov [rbp+var_68], rcx
mov [rbp+var_6C], eax
lea rdi, [rbp+var_6D]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_4125
loc_3FE1:
mov rax, [rbp+var_38]
mov [rbp+var_D8], rax
lea rdi, [rbp+var_99]
mov [rbp+var_D0], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rsi, [rbp+var_D8]
mov rdx, [rbp+var_D0]
lea rdi, [rbp+var_98]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1EPKcRKS3_; std::string::basic_string(char const*,std::allocator<char> const&)
jmp short $+2
loc_401B:
lea rdi, [rbp+var_99]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
mov rdi, [rbp+var_38]
call _free
lea rdi, [rbp+var_98]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
test al, 1
jnz loc_40C5
lea rdi, [rbp+var_98]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4backEv; std::string::back(void)
movsx eax, byte ptr [rax]
cmp eax, 5Ch ; '\'
jnz short loc_40C5
lea rdi, [rbp+var_98]
mov [rbp+var_E0], rdi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE8pop_backEv; std::string::pop_back(void)
mov rsi, [rbp+var_E0]
lea rdi, [rbp+var_30]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEpLERKS4_; std::string::operator+=(std::string const&)
jmp short $+2
loc_407D:
lea rsi, asc_9032; "> "
lea rdi, [rbp+var_60]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc; std::string::operator=(char const*)
jmp short $+2
loc_408F:
jmp short loc_40DB
mov rcx, rax
mov eax, edx
mov [rbp+var_68], rcx
mov [rbp+var_6C], eax
lea rdi, [rbp+var_99]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_4125
mov rcx, rax
mov eax, edx
mov [rbp+var_68], rcx
mov [rbp+var_6C], eax
lea rdi, [rbp+var_98]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_4125
loc_40C5:
lea rdi, [rbp+var_30]
lea rsi, [rbp+var_98]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEpLERKS4_; std::string::operator+=(std::string const&)
jmp short $+2
loc_40D7:
mov [rbp+var_39], 0
loc_40DB:
lea rdi, [rbp+var_98]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp loc_3F0B
loc_40EC:
mov rdi, [rbp+var_B8]
lea rsi, [rbp+var_30]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1EOS4_; std::string::basic_string(std::string&&)
mov [rbp+var_74], 1
loc_4103:
lea rdi, [rbp+var_60]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rbp+var_30]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov rax, [rbp+var_B0]
add rsp, 0E0h
pop rbp
retn
loc_4125:
lea rdi, [rbp+var_60]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_412E:
lea rdi, [rbp+var_30]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov rdi, [rbp+var_68]
call __Unwind_Resume
| long long Shell::readMultiLineInput[abi:cxx11](long long a1, _BYTE *a2)
{
long long v2; // rax
long long v4; // [rsp+8h] [rbp-D8h]
char v5; // [rsp+47h] [rbp-99h] BYREF
_BYTE v6[36]; // [rsp+48h] [rbp-98h] BYREF
int v7; // [rsp+6Ch] [rbp-74h]
char v8; // [rsp+73h] [rbp-6Dh] BYREF
_BYTE v9[39]; // [rsp+80h] [rbp-60h] BYREF
char v10; // [rsp+A7h] [rbp-39h]
long long v11; // [rsp+A8h] [rbp-38h]
_BYTE v12[32]; // [rsp+B0h] [rbp-30h] BYREF
_BYTE *v13; // [rsp+D0h] [rbp-10h]
long long v14; // [rsp+D8h] [rbp-8h]
v14 = a1;
v13 = a2;
std::string::basic_string(v12);
v10 = 1;
std::operator+<char>(v9, a2 + 8, &unk_9006);
while ( (v10 & 1) != 0 )
{
v2 = std::string::c_str(v9);
v11 = readline(v2);
if ( !v11 )
{
std::operator<<<std::char_traits<char>>(&std::cout, "exit\n");
*a2 = 0;
std::allocator<char>::allocator();
std::string::basic_string(a1, "", &v8);
std::allocator<char>::~allocator(&v8);
v7 = 1;
goto LABEL_11;
}
v4 = v11;
std::allocator<char>::allocator();
std::string::basic_string(v6, v4, &v5);
std::allocator<char>::~allocator(&v5);
free(v11);
if ( (std::string::empty(v6) & 1) != 0 || *(_BYTE *)std::string::back(v6) != 92 )
{
std::string::operator+=(v12, v6);
v10 = 0;
}
else
{
std::string::pop_back();
std::string::operator+=(v12, v6);
std::string::operator=(v9, "> ");
}
std::string::~string(v6);
}
std::string::basic_string(a1, v12);
v7 = 1;
LABEL_11:
std::string::~string(v9);
std::string::~string(v12);
return a1;
}
| readMultiLineInput[abi:cxx11]:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xe0
MOV qword ptr [RBP + -0xb8],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0xb0],RAX
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0xa8],RAX
LEA RDI,[RBP + -0x30]
CALL 0x00103420
MOV RSI,qword ptr [RBP + -0xa8]
MOV byte ptr [RBP + -0x39],0x1
ADD RSI,0x8
LAB_00103ef7:
LEA RDX,[0x109006]
LEA RDI,[RBP + -0x60]
CALL 0x00104650
JMP 0x00103f09
LAB_00103f09:
JMP 0x00103f0b
LAB_00103f0b:
TEST byte ptr [RBP + -0x39],0x1
JZ 0x001040ec
LEA RDI,[RBP + -0x60]
CALL 0x00103140
MOV RDI,RAX
LAB_00103f21:
CALL 0x00103290
MOV qword ptr [RBP + -0xc0],RAX
JMP 0x00103f2f
LAB_00103f2f:
MOV RAX,qword ptr [RBP + -0xc0]
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x00103fe1
MOV RDI,qword ptr [0x0010cfd0]
LEA RSI,[0x10902c]
CALL 0x001032c0
JMP 0x00103f5a
LAB_00103f5a:
MOV RAX,qword ptr [RBP + -0xa8]
MOV byte ptr [RAX],0x0
LEA RDI,[RBP + -0x6d]
MOV qword ptr [RBP + -0xc8],RDI
CALL 0x00103510
MOV RDI,qword ptr [RBP + -0xb8]
MOV RDX,qword ptr [RBP + -0xc8]
LAB_00103f82:
LEA RSI,[0x10913a]
CALL 0x00103410
JMP 0x00103f90
LAB_00103f90:
LEA RDI,[RBP + -0x6d]
CALL 0x00103310
MOV dword ptr [RBP + -0x74],0x1
JMP 0x00104103
LAB_00103fe1:
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0xd8],RAX
LEA RDI,[RBP + -0x99]
MOV qword ptr [RBP + -0xd0],RDI
CALL 0x00103510
MOV RSI,qword ptr [RBP + -0xd8]
MOV RDX,qword ptr [RBP + -0xd0]
LAB_0010400d:
LEA RDI,[RBP + -0x98]
CALL 0x00103410
JMP 0x0010401b
LAB_0010401b:
LEA RDI,[RBP + -0x99]
CALL 0x00103310
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x00103340
LEA RDI,[RBP + -0x98]
CALL 0x001034e0
TEST AL,0x1
JNZ 0x001040c5
LEA RDI,[RBP + -0x98]
CALL 0x00103220
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x5c
JNZ 0x001040c5
LEA RDI,[RBP + -0x98]
MOV qword ptr [RBP + -0xe0],RDI
CALL 0x00103370
MOV RSI,qword ptr [RBP + -0xe0]
LAB_00104072:
LEA RDI,[RBP + -0x30]
CALL 0x001033a0
JMP 0x0010407d
LAB_0010407d:
LEA RSI,[0x109032]
LEA RDI,[RBP + -0x60]
CALL 0x00103400
JMP 0x0010408f
LAB_0010408f:
JMP 0x001040db
LAB_001040c5:
LEA RDI,[RBP + -0x30]
LEA RSI,[RBP + -0x98]
CALL 0x001033a0
LAB_001040d5:
JMP 0x001040d7
LAB_001040d7:
MOV byte ptr [RBP + -0x39],0x0
LAB_001040db:
LEA RDI,[RBP + -0x98]
CALL 0x001031d0
JMP 0x00103f0b
LAB_001040ec:
MOV RDI,qword ptr [RBP + -0xb8]
LEA RSI,[RBP + -0x30]
CALL 0x001031b0
MOV dword ptr [RBP + -0x74],0x1
LAB_00104103:
LEA RDI,[RBP + -0x60]
CALL 0x001031d0
LEA RDI,[RBP + -0x30]
CALL 0x001031d0
MOV RAX,qword ptr [RBP + -0xb0]
ADD RSP,0xe0
POP RBP
RET
|
/* Shell::readMultiLineInput[abi:cxx11]() */
string * Shell::readMultiLineInput_abi_cxx11_(void)
{
int8 uVar1;
char *pcVar2;
ulong uVar3;
int1 *in_RSI;
string *in_RDI;
allocator local_a1;
string local_a0 [36];
int4 local_7c;
allocator local_75 [13];
string local_68 [39];
byte local_41;
char *local_40;
string local_38 [48];
std::__cxx11::string::string(local_38);
local_41 = 1;
/* try { // try from 00103ef7 to 00103f06 has its CatchHandler @ 00103fa5 */
std::operator+(local_68,in_RSI + 8);
do {
if ((local_41 & 1) == 0) {
std::__cxx11::string::string(in_RDI,local_38);
LAB_00104103:
local_7c = 1;
std::__cxx11::string::~string(local_68);
std::__cxx11::string::~string(local_38);
return in_RDI;
}
uVar1 = std::__cxx11::string::c_str();
/* try { // try from 00103f21 to 00103f57 has its CatchHandler @ 00103fb6 */
pcVar2 = (char *)readline(uVar1);
local_40 = pcVar2;
if (pcVar2 == (char *)0x0) {
std::operator<<((ostream *)PTR_cout_0010cfd0,"exit\n");
*in_RSI = 0;
std::allocator<char>::allocator();
/* try { // try from 00103f82 to 00103f8d has its CatchHandler @ 00103fc7 */
std::__cxx11::string::string(in_RDI,"",local_75);
std::allocator<char>::~allocator((allocator<char> *)local_75);
goto LAB_00104103;
}
std::allocator<char>::allocator();
/* try { // try from 0010400d to 00104018 has its CatchHandler @ 00104091 */
std::__cxx11::string::string(local_a0,pcVar2,&local_a1);
std::allocator<char>::~allocator((allocator<char> *)&local_a1);
free(local_40);
uVar3 = std::__cxx11::string::empty();
if ((uVar3 & 1) == 0) {
pcVar2 = (char *)std::__cxx11::string::back();
if (*pcVar2 != '\\') goto LAB_001040c5;
std::__cxx11::string::pop_back();
/* try { // try from 00104072 to 001040d4 has its CatchHandler @ 001040ab */
std::__cxx11::string::operator+=(local_38,local_a0);
std::__cxx11::string::operator=(local_68,"> ");
}
else {
LAB_001040c5:
std::__cxx11::string::operator+=(local_38,local_a0);
local_41 = 0;
}
std::__cxx11::string::~string(local_a0);
} while( true );
}
| |
41,567 | my_uca_alloc_contractions | eloqsql/strings/ctype-uca.c | static my_bool
my_uca_alloc_contractions(MY_CONTRACTIONS *contractions,
MY_CHARSET_LOADER *loader, size_t n)
{
size_t size= n * sizeof(MY_CONTRACTION);
if (!(contractions->item= (loader->once_alloc)(size)) ||
!(contractions->flags= (char *) (loader->once_alloc)(MY_UCA_CNT_FLAG_SIZE)))
return 1;
memset(contractions->item, 0, size);
memset(contractions->flags, 0, MY_UCA_CNT_FLAG_SIZE);
return 0;
} | O0 | c | my_uca_alloc_contractions:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
imulq $0x58, -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x80(%rax), %rax
movq -0x28(%rbp), %rdi
callq *%rax
movq -0x10(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
je 0x503a9
movq -0x18(%rbp), %rax
movl $0x1000, %edi # imm = 0x1000
callq *0x80(%rax)
movq -0x10(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0x503af
movb $0x1, -0x1(%rbp)
jmp 0x503da
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rdx
xorl %esi, %esi
callq 0x24190
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
xorl %esi, %esi
movl $0x1000, %edx # imm = 0x1000
callq 0x24190
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_uca_alloc_contractions:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
imul rax, [rbp+var_20], 58h ; 'X'
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov rax, [rax+80h]
mov rdi, [rbp+var_28]
call rax
mov rcx, [rbp+var_10]
mov [rcx+8], rax
cmp rax, 0
jz short loc_503A9
mov rax, [rbp+var_18]
mov edi, 1000h
call qword ptr [rax+80h]
mov rcx, [rbp+var_10]
mov [rcx+10h], rax
cmp rax, 0
jnz short loc_503AF
loc_503A9:
mov [rbp+var_1], 1
jmp short loc_503DA
loc_503AF:
mov rax, [rbp+var_10]
mov rdi, [rax+8]
mov rdx, [rbp+var_28]
xor esi, esi
call _memset
mov rax, [rbp+var_10]
mov rdi, [rax+10h]
xor esi, esi
mov edx, 1000h
call _memset
mov [rbp+var_1], 0
loc_503DA:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
| char my_uca_alloc_contractions(long long a1, long long a2, long long a3)
{
long long v3; // rax
long long v4; // rax
long long v6; // [rsp+8h] [rbp-28h]
v6 = 88 * a3;
v3 = (*(long long ( **)(long long))(a2 + 128))(88 * a3);
*(_QWORD *)(a1 + 8) = v3;
if ( !v3 )
return 1;
v4 = (*(long long ( **)(long long))(a2 + 128))(4096LL);
*(_QWORD *)(a1 + 16) = v4;
if ( !v4 )
return 1;
memset(*(_QWORD *)(a1 + 8), 0LL, v6);
memset(*(_QWORD *)(a1 + 16), 0LL, 4096LL);
return 0;
}
| my_uca_alloc_contractions:
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
IMUL RAX,qword ptr [RBP + -0x20],0x58
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x80]
MOV RDI,qword ptr [RBP + -0x28]
CALL RAX
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x8],RAX
CMP RAX,0x0
JZ 0x001503a9
MOV RAX,qword ptr [RBP + -0x18]
MOV EDI,0x1000
CALL qword ptr [RAX + 0x80]
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x10],RAX
CMP RAX,0x0
JNZ 0x001503af
LAB_001503a9:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001503da
LAB_001503af:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x8]
MOV RDX,qword ptr [RBP + -0x28]
XOR ESI,ESI
CALL 0x00124190
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x10]
XOR ESI,ESI
MOV EDX,0x1000
CALL 0x00124190
MOV byte ptr [RBP + -0x1],0x0
LAB_001503da:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 my_uca_alloc_contractions(long param_1,long param_2,long param_3)
{
long lVar1;
lVar1 = (**(code **)(param_2 + 0x80))(param_3 * 0x58);
*(long *)(param_1 + 8) = lVar1;
if (lVar1 != 0) {
lVar1 = (**(code **)(param_2 + 0x80))(0x1000);
*(long *)(param_1 + 0x10) = lVar1;
if (lVar1 != 0) {
memset(*(void **)(param_1 + 8),0,param_3 * 0x58);
memset(*(void **)(param_1 + 0x10),0,0x1000);
return 0;
}
}
return 1;
}
| |
41,568 | R3D_SetLightOuterCutOff | r3d/src/r3d_lighting.c | void R3D_SetLightOuterCutOff(R3D_Light id, float degrees)
{
r3d_get_and_check_light(light, id);
light->outerCutOff = cosf(degrees * DEG2RAD);
} | O3 | c | R3D_SetLightOuterCutOff:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %edx
testl %edi, %edi
je 0xbeba7
leaq 0x1039d2(%rip), %rax # 0x1c2540
cmpl %edx, 0x168(%rax)
jbe 0xbeba7
movq 0x128(%rax), %rcx
leal -0x1(%rdx), %ebx
cmpb $0x1, (%rcx,%rbx)
jne 0xbeba7
movq 0x108(%rax), %r14
cmpq %rbx, 0x110(%rax)
setbe %cl
testq %r14, %r14
sete %sil
orb %cl, %sil
cmpb $0x1, %sil
jne 0xbebbe
leaq 0x54233(%rip), %rsi # 0x112de1
movl $0x5, %edi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0xaa1bd
imulq 0x120(%rax), %rbx
mulss 0x24446(%rip), %xmm0 # 0xe3014
callq 0x8270
movss %xmm0, 0xac(%r14,%rbx)
popq %rbx
popq %r14
popq %rbp
retq
| R3D_SetLightOuterCutOff:
push rbp
mov rbp, rsp
push r14
push rbx
mov edx, edi
test edi, edi
jz short loc_BEBA7
lea rax, R3D
cmp [rax+168h], edx
jbe short loc_BEBA7
mov rcx, [rax+128h]
lea ebx, [rdx-1]
cmp byte ptr [rcx+rbx], 1
jnz short loc_BEBA7
mov r14, [rax+108h]
cmp [rax+110h], rbx
setbe cl
test r14, r14
setz sil
or sil, cl
cmp sil, 1
jnz short loc_BEBBE
loc_BEBA7:
lea rsi, aLightIdIIsNotV; "Light [ID %i] is not valid"
mov edi, 5
xor eax, eax
pop rbx
pop r14
pop rbp
jmp TraceLog
loc_BEBBE:
imul rbx, [rax+120h]
mulss xmm0, cs:dword_E3014
call _cosf
movss dword ptr [r14+rbx+0ACh], xmm0
pop rbx
pop r14
pop rbp
retn
| void R3D_SetLightOuterCutOff(unsigned int a1, double a2)
{
unsigned long long v2; // rbx
long long v3; // r14
long long v4; // rbx
if ( a1
&& *((_DWORD *)&R3D + 90) > a1
&& (v2 = a1 - 1, *(_BYTE *)(*((_QWORD *)&R3D + 37) + v2) == 1)
&& (v3 = *((_QWORD *)&R3D + 33), *((_QWORD *)&R3D + 34) > v2 && v3 != 0) )
{
v4 = *((_QWORD *)&R3D + 36) * v2;
*(float *)&a2 = *(float *)&a2 * 0.017453292;
*(float *)(v3 + v4 + 172) = cosf(a2);
}
else
{
TraceLog(5, (long long)"Light [ID %i] is not valid", a1);
}
}
| R3D_SetLightOuterCutOff:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV EDX,EDI
TEST EDI,EDI
JZ 0x001beba7
LEA RAX,[0x2c2540]
CMP dword ptr [RAX + 0x168],EDX
JBE 0x001beba7
MOV RCX,qword ptr [RAX + 0x128]
LEA EBX,[RDX + -0x1]
CMP byte ptr [RCX + RBX*0x1],0x1
JNZ 0x001beba7
MOV R14,qword ptr [RAX + 0x108]
CMP qword ptr [RAX + 0x110],RBX
SETBE CL
TEST R14,R14
SETZ SIL
OR SIL,CL
CMP SIL,0x1
JNZ 0x001bebbe
LAB_001beba7:
LEA RSI,[0x212de1]
MOV EDI,0x5
XOR EAX,EAX
POP RBX
POP R14
POP RBP
JMP 0x001aa1bd
LAB_001bebbe:
IMUL RBX,qword ptr [RAX + 0x120]
MULSS XMM0,dword ptr [0x001e3014]
CALL 0x00108270
MOVSS dword ptr [R14 + RBX*0x1 + 0xac],XMM0
POP RBX
POP R14
POP RBP
RET
|
void R3D_SetLightOuterCutOff(float param_1,uint param_2)
{
long lVar1;
ulong uVar2;
long lVar3;
float fVar4;
lVar1 = DAT_002c2648;
if ((param_2 != 0) && (param_2 < DAT_002c26a8)) {
uVar2 = (ulong)(param_2 - 1);
if (*(char *)(DAT_002c2668 + uVar2) == '\x01') {
if (DAT_002c2648 != 0 && uVar2 < DAT_002c2650) {
lVar3 = uVar2 * DAT_002c2660;
fVar4 = cosf(param_1 * DAT_001e3014);
*(float *)(lVar1 + 0xac + lVar3) = fVar4;
return;
}
}
}
TraceLog(5,"Light [ID %i] is not valid");
return;
}
| |
41,569 | get_dynamic | eloqsql/mysys/array.c | void get_dynamic(DYNAMIC_ARRAY *array, void *element, uint idx)
{
if (idx >= array->elements)
{
DBUG_PRINT("warning",("To big array idx: %d, array size is %d",
idx,array->elements));
bzero(element,array->size_of_element);
return;
}
memcpy(element,array->buffer+idx*array->size_of_element,
(size_t) array->size_of_element);
} | O0 | c | get_dynamic:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jb 0x6eaa9
jmp 0x6ea91
jmp 0x6ea93
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x362e0
jmp 0x6ead2
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
addq %rax, %rsi
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, %edx
callq 0x360b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| get_dynamic:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov eax, [rbp+var_14]
mov rcx, [rbp+var_8]
cmp eax, [rcx+8]
jb short loc_6EAA9
jmp short $+2
loc_6EA91:
jmp short $+2
loc_6EA93:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_8]
mov eax, [rax+14h]
mov edx, eax
xor esi, esi
call _memset
jmp short loc_6EAD2
loc_6EAA9:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_8]
mov rsi, [rax]
mov eax, [rbp+var_14]
mov rcx, [rbp+var_8]
imul eax, [rcx+14h]
mov eax, eax
add rsi, rax
mov rax, [rbp+var_8]
mov eax, [rax+14h]
mov edx, eax
call _memcpy
loc_6EAD2:
add rsp, 20h
pop rbp
retn
| long long get_dynamic(long long a1, long long a2, unsigned int a3)
{
if ( a3 < *(_DWORD *)(a1 + 8) )
return memcpy(a2, *(_DWORD *)(a1 + 20) * a3 + *(_QWORD *)a1, *(unsigned int *)(a1 + 20));
else
return memset(a2, 0LL, *(unsigned int *)(a1 + 20));
}
| get_dynamic:
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
MOV EAX,dword ptr [RBP + -0x14]
MOV RCX,qword ptr [RBP + -0x8]
CMP EAX,dword ptr [RCX + 0x8]
JC 0x0016eaa9
JMP 0x0016ea91
LAB_0016ea91:
JMP 0x0016ea93
LAB_0016ea93:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x14]
MOV EDX,EAX
XOR ESI,ESI
CALL 0x001362e0
JMP 0x0016ead2
LAB_0016eaa9:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x14]
MOV RCX,qword ptr [RBP + -0x8]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
ADD RSI,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x14]
MOV EDX,EAX
CALL 0x001360b0
LAB_0016ead2:
ADD RSP,0x20
POP RBP
RET
|
void get_dynamic(long *param_1,void *param_2,uint param_3)
{
if (param_3 < *(uint *)(param_1 + 1)) {
memcpy(param_2,(void *)(*param_1 + (ulong)(param_3 * *(int *)((long)param_1 + 0x14))),
(ulong)*(uint *)((long)param_1 + 0x14));
}
else {
memset(param_2,0,(ulong)*(uint *)((long)param_1 + 0x14));
}
return;
}
| |
41,570 | minja::Context::get(minja::Value const&) | monkey531[P]llama/common/minja.hpp | virtual Value get(const Value & key) {
if (values_.contains(key)) return values_.at(key);
if (parent_) return parent_->get(key);
return Value();
} | O3 | cpp | minja::Context::get(minja::Value const&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rsi), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x9305a
testb %al, %al
je 0x9c78a
movq %r12, %rdi
movq %r14, %rsi
callq 0x92e48
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8d494
jmp 0x9c7dd
movq 0x68(%r15), %rsi
testq %rsi, %rsi
je 0x9c7a1
movq (%rsi), %rax
movq %rbx, %rdi
movq %r14, %rdx
callq *0x10(%rax)
jmp 0x9c7dd
leaq 0x40(%rbx), %r14
movq $0x0, 0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
movb $0x0, 0x40(%rbx)
movq %r14, %rdi
movl $0x1, %esi
callq 0x5834c
movq %r14, %rdi
movl $0x1, %esi
callq 0x5834c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| _ZN5minja7Context3getERKNS_5ValueE:
push r15
push r14
push r12
push rbx
push rax
mov r14, rdx
mov r15, rsi
mov rbx, rdi
lea r12, [rsi+18h]
mov rdi, r12; this
mov rsi, rdx; minja::Value *
call _ZNK5minja5Value8containsERKS0_; minja::Value::contains(minja::Value const&)
test al, al
jz short loc_9C78A
mov rdi, r12; this
mov rsi, r14; minja::Value *
call _ZN5minja5Value2atERKS0_; minja::Value::at(minja::Value const&)
mov rdi, rbx; this
mov rsi, rax; minja::Value *
call _ZN5minja5ValueC2ERKS0_; minja::Value::Value(minja::Value const&)
jmp short loc_9C7DD
loc_9C78A:
mov rsi, [r15+68h]
test rsi, rsi
jz short loc_9C7A1
mov rax, [rsi]
mov rdi, rbx
mov rdx, r14
call qword ptr [rax+10h]
jmp short loc_9C7DD
loc_9C7A1:
lea r14, [rbx+40h]
mov qword ptr [rbx+48h], 0
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
movups xmmword ptr [rbx+10h], xmm0
movups xmmword ptr [rbx+20h], xmm0
movups xmmword ptr [rbx+30h], xmm0
mov byte ptr [rbx+40h], 0
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)
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)
loc_9C7DD:
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| minja::Context * minja::Context::get(
minja::Context *this,
const minja::Value *a2,
const minja::Value *a3,
__m128d a4)
{
const minja::Value *v5; // rax
long long v6; // rsi
if ( minja::Value::contains((const minja::Value *)((char *)a2 + 24), a3, a4) )
{
v5 = (const minja::Value *)minja::Value::at((const minja::Value *)((char *)a2 + 24), a3);
minja::Value::Value(this, v5);
}
else
{
v6 = *((_QWORD *)a2 + 13);
if ( v6 )
{
(*(void ( **)(minja::Context *, long long, const minja::Value *))(*(_QWORD *)v6 + 16LL))(this, v6, a3);
}
else
{
*((_QWORD *)this + 9) = 0LL;
*(_OWORD *)this = 0LL;
*((_OWORD *)this + 1) = 0LL;
*((_OWORD *)this + 2) = 0LL;
*((_OWORD *)this + 3) = 0LL;
*((_BYTE *)this + 64) = 0;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)this + 64);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)this + 64);
}
}
return this;
}
| get:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
LEA R12,[RSI + 0x18]
MOV RDI,R12
MOV RSI,RDX
CALL 0x0019305a
TEST AL,AL
JZ 0x0019c78a
MOV RDI,R12
MOV RSI,R14
CALL 0x00192e48
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0018d494
JMP 0x0019c7dd
LAB_0019c78a:
MOV RSI,qword ptr [R15 + 0x68]
TEST RSI,RSI
JZ 0x0019c7a1
MOV RAX,qword ptr [RSI]
MOV RDI,RBX
MOV RDX,R14
CALL qword ptr [RAX + 0x10]
JMP 0x0019c7dd
LAB_0019c7a1:
LEA R14,[RBX + 0x40]
MOV qword ptr [RBX + 0x48],0x0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOVUPS xmmword ptr [RBX + 0x20],XMM0
MOVUPS xmmword ptr [RBX + 0x30],XMM0
MOV byte ptr [RBX + 0x40],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x0015834c
MOV RDI,R14
MOV ESI,0x1
CALL 0x0015834c
LAB_0019c7dd:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* minja::Context::get(minja::Value const&) */
Value * minja::Context::get(Value *param_1)
{
char cVar1;
Value *pVVar2;
Value *in_RDX;
long in_RSI;
bool bVar3;
cVar1 = Value::contains((Value *)(in_RSI + 0x18),in_RDX);
if (cVar1 == '\0') {
if (*(long **)(in_RSI + 0x68) == (long *)0x0) {
bVar3 = (bool)((char)param_1 + '@');
*(int8 *)(param_1 + 0x48) = 0;
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(param_1 + 0x18) = 0;
*(int8 *)(param_1 + 0x20) = 0;
*(int8 *)(param_1 + 0x28) = 0;
*(int8 *)(param_1 + 0x30) = 0;
*(int8 *)(param_1 + 0x38) = 0;
param_1[0x40] = (Value)0x0;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar3);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar3);
}
else {
(**(code **)(**(long **)(in_RSI + 0x68) + 0x10))(param_1);
}
}
else {
pVVar2 = (Value *)Value::at((Value *)(in_RSI + 0x18),in_RDX);
Value::Value(param_1,pVVar2);
}
return param_1;
}
| |
41,571 | my_fwrite | eloqsql/mysys/my_fstream.c | size_t my_fwrite(FILE *stream, const uchar *Buffer, size_t Count, myf MyFlags)
{
size_t writtenbytes =0;
my_off_t seekptr;
#if !defined(NO_BACKGROUND) && defined(USE_MY_STREAM)
uint errors;
#endif
DBUG_ENTER("my_fwrite");
DBUG_PRINT("my",("stream:%p Buffer:%p Count: %u MyFlags: %lu",
stream, Buffer, (uint) Count, MyFlags));
#if !defined(NO_BACKGROUND) && defined(USE_MY_STREAM)
errors=0;
#endif
seekptr= ftell(stream);
for (;;)
{
size_t written;
if ((written = (size_t) fwrite((char*) Buffer,sizeof(char),
Count, stream)) != Count)
{
DBUG_PRINT("error",("Write only %d bytes", (int) writtenbytes));
my_errno=errno;
if (written != (size_t) -1)
{
seekptr+=written;
Buffer+=written;
writtenbytes+=written;
Count-=written;
}
#ifdef EINTR
if (errno == EINTR)
{
(void) my_fseek(stream,seekptr,MY_SEEK_SET,MYF(0));
continue;
}
#endif
#if !defined(NO_BACKGROUND) && defined(USE_MY_STREAM)
if (my_thread_var->abort)
MyFlags&= ~ MY_WAIT_IF_FULL; /* End if aborted by user */
if ((errno == ENOSPC || errno == EDQUOT) &&
(MyFlags & MY_WAIT_IF_FULL))
{
wait_for_free_space("[stream]", errors);
errors++;
(void) my_fseek(stream,seekptr,MY_SEEK_SET,MYF(0));
continue;
}
#endif
if (ferror(stream) || (MyFlags & (MY_NABP | MY_FNABP)))
{
if (MyFlags & (MY_WME | MY_FAE | MY_FNABP))
{
my_error(EE_WRITE, MYF(ME_BELL),
my_filename(my_fileno(stream)), errno);
}
writtenbytes= (size_t) -1; /* Return that we got error */
break;
}
}
if (MyFlags & (MY_NABP | MY_FNABP))
writtenbytes= 0; /* Everything OK */
else
writtenbytes+= written;
break;
}
DBUG_RETURN(writtenbytes);
} | O3 | c | my_fwrite:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, -0x30(%rbp)
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
callq 0x36cb0
movq %rax, %r13
movl $0x1, %esi
movq %rbx, -0x48(%rbp)
movq %rbx, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq 0x36b20
cmpq %r12, %rax
jne 0x5e29f
movq $0x0, -0x38(%rbp)
jmp 0x5e337
movq %rax, %r15
movq $0x0, -0x38(%rbp)
callq 0x36a10
movq %rax, -0x40(%rbp)
movq %r14, %rbx
movq -0x40(%rbp), %rax
movl (%rax), %r14d
callq 0x62622
movl %r14d, (%rax)
movq %r13, %rsi
cmpq $-0x1, %r15
je 0x5e2dc
addq %r15, %rsi
addq %r15, -0x48(%rbp)
addq %r15, -0x38(%rbp)
subq %r15, %r12
movq -0x40(%rbp), %rax
cmpl $0x4, (%rax)
movq %rbx, %r14
movq %rbx, %rdi
jne 0x5e31f
movq %rsi, %r13
xorl %edx, %edx
callq 0x36060
testl %eax, %eax
jne 0x5e301
movq %r14, %rdi
callq 0x36cb0
movl $0x1, %esi
movq -0x48(%rbp), %rdi
movq %r12, %rdx
movq %r14, %rcx
callq 0x36b20
movq %rax, %r15
cmpq %r12, %rax
jne 0x5e2b3
jmp 0x5e337
callq 0x367f0
testl %eax, %eax
sete %al
testb $0x6, -0x30(%rbp)
sete %cl
movq %r15, %r12
testb %al, %cl
je 0x5e357
addq -0x38(%rbp), %r12
xorl %ebx, %ebx
testb $0x6, -0x30(%rbp)
cmoveq %r12, %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq $-0x1, %rbx
testb $0x1a, -0x30(%rbp)
je 0x5e345
movq %r14, %rdi
callq 0x36c00
movl %eax, %edi
callq 0x651f8
movq -0x40(%rbp), %rcx
movl (%rcx), %ecx
movl $0x4, %esi
movl $0x3, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x5da6b
jmp 0x5e345
| my_fwrite:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov [rbp+var_30], rcx
mov r12, rdx
mov rbx, rsi
mov r14, rdi
call _ftello64
mov r13, rax
mov esi, 1
mov [rbp+var_48], rbx
mov rdi, rbx
mov rdx, r12
mov rcx, r14
call _fwrite
cmp rax, r12
jnz short loc_5E29F
mov [rbp+var_38], 0
jmp loc_5E337
loc_5E29F:
mov r15, rax
mov [rbp+var_38], 0
call ___errno_location
mov [rbp+var_40], rax
loc_5E2B3:
mov rbx, r14
mov rax, [rbp+var_40]
mov r14d, [rax]
call _my_thread_var
mov [rax], r14d
mov rsi, r13
cmp r15, 0FFFFFFFFFFFFFFFFh
jz short loc_5E2DC
add rsi, r15
add [rbp+var_48], r15
add [rbp+var_38], r15
sub r12, r15
loc_5E2DC:
mov rax, [rbp+var_40]
cmp dword ptr [rax], 4
mov r14, rbx
mov rdi, rbx
jnz short loc_5E31F
mov r13, rsi
xor edx, edx
call _fseeko64
test eax, eax
jnz short loc_5E301
mov rdi, r14
call _ftello64
loc_5E301:
mov esi, 1
mov rdi, [rbp+var_48]
mov rdx, r12
mov rcx, r14
call _fwrite
mov r15, rax
cmp rax, r12
jnz short loc_5E2B3
jmp short loc_5E337
loc_5E31F:
call _ferror
test eax, eax
setz al
test byte ptr [rbp+var_30], 6
setz cl
mov r12, r15
test cl, al
jz short loc_5E357
loc_5E337:
add r12, [rbp+var_38]
xor ebx, ebx
test byte ptr [rbp+var_30], 6
cmovz rbx, r12
loc_5E345:
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_5E357:
mov rbx, 0FFFFFFFFFFFFFFFFh
test byte ptr [rbp+var_30], 1Ah
jz short loc_5E345
mov rdi, r14
call _fileno
mov edi, eax
call my_filename
mov rcx, [rbp+var_40]
mov ecx, [rcx]
mov esi, 4
mov edi, 3
mov rdx, rax
xor eax, eax
call my_error
jmp short loc_5E345
| long long my_fwrite(long long a1, long long a2, long long a3, char a4)
{
long long v6; // r13
long long v7; // rdi
long long v8; // rax
long long v9; // r15
long long v10; // rbx
unsigned int v11; // r14d
long long v12; // rsi
long long v13; // r12
long long v14; // rbx
unsigned int v16; // eax
long long v17; // rax
long long v18; // [rsp+8h] [rbp-48h]
unsigned int *v19; // [rsp+10h] [rbp-40h]
long long v20; // [rsp+18h] [rbp-38h]
v6 = ((long long (*)(void))ftello64)();
v18 = a2;
v7 = a2;
v8 = fwrite(a2, 1LL, a3, a1);
if ( v8 == a3 )
{
v20 = 0LL;
LABEL_12:
v13 = v20 + a3;
v14 = 0LL;
if ( (a4 & 6) == 0 )
return v13;
return v14;
}
v9 = v8;
v20 = 0LL;
v19 = (unsigned int *)__errno_location(a2);
while ( 1 )
{
v10 = a1;
v11 = *v19;
*(_DWORD *)my_thread_var(v7) = v11;
v12 = v6;
if ( v9 != -1 )
{
v12 = v9 + v6;
v18 += v9;
v20 += v9;
a3 -= v9;
}
a1 = v10;
if ( *v19 != 4 )
break;
v6 = v12;
if ( !(unsigned int)fseeko64(v10, v12, 0LL) )
ftello64(v10);
v7 = v18;
v9 = fwrite(v18, 1LL, a3, v10);
if ( v9 == a3 )
goto LABEL_12;
}
a3 = v9;
if ( (unsigned int)ferror(v10) == 0 && (a4 & 6) == 0 )
goto LABEL_12;
v14 = -1LL;
if ( (a4 & 0x1A) != 0 )
{
v16 = fileno(a1);
v17 = my_filename(v16);
my_error(3u, 4LL, v17, *v19);
}
return v14;
}
| my_fwrite:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x30],RCX
MOV R12,RDX
MOV RBX,RSI
MOV R14,RDI
CALL 0x00136cb0
MOV R13,RAX
MOV ESI,0x1
MOV qword ptr [RBP + -0x48],RBX
MOV RDI,RBX
MOV RDX,R12
MOV RCX,R14
CALL 0x00136b20
CMP RAX,R12
JNZ 0x0015e29f
MOV qword ptr [RBP + -0x38],0x0
JMP 0x0015e337
LAB_0015e29f:
MOV R15,RAX
MOV qword ptr [RBP + -0x38],0x0
CALL 0x00136a10
MOV qword ptr [RBP + -0x40],RAX
LAB_0015e2b3:
MOV RBX,R14
MOV RAX,qword ptr [RBP + -0x40]
MOV R14D,dword ptr [RAX]
CALL 0x00162622
MOV dword ptr [RAX],R14D
MOV RSI,R13
CMP R15,-0x1
JZ 0x0015e2dc
ADD RSI,R15
ADD qword ptr [RBP + -0x48],R15
ADD qword ptr [RBP + -0x38],R15
SUB R12,R15
LAB_0015e2dc:
MOV RAX,qword ptr [RBP + -0x40]
CMP dword ptr [RAX],0x4
MOV R14,RBX
MOV RDI,RBX
JNZ 0x0015e31f
MOV R13,RSI
XOR EDX,EDX
CALL 0x00136060
TEST EAX,EAX
JNZ 0x0015e301
MOV RDI,R14
CALL 0x00136cb0
LAB_0015e301:
MOV ESI,0x1
MOV RDI,qword ptr [RBP + -0x48]
MOV RDX,R12
MOV RCX,R14
CALL 0x00136b20
MOV R15,RAX
CMP RAX,R12
JNZ 0x0015e2b3
JMP 0x0015e337
LAB_0015e31f:
CALL 0x001367f0
TEST EAX,EAX
SETZ AL
TEST byte ptr [RBP + -0x30],0x6
SETZ CL
MOV R12,R15
TEST CL,AL
JZ 0x0015e357
LAB_0015e337:
ADD R12,qword ptr [RBP + -0x38]
XOR EBX,EBX
TEST byte ptr [RBP + -0x30],0x6
CMOVZ RBX,R12
LAB_0015e345:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0015e357:
MOV RBX,-0x1
TEST byte ptr [RBP + -0x30],0x1a
JZ 0x0015e345
MOV RDI,R14
CALL 0x00136c00
MOV EDI,EAX
CALL 0x001651f8
MOV RCX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RCX]
MOV ESI,0x4
MOV EDI,0x3
MOV RDX,RAX
XOR EAX,EAX
CALL 0x0015da6b
JMP 0x0015e345
|
long my_fwrite(FILE *param_1,void *param_2,size_t param_3,ulong param_4)
{
int iVar1;
__off64_t __off;
size_t sVar2;
int *piVar3;
int *piVar4;
int8 uVar5;
long lVar6;
void *local_50;
long local_40;
__off = ftello64(param_1);
sVar2 = fwrite(param_2,1,param_3,param_1);
if (sVar2 == param_3) {
local_40 = 0;
}
else {
local_40 = 0;
piVar3 = __errno_location();
local_50 = param_2;
do {
iVar1 = *piVar3;
piVar4 = (int *)_my_thread_var();
*piVar4 = iVar1;
if (sVar2 != 0xffffffffffffffff) {
__off = __off + sVar2;
local_50 = (void *)((long)local_50 + sVar2);
local_40 = local_40 + sVar2;
param_3 = param_3 - sVar2;
}
if (*piVar3 != 4) {
iVar1 = ferror(param_1);
param_3 = sVar2;
if ((param_4 & 6) != 0 || iVar1 != 0) {
if ((param_4 & 0x1a) == 0) {
return -1;
}
iVar1 = fileno(param_1);
uVar5 = my_filename(iVar1);
my_error(3,4,uVar5,*piVar3);
return -1;
}
break;
}
iVar1 = fseeko64(param_1,__off,0);
if (iVar1 == 0) {
ftello64(param_1);
}
sVar2 = fwrite(local_50,1,param_3,param_1);
} while (sVar2 != param_3);
}
lVar6 = 0;
if ((param_4 & 6) == 0) {
lVar6 = param_3 + local_40;
}
return lVar6;
}
| |
41,572 | 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 0x284fe2(%rip), %r14 # 0x2d77a0
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 0x527e6
testl %r13d, %r13d
je 0x52814
movl $0x9, %r8d
jmp 0x5280f
testl %r13d, %r13d
sete %r8b
cmpl $0x0, -0x70(%rbp)
setg %dil
xorl %eax, %eax
testb %r8b, %dil
je 0x528da
movl $0x1, %r13d
movl $0x9, %r8d
movq %rsi, %r15
movq %r14, %rax
jmp 0x52824
xorl %r13d, %r13d
movl $0x8, %r8d
leaq 0x284e7c(%rip), %rax # 0x2d76a0
movzbl (%r15), %edi
movb (%rax,%rdi), %al
cmpb $-0x1, %al
jne 0x528d4
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 0x29aced(%rip), %rax # 0x2ed550
movq (%r8,%rax), %r13
movb (%r13), %r10b
testb %r10b, %r10b
je 0x5289b
cmpq %rdx, %r11
jge 0x5289b
incq %r13
movq %rcx, %rbx
cmpb (%r15), %r10b
jne 0x528a0
incq %r15
movb (%r13), %r10b
testb %r10b, %r10b
je 0x5289b
leaq 0x1(%rbx), %rax
incq %r13
cmpq %rdx, %rbx
movq %rax, %rbx
jl 0x5287b
testb %r10b, %r10b
je 0x528b0
incq %rdi
cmpq $0x50, %rdi
movq %r12, %r15
jne 0x52855
movb $-0x1, %al
jmp 0x528c5
leaq 0x29ac99(%rip), %rax # 0x2ed550
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 0x528f1
testl %ebx, %ebx
je 0x5291e
movl $0x9, %r10d
jmp 0x52919
testl %ebx, %ebx
sete %dil
cmpl $0x0, -0x78(%rbp)
setg %r8b
xorl %r10d, %r10d
testb %dil, %r8b
je 0x52a18
movl $0x1, %ebx
movl $0x9, %r10d
movq %rcx, %r12
movq %r14, %r8
jmp 0x5292d
xorl %ebx, %ebx
movl $0x8, %r10d
leaq 0x284d73(%rip), %r8 # 0x2d76a0
movzbl (%r12), %edi
movb (%r8,%rdi), %dil
cmpb $-0x1, %dil
jne 0x52a11
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 0x29abdf(%rip), %rcx # 0x2ed550
movq (%r15,%rcx), %rbx
movb (%rbx), %r13b
testb %r13b, %r13b
je 0x529ac
cmpq %r9, %r14
jge 0x529ac
incq %rbx
movq %rsi, %rdi
movq %r11, %r10
cmpb (%r10), %r13b
jne 0x529b4
incq %r10
movb (%rbx), %r13b
testb %r13b, %r13b
je 0x529af
leaq 0x1(%rdi), %r12
incq %rbx
cmpq %r9, %rdi
movq %r12, %rdi
jl 0x5298b
jmp 0x529af
movq %r11, %r10
testb %r13b, %r13b
je 0x529df
incq %r8
cmpq $0x50, %r8
jne 0x52963
movb $-0x1, %dil
movq -0x48(%rbp), %rcx
movq -0x58(%rbp), %rsi
leaq 0x284dd1(%rip), %r14 # 0x2d77a0
movq -0x40(%rbp), %r13
movl -0x2c(%rbp), %ebx
movq -0x38(%rbp), %r15
movq %r11, %r12
jmp 0x52a11
leaq 0x29ab6a(%rip), %rcx # 0x2ed550
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 0x284d9a(%rip), %r14 # 0x2d77a0
movq -0x40(%rbp), %r13
movl -0x2c(%rbp), %ebx
movq -0x38(%rbp), %r15
movzbl %dil, %r10d
incq %r12
testl %eax, %eax
je 0x52a25
cmpl %r10d, %eax
je 0x527ce
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_527CE:
mov rax, r15
sub rax, rsi
cmp rax, rdx
jge short loc_527E6
test r13d, r13d
jz short loc_52814
mov r8d, 9
jmp short loc_5280F
loc_527E6:
test r13d, r13d
setz r8b
cmp dword ptr [rbp+var_70], 0
setnle dil
xor eax, eax
test dil, r8b
jz loc_528DA
mov r13d, 1
mov r8d, 9
mov r15, rsi
loc_5280F:
mov rax, r14
jmp short loc_52824
loc_52814:
xor r13d, r13d
mov r8d, 8
lea rax, _sort_order_win1250ch1
loc_52824:
movzx edi, byte ptr [r15]
mov al, [rax+rdi]
cmp al, 0FFh
jnz loc_528D4
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_52855:
mov r8, rdi
shl r8, 4
lea rax, doubles_0
mov r13, [r8+rax]
mov r10b, [r13+0]
test r10b, r10b
jz short loc_5289B
cmp r11, rdx
jge short loc_5289B
inc r13
mov rbx, rcx
loc_5287B:
cmp r10b, [r15]
jnz short loc_528A0
inc r15
mov r10b, [r13+0]
test r10b, r10b
jz short loc_5289B
lea rax, [rbx+1]
inc r13
cmp rbx, rdx
mov rbx, rax
jl short loc_5287B
loc_5289B:
test r10b, r10b
jz short loc_528B0
loc_528A0:
inc rdi
cmp rdi, 50h ; 'P'
mov r15, r12
jnz short loc_52855
mov al, 0FFh
jmp short loc_528C5
loc_528B0:
lea rax, doubles_0
add r8, rax
mov rax, [rbp+var_50]
mov al, [r8+rax]
dec r15
loc_528C5:
mov rcx, [rbp+var_48]
mov r13, [rbp+var_40]
mov ebx, [rbp+var_2C]
mov r12, [rbp+var_38]
loc_528D4:
movzx eax, al
inc r15
loc_528DA:
mov rdi, r12
sub rdi, rcx
cmp rdi, r9
jge short loc_528F1
test ebx, ebx
jz short loc_5291E
mov r10d, 9
jmp short loc_52919
loc_528F1:
test ebx, ebx
setz dil
cmp dword ptr [rbp+var_78], 0
setnle r8b
xor r10d, r10d
test r8b, dil
jz loc_52A18
mov ebx, 1
mov r10d, 9
mov r12, rcx
loc_52919:
mov r8, r14
jmp short loc_5292D
loc_5291E:
xor ebx, ebx
mov r10d, 8
lea r8, _sort_order_win1250ch1
loc_5292D:
movzx edi, byte ptr [r12]
mov dil, [r8+rdi]
cmp dil, 0FFh
jnz loc_52A11
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_52963:
mov r15, r8
shl r15, 4
lea rcx, doubles_0
mov rbx, [r15+rcx]
mov r13b, [rbx]
test r13b, r13b
jz short loc_529AC
cmp r14, r9
jge short loc_529AC
inc rbx
mov rdi, rsi
mov r10, r11
loc_5298B:
cmp r13b, [r10]
jnz short loc_529B4
inc r10
mov r13b, [rbx]
test r13b, r13b
jz short loc_529AF
lea r12, [rdi+1]
inc rbx
cmp rdi, r9
mov rdi, r12
jl short loc_5298B
jmp short loc_529AF
loc_529AC:
mov r10, r11
loc_529AF:
test r13b, r13b
jz short loc_529DF
loc_529B4:
inc r8
cmp r8, 50h ; 'P'
jnz short loc_52963
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_52A11
loc_529DF:
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_52A11:
movzx r10d, dil
inc r12
loc_52A18:
test eax, eax
jz short loc_52A25
cmp eax, r10d
jz loc_527CE
loc_52A25:
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,[0x3d77a0]
MOV R15,RSI
MOV R12,RCX
XOR EBX,EBX
MOV qword ptr [RBP + -0x48],RCX
MOV qword ptr [RBP + -0x58],RSI
LAB_001527ce:
MOV RAX,R15
SUB RAX,RSI
CMP RAX,RDX
JGE 0x001527e6
TEST R13D,R13D
JZ 0x00152814
MOV R8D,0x9
JMP 0x0015280f
LAB_001527e6:
TEST R13D,R13D
SETZ R8B
CMP dword ptr [RBP + -0x70],0x0
SETG DIL
XOR EAX,EAX
TEST DIL,R8B
JZ 0x001528da
MOV R13D,0x1
MOV R8D,0x9
MOV R15,RSI
LAB_0015280f:
MOV RAX,R14
JMP 0x00152824
LAB_00152814:
XOR R13D,R13D
MOV R8D,0x8
LEA RAX,[0x3d76a0]
LAB_00152824:
MOVZX EDI,byte ptr [R15]
MOV AL,byte ptr [RAX + RDI*0x1]
CMP AL,0xff
JNZ 0x001528d4
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_00152855:
MOV R8,RDI
SHL R8,0x4
LEA RAX,[0x3ed550]
MOV R13,qword ptr [R8 + RAX*0x1]
MOV R10B,byte ptr [R13]
TEST R10B,R10B
JZ 0x0015289b
CMP R11,RDX
JGE 0x0015289b
INC R13
MOV RBX,RCX
LAB_0015287b:
CMP R10B,byte ptr [R15]
JNZ 0x001528a0
INC R15
MOV R10B,byte ptr [R13]
TEST R10B,R10B
JZ 0x0015289b
LEA RAX,[RBX + 0x1]
INC R13
CMP RBX,RDX
MOV RBX,RAX
JL 0x0015287b
LAB_0015289b:
TEST R10B,R10B
JZ 0x001528b0
LAB_001528a0:
INC RDI
CMP RDI,0x50
MOV R15,R12
JNZ 0x00152855
MOV AL,0xff
JMP 0x001528c5
LAB_001528b0:
LEA RAX,[0x3ed550]
ADD R8,RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV AL,byte ptr [R8 + RAX*0x1]
DEC R15
LAB_001528c5:
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_001528d4:
MOVZX EAX,AL
INC R15
LAB_001528da:
MOV RDI,R12
SUB RDI,RCX
CMP RDI,R9
JGE 0x001528f1
TEST EBX,EBX
JZ 0x0015291e
MOV R10D,0x9
JMP 0x00152919
LAB_001528f1:
TEST EBX,EBX
SETZ DIL
CMP dword ptr [RBP + -0x78],0x0
SETG R8B
XOR R10D,R10D
TEST R8B,DIL
JZ 0x00152a18
MOV EBX,0x1
MOV R10D,0x9
MOV R12,RCX
LAB_00152919:
MOV R8,R14
JMP 0x0015292d
LAB_0015291e:
XOR EBX,EBX
MOV R10D,0x8
LEA R8,[0x3d76a0]
LAB_0015292d:
MOVZX EDI,byte ptr [R12]
MOV DIL,byte ptr [R8 + RDI*0x1]
CMP DIL,0xff
JNZ 0x00152a11
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_00152963:
MOV R15,R8
SHL R15,0x4
LEA RCX,[0x3ed550]
MOV RBX,qword ptr [R15 + RCX*0x1]
MOV R13B,byte ptr [RBX]
TEST R13B,R13B
JZ 0x001529ac
CMP R14,R9
JGE 0x001529ac
INC RBX
MOV RDI,RSI
MOV R10,R11
LAB_0015298b:
CMP R13B,byte ptr [R10]
JNZ 0x001529b4
INC R10
MOV R13B,byte ptr [RBX]
TEST R13B,R13B
JZ 0x001529af
LEA R12,[RDI + 0x1]
INC RBX
CMP RDI,R9
MOV RDI,R12
JL 0x0015298b
JMP 0x001529af
LAB_001529ac:
MOV R10,R11
LAB_001529af:
TEST R13B,R13B
JZ 0x001529df
LAB_001529b4:
INC R8
CMP R8,0x50
JNZ 0x00152963
MOV DIL,0xff
MOV RCX,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x58]
LEA R14,[0x3d77a0]
MOV R13,qword ptr [RBP + -0x40]
MOV EBX,dword ptr [RBP + -0x2c]
MOV R15,qword ptr [RBP + -0x38]
MOV R12,R11
JMP 0x00152a11
LAB_001529df:
LEA RCX,[0x3ed550]
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,[0x3d77a0]
MOV R13,qword ptr [RBP + -0x40]
MOV EBX,dword ptr [RBP + -0x2c]
MOV R15,qword ptr [RBP + -0x38]
LAB_00152a11:
MOVZX R10D,DIL
INC R12
LAB_00152a18:
TEST EAX,EAX
JZ 0x00152a25
CMP EAX,R10D
JZ 0x001527ce
LAB_00152a25:
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_0015280f:
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_001528a0;
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_001528d4;
}
LAB_001528a0:
lVar11 = lVar11 + 1;
} while (lVar11 != 0x50);
bVar6 = 0xff;
}
LAB_001528d4:
uVar8 = (uint)bVar6;
pbVar18 = pbVar18 + 1;
}
else {
uVar8 = 0;
if (0 < iVar7 && !bVar2) {
bVar2 = true;
pbVar18 = param_2;
goto LAB_0015280f;
}
}
if ((long)pbVar15 - (long)param_4 < (long)iVar12) {
if (bVar1) {
LAB_00152919:
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_001529b4;
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_00152a11;
}
LAB_001529b4:
lVar11 = lVar11 + 1;
} while (lVar11 != 0x50);
bVar6 = 0xff;
}
LAB_00152a11:
uVar13 = (uint)bVar6;
pbVar15 = pbVar15 + 1;
}
else {
uVar13 = 0;
if (0 < iVar12 && !bVar1) {
bVar1 = true;
pbVar15 = param_4;
goto LAB_00152919;
}
}
if ((uVar8 == 0) || (uVar8 != uVar13)) {
return uVar8 - uVar13;
}
} while( true );
}
| |
41,573 | Column_definition::set_attributes(THD*, Lex_field_type_st const&, charset_info_st const*, column_definition_type_t) | eloqsql/sql/field.cc | bool Column_definition::set_attributes(THD *thd,
const Lex_field_type_st &def,
CHARSET_INFO *cs,
column_definition_type_t type)
{
DBUG_ASSERT(type_handler() == &type_handler_null);
DBUG_ASSERT(charset == &my_charset_bin || charset == NULL);
DBUG_ASSERT(length == 0);
DBUG_ASSERT(decimals == 0);
set_handler(def.type_handler());
return type_handler()->Column_definition_set_attributes(thd, this,
def, cs, type);
} | O0 | cpp | Column_definition::set_attributes(THD*, Lex_field_type_st const&, charset_info_st const*, column_definition_type_t):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xcf3136
jmp 0xcf3138
jmp 0xcf313a
jmp 0xcf313c
jmp 0xcf313e
jmp 0xcf3140
jmp 0xcf3142
movq -0x18(%rbp), %rdi
callq 0x9d15e0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x913060
movq -0x30(%rbp), %rdi
callq 0x885e00
movq -0x30(%rbp), %rdx
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl -0x24(%rbp), %r9d
movq (%rdi), %rax
callq *0x228(%rax)
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ZN17Column_definition14set_attributesEP3THDRK17Lex_field_type_stPK15charset_info_st24column_definition_type_t:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_24], r8d
mov rax, [rbp+var_8]
mov [rbp+var_30], rax
jmp short $+2
loc_CF3136:
jmp short $+2
loc_CF3138:
jmp short $+2
loc_CF313A:
jmp short $+2
loc_CF313C:
jmp short $+2
loc_CF313E:
jmp short $+2
loc_CF3140:
jmp short $+2
loc_CF3142:
mov rdi, [rbp+var_18]; this
call _ZNK17Lex_field_type_st12type_handlerEv; Lex_field_type_st::type_handler(void)
mov rdi, [rbp+var_30]; this
mov rsi, rax; Type_handler *
call _ZN30Type_handler_hybrid_field_type11set_handlerEPK12Type_handler; Type_handler_hybrid_field_type::set_handler(Type_handler const*)
mov rdi, [rbp+var_30]; this
call _ZNK30Type_handler_hybrid_field_type12type_handlerEv; Type_handler_hybrid_field_type::type_handler(void)
mov rdx, [rbp+var_30]
mov rdi, rax
mov rsi, [rbp+var_10]
mov rcx, [rbp+var_18]
mov r8, [rbp+var_20]
mov r9d, [rbp+var_24]
mov rax, [rdi]
call qword ptr [rax+228h]
and al, 1
add rsp, 30h
pop rbp
retn
| char Column_definition::set_attributes(
Type_handler_hybrid_field_type *a1,
long long a2,
Lex_field_type_st *a3,
long long a4,
unsigned int a5)
{
const Type_handler *v5; // rax
long long v6; // rax
v5 = (const Type_handler *)Lex_field_type_st::type_handler(a3);
Type_handler_hybrid_field_type::set_handler(a1, v5);
v6 = Type_handler_hybrid_field_type::type_handler(a1);
return (*(long long ( **)(long long, long long, Type_handler_hybrid_field_type *, Lex_field_type_st *, long long, _QWORD))(*(_QWORD *)v6 + 552LL))(
v6,
a2,
a1,
a3,
a4,
a5) & 1;
}
| Item_func_div_fix_length_and_dec:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00d027c0
XOR EAX,EAX
AND AL,0x1
ADD RSP,0x10
POP RBP
RET
|
/* Type_handler_decimal_result::Item_func_div_fix_length_and_dec(Item_func_div*) const */
int8 __thiscall
Type_handler_decimal_result::Item_func_div_fix_length_and_dec
(Type_handler_decimal_result *this,Item_func_div *param_1)
{
Item_num_op::fix_length_and_dec_decimal((Item_num_op *)param_1);
return 0;
}
| |
41,574 | 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;
} | O1 | 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 0x7e66
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 0x4440
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 0x4310
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rbx, %rsi
callq 0x86ba
addq $0x8, %r14
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0xa2d8
movq %rax, %r14
leaq 0x20(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x7f09
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4460
testq %r14, %r14
je 0x7f32
movq 0x28(%r14), %r14
movl $0x80, %esi
movq %rbx, %rdi
callq 0x4460
movq %r14, %rax
addq $0x100, %rsp # imm = 0x100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x4250
movq %rax, %r14
leaq 0x4594(%rip), %rsi # 0xc4da
leaq 0x10(%rsp), %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x5b59
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x4670
xorl %ebp, %ebp
movq 0x9082(%rip), %rsi # 0x10ff0
movq 0x9053(%rip), %rdx # 0x10fc8
movq %r14, %rdi
callq 0x46e0
movq %rax, %r15
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x7f9f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4460
jmp 0x7f9f
movq %rax, %r15
movb $0x1, %bpl
testb %bpl, %bpl
je 0x7fd1
movq %r14, %rdi
callq 0x4360
jmp 0x7fd1
movq %rax, %r15
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7fd1
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4460
jmp 0x7fd1
movq %rax, %r15
movl $0x80, %esi
movq %rbx, %rdi
callq 0x4460
movq %r15, %rdi
callq 0x4730
| _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_7E66
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_7E66:
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_7F09
mov rsi, [rsp+128h+var_108]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7F09:
test r14, r14
jz short loc_7F32
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_7F32:
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_7F9F
mov rsi, [rsp+128h+var_108]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_7F9F
mov r15, rax
mov bpl, 1
loc_7F9F:
test bpl, bpl
jz short loc_7FD1
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_7FD1
mov r15, rax
lea rax, [rsp+128h+var_108]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_7FD1
mov rsi, [rsp+128h+var_108]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_7FD1
mov r15, rax
loc_7FD1:
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 0x00107e66
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_00107e66:
MOV EDI,0x80
CALL 0x00104440
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 0x00104310
LAB_00107ec7:
LEA RDI,[RSP + 0x10]
LEA RDX,[RSP + 0xf]
MOV RSI,RBX
CALL 0x001086ba
ADD R14,0x8
LAB_00107edd:
LEA RSI,[RSP + 0x10]
MOV RDI,R14
CALL 0x0010a2d8
LAB_00107eea:
MOV R14,RAX
LEA R12,[RSP + 0x20]
MOV RDI,qword ptr [R12 + -0x10]
CMP RDI,R12
JZ 0x00107f09
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x00104460
LAB_00107f09:
TEST R14,R14
JZ 0x00107f32
MOV R14,qword ptr [R14 + 0x28]
MOV ESI,0x80
MOV RDI,RBX
CALL 0x00104460
MOV RAX,R14
ADD RSP,0x100
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00107f32:
MOV EDI,0x10
CALL 0x00104250
MOV R14,RAX
LAB_00107f3f:
LEA RSI,[0x10c4da]
LEA RDI,[RSP + 0x10]
MOV RDX,RBX
XOR EAX,EAX
CALL 0x00105b59
MOV BPL,0x1
LAB_00107f58:
LEA RSI,[RSP + 0x10]
MOV RDI,R14
CALL 0x00104670
XOR EBP,EBP
MOV RSI,qword ptr [0x00110ff0]
MOV RDX,qword ptr [0x00110fc8]
MOV RDI,R14
CALL 0x001046e0
|
/* 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 00107ec7 to 00107ed8 has its CatchHandler @ 00107fce */
std::__cxx11::string::string<std::allocator<char>>((string *)local_118,__s,&local_119);
/* try { // try from 00107edd to 00107ee9 has its CatchHandler @ 00107fae */
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 00107f3f to 00107f54 has its CatchHandler @ 00107f99 */
string_format_abi_cxx11_((char *)local_118,"weight tensor not found: %s",__s);
/* try { // try from 00107f58 to 00107f7c has its CatchHandler @ 00107f7d */
std::runtime_error::runtime_error(this,(string *)local_118);
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_00110ff0,PTR__runtime_error_00110fc8);
}
| |
41,575 | JS_ObjectDefineProperties | bluesky950520[P]quickjs/quickjs.c | static __exception int JS_ObjectDefineProperties(JSContext *ctx,
JSValue obj,
JSValue properties)
{
JSValue props, desc;
JSObject *p;
JSPropertyEnum *atoms;
uint32_t len, i;
int ret = -1;
if (!JS_IsObject(obj)) {
JS_ThrowTypeError(ctx, "Object.defineProperties called on non-object");
return -1;
}
desc = JS_UNDEFINED;
props = JS_ToObject(ctx, properties);
if (JS_IsException(props))
return -1;
p = JS_VALUE_GET_OBJ(props);
if (JS_GetOwnPropertyNamesInternal(ctx, &atoms, &len, p, JS_GPN_ENUM_ONLY | JS_GPN_STRING_MASK | JS_GPN_SYMBOL_MASK) < 0)
goto exception;
// XXX: ECMA specifies that all descriptions should be validated before
// modifying the object. This would require allocating an array
// JSPropertyDescriptor and use 2 separate loops.
for(i = 0; i < len; i++) {
JS_FreeValue(ctx, desc);
desc = JS_GetProperty(ctx, props, atoms[i].atom);
if (JS_IsException(desc))
goto exception;
if (JS_DefinePropertyDesc(ctx, obj, atoms[i].atom, desc,
JS_PROP_THROW | JS_PROP_DEFINE_PROPERTY) < 0)
goto exception;
}
ret = 0;
exception:
js_free_prop_enum(ctx, atoms, len);
JS_FreeValue(ctx, props);
JS_FreeValue(ctx, desc);
return ret;
} | O0 | c | JS_ObjectDefineProperties:
subq $0xb8, %rsp
movq %rsi, 0xa0(%rsp)
movq %rdx, 0xa8(%rsp)
movq %rcx, 0x90(%rsp)
movq %r8, 0x98(%rsp)
movq %rdi, 0x88(%rsp)
movl $0xffffffff, 0x4c(%rsp) # imm = 0xFFFFFFFF
movq 0xa0(%rsp), %rdi
movq 0xa8(%rsp), %rsi
callq 0x2af70
cmpl $0x0, %eax
jne 0xc08d1
movq 0x88(%rsp), %rdi
leaq 0x501a3(%rip), %rsi # 0x110a53
movb $0x0, %al
callq 0x2d300
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movl $0xffffffff, 0xb4(%rsp) # imm = 0xFFFFFFFF
jmp 0xc0ac7
movl $0x0, 0x28(%rsp)
movq $0x3, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x88(%rsp), %rdi
movq 0x90(%rsp), %rsi
movq 0x98(%rsp), %rdx
callq 0x37770
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x78(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0xc095b
movl $0xffffffff, 0xb4(%rsp) # imm = 0xFFFFFFFF
jmp 0xc0ac7
movq 0x78(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x88(%rsp), %rdi
movq 0x60(%rsp), %rcx
leaq 0x58(%rsp), %rsi
leaq 0x54(%rsp), %rdx
movl $0x13, %r8d
callq 0x2f5e0
cmpl $0x0, %eax
jge 0xc0991
jmp 0xc0a75
movl $0x0, 0x50(%rsp)
movl 0x50(%rsp), %eax
cmpl 0x54(%rsp), %eax
jae 0xc0a6d
movq 0x88(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
callq 0x23c90
movq 0x88(%rsp), %rdi
movq 0x58(%rsp), %rax
movl 0x50(%rsp), %ecx
movl 0x4(%rax,%rcx,8), %ecx
movq 0x78(%rsp), %rsi
movq 0x80(%rsp), %rdx
callq 0x29d80
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x68(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0xc0a19
jmp 0xc0a75
movq 0x88(%rsp), %rdi
movq 0x58(%rsp), %rax
movl 0x50(%rsp), %ecx
movl 0x4(%rax,%rcx,8), %ecx
movq 0xa0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
movq 0x68(%rsp), %r8
movq 0x70(%rsp), %r9
movl $0x44000, (%rsp) # imm = 0x44000
callq 0xc0ae0
cmpl $0x0, %eax
jge 0xc0a5b
jmp 0xc0a75
jmp 0xc0a5d
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0xc0999
movl $0x0, 0x4c(%rsp)
movq 0x88(%rsp), %rdi
movq 0x58(%rsp), %rsi
movl 0x54(%rsp), %edx
callq 0x30a40
movq 0x88(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq 0x80(%rsp), %rdx
callq 0x23c90
movq 0x88(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
callq 0x23c90
movl 0x4c(%rsp), %eax
movl %eax, 0xb4(%rsp)
movl 0xb4(%rsp), %eax
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
| JS_ObjectDefineProperties:
sub rsp, 0B8h
mov [rsp+0B8h+var_18], rsi
mov [rsp+0B8h+var_10], rdx
mov [rsp+0B8h+var_28], rcx
mov [rsp+0B8h+var_20], r8
mov [rsp+0B8h+var_30], rdi
mov [rsp+0B8h+var_6C], 0FFFFFFFFh
mov rdi, [rsp+0B8h+var_18]
mov rsi, [rsp+0B8h+var_10]
call JS_IsObject
cmp eax, 0
jnz short loc_C08D1
mov rdi, [rsp+0B8h+var_30]
lea rsi, aObjectDefinepr; "Object.defineProperties called on non-o"...
mov al, 0
call JS_ThrowTypeError
mov [rsp+0B8h+var_80], rax
mov [rsp+0B8h+var_78], rdx
mov [rsp+0B8h+var_4], 0FFFFFFFFh
jmp loc_C0AC7
loc_C08D1:
mov dword ptr [rsp+0B8h+var_90], 0
mov [rsp+0B8h+var_88], 3
mov rax, [rsp+0B8h+var_90]
mov [rsp+0B8h+var_50], rax
mov rax, [rsp+0B8h+var_88]
mov [rsp+0B8h+var_48], rax
mov rdi, [rsp+0B8h+var_30]
mov rsi, [rsp+0B8h+var_28]
mov rdx, [rsp+0B8h+var_20]
call JS_ToObject
mov [rsp+0B8h+var_A0], rax
mov [rsp+0B8h+var_98], rdx
mov rax, [rsp+0B8h+var_A0]
mov [rsp+0B8h+var_40], rax
mov rax, [rsp+0B8h+var_98]
mov [rsp+0B8h+var_38], rax
mov rdi, [rsp+0B8h+var_40]
mov rsi, [rsp+0B8h+var_38]
call JS_IsException_1
cmp eax, 0
jz short loc_C095B
mov [rsp+0B8h+var_4], 0FFFFFFFFh
jmp loc_C0AC7
loc_C095B:
mov rax, [rsp+0B8h+var_40]
mov [rsp+0B8h+var_58], rax
mov rdi, [rsp+0B8h+var_30]
mov rcx, [rsp+0B8h+var_58]
lea rsi, [rsp+0B8h+var_60]
lea rdx, [rsp+0B8h+var_64]
mov r8d, 13h
call JS_GetOwnPropertyNamesInternal
cmp eax, 0
jge short loc_C0991
jmp loc_C0A75
loc_C0991:
mov [rsp+0B8h+var_68], 0
loc_C0999:
mov eax, [rsp+0B8h+var_68]
cmp eax, [rsp+0B8h+var_64]
jnb loc_C0A6D
mov rdi, [rsp+0B8h+var_30]
mov rsi, [rsp+0B8h+var_50]
mov rdx, [rsp+0B8h+var_48]
call JS_FreeValue
mov rdi, [rsp+0B8h+var_30]
mov rax, [rsp+0B8h+var_60]
mov ecx, [rsp+0B8h+var_68]
mov ecx, [rax+rcx*8+4]
mov rsi, [rsp+0B8h+var_40]
mov rdx, [rsp+0B8h+var_38]
call JS_GetProperty
mov [rsp+0B8h+var_B0], rax
mov [rsp+0B8h+var_A8], rdx
mov rax, [rsp+0B8h+var_B0]
mov [rsp+0B8h+var_50], rax
mov rax, [rsp+0B8h+var_A8]
mov [rsp+0B8h+var_48], rax
mov rdi, [rsp+0B8h+var_50]
mov rsi, [rsp+0B8h+var_48]
call JS_IsException_1
cmp eax, 0
jz short loc_C0A19
jmp short loc_C0A75
loc_C0A19:
mov rdi, [rsp+0B8h+var_30]
mov rax, [rsp+0B8h+var_60]
mov ecx, [rsp+0B8h+var_68]
mov ecx, [rax+rcx*8+4]
mov rsi, [rsp+0B8h+var_18]
mov rdx, [rsp+0B8h+var_10]
mov r8, [rsp+0B8h+var_50]
mov r9, [rsp+0B8h+var_48]
mov [rsp+0B8h+var_B8], 44000h
call JS_DefinePropertyDesc
cmp eax, 0
jge short loc_C0A5B
jmp short loc_C0A75
loc_C0A5B:
jmp short $+2
loc_C0A5D:
mov eax, [rsp+0B8h+var_68]
add eax, 1
mov [rsp+0B8h+var_68], eax
jmp loc_C0999
loc_C0A6D:
mov [rsp+0B8h+var_6C], 0
loc_C0A75:
mov rdi, [rsp+0B8h+var_30]
mov rsi, [rsp+0B8h+var_60]
mov edx, [rsp+0B8h+var_64]
call js_free_prop_enum
mov rdi, [rsp+0B8h+var_30]
mov rsi, [rsp+0B8h+var_40]
mov rdx, [rsp+0B8h+var_38]
call JS_FreeValue
mov rdi, [rsp+0B8h+var_30]
mov rsi, [rsp+0B8h+var_50]
mov rdx, [rsp+0B8h+var_48]
call JS_FreeValue
mov eax, [rsp+0B8h+var_6C]
mov [rsp+0B8h+var_4], eax
loc_C0AC7:
mov eax, [rsp+0B8h+var_4]
add rsp, 0B8h
retn
| long long JS_ObjectDefineProperties(
long long a1,
long long a2,
long long a3,
_DWORD *a4,
long long a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
long long v13; // rdx
long long v14; // rcx
long long v15; // r8
long long v16; // r9
__m128 v17; // xmm4
__m128 v18; // xmm5
long long v19; // rdx
long long v20; // rdx
char v22; // [rsp+0h] [rbp-B8h]
long long v23; // [rsp+28h] [rbp-90h]
unsigned int v24; // [rsp+4Ch] [rbp-6Ch]
unsigned int i; // [rsp+50h] [rbp-68h]
unsigned int v26; // [rsp+54h] [rbp-64h] BYREF
long long v27[2]; // [rsp+58h] [rbp-60h] BYREF
long long Property; // [rsp+68h] [rbp-50h]
long long v29; // [rsp+70h] [rbp-48h]
_DWORD *v30; // [rsp+78h] [rbp-40h]
long long v31; // [rsp+80h] [rbp-38h]
long long v32; // [rsp+88h] [rbp-30h]
_DWORD *v33; // [rsp+90h] [rbp-28h]
long long v34; // [rsp+98h] [rbp-20h]
long long v35; // [rsp+A0h] [rbp-18h]
long long v36; // [rsp+A8h] [rbp-10h]
v35 = a2;
v36 = a3;
v33 = a4;
v34 = a5;
v32 = a1;
v24 = -1;
if ( JS_IsObject(a2, a3) )
{
LODWORD(v23) = 0;
Property = v23;
v29 = 3LL;
v30 = JS_ToObject(v32, v33, v34, a6, a7, a8, a9, v17, v18, a12, a13, v14, v15, v16);
v31 = v19;
if ( JS_IsException_1((long long)v30, v19) )
{
return (unsigned int)-1;
}
else
{
v27[1] = (long long)v30;
if ( (int)JS_GetOwnPropertyNamesInternal(v32, v27, &v26, (long long)v30, 19) >= 0 )
{
for ( i = 0; i < v26; ++i )
{
JS_FreeValue(v32, Property, v29);
Property = JS_GetProperty(v32, (int)v30, v31, *(_DWORD *)(v27[0] + 8LL * i + 4));
v29 = v20;
if ( JS_IsException_1(Property, v20)
|| (int)JS_DefinePropertyDesc(v32, v35, v36, *(_DWORD *)(v27[0] + 8LL * i + 4), Property, v29, 278528) < 0 )
{
goto LABEL_12;
}
}
v24 = 0;
}
LABEL_12:
js_free_prop_enum(v32, v27[0], v26);
JS_FreeValue(v32, (long long)v30, v31);
JS_FreeValue(v32, Property, v29);
return v24;
}
}
else
{
JS_ThrowTypeError(
v32,
(long long)"Object.defineProperties called on non-object",
v13,
v14,
v15,
v16,
a6,
a7,
a8,
a9,
v17,
v18,
a12,
a13,
v22);
return (unsigned int)-1;
}
}
| JS_ObjectDefineProperties:
SUB RSP,0xb8
MOV qword ptr [RSP + 0xa0],RSI
MOV qword ptr [RSP + 0xa8],RDX
MOV qword ptr [RSP + 0x90],RCX
MOV qword ptr [RSP + 0x98],R8
MOV qword ptr [RSP + 0x88],RDI
MOV dword ptr [RSP + 0x4c],0xffffffff
MOV RDI,qword ptr [RSP + 0xa0]
MOV RSI,qword ptr [RSP + 0xa8]
CALL 0x0012af70
CMP EAX,0x0
JNZ 0x001c08d1
MOV RDI,qword ptr [RSP + 0x88]
LEA RSI,[0x210a53]
MOV AL,0x0
CALL 0x0012d300
MOV qword ptr [RSP + 0x38],RAX
MOV qword ptr [RSP + 0x40],RDX
MOV dword ptr [RSP + 0xb4],0xffffffff
JMP 0x001c0ac7
LAB_001c08d1:
MOV dword ptr [RSP + 0x28],0x0
MOV qword ptr [RSP + 0x30],0x3
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x68],RAX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x70],RAX
MOV RDI,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x90]
MOV RDX,qword ptr [RSP + 0x98]
CALL 0x00137770
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],RDX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x78],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x80],RAX
MOV RDI,qword ptr [RSP + 0x78]
MOV RSI,qword ptr [RSP + 0x80]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x001c095b
MOV dword ptr [RSP + 0xb4],0xffffffff
JMP 0x001c0ac7
LAB_001c095b:
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x60],RAX
MOV RDI,qword ptr [RSP + 0x88]
MOV RCX,qword ptr [RSP + 0x60]
LEA RSI,[RSP + 0x58]
LEA RDX,[RSP + 0x54]
MOV R8D,0x13
CALL 0x0012f5e0
CMP EAX,0x0
JGE 0x001c0991
JMP 0x001c0a75
LAB_001c0991:
MOV dword ptr [RSP + 0x50],0x0
LAB_001c0999:
MOV EAX,dword ptr [RSP + 0x50]
CMP EAX,dword ptr [RSP + 0x54]
JNC 0x001c0a6d
MOV RDI,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x68]
MOV RDX,qword ptr [RSP + 0x70]
CALL 0x00123c90
MOV RDI,qword ptr [RSP + 0x88]
MOV RAX,qword ptr [RSP + 0x58]
MOV ECX,dword ptr [RSP + 0x50]
MOV ECX,dword ptr [RAX + RCX*0x8 + 0x4]
MOV RSI,qword ptr [RSP + 0x78]
MOV RDX,qword ptr [RSP + 0x80]
CALL 0x00129d80
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RDX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x68],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x70],RAX
MOV RDI,qword ptr [RSP + 0x68]
MOV RSI,qword ptr [RSP + 0x70]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x001c0a19
JMP 0x001c0a75
LAB_001c0a19:
MOV RDI,qword ptr [RSP + 0x88]
MOV RAX,qword ptr [RSP + 0x58]
MOV ECX,dword ptr [RSP + 0x50]
MOV ECX,dword ptr [RAX + RCX*0x8 + 0x4]
MOV RSI,qword ptr [RSP + 0xa0]
MOV RDX,qword ptr [RSP + 0xa8]
MOV R8,qword ptr [RSP + 0x68]
MOV R9,qword ptr [RSP + 0x70]
MOV dword ptr [RSP],0x44000
CALL 0x001c0ae0
CMP EAX,0x0
JGE 0x001c0a5b
JMP 0x001c0a75
LAB_001c0a5b:
JMP 0x001c0a5d
LAB_001c0a5d:
MOV EAX,dword ptr [RSP + 0x50]
ADD EAX,0x1
MOV dword ptr [RSP + 0x50],EAX
JMP 0x001c0999
LAB_001c0a6d:
MOV dword ptr [RSP + 0x4c],0x0
LAB_001c0a75:
MOV RDI,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x58]
MOV EDX,dword ptr [RSP + 0x54]
CALL 0x00130a40
MOV RDI,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x78]
MOV RDX,qword ptr [RSP + 0x80]
CALL 0x00123c90
MOV RDI,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x68]
MOV RDX,qword ptr [RSP + 0x70]
CALL 0x00123c90
MOV EAX,dword ptr [RSP + 0x4c]
MOV dword ptr [RSP + 0xb4],EAX
LAB_001c0ac7:
MOV EAX,dword ptr [RSP + 0xb4]
ADD RSP,0xb8
RET
|
int4
JS_ObjectDefineProperties
(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5)
{
int iVar1;
int1 auVar2 [16];
uint uStack_8c;
int4 local_6c;
uint local_68;
uint local_64;
long local_60;
int8 local_58;
int1 local_50 [16];
int1 local_40 [16];
int8 local_30;
int8 local_28;
int8 local_20;
int8 local_18;
int8 local_10;
int4 local_4;
local_6c = 0xffffffff;
local_30 = param_1;
local_28 = param_4;
local_20 = param_5;
local_18 = param_2;
local_10 = param_3;
iVar1 = JS_IsObject(param_2,param_3);
if (iVar1 == 0) {
JS_ThrowTypeError(local_30,"Object.defineProperties called on non-object");
local_4 = 0xffffffff;
}
else {
local_50._0_8_ = (ulong)uStack_8c << 0x20;
local_50._8_8_ = 3;
local_40 = JS_ToObject(local_30,local_28,local_20);
iVar1 = JS_IsException(local_40._0_8_,local_40._8_8_);
if (iVar1 == 0) {
local_58 = local_40._0_8_;
iVar1 = JS_GetOwnPropertyNamesInternal(local_30,&local_60,&local_64,local_40._0_8_,0x13);
if (-1 < iVar1) {
local_68 = 0;
while( true ) {
if (local_64 <= local_68) break;
JS_FreeValue(local_30,local_50._0_8_,local_50._8_8_);
auVar2 = JS_GetProperty(local_30,local_40._0_8_,local_40._8_8_,
*(int4 *)(local_60 + 4 + (ulong)local_68 * 8));
local_50 = auVar2;
iVar1 = JS_IsException(auVar2._0_8_,auVar2._8_8_);
if (iVar1 != 0) goto LAB_001c0a75;
iVar1 = JS_DefinePropertyDesc
(local_30,local_18,local_10,
*(int4 *)(local_60 + 4 + (ulong)local_68 * 8),local_50._0_8_,
local_50._8_8_,0x44000);
if (iVar1 < 0) goto LAB_001c0a75;
local_68 = local_68 + 1;
}
local_6c = 0;
}
LAB_001c0a75:
js_free_prop_enum(local_30,local_60,local_64);
JS_FreeValue(local_30,local_40._0_8_,local_40._8_8_);
JS_FreeValue(local_30,local_50._0_8_,local_50._8_8_);
local_4 = local_6c;
}
else {
local_4 = 0xffffffff;
}
}
return local_4;
}
| |
41,576 | JS_ObjectDefineProperties | bluesky950520[P]quickjs/quickjs.c | static __exception int JS_ObjectDefineProperties(JSContext *ctx,
JSValue obj,
JSValue properties)
{
JSValue props, desc;
JSObject *p;
JSPropertyEnum *atoms;
uint32_t len, i;
int ret = -1;
if (!JS_IsObject(obj)) {
JS_ThrowTypeError(ctx, "Object.defineProperties called on non-object");
return -1;
}
desc = JS_UNDEFINED;
props = JS_ToObject(ctx, properties);
if (JS_IsException(props))
return -1;
p = JS_VALUE_GET_OBJ(props);
if (JS_GetOwnPropertyNamesInternal(ctx, &atoms, &len, p, JS_GPN_ENUM_ONLY | JS_GPN_STRING_MASK | JS_GPN_SYMBOL_MASK) < 0)
goto exception;
// XXX: ECMA specifies that all descriptions should be validated before
// modifying the object. This would require allocating an array
// JSPropertyDescriptor and use 2 separate loops.
for(i = 0; i < len; i++) {
JS_FreeValue(ctx, desc);
desc = JS_GetProperty(ctx, props, atoms[i].atom);
if (JS_IsException(desc))
goto exception;
if (JS_DefinePropertyDesc(ctx, obj, atoms[i].atom, desc,
JS_PROP_THROW | JS_PROP_DEFINE_PROPERTY) < 0)
goto exception;
}
ret = 0;
exception:
js_free_prop_enum(ctx, atoms, len);
JS_FreeValue(ctx, props);
JS_FreeValue(ctx, desc);
return ret;
} | O1 | c | JS_ObjectDefineProperties:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x28(%rsp)
movq %rdi, %rbx
movq %rdx, 0x30(%rsp)
cmpl $-0x1, %edx
jne 0x7120b
movq %rbx, %rdi
movq %rcx, %rsi
movq %r8, %rdx
callq 0x26ddd
movq %rax, 0x8(%rsp)
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
movq %rdx, 0x10(%rsp)
cmpl $0x6, %edx
je 0x7125d
movq 0x8(%rsp), %rcx
leaq 0x18(%rsp), %rsi
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
movl $0x13, %r8d
callq 0x235bd
movl $0x3, %r13d
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
xorl %ebp, %ebp
testl %eax, %eax
js 0x7122a
movl 0x4(%rsp), %eax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x71206
movq 0x18(%rsp), %r14
movq 0x8(%rsp), %r12
xorl %r15d, %r15d
xorl %ebp, %ebp
movq 0x18(%rbx), %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x1d8c6
movl 0x4(%r14,%r15,8), %ecx
movq %rbx, %rdi
movq %r12, %rsi
movq 0x10(%rsp), %rdx
movq %r12, %r8
movq %rdx, %r9
pushq $0x0
pushq $0x0
callq 0x22fa3
addq $0x10, %rsp
movq %rax, %rbp
movq %rdx, %r13
cmpl $0x6, %r13d
je 0x71224
movl 0x4(%r14,%r15,8), %ecx
subq $0x8, %rsp
movq %rbx, %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq %rbp, %r8
movq %r13, %r9
pushq $0x44000 # imm = 0x44000
callq 0x7126f
addq $0x10, %rsp
testl %eax, %eax
js 0x71224
incq %r15
cmpq %r15, 0x20(%rsp)
jne 0x71190
xorl %r14d, %r14d
jmp 0x7122a
leaq 0x307dd(%rip), %rsi # 0xa19ef
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22567
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
jmp 0x7125d
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
movq 0x18(%rsp), %rsi
movl 0x4(%rsp), %edx
movq %rbx, %rdi
callq 0x23e79
movq 0x8(%rsp), %rsi
movq 0x18(%rbx), %rdi
movq 0x10(%rsp), %rdx
callq 0x1d8c6
movq 0x18(%rbx), %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x1d8c6
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| JS_ObjectDefineProperties:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov [rsp+68h+var_40], rsi
mov rbx, rdi
mov [rsp+68h+var_38], rdx
cmp edx, 0FFFFFFFFh
jnz loc_7120B
mov rdi, rbx
mov rsi, rcx
mov rdx, r8
call JS_ToObject
mov [rsp+68h+var_60], rax
mov r14d, 0FFFFFFFFh
mov [rsp+68h+var_58], rdx
cmp edx, 6
jz loc_7125D
mov rcx, [rsp+68h+var_60]
lea rsi, [rsp+68h+var_50]
lea rdx, [rsp+68h+var_64]
mov rdi, rbx
mov r8d, 13h
call JS_GetOwnPropertyNamesInternal
mov r13d, 3
mov r14d, 0FFFFFFFFh
xor ebp, ebp
test eax, eax
js loc_7122A
mov eax, [rsp+68h+var_64]
mov [rsp+68h+var_48], rax
test rax, rax
jz loc_71206
mov r14, [rsp+68h+var_50]
mov r12, [rsp+68h+var_60]
xor r15d, r15d
xor ebp, ebp
loc_71190:
mov rdi, [rbx+18h]
mov rsi, rbp
mov rdx, r13
call JS_FreeValueRT
mov ecx, [r14+r15*8+4]
mov rdi, rbx
mov rsi, r12
mov rdx, [rsp+68h+var_58]
mov r8, r12
mov r9, rdx
push 0
push 0
call JS_GetPropertyInternal2
add rsp, 10h
mov rbp, rax
mov r13, rdx
cmp r13d, 6
jz short loc_71224
mov ecx, [r14+r15*8+4]
sub rsp, 8
mov rdi, rbx
mov rsi, [rsp+70h+var_40]
mov rdx, [rsp+70h+var_38]
mov r8, rbp
mov r9, r13
push 44000h
call JS_DefinePropertyDesc
add rsp, 10h
test eax, eax
js short loc_71224
inc r15
cmp [rsp+68h+var_48], r15
jnz short loc_71190
loc_71206:
xor r14d, r14d
jmp short loc_7122A
loc_7120B:
lea rsi, aObjectDefinepr; "Object.defineProperties called on non-o"...
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
mov r14d, 0FFFFFFFFh
jmp short loc_7125D
loc_71224:
mov r14d, 0FFFFFFFFh
loc_7122A:
mov rsi, [rsp+68h+var_50]
mov edx, [rsp+68h+var_64]
mov rdi, rbx
call js_free_prop_enum
mov rsi, [rsp+68h+var_60]
mov rdi, [rbx+18h]
mov rdx, [rsp+68h+var_58]
call JS_FreeValueRT
mov rdi, [rbx+18h]
mov rsi, rbp
mov rdx, r13
call JS_FreeValueRT
loc_7125D:
mov eax, r14d
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long JS_ObjectDefineProperties(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
unsigned int v14; // r14d
long long v15; // rdx
long long v16; // r13
_DWORD *v17; // rbp
long long v18; // r14
_DWORD *v19; // r12
long long v20; // r15
unsigned long long PropertyInternal2; // rax
long long v22; // rdx
char v24; // [rsp+0h] [rbp-68h]
unsigned int v25; // [rsp+4h] [rbp-64h] BYREF
_DWORD *v26; // [rsp+8h] [rbp-60h]
long long v27; // [rsp+10h] [rbp-58h]
long long v28; // [rsp+18h] [rbp-50h] BYREF
long long v29; // [rsp+20h] [rbp-48h]
long long v30; // [rsp+28h] [rbp-40h]
long long v31; // [rsp+30h] [rbp-38h]
v30 = a2;
v31 = a3;
if ( (_DWORD)a3 == -1 )
{
v26 = JS_ToObject(a1, a4, a5, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
v14 = -1;
v27 = v15;
if ( (_DWORD)v15 != 6 )
{
v16 = 3LL;
v14 = -1;
v17 = 0LL;
if ( (int)JS_GetOwnPropertyNamesInternal(a1, &v28, &v25, (long long)v26, 19) >= 0 )
{
v29 = v25;
if ( v25 )
{
v18 = v28;
v19 = v26;
v20 = 0LL;
v17 = 0LL;
while ( 1 )
{
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v17, v16);
PropertyInternal2 = JS_GetPropertyInternal2(
a1,
(long long)v19,
v27,
*(_DWORD *)(v18 + 8 * v20 + 4),
(long long)v19,
v27,
0LL,
0);
v17 = (_DWORD *)PropertyInternal2;
v16 = v22;
if ( (_DWORD)v22 == 6
|| (int)JS_DefinePropertyDesc(
a1,
v30,
v31,
*(_DWORD *)(v18 + 8 * v20 + 4),
PropertyInternal2,
v22,
278528) < 0 )
{
break;
}
if ( v29 == ++v20 )
goto LABEL_9;
}
v14 = -1;
}
else
{
LABEL_9:
v14 = 0;
}
}
js_free_prop_enum(a1, v28, v25);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v26, v27);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v17, v16);
}
}
else
{
JS_ThrowTypeError(
a1,
(long long)"Object.defineProperties called on non-object",
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v24);
return (unsigned int)-1;
}
return v14;
}
| JS_ObjectDefineProperties:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RSI
MOV RBX,RDI
MOV qword ptr [RSP + 0x30],RDX
CMP EDX,-0x1
JNZ 0x0017120b
MOV RDI,RBX
MOV RSI,RCX
MOV RDX,R8
CALL 0x00126ddd
MOV qword ptr [RSP + 0x8],RAX
MOV R14D,0xffffffff
MOV qword ptr [RSP + 0x10],RDX
CMP EDX,0x6
JZ 0x0017125d
MOV RCX,qword ptr [RSP + 0x8]
LEA RSI,[RSP + 0x18]
LEA RDX,[RSP + 0x4]
MOV RDI,RBX
MOV R8D,0x13
CALL 0x001235bd
MOV R13D,0x3
MOV R14D,0xffffffff
XOR EBP,EBP
TEST EAX,EAX
JS 0x0017122a
MOV EAX,dword ptr [RSP + 0x4]
MOV qword ptr [RSP + 0x20],RAX
TEST RAX,RAX
JZ 0x00171206
MOV R14,qword ptr [RSP + 0x18]
MOV R12,qword ptr [RSP + 0x8]
XOR R15D,R15D
XOR EBP,EBP
LAB_00171190:
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,RBP
MOV RDX,R13
CALL 0x0011d8c6
MOV ECX,dword ptr [R14 + R15*0x8 + 0x4]
MOV RDI,RBX
MOV RSI,R12
MOV RDX,qword ptr [RSP + 0x10]
MOV R8,R12
MOV R9,RDX
PUSH 0x0
PUSH 0x0
CALL 0x00122fa3
ADD RSP,0x10
MOV RBP,RAX
MOV R13,RDX
CMP R13D,0x6
JZ 0x00171224
MOV ECX,dword ptr [R14 + R15*0x8 + 0x4]
SUB RSP,0x8
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x38]
MOV R8,RBP
MOV R9,R13
PUSH 0x44000
CALL 0x0017126f
ADD RSP,0x10
TEST EAX,EAX
JS 0x00171224
INC R15
CMP qword ptr [RSP + 0x20],R15
JNZ 0x00171190
LAB_00171206:
XOR R14D,R14D
JMP 0x0017122a
LAB_0017120b:
LEA RSI,[0x1a19ef]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x00122567
MOV R14D,0xffffffff
JMP 0x0017125d
LAB_00171224:
MOV R14D,0xffffffff
LAB_0017122a:
MOV RSI,qword ptr [RSP + 0x18]
MOV EDX,dword ptr [RSP + 0x4]
MOV RDI,RBX
CALL 0x00123e79
MOV RSI,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RBX + 0x18]
MOV RDX,qword ptr [RSP + 0x10]
CALL 0x0011d8c6
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,RBP
MOV RDX,R13
CALL 0x0011d8c6
LAB_0017125d:
MOV EAX,R14D
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
JS_ObjectDefineProperties
(long param_1,int8 param_2,int8 param_3,int8 param_4,int8 param_5)
{
int8 uVar1;
long lVar2;
int iVar3;
int8 uVar4;
ulong uVar5;
int1 auVar6 [16];
uint local_64;
int1 local_60 [16];
long local_50;
ulong local_48;
int8 local_40;
int8 local_38;
local_40 = param_2;
local_38 = param_3;
if ((int)param_3 == -1) {
local_60 = JS_ToObject(param_1,param_4,param_5);
uVar4 = 0xffffffff;
if (local_60._8_4_ != 6) {
iVar3 = JS_GetOwnPropertyNamesInternal(param_1,&local_50,&local_64,local_60._0_8_,0x13);
lVar2 = local_50;
uVar1 = local_60._0_8_;
uVar4 = 0xffffffff;
auVar6 = ZEXT816(3) << 0x40;
if (-1 < iVar3) {
local_48 = (ulong)local_64;
if (local_48 != 0) {
uVar5 = 0;
auVar6 = ZEXT816(3) << 0x40;
do {
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),auVar6._0_8_,auVar6._8_8_);
auVar6 = JS_GetPropertyInternal2
(param_1,uVar1,local_60._8_8_,*(int4 *)(lVar2 + 4 + uVar5 * 8),
uVar1,local_60._8_8_,0,0);
if (auVar6._8_4_ == 6) {
LAB_00171224:
uVar4 = 0xffffffff;
goto LAB_0017122a;
}
iVar3 = JS_DefinePropertyDesc
(param_1,local_40,local_38,*(int4 *)(lVar2 + 4 + uVar5 * 8),
auVar6._0_8_,auVar6._8_8_,0x44000);
if (iVar3 < 0) goto LAB_00171224;
uVar5 = uVar5 + 1;
} while (local_48 != uVar5);
}
uVar4 = 0;
}
LAB_0017122a:
js_free_prop_enum(param_1,local_50,local_64);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),local_60._0_8_,local_60._8_8_);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),auVar6._0_8_,auVar6._8_8_);
}
}
else {
JS_ThrowTypeError(param_1,"Object.defineProperties called on non-object");
uVar4 = 0xffffffff;
}
return uVar4;
}
| |
41,577 | js_std_free_handlers | bluesky950520[P]quickjs/quickjs-libc.c | void js_std_free_handlers(JSRuntime *rt)
{
JSThreadState *ts = js_get_thread_state(rt);
struct list_head *el, *el1;
list_for_each_safe(el, el1, &ts->os_rw_handlers) {
JSOSRWHandler *rh = list_entry(el, JSOSRWHandler, link);
free_rw_handler(rt, rh);
}
list_for_each_safe(el, el1, &ts->os_signal_handlers) {
JSOSSignalHandler *sh = list_entry(el, JSOSSignalHandler, link);
free_sh(rt, sh);
}
list_for_each_safe(el, el1, &ts->os_timers) {
JSOSTimer *th = list_entry(el, JSOSTimer, link);
free_timer(rt, th);
}
#ifdef USE_WORKER
/* XXX: free port_list ? */
js_free_message_pipe(ts->recv_pipe);
js_free_message_pipe(ts->send_pipe);
#endif
} | O0 | c | js_std_free_handlers:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x178c0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq %rcx, %rax
je 0x177d6
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x178e0
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x17794
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
addq $0x10, %rcx
cmpq %rcx, %rax
je 0x17838
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x17950
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x177f2
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
addq $0x20, %rcx
cmpq %rcx, %rax
je 0x17898
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
movq (%rsp), %rsi
callq 0x179a0
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x17854
movq 0x28(%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x179f0
movq 0x28(%rsp), %rax
movq 0x70(%rax), %rdi
callq 0x179f0
addq $0x38, %rsp
retq
nopl (%rax)
| js_std_free_handlers:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov rdi, [rsp+38h+var_8]
call js_get_thread_state
mov [rsp+38h+var_10], rax
mov rax, [rsp+38h+var_10]
mov rax, [rax+8]
mov [rsp+38h+var_18], rax
mov rax, [rsp+38h+var_18]
mov rax, [rax+8]
mov [rsp+38h+var_20], rax
loc_17794:
mov rax, [rsp+38h+var_18]
mov rcx, [rsp+38h+var_10]
cmp rax, rcx
jz short loc_177D6
mov rax, [rsp+38h+var_18]
mov [rsp+38h+var_28], rax
mov rdi, [rsp+38h+var_8]
mov rsi, [rsp+38h+var_28]
call free_rw_handler
mov rax, [rsp+38h+var_20]
mov [rsp+38h+var_18], rax
mov rax, [rsp+38h+var_18]
mov rax, [rax+8]
mov [rsp+38h+var_20], rax
jmp short loc_17794
loc_177D6:
mov rax, [rsp+38h+var_10]
mov rax, [rax+18h]
mov [rsp+38h+var_18], rax
mov rax, [rsp+38h+var_18]
mov rax, [rax+8]
mov [rsp+38h+var_20], rax
loc_177F2:
mov rax, [rsp+38h+var_18]
mov rcx, [rsp+38h+var_10]
add rcx, 10h
cmp rax, rcx
jz short loc_17838
mov rax, [rsp+38h+var_18]
mov [rsp+38h+var_30], rax
mov rdi, [rsp+38h+var_8]
mov rsi, [rsp+38h+var_30]
call free_sh
mov rax, [rsp+38h+var_20]
mov [rsp+38h+var_18], rax
mov rax, [rsp+38h+var_18]
mov rax, [rax+8]
mov [rsp+38h+var_20], rax
jmp short loc_177F2
loc_17838:
mov rax, [rsp+38h+var_10]
mov rax, [rax+28h]
mov [rsp+38h+var_18], rax
mov rax, [rsp+38h+var_18]
mov rax, [rax+8]
mov [rsp+38h+var_20], rax
loc_17854:
mov rax, [rsp+38h+var_18]
mov rcx, [rsp+38h+var_10]
add rcx, 20h ; ' '
cmp rax, rcx
jz short loc_17898
mov rax, [rsp+38h+var_18]
mov [rsp+38h+var_38], rax
mov rdi, [rsp+38h+var_8]
mov rsi, [rsp+38h+var_38]
call free_timer
mov rax, [rsp+38h+var_20]
mov [rsp+38h+var_18], rax
mov rax, [rsp+38h+var_18]
mov rax, [rax+8]
mov [rsp+38h+var_20], rax
jmp short loc_17854
loc_17898:
mov rax, [rsp+38h+var_10]
mov rdi, [rax+68h]
call js_free_message_pipe
mov rax, [rsp+38h+var_10]
mov rdi, [rax+70h]
call js_free_message_pipe
add rsp, 38h
retn
| long long js_std_free_handlers(long long a1)
{
_QWORD *v2; // [rsp+18h] [rbp-20h]
_QWORD *v3; // [rsp+18h] [rbp-20h]
_QWORD *v4; // [rsp+18h] [rbp-20h]
_QWORD *v5; // [rsp+20h] [rbp-18h]
_QWORD *v6; // [rsp+20h] [rbp-18h]
_QWORD *v7; // [rsp+20h] [rbp-18h]
_QWORD *thread_state; // [rsp+28h] [rbp-10h]
thread_state = (_QWORD *)js_get_thread_state(a1);
v5 = (_QWORD *)thread_state[1];
v2 = (_QWORD *)v5[1];
while ( v5 != thread_state )
{
free_rw_handler(a1, v5);
v5 = v2;
v2 = (_QWORD *)v2[1];
}
v6 = (_QWORD *)thread_state[3];
v3 = (_QWORD *)v6[1];
while ( v6 != thread_state + 2 )
{
free_sh(a1, v6);
v6 = v3;
v3 = (_QWORD *)v3[1];
}
v7 = (_QWORD *)thread_state[5];
v4 = (_QWORD *)v7[1];
while ( v7 != thread_state + 4 )
{
free_timer(a1, v7);
v7 = v4;
v4 = (_QWORD *)v4[1];
}
js_free_message_pipe(thread_state[13]);
return js_free_message_pipe(thread_state[14]);
}
| js_std_free_handlers:
SUB RSP,0x38
MOV qword ptr [RSP + 0x30],RDI
MOV RDI,qword ptr [RSP + 0x30]
CALL 0x001178c0
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x18],RAX
LAB_00117794:
MOV RAX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x28]
CMP RAX,RCX
JZ 0x001177d6
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x10]
CALL 0x001178e0
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x18],RAX
JMP 0x00117794
LAB_001177d6:
MOV RAX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x18],RAX
LAB_001177f2:
MOV RAX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x28]
ADD RCX,0x10
CMP RAX,RCX
JZ 0x00117838
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x00117950
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x18],RAX
JMP 0x001177f2
LAB_00117838:
MOV RAX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x18],RAX
LAB_00117854:
MOV RAX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x28]
ADD RCX,0x20
CMP RAX,RCX
JZ 0x00117898
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP]
CALL 0x001179a0
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x18],RAX
JMP 0x00117854
LAB_00117898:
MOV RAX,qword ptr [RSP + 0x28]
MOV RDI,qword ptr [RAX + 0x68]
CALL 0x001179f0
MOV RAX,qword ptr [RSP + 0x28]
MOV RDI,qword ptr [RAX + 0x70]
CALL 0x001179f0
ADD RSP,0x38
RET
|
void js_std_free_handlers(int8 param_1)
{
long lVar1;
int8 local_20;
int8 local_18;
lVar1 = js_get_thread_state(param_1);
local_18 = *(long *)(lVar1 + 8);
local_20 = *(long *)(local_18 + 8);
while (local_18 != lVar1) {
free_rw_handler(param_1,local_18);
local_18 = local_20;
local_20 = *(long *)(local_20 + 8);
}
local_18 = *(long *)(lVar1 + 0x18);
local_20 = *(long *)(local_18 + 8);
while (local_18 != lVar1 + 0x10) {
free_sh(param_1,local_18);
local_18 = local_20;
local_20 = *(long *)(local_20 + 8);
}
local_18 = *(long *)(lVar1 + 0x28);
local_20 = *(long *)(local_18 + 8);
while (local_18 != lVar1 + 0x20) {
free_timer(param_1,local_18);
local_18 = local_20;
local_20 = *(long *)(local_20 + 8);
}
js_free_message_pipe(*(int8 *)(lVar1 + 0x68));
js_free_message_pipe(*(int8 *)(lVar1 + 0x70));
return;
}
| |
41,578 | js_std_free_handlers | bluesky950520[P]quickjs/quickjs-libc.c | void js_std_free_handlers(JSRuntime *rt)
{
JSThreadState *ts = js_get_thread_state(rt);
struct list_head *el, *el1;
list_for_each_safe(el, el1, &ts->os_rw_handlers) {
JSOSRWHandler *rh = list_entry(el, JSOSRWHandler, link);
free_rw_handler(rt, rh);
}
list_for_each_safe(el, el1, &ts->os_signal_handlers) {
JSOSSignalHandler *sh = list_entry(el, JSOSSignalHandler, link);
free_sh(rt, sh);
}
list_for_each_safe(el, el1, &ts->os_timers) {
JSOSTimer *th = list_entry(el, JSOSTimer, link);
free_timer(rt, th);
}
#ifdef USE_WORKER
/* XXX: free port_list ? */
js_free_message_pipe(ts->recv_pipe);
js_free_message_pipe(ts->send_pipe);
#endif
} | O2 | c | js_std_free_handlers:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x13e3a
movq %rax, %r14
movq %rax, %r15
movq 0x8(%rax), %rsi
cmpq %r14, %rsi
je 0x13de3
movq 0x8(%rsi), %r12
movq %rbx, %rdi
callq 0x13e46
movq %r12, %rsi
jmp 0x13dcd
leaq 0x10(%r14), %r12
movq 0x18(%r15), %rsi
cmpq %r12, %rsi
je 0x13e01
movq 0x8(%rsi), %r13
movq %rbx, %rdi
callq 0x13e96
movq %r13, %rsi
jmp 0x13deb
addq $0x20, %r14
movq 0x28(%r15), %rsi
cmpq %r14, %rsi
je 0x13e1f
movq 0x8(%rsi), %r12
movq %rbx, %rdi
callq 0x13ed3
movq %r12, %rsi
jmp 0x13e09
movq 0x68(%r15), %rdi
callq 0x13f10
movq 0x70(%r15), %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x13f10
| js_std_free_handlers:
push r15
push r14
push r13
push r12
push rbx
mov rbx, rdi
call js_get_thread_state
mov r14, rax
mov r15, rax
mov rsi, [rax+8]
loc_13DCD:
cmp rsi, r14
jz short loc_13DE3
mov r12, [rsi+8]
mov rdi, rbx
call free_rw_handler
mov rsi, r12
jmp short loc_13DCD
loc_13DE3:
lea r12, [r14+10h]
mov rsi, [r15+18h]
loc_13DEB:
cmp rsi, r12
jz short loc_13E01
mov r13, [rsi+8]
mov rdi, rbx
call free_sh
mov rsi, r13
jmp short loc_13DEB
loc_13E01:
add r14, 20h ; ' '
mov rsi, [r15+28h]
loc_13E09:
cmp rsi, r14
jz short loc_13E1F
mov r12, [rsi+8]
mov rdi, rbx
call free_timer
mov rsi, r12
jmp short loc_13E09
loc_13E1F:
mov rdi, [r15+68h]
call js_free_message_pipe
mov rdi, [r15+70h]
pop rbx
pop r12
pop r13
pop r14
pop r15
jmp js_free_message_pipe
| long long js_std_free_handlers(long long a1)
{
long long thread_state; // r14
_QWORD *v2; // r15
long long i; // rsi
long long v4; // r12
long long j; // rsi
long long v6; // r13
long long v7; // r14
long long k; // rsi
long long v9; // r12
thread_state = js_get_thread_state(a1);
v2 = (_QWORD *)thread_state;
for ( i = *(_QWORD *)(thread_state + 8); i != thread_state; i = v4 )
{
v4 = *(_QWORD *)(i + 8);
free_rw_handler(a1);
}
for ( j = *(_QWORD *)(thread_state + 24); j != thread_state + 16; j = v6 )
{
v6 = *(_QWORD *)(j + 8);
free_sh(a1);
}
v7 = thread_state + 32;
for ( k = v2[5]; k != v7; k = v9 )
{
v9 = *(_QWORD *)(k + 8);
free_timer(a1);
}
js_free_message_pipe(v2[13]);
return js_free_message_pipe(v2[14]);
}
| js_std_free_handlers:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV RBX,RDI
CALL 0x00113e3a
MOV R14,RAX
MOV R15,RAX
MOV RSI,qword ptr [RAX + 0x8]
LAB_00113dcd:
CMP RSI,R14
JZ 0x00113de3
MOV R12,qword ptr [RSI + 0x8]
MOV RDI,RBX
CALL 0x00113e46
MOV RSI,R12
JMP 0x00113dcd
LAB_00113de3:
LEA R12,[R14 + 0x10]
MOV RSI,qword ptr [R15 + 0x18]
LAB_00113deb:
CMP RSI,R12
JZ 0x00113e01
MOV R13,qword ptr [RSI + 0x8]
MOV RDI,RBX
CALL 0x00113e96
MOV RSI,R13
JMP 0x00113deb
LAB_00113e01:
ADD R14,0x20
MOV RSI,qword ptr [R15 + 0x28]
LAB_00113e09:
CMP RSI,R14
JZ 0x00113e1f
MOV R12,qword ptr [RSI + 0x8]
MOV RDI,RBX
CALL 0x00113ed3
MOV RSI,R12
JMP 0x00113e09
LAB_00113e1f:
MOV RDI,qword ptr [R15 + 0x68]
CALL 0x00113f10
MOV RDI,qword ptr [R15 + 0x70]
POP RBX
POP R12
POP R13
POP R14
POP R15
JMP 0x00113f10
|
void js_std_free_handlers(int8 param_1)
{
long lVar1;
long lVar2;
lVar1 = js_get_thread_state();
lVar2 = *(long *)(lVar1 + 8);
while (lVar2 != lVar1) {
lVar2 = *(long *)(lVar2 + 8);
free_rw_handler(param_1);
}
lVar2 = *(long *)(lVar1 + 0x18);
while (lVar2 != lVar1 + 0x10) {
lVar2 = *(long *)(lVar2 + 8);
free_sh(param_1);
}
lVar2 = *(long *)(lVar1 + 0x28);
while (lVar2 != lVar1 + 0x20) {
lVar2 = *(long *)(lVar2 + 8);
free_timer(param_1);
}
js_free_message_pipe(*(int8 *)(lVar1 + 0x68));
js_free_message_pipe(*(int8 *)(lVar1 + 0x70));
return;
}
| |
41,579 | js_regexp_get_flag | bluesky950520[P]quickjs/quickjs.c | static JSValue js_regexp_get_flag(JSContext *ctx, JSValue this_val, int mask)
{
JSRegExp *re;
int flags;
if (JS_VALUE_GET_TAG(this_val) != JS_TAG_OBJECT)
return JS_ThrowTypeErrorNotAnObject(ctx);
re = js_get_regexp(ctx, this_val, FALSE);
if (!re) {
if (js_same_value(ctx, this_val, ctx->class_proto[JS_CLASS_REGEXP]))
return JS_UNDEFINED;
else
return JS_ThrowTypeErrorInvalidClass(ctx, JS_CLASS_REGEXP);
}
flags = lre_get_flags(re->bytecode->u.str8);
return js_bool(flags & mask);
} | O0 | c | js_regexp_get_flag:
subq $0x48, %rsp
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rdi, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq 0x30(%rsp), %rax
cmpl $-0x1, %eax
je 0x8544a
movq 0x20(%rsp), %rdi
callq 0x35890
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
jmp 0x854f8
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
xorl %ecx, %ecx
callq 0x8a5c0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x854cb
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x120(%rax), %rcx
movq 0x128(%rax), %r8
callq 0x3be00
cmpl $0x0, %eax
je 0x854b0
movl $0x0, 0x38(%rsp)
movq $0x3, 0x40(%rsp)
jmp 0x854f8
movq 0x20(%rsp), %rdi
movl $0x12, %esi
callq 0x3e710
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
jmp 0x854f8
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
addq $0x18, %rdi
callq 0x103fa0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %edi
andl 0x1c(%rsp), %edi
callq 0x5d540
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdx
addq $0x48, %rsp
retq
nopw (%rax,%rax)
| js_regexp_get_flag:
sub rsp, 48h
mov [rsp+48h+var_20], rsi
mov [rsp+48h+var_18], rdx
mov [rsp+48h+var_28], rdi
mov [rsp+48h+var_2C], ecx
mov rax, [rsp+48h+var_18]
cmp eax, 0FFFFFFFFh
jz short loc_8544A
mov rdi, [rsp+48h+var_28]
call JS_ThrowTypeErrorNotAnObject
mov [rsp+48h+var_10], rax
mov [rsp+48h+var_8], rdx
jmp loc_854F8
loc_8544A:
mov rdi, [rsp+48h+var_28]
mov rsi, [rsp+48h+var_20]
mov rdx, [rsp+48h+var_18]
xor ecx, ecx
call js_get_regexp
mov [rsp+48h+var_38], rax
cmp [rsp+48h+var_38], 0
jnz short loc_854CB
mov rdi, [rsp+48h+var_28]
mov rax, [rsp+48h+var_28]
mov rax, [rax+40h]
mov rsi, [rsp+48h+var_20]
mov rdx, [rsp+48h+var_18]
mov rcx, [rax+120h]
mov r8, [rax+128h]
call js_same_value
cmp eax, 0
jz short loc_854B0
mov dword ptr [rsp+48h+var_10], 0
mov [rsp+48h+var_8], 3
jmp short loc_854F8
loc_854B0:
mov rdi, [rsp+48h+var_28]
mov esi, 12h
call JS_ThrowTypeErrorInvalidClass
mov [rsp+48h+var_10], rax
mov [rsp+48h+var_8], rdx
jmp short loc_854F8
loc_854CB:
mov rax, [rsp+48h+var_38]
mov rdi, [rax+8]
add rdi, 18h
call lre_get_flags
mov [rsp+48h+var_3C], eax
mov edi, [rsp+48h+var_3C]
and edi, [rsp+48h+var_2C]
call js_bool
mov [rsp+48h+var_10], rax
mov [rsp+48h+var_8], rdx
loc_854F8:
mov rax, [rsp+48h+var_10]
mov rdx, [rsp+48h+var_8]
add rsp, 48h
retn
| long long js_regexp_get_flag(
long long a1,
_DWORD *a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
unsigned int flags; // [rsp+Ch] [rbp-3Ch]
long long regexp; // [rsp+10h] [rbp-38h]
int v17; // [rsp+1Ch] [rbp-2Ch]
unsigned int v18; // [rsp+30h] [rbp-18h]
long long v19; // [rsp+38h] [rbp-10h]
v18 = a3;
v17 = a4;
if ( (_DWORD)a3 != -1 )
return JS_ThrowTypeErrorNotAnObject(a1, a7, a8, a9, a10, a11, a12, a13, a14, (long long)a2, a3, a4, a5, a6);
regexp = js_get_regexp(a1, a2, a3, 0LL);
if ( regexp )
{
flags = lre_get_flags(*(_QWORD *)(regexp + 8) + 24LL);
return js_bool(v17 & flags);
}
else if ( (unsigned int)js_same_value(
a1,
a2,
v18,
*(_DWORD **)(*(_QWORD *)(a1 + 64) + 288LL),
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 296LL)) )
{
LODWORD(v19) = 0;
}
else
{
return JS_ThrowTypeErrorInvalidClass(a1, 18);
}
return v19;
}
| js_regexp_get_flag:
SUB RSP,0x48
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x30],RDX
MOV qword ptr [RSP + 0x20],RDI
MOV dword ptr [RSP + 0x1c],ECX
MOV RAX,qword ptr [RSP + 0x30]
CMP EAX,-0x1
JZ 0x0018544a
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x00135890
MOV qword ptr [RSP + 0x38],RAX
MOV qword ptr [RSP + 0x40],RDX
JMP 0x001854f8
LAB_0018544a:
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
XOR ECX,ECX
CALL 0x0018a5c0
MOV qword ptr [RSP + 0x10],RAX
CMP qword ptr [RSP + 0x10],0x0
JNZ 0x001854cb
MOV RDI,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + 0x40]
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
MOV RCX,qword ptr [RAX + 0x120]
MOV R8,qword ptr [RAX + 0x128]
CALL 0x0013be00
CMP EAX,0x0
JZ 0x001854b0
MOV dword ptr [RSP + 0x38],0x0
MOV qword ptr [RSP + 0x40],0x3
JMP 0x001854f8
LAB_001854b0:
MOV RDI,qword ptr [RSP + 0x20]
MOV ESI,0x12
CALL 0x0013e710
MOV qword ptr [RSP + 0x38],RAX
MOV qword ptr [RSP + 0x40],RDX
JMP 0x001854f8
LAB_001854cb:
MOV RAX,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RAX + 0x8]
ADD RDI,0x18
CALL 0x00203fa0
MOV dword ptr [RSP + 0xc],EAX
MOV EDI,dword ptr [RSP + 0xc]
AND EDI,dword ptr [RSP + 0x1c]
CALL 0x0015d540
MOV qword ptr [RSP + 0x38],RAX
MOV qword ptr [RSP + 0x40],RDX
LAB_001854f8:
MOV RAX,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x40]
ADD RSP,0x48
RET
|
int1 [16] js_regexp_get_flag(long param_1,int8 param_2,int8 param_3,uint param_4)
{
int iVar1;
uint uVar2;
long lVar3;
int1 auVar4 [16];
int4 local_10;
int4 uStack_c;
int8 local_8;
if ((int)param_3 == -1) {
lVar3 = js_get_regexp(param_1,param_2,param_3,0);
if (lVar3 == 0) {
iVar1 = js_same_value(param_1,param_2,param_3,
*(int8 *)(*(long *)(param_1 + 0x40) + 0x120),
*(int8 *)(*(long *)(param_1 + 0x40) + 0x128));
if (iVar1 == 0) {
auVar4 = JS_ThrowTypeErrorInvalidClass(param_1,0x12);
local_8 = auVar4._8_8_;
local_10 = auVar4._0_4_;
uStack_c = auVar4._4_4_;
}
else {
local_10 = 0;
local_8 = 3;
}
}
else {
uVar2 = lre_get_flags(*(long *)(lVar3 + 8) + 0x18);
auVar4 = js_bool(uVar2 & param_4);
local_8 = auVar4._8_8_;
local_10 = auVar4._0_4_;
uStack_c = auVar4._4_4_;
}
}
else {
auVar4 = JS_ThrowTypeErrorNotAnObject(param_1);
local_8 = auVar4._8_8_;
local_10 = auVar4._0_4_;
uStack_c = auVar4._4_4_;
}
auVar4._4_4_ = uStack_c;
auVar4._0_4_ = local_10;
auVar4._8_8_ = local_8;
return auVar4;
}
| |
41,580 | pvio_socket_async_write | eloqsql/libmariadb/plugins/pvio/pvio_socket.c | ssize_t pvio_socket_async_write(MARIADB_PVIO *pvio, const uchar *buffer, size_t length)
{
ssize_t r= -1;
struct st_pvio_socket *csock= NULL;
#ifndef _WIN32
int write_flags= MSG_DONTWAIT;
#ifdef MSG_NOSIGNAL
write_flags|= MSG_NOSIGNAL;
#endif
#endif
if (!pvio || !pvio->data)
return -1;
csock= (struct st_pvio_socket *)pvio->data;
#ifndef WIN32
r= ma_send(csock->socket, buffer, length, write_flags);
#else
/* Windows doesn't support MSG_DONTWAIT, so we need to set
socket to non blocking */
pvio_socket_blocking(pvio, 0, 0);
r= send(csock->socket, (const char *)buffer, (int)length, 0);
#endif
return r;
} | O3 | c | pvio_socket_async_write:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x315cf
movq (%rdi), %rax
testq %rax, %rax
je 0x315cf
movl (%rax), %edi
popq %rbp
jmp 0x3211f
movq $-0x1, %rax
popq %rbp
retq
| pvio_socket_async_write:
push rbp
mov rbp, rsp
test rdi, rdi
jz short loc_315CF
mov rax, [rdi]
test rax, rax
jz short loc_315CF
mov edi, [rax]
pop rbp
jmp ma_send
loc_315CF:
mov rax, 0FFFFFFFFFFFFFFFFh
pop rbp
retn
| long long pvio_socket_async_write(_QWORD *a1, long long a2, long long a3)
{
if ( a1 && *a1 )
return ma_send(*(unsigned int *)*a1, a2, a3);
else
return -1LL;
}
| pvio_socket_async_write:
PUSH RBP
MOV RBP,RSP
TEST RDI,RDI
JZ 0x001315cf
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x001315cf
MOV EDI,dword ptr [RAX]
POP RBP
JMP 0x0013211f
LAB_001315cf:
MOV RAX,-0x1
POP RBP
RET
|
int8 pvio_socket_async_write(int8 *param_1)
{
int8 uVar1;
if ((param_1 != (int8 *)0x0) && ((int4 *)*param_1 != (int4 *)0x0)) {
uVar1 = ma_send(*(int4 *)*param_1);
return uVar1;
}
return 0xffffffffffffffff;
}
| |
41,581 | ma_real_read | eloqsql/libmariadb/libmariadb/ma_net.c | static ulong ma_real_read(NET *net, size_t *complen)
{
uchar *pos;
ssize_t length;
uint i;
ulong len=packet_error;
size_t remain= (net->compress ? NET_HEADER_SIZE+COMP_HEADER_SIZE :
NET_HEADER_SIZE);
*complen = 0;
net->reading_or_writing=1;
pos = net->buff + net->where_b; /* net->packet -4 */
for (i=0 ; i < 2 ; i++)
{
while (remain > 0)
{
/* First read is done with non blocking mode */
if ((length=ma_pvio_cache_read(net->pvio, pos,remain)) <= 0L)
{
len= packet_error;
net->error=2; /* Close socket */
goto end;
}
remain -= (ulong) length;
pos+= (ulong) length;
}
if (i == 0)
{ /* First parts is packet length */
ulong helping;
net->pkt_nr= net->buff[net->where_b + 3];
net->compress_pkt_nr= ++net->pkt_nr;
#ifdef HAVE_COMPRESS
if (net->compress)
{
/* complen is > 0 if package is really compressed */
*complen=uint3korr(&(net->buff[net->where_b + NET_HEADER_SIZE]));
}
#endif
len=uint3korr(net->buff+net->where_b);
if (!len)
goto end;
helping = max(len,(ulong)*complen) + net->where_b;
/* The necessary size of net->buff */
if (helping >= net->max_packet)
{
if (net_realloc(net, helping))
{
len= packet_error; /* Return error */
goto end;
}
}
pos=net->buff + net->where_b;
remain = len;
}
}
end:
net->reading_or_writing=0;
return(len);
} | O3 | c | ma_real_read:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xffffffff, %r13d # imm = 0xFFFFFFFF
xorl %eax, %eax
cmpb $0x0, 0x84(%rdi)
setne %al
leaq (%rax,%rax,2), %r15
addq $0x4, %r15
movq %rsi, -0x30(%rbp)
movq $0x0, (%rsi)
movb $0x1, 0x80(%rdi)
movq 0x8(%rdi), %r12
addq 0x48(%rdi), %r12
movb $0x1, %r14b
movq (%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1ff31
testq %rax, %rax
jle 0x33bff
addq %rax, %r12
subq %rax, %r15
jne 0x33b1a
testb $0x1, %r14b
je 0x33c0c
movq 0x8(%rbx), %rax
movq 0x48(%rbx), %r12
movzbl 0x3(%rax,%r12), %ecx
incl %ecx
movl %ecx, 0x60(%rbx)
movl %ecx, 0x64(%rbx)
cmpb $0x0, 0x84(%rbx)
je 0x33b83
movzwl 0x4(%rax,%r12), %ecx
movzbl 0x6(%rax,%r12), %eax
shll $0x10, %eax
orq %rcx, %rax
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
movq 0x8(%rbx), %rax
movq 0x48(%rbx), %r12
movzwl (%rax,%r12), %ecx
movzbl 0x2(%rax,%r12), %r15d
shll $0x10, %r15d
orq %rcx, %r15
je 0x33c25
movq -0x30(%rbp), %rcx
movq (%rcx), %r14
cmpq %r14, %r15
cmovaq %r15, %r14
addq %r12, %r14
cmpq 0x50(%rbx), %r14
jb 0x33bf1
cmpq %r14, 0x58(%rbx)
jbe 0x33c2a
addq $0xfff, %r14 # imm = 0xFFF
andq $-0x1000, %r14 # imm = 0xF000
leaq 0x7(%r14), %rsi
movq %rax, %rdi
callq 0x13730
testq %rax, %rax
je 0x33c51
movq %rax, 0x18(%rbx)
movq %rax, 0x8(%rbx)
movq %r14, 0x50(%rbx)
movq %rax, %rcx
addq %r14, %rcx
movq %rcx, 0x10(%rbx)
movq 0x48(%rbx), %r12
addq %rax, %r12
xorl %r14d, %r14d
movq %r15, %r13
jmp 0x33b1a
movb $0x2, 0x94(%rbx)
movl $0xffffffff, %r13d # imm = 0xFFFFFFFF
movb $0x0, 0x80(%rbx)
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r13d, %r13d
jmp 0x33c0c
movb $0x1, 0x94(%rbx)
movq (%rbx), %r8
movq 0x40(%r8), %rdi
leaq 0x18051(%rip), %rax # 0x4bc90
movq (%rax), %rdx
movl $0x7e4, %esi # imm = 0x7E4
xorl %ecx, %ecx
xorl %eax, %eax
callq *0x50(%r8)
jmp 0x33c06
movb $0x1, 0x94(%rbx)
jmp 0x33c06
| ma_real_read:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
mov r13d, 0FFFFFFFFh
xor eax, eax
cmp byte ptr [rdi+84h], 0
setnz al
lea r15, [rax+rax*2]
add r15, 4
mov [rbp+var_30], rsi
mov qword ptr [rsi], 0
mov byte ptr [rdi+80h], 1
mov r12, [rdi+8]
add r12, [rdi+48h]
mov r14b, 1
loc_33B1A:
mov rdi, [rbx]
mov rsi, r12
mov rdx, r15
call ma_pvio_cache_read
test rax, rax
jle loc_33BFF
add r12, rax
sub r15, rax
jnz short loc_33B1A
test r14b, 1
jz loc_33C0C
mov rax, [rbx+8]
mov r12, [rbx+48h]
movzx ecx, byte ptr [rax+r12+3]
inc ecx
mov [rbx+60h], ecx
mov [rbx+64h], ecx
cmp byte ptr [rbx+84h], 0
jz short loc_33B83
movzx ecx, word ptr [rax+r12+4]
movzx eax, byte ptr [rax+r12+6]
shl eax, 10h
or rax, rcx
mov rcx, [rbp+var_30]
mov [rcx], rax
mov rax, [rbx+8]
mov r12, [rbx+48h]
loc_33B83:
movzx ecx, word ptr [rax+r12]
movzx r15d, byte ptr [rax+r12+2]
shl r15d, 10h
or r15, rcx
jz loc_33C25
mov rcx, [rbp+var_30]
mov r14, [rcx]
cmp r15, r14
cmova r14, r15
add r14, r12
cmp r14, [rbx+50h]
jb short loc_33BF1
cmp [rbx+58h], r14
jbe short loc_33C2A
add r14, 0FFFh
and r14, 0FFFFFFFFFFFFF000h
lea rsi, [r14+7]
mov rdi, rax
call _realloc
test rax, rax
jz short loc_33C51
mov [rbx+18h], rax
mov [rbx+8], rax
mov [rbx+50h], r14
mov rcx, rax
add rcx, r14
mov [rbx+10h], rcx
mov r12, [rbx+48h]
loc_33BF1:
add r12, rax
xor r14d, r14d
mov r13, r15
jmp loc_33B1A
loc_33BFF:
mov byte ptr [rbx+94h], 2
loc_33C06:
mov r13d, 0FFFFFFFFh
loc_33C0C:
mov byte ptr [rbx+80h], 0
mov rax, r13
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_33C25:
xor r13d, r13d
jmp short loc_33C0C
loc_33C2A:
mov byte ptr [rbx+94h], 1
mov r8, [rbx]
mov rdi, [r8+40h]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov esi, 7E4h
xor ecx, ecx
xor eax, eax
call qword ptr [r8+50h]
jmp short loc_33C06
loc_33C51:
mov byte ptr [rbx+94h], 1
jmp short loc_33C06
| long long ma_real_read(long long a1, unsigned long long *a2)
{
long long v2; // r13
unsigned long long v3; // r15
long long v4; // r12
char i; // r14
long long v6; // rax
long long v7; // rax
long long v8; // r12
int v9; // ecx
unsigned long long v10; // r14
unsigned long long v11; // r14
unsigned long long v12; // r14
v2 = 0xFFFFFFFFLL;
v3 = 3LL * (*(_BYTE *)(a1 + 132) != 0) + 4;
*a2 = 0LL;
*(_BYTE *)(a1 + 128) = 1;
v4 = *(_QWORD *)(a1 + 72) + *(_QWORD *)(a1 + 8);
for ( i = 1; ; i = 0 )
{
do
{
v6 = ma_pvio_cache_read(*(_QWORD **)a1, v4, v3);
if ( v6 <= 0 )
{
*(_BYTE *)(a1 + 148) = 2;
goto LABEL_16;
}
v4 += v6;
v3 -= v6;
}
while ( v3 );
if ( (i & 1) == 0 )
goto LABEL_17;
v7 = *(_QWORD *)(a1 + 8);
v8 = *(_QWORD *)(a1 + 72);
v9 = *(unsigned __int8 *)(v7 + v8 + 3) + 1;
*(_DWORD *)(a1 + 96) = v9;
*(_DWORD *)(a1 + 100) = v9;
if ( *(_BYTE *)(a1 + 132) )
{
*a2 = *(unsigned __int16 *)(v7 + v8 + 4) | (unsigned long long)(*(unsigned __int8 *)(v7 + v8 + 6) << 16);
v7 = *(_QWORD *)(a1 + 8);
v8 = *(_QWORD *)(a1 + 72);
}
v3 = *(unsigned __int16 *)(v7 + v8) | (unsigned long long)(*(unsigned __int8 *)(v7 + v8 + 2) << 16);
if ( !v3 )
break;
v10 = *a2;
if ( v3 > *a2 )
v10 = *(unsigned __int16 *)(v7 + v8) | (unsigned long long)(*(unsigned __int8 *)(v7 + v8 + 2) << 16);
v11 = v8 + v10;
if ( v11 >= *(_QWORD *)(a1 + 80) )
{
if ( *(_QWORD *)(a1 + 88) <= v11 )
{
*(_BYTE *)(a1 + 148) = 1;
(*(void ( **)(_QWORD, long long, char *, _QWORD))(*(_QWORD *)a1 + 80LL))(
*(_QWORD *)(*(_QWORD *)a1 + 64LL),
2020LL,
SQLSTATE_UNKNOWN,
0LL);
}
else
{
v12 = (v11 + 4095) & 0xFFFFFFFFFFFFF000LL;
v7 = realloc(v7, v12 + 7);
if ( v7 )
{
*(_QWORD *)(a1 + 24) = v7;
*(_QWORD *)(a1 + 8) = v7;
*(_QWORD *)(a1 + 80) = v12;
*(_QWORD *)(a1 + 16) = v12 + v7;
v8 = *(_QWORD *)(a1 + 72);
goto LABEL_14;
}
*(_BYTE *)(a1 + 148) = 1;
}
LABEL_16:
v2 = 0xFFFFFFFFLL;
goto LABEL_17;
}
LABEL_14:
v4 = v7 + v8;
v2 = v3;
}
v2 = 0LL;
LABEL_17:
*(_BYTE *)(a1 + 128) = 0;
return v2;
}
| ma_real_read:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R13D,0xffffffff
XOR EAX,EAX
CMP byte ptr [RDI + 0x84],0x0
SETNZ AL
LEA R15,[RAX + RAX*0x2]
ADD R15,0x4
MOV qword ptr [RBP + -0x30],RSI
MOV qword ptr [RSI],0x0
MOV byte ptr [RDI + 0x80],0x1
MOV R12,qword ptr [RDI + 0x8]
ADD R12,qword ptr [RDI + 0x48]
MOV R14B,0x1
LAB_00133b1a:
MOV RDI,qword ptr [RBX]
MOV RSI,R12
MOV RDX,R15
CALL 0x0011ff31
TEST RAX,RAX
JLE 0x00133bff
ADD R12,RAX
SUB R15,RAX
JNZ 0x00133b1a
TEST R14B,0x1
JZ 0x00133c0c
MOV RAX,qword ptr [RBX + 0x8]
MOV R12,qword ptr [RBX + 0x48]
MOVZX ECX,byte ptr [RAX + R12*0x1 + 0x3]
INC ECX
MOV dword ptr [RBX + 0x60],ECX
MOV dword ptr [RBX + 0x64],ECX
CMP byte ptr [RBX + 0x84],0x0
JZ 0x00133b83
MOVZX ECX,word ptr [RAX + R12*0x1 + 0x4]
MOVZX EAX,byte ptr [RAX + R12*0x1 + 0x6]
SHL EAX,0x10
OR RAX,RCX
MOV RCX,qword ptr [RBP + -0x30]
MOV qword ptr [RCX],RAX
MOV RAX,qword ptr [RBX + 0x8]
MOV R12,qword ptr [RBX + 0x48]
LAB_00133b83:
MOVZX ECX,word ptr [RAX + R12*0x1]
MOVZX R15D,byte ptr [RAX + R12*0x1 + 0x2]
SHL R15D,0x10
OR R15,RCX
JZ 0x00133c25
MOV RCX,qword ptr [RBP + -0x30]
MOV R14,qword ptr [RCX]
CMP R15,R14
CMOVA R14,R15
ADD R14,R12
CMP R14,qword ptr [RBX + 0x50]
JC 0x00133bf1
CMP qword ptr [RBX + 0x58],R14
JBE 0x00133c2a
ADD R14,0xfff
AND R14,-0x1000
LEA RSI,[R14 + 0x7]
MOV RDI,RAX
CALL 0x00113730
TEST RAX,RAX
JZ 0x00133c51
MOV qword ptr [RBX + 0x18],RAX
MOV qword ptr [RBX + 0x8],RAX
MOV qword ptr [RBX + 0x50],R14
MOV RCX,RAX
ADD RCX,R14
MOV qword ptr [RBX + 0x10],RCX
MOV R12,qword ptr [RBX + 0x48]
LAB_00133bf1:
ADD R12,RAX
XOR R14D,R14D
MOV R13,R15
JMP 0x00133b1a
LAB_00133bff:
MOV byte ptr [RBX + 0x94],0x2
LAB_00133c06:
MOV R13D,0xffffffff
LAB_00133c0c:
MOV byte ptr [RBX + 0x80],0x0
MOV RAX,R13
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00133c25:
XOR R13D,R13D
JMP 0x00133c0c
LAB_00133c2a:
MOV byte ptr [RBX + 0x94],0x1
MOV R8,qword ptr [RBX]
MOV RDI,qword ptr [R8 + 0x40]
LEA RAX,[0x14bc90]
MOV RDX,qword ptr [RAX]
MOV ESI,0x7e4
XOR ECX,ECX
XOR EAX,EAX
CALL qword ptr [R8 + 0x50]
JMP 0x00133c06
LAB_00133c51:
MOV byte ptr [RBX + 0x94],0x1
JMP 0x00133c06
|
ulong ma_real_read(long *param_1,ulong *param_2)
{
char cVar1;
long lVar2;
void *__ptr;
int iVar3;
long lVar4;
ulong uVar5;
bool bVar6;
ulong uVar7;
uVar5 = 0xffffffff;
cVar1 = *(char *)((long)param_1 + 0x84);
*param_2 = 0;
*(int1 *)(param_1 + 0x10) = 1;
lVar4 = param_1[1] + param_1[9];
bVar6 = true;
uVar7 = (ulong)(cVar1 != '\0') * 3 + 4;
do {
do {
lVar2 = ma_pvio_cache_read(*param_1,lVar4,uVar7);
if (lVar2 < 1) {
*(int1 *)((long)param_1 + 0x94) = 2;
LAB_00133c06:
uVar5 = 0xffffffff;
LAB_00133c0c:
*(int1 *)(param_1 + 0x10) = 0;
return uVar5;
}
lVar4 = lVar4 + lVar2;
uVar7 = uVar7 - lVar2;
} while (uVar7 != 0);
if (!bVar6) goto LAB_00133c0c;
__ptr = (void *)param_1[1];
lVar4 = param_1[9];
iVar3 = *(byte *)((long)__ptr + lVar4 + 3) + 1;
*(int *)(param_1 + 0xc) = iVar3;
*(int *)((long)param_1 + 100) = iVar3;
if (*(char *)((long)param_1 + 0x84) != '\0') {
*param_2 = (ulong)CONCAT12(*(int1 *)((long)__ptr + lVar4 + 6),
*(int2 *)((long)__ptr + lVar4 + 4));
__ptr = (void *)param_1[1];
lVar4 = param_1[9];
}
uVar5 = (ulong)CONCAT12(*(int1 *)((long)__ptr + lVar4 + 2),
*(int2 *)((long)__ptr + lVar4));
if (uVar5 == 0) {
uVar5 = 0;
goto LAB_00133c0c;
}
uVar7 = *param_2;
if (*param_2 < uVar5) {
uVar7 = uVar5;
}
uVar7 = uVar7 + lVar4;
if ((ulong)param_1[10] <= uVar7) {
if ((ulong)param_1[0xb] <= uVar7) {
*(int1 *)((long)param_1 + 0x94) = 1;
(**(code **)(*param_1 + 0x50))(*(int8 *)(*param_1 + 0x40),0x7e4,SQLSTATE_UNKNOWN,0);
goto LAB_00133c06;
}
uVar7 = uVar7 + 0xfff & 0xfffffffffffff000;
__ptr = realloc(__ptr,uVar7 + 7);
if (__ptr == (void *)0x0) {
*(int1 *)((long)param_1 + 0x94) = 1;
goto LAB_00133c06;
}
param_1[3] = (long)__ptr;
param_1[1] = (long)__ptr;
param_1[10] = uVar7;
param_1[2] = (long)__ptr + uVar7;
lVar4 = param_1[9];
}
lVar4 = lVar4 + (long)__ptr;
bVar6 = false;
uVar7 = uVar5;
} while( true );
}
| |
41,582 | testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::~MatcherBase() | seiftnesse[P]memoryallocator/build_O1/_deps/googletest-src/googletest/include/gtest/gtest-matchers.h | ~MatcherBase() override { Destroy(); } | O1 | c | testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::~MatcherBase():
pushq %rax
leaq 0x1cfbe(%rip), %rax # 0x59b28
movq %rax, (%rdi)
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x3cb91
cmpq $0x0, 0x18(%rax)
je 0x3cb91
movq 0x10(%rdi), %rax
lock
decl (%rax)
jne 0x3cb91
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdi
callq *0x18(%rax)
popq %rax
retq
movq %rax, %rdi
callq 0xf6fa
nop
| _ZN7testing8internal11MatcherBaseIRKSt17basic_string_viewIcSt11char_traitsIcEEED2Ev:
push rax
lea rax, off_59B28
mov [rdi], rax
mov rax, [rdi+8]
test rax, rax
jz short loc_3CB91
cmp qword ptr [rax+18h], 0
jz short loc_3CB91
mov rax, [rdi+10h]
lock dec dword ptr [rax]
jnz short loc_3CB91
mov rax, [rdi+8]
mov rdi, [rdi+10h]
call qword ptr [rax+18h]
loc_3CB91:
pop rax
retn
mov rdi, rax
call __clang_call_terminate
| void __spoils<rdx,rcx,r8,r9,r10,r11,xmm4,xmm5> testing::internal::MatcherBase<std::string_view const&>::~MatcherBase(
long long a1)
{
long long v1; // rax
*(_QWORD *)a1 = &off_59B28;
v1 = *(_QWORD *)(a1 + 8);
if ( v1 && *(_QWORD *)(v1 + 24) && !_InterlockedDecrement(*(volatile signed __int32 **)(a1 + 16)) )
(*(void ( **)(_QWORD))(*(_QWORD *)(a1 + 8) + 24LL))(*(_QWORD *)(a1 + 16));
}
| ~MatcherBase:
PUSH RAX
LEA RAX,[0x159b28]
MOV qword ptr [RDI],RAX
MOV RAX,qword ptr [RDI + 0x8]
TEST RAX,RAX
JZ 0x0013cb91
CMP qword ptr [RAX + 0x18],0x0
JZ 0x0013cb91
MOV RAX,qword ptr [RDI + 0x10]
DEC.LOCK dword ptr [RAX]
JNZ 0x0013cb91
MOV RAX,qword ptr [RDI + 0x8]
MOV RDI,qword ptr [RDI + 0x10]
LAB_0013cb8e:
CALL qword ptr [RAX + 0x18]
LAB_0013cb91:
POP RAX
RET
|
/* testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char> >
const&>::~MatcherBase() */
int8 __thiscall
testing::internal::MatcherBase<std::basic_string_view<char,std::char_traits<char>>const&>::
~MatcherBase(MatcherBase<std::basic_string_view<char,std::char_traits<char>>const&> *this)
{
int *piVar1;
int8 in_RAX;
*(int ***)this = &PTR__MatcherBase_00159b28;
if ((*(long *)(this + 8) != 0) && (*(long *)(*(long *)(this + 8) + 0x18) != 0)) {
piVar1 = *(int **)(this + 0x10);
LOCK();
*piVar1 = *piVar1 + -1;
UNLOCK();
if (*piVar1 == 0) {
/* try { // try from 0013cb8e to 0013cb90 has its CatchHandler @ 0013cb93 */
(**(code **)(*(long *)(this + 8) + 0x18))(*(int8 *)(this + 0x10));
}
}
return in_RAX;
}
| |
41,583 | ItemInfoBuilder::~ItemInfoBuilder() | untodesu[P]voxelius/game/shared/item_registry.hh | virtual ~ItemInfoBuilder(void) = default; | O3 | cpp | ItemInfoBuilder::~ItemInfoBuilder():
pushq %rbx
movq %rdi, %rbx
movq 0x58(%rdi), %rdi
testq %rdi, %rdi
je 0x7b234
callq 0x2f116
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x7b24c
movq (%rax), %rsi
incq %rsi
callq 0x268e0
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x7b265
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x268e0
popq %rbx
retq
nop
| _ZN15ItemInfoBuilderD2Ev:
push rbx
mov rbx, rdi
mov rdi, [rdi+58h]
test rdi, rdi
jz short loc_7B234
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_7B234:
mov rdi, [rbx+28h]; void *
lea rax, [rbx+38h]
cmp rdi, rax
jz short loc_7B24C
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7B24C:
mov rdi, [rbx+8]; void *
add rbx, 18h
cmp rdi, rbx
jz short loc_7B265
mov rsi, [rbx]
inc rsi; unsigned __int64
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
loc_7B265:
pop rbx
retn
| void ItemInfoBuilder::~ItemInfoBuilder(ItemInfoBuilder *this)
{
volatile signed __int32 *v2; // rdi
char *v3; // rdi
_QWORD *v4; // rdi
_QWORD *v5; // rbx
v2 = (volatile signed __int32 *)*((_QWORD *)this + 11);
if ( v2 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v2);
v3 = (char *)*((_QWORD *)this + 5);
if ( v3 != (char *)this + 56 )
operator delete(v3, *((_QWORD *)this + 7) + 1LL);
v4 = (_QWORD *)*((_QWORD *)this + 1);
v5 = (_QWORD *)((char *)this + 24);
if ( v4 != v5 )
operator delete(v4, *v5 + 1LL);
}
| ~ItemInfoBuilder:
PUSH RBX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x58]
TEST RDI,RDI
JZ 0x0017b234
CALL 0x0012f116
LAB_0017b234:
MOV RDI,qword ptr [RBX + 0x28]
LEA RAX,[RBX + 0x38]
CMP RDI,RAX
JZ 0x0017b24c
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x001268e0
LAB_0017b24c:
MOV RDI,qword ptr [RBX + 0x8]
ADD RBX,0x18
CMP RDI,RBX
JZ 0x0017b265
MOV RSI,qword ptr [RBX]
INC RSI
POP RBX
JMP 0x001268e0
LAB_0017b265:
POP RBX
RET
|
/* ItemInfoBuilder::~ItemInfoBuilder() */
void __thiscall ItemInfoBuilder::~ItemInfoBuilder(ItemInfoBuilder *this)
{
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x58) !=
(_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 + 0x58));
}
if (*(ItemInfoBuilder **)(this + 0x28) != this + 0x38) {
operator_delete(*(ItemInfoBuilder **)(this + 0x28),*(long *)(this + 0x38) + 1);
}
if (*(ItemInfoBuilder **)(this + 8) != this + 0x18) {
operator_delete(*(ItemInfoBuilder **)(this + 8),*(long *)(this + 0x18) + 1);
return;
}
return;
}
| |
41,584 | testing::FormatCountableNoun[abi:cxx11](int, char const*, char const*) | seiftnesse[P]memoryallocator/build_O1/_deps/googletest-src/googletest/src/gtest.cc | static std::string FormatCountableNoun(int count, const char* singular_form,
const char* plural_form) {
return internal::StreamableToString(count) + " " +
(count == 1 ? singular_form : plural_form);
} | O1 | cpp | testing::FormatCountableNoun[abi:cxx11](int, char const*, char const*):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x4(%rsp), %rax
movl %esi, (%rax)
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x35203
leaq 0x1c244(%rip), %rsi # 0x42e3a
movq %r12, %rdi
callq 0x9a70
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x26c26
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x26c2e
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
cmpl $0x1, 0x4(%rsp)
cmoveq %r15, %r14
movq %r14, %rsi
callq 0x9a70
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x26c7d
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x26c83
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x26cb1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x94c0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x26ccc
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x94c0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x26cfa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x94c0
jmp 0x26cfa
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x26d15
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x94c0
movq %rbx, %rdi
callq 0x99a0
nop
| _ZN7testingL19FormatCountableNounB5cxx11EiPKcS1_:
push r15
push r14
push r12
push rbx
sub rsp, 48h
mov r14, rcx
mov r15, rdx
mov rbx, rdi
lea rax, [rsp+68h+var_64]
mov [rax], esi
lea r12, [rsp+68h+var_40]
mov rdi, r12
mov rsi, rax
call _ZN7testing8internal18StreamableToStringIiEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKT_; testing::internal::StreamableToString<int>(int const&)
lea rsi, asc_42E38+2; " "
mov rdi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea r12, [rsp+68h+var_50]
mov [r12-10h], r12
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_26C26
mov [rsp+68h+var_60], rdx
mov rdx, [rcx]
mov [rsp+68h+var_50], rdx
jmp short loc_26C2E
loc_26C26:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r12], xmm0
loc_26C2E:
mov rdx, [rax+8]
lea rdi, [rsp+68h+var_60]
mov [rdi+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
cmp [rsp+68h+var_64], 1
cmovz r14, r15
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rdx, [rbx+10h]
mov [rbx], rdx
mov rsi, [rax]
mov rcx, rax
add rcx, 10h
cmp rsi, rcx
jz short loc_26C7D
mov [rbx], rsi
mov rdx, [rcx]
mov [rbx+10h], rdx
jmp short loc_26C83
loc_26C7D:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rdx], xmm0
loc_26C83:
mov rdx, [rax+8]
mov [rbx+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rdi, [rsp+68h+var_60]; void *
cmp rdi, r12
jz short loc_26CB1
mov rsi, [rsp+68h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_26CB1:
lea rax, [rsp+68h+var_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_26CCC
mov rsi, [rsp+68h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_26CCC:
mov rax, rbx
add rsp, 48h
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, r12
jz short loc_26CFA
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_26CFA
mov rbx, rax
loc_26CFA:
lea rax, [rsp+arg_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_26D15
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_26D15:
mov rdi, rbx
call __Unwind_Resume
| long long testing::FormatCountableNoun[abi:cxx11](long long a1, int a2, const char *a3, const char *a4)
{
long long v6; // rax
__int128 *v7; // rcx
long long v8; // rax
_OWORD *v9; // rcx
int v11; // [rsp+4h] [rbp-64h] BYREF
void *v12[2]; // [rsp+8h] [rbp-60h] BYREF
__int128 v13; // [rsp+18h] [rbp-50h] BYREF
void *v14[2]; // [rsp+28h] [rbp-40h] BYREF
long long v15; // [rsp+38h] [rbp-30h] BYREF
v11 = a2;
testing::internal::StreamableToString<int>(v14, &v11);
v6 = std::string::append(v14, " ");
v12[0] = &v13;
v7 = (__int128 *)(v6 + 16);
if ( *(_QWORD *)v6 == v6 + 16 )
{
v13 = *v7;
}
else
{
v12[0] = *(void **)v6;
*(_QWORD *)&v13 = *(_QWORD *)v7;
}
v12[1] = *(void **)(v6 + 8);
*(_QWORD *)v6 = v7;
*(_QWORD *)(v6 + 8) = 0LL;
*(_BYTE *)(v6 + 16) = 0;
if ( v11 == 1 )
a4 = a3;
v8 = std::string::append(v12, a4);
*(_QWORD *)a1 = a1 + 16;
v9 = (_OWORD *)(v8 + 16);
if ( *(_QWORD *)v8 == v8 + 16 )
{
*(_OWORD *)(a1 + 16) = *v9;
}
else
{
*(_QWORD *)a1 = *(_QWORD *)v8;
*(_QWORD *)(a1 + 16) = *(_QWORD *)v9;
}
*(_QWORD *)(a1 + 8) = *(_QWORD *)(v8 + 8);
*(_QWORD *)v8 = v9;
*(_QWORD *)(v8 + 8) = 0LL;
*(_BYTE *)(v8 + 16) = 0;
if ( v12[0] != &v13 )
operator delete(v12[0], v13 + 1);
if ( v14[0] != &v15 )
operator delete(v14[0], v15 + 1);
return a1;
}
| FormatCountableNoun[abi:cxx11]:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R14,RCX
MOV R15,RDX
MOV RBX,RDI
LEA RAX,[RSP + 0x4]
MOV dword ptr [RAX],ESI
LEA R12,[RSP + 0x28]
MOV RDI,R12
MOV RSI,RAX
CALL 0x00135203
LAB_00126bef:
LEA RSI,[0x142e3a]
MOV RDI,R12
CALL 0x00109a70
LEA R12,[RSP + 0x18]
MOV qword ptr [R12 + -0x10],R12
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x00126c26
MOV qword ptr [RSP + 0x8],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x18],RDX
JMP 0x00126c2e
LAB_00126c26:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R12],XMM0
LAB_00126c2e:
MOV RDX,qword ptr [RAX + 0x8]
LEA RDI,[RSP + 0x8]
MOV qword ptr [RDI + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
CMP dword ptr [RSP + 0x4],0x1
CMOVZ R14,R15
LAB_00126c53:
MOV RSI,R14
CALL 0x00109a70
LAB_00126c5b:
LEA RDX,[RBX + 0x10]
MOV qword ptr [RBX],RDX
MOV RSI,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RSI,RCX
JZ 0x00126c7d
MOV qword ptr [RBX],RSI
MOV RDX,qword ptr [RCX]
MOV qword ptr [RBX + 0x10],RDX
JMP 0x00126c83
LAB_00126c7d:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RDX],XMM0
LAB_00126c83:
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RBX + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R12
JZ 0x00126cb1
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001094c0
LAB_00126cb1:
LEA RAX,[RSP + 0x38]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00126ccc
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x001094c0
LAB_00126ccc:
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R12
POP R14
POP R15
RET
|
/* testing::FormatCountableNoun[abi:cxx11](int, char const*, char const*) */
long * testing::FormatCountableNoun_abi_cxx11_(int param_1,char *param_2,char *param_3)
{
long lVar1;
long *plVar2;
int8 *puVar3;
long *plVar4;
int4 in_register_0000003c;
long *plVar5;
int local_64;
long *local_60;
long local_58;
long local_50;
long lStack_48;
long *local_40 [2];
long local_30 [2];
plVar5 = (long *)CONCAT44(in_register_0000003c,param_1);
local_64 = (int)param_2;
internal::StreamableToString<int>((internal *)local_40,&local_64);
/* try { // try from 00126bef to 00126bfd has its CatchHandler @ 00126cf7 */
plVar2 = (long *)std::__cxx11::string::append((char *)local_40);
plVar4 = plVar2 + 2;
if ((long *)*plVar2 == plVar4) {
local_50 = *plVar4;
lStack_48 = plVar2[3];
local_60 = &local_50;
}
else {
local_50 = *plVar4;
local_60 = (long *)*plVar2;
}
local_58 = plVar2[1];
*plVar2 = (long)plVar4;
plVar2[1] = 0;
*(int1 *)(plVar2 + 2) = 0;
/* try { // try from 00126c53 to 00126c5a has its CatchHandler @ 00126cdb */
puVar3 = (int8 *)std::__cxx11::string::append((char *)&local_60);
*plVar5 = (long)(plVar5 + 2);
plVar2 = puVar3 + 2;
if ((long *)*puVar3 == plVar2) {
lVar1 = puVar3[3];
plVar5[2] = *plVar2;
plVar5[3] = lVar1;
}
else {
*plVar5 = (long)*puVar3;
plVar5[2] = *plVar2;
}
plVar5[1] = puVar3[1];
*puVar3 = plVar2;
puVar3[1] = 0;
*(int1 *)(puVar3 + 2) = 0;
if (local_60 != &local_50) {
operator_delete(local_60,local_50 + 1);
}
if (local_40[0] != local_30) {
operator_delete(local_40[0],local_30[0] + 1);
}
return plVar5;
}
| |
41,585 | JS_ThrowPlainError | bluesky950520[P]quickjs/quickjs.c | JSValue __attribute__((format(printf, 2, 3))) JS_ThrowPlainError(JSContext *ctx, const char *fmt, ...)
{
JSValue val;
va_list ap;
va_start(ap, fmt);
val = JS_ThrowError(ctx, JS_PLAIN_ERROR, fmt, ap);
va_end(ap);
return val;
} | O0 | c | JS_ThrowPlainError:
subq $0x108, %rsp # imm = 0x108
testb %al, %al
je 0x2d08c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rdi, 0xe8(%rsp)
movq %rsi, 0xe0(%rsp)
movq %rsp, %rax
movq %rax, 0xd0(%rsp)
leaq 0x110(%rsp), %rax
movq %rax, 0xc8(%rsp)
movl $0x30, 0xc4(%rsp)
movl $0x10, 0xc0(%rsp)
movq 0xe8(%rsp), %rdi
movq 0xe0(%rsp), %rdx
movl $0x8, %esi
leaq 0xc0(%rsp), %rcx
callq 0x2d140
movq %rax, 0xb0(%rsp)
movq %rdx, 0xb8(%rsp)
movups 0xb0(%rsp), %xmm0
movaps %xmm0, 0xf0(%rsp)
movq 0xf0(%rsp), %rax
movq 0xf8(%rsp), %rdx
addq $0x108, %rsp # imm = 0x108
retq
nopl (%rax,%rax)
| JS_ThrowPlainError:
sub rsp, 108h
test al, al
jz short loc_2D08C
movaps [rsp+108h+var_D8], xmm0
movaps [rsp+108h+var_C8], xmm1
movaps [rsp+108h+var_B8], xmm2
movaps [rsp+108h+var_A8], xmm3
movaps [rsp+108h+var_98], xmm4
movaps [rsp+108h+var_88], xmm5
movaps [rsp+108h+var_78], xmm6
movaps [rsp+108h+var_68], xmm7
loc_2D08C:
mov [rsp+108h+var_E0], r9
mov [rsp+108h+var_E8], r8
mov [rsp+108h+var_F0], rcx
mov [rsp+108h+var_F8], rdx
mov [rsp+108h+var_20], rdi
mov [rsp+108h+var_28], rsi
mov rax, rsp
mov [rsp+108h+var_38], rax
lea rax, [rsp+108h+arg_0]
mov [rsp+108h+var_40], rax
mov [rsp+108h+var_44], 30h ; '0'
mov [rsp+108h+var_48], 10h
mov rdi, [rsp+108h+var_20]
mov rdx, [rsp+108h+var_28]
mov esi, 8
lea rcx, [rsp+108h+var_48]
call JS_ThrowError
mov qword ptr [rsp+108h+var_58], rax
mov qword ptr [rsp+108h+var_58+8], rdx
movups xmm0, [rsp+108h+var_58]
movaps [rsp+108h+var_18], xmm0
mov rax, qword ptr [rsp+108h+var_18]
mov rdx, qword ptr [rsp+108h+var_18+8]
add rsp, 108h
retn
| long long JS_ThrowPlainError(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
_QWORD v16[6]; // [rsp+0h] [rbp-108h] BYREF
__m128 v17; // [rsp+30h] [rbp-D8h]
__m128 v18; // [rsp+40h] [rbp-C8h]
__m128 v19; // [rsp+50h] [rbp-B8h]
__m128 v20; // [rsp+60h] [rbp-A8h]
__m128 v21; // [rsp+70h] [rbp-98h]
__m128 v22; // [rsp+80h] [rbp-88h]
__m128 v23; // [rsp+90h] [rbp-78h]
__m128 v24; // [rsp+A0h] [rbp-68h]
_DWORD v25[2]; // [rsp+C0h] [rbp-48h] BYREF
char *v26; // [rsp+C8h] [rbp-40h]
_QWORD *v27; // [rsp+D0h] [rbp-38h]
long long v28; // [rsp+E0h] [rbp-28h]
long long v29; // [rsp+E8h] [rbp-20h]
v17 = a7;
v18 = a8;
v19 = a9;
v20 = a10;
v21 = a11;
v22 = a12;
v23 = a13;
v24 = a14;
v16[5] = a6;
v16[4] = a5;
v16[3] = a4;
v16[2] = a3;
v29 = a1;
v28 = a2;
v27 = v16;
v26 = &a15;
v25[1] = 48;
v25[0] = 16;
return JS_ThrowError(a1, 8LL, a2, v25);
}
| JS_ThrowPlainError:
SUB RSP,0x108
TEST AL,AL
JZ 0x0012d08c
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVAPS xmmword ptr [RSP + 0x40],XMM1
MOVAPS xmmword ptr [RSP + 0x50],XMM2
MOVAPS xmmword ptr [RSP + 0x60],XMM3
MOVAPS xmmword ptr [RSP + 0x70],XMM4
MOVAPS xmmword ptr [RSP + 0x80],XMM5
MOVAPS xmmword ptr [RSP + 0x90],XMM6
MOVAPS xmmword ptr [RSP + 0xa0],XMM7
LAB_0012d08c:
MOV qword ptr [RSP + 0x28],R9
MOV qword ptr [RSP + 0x20],R8
MOV qword ptr [RSP + 0x18],RCX
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RSP + 0xe8],RDI
MOV qword ptr [RSP + 0xe0],RSI
MOV RAX,RSP
MOV qword ptr [RSP + 0xd0],RAX
LEA RAX,[RSP + 0x110]
MOV qword ptr [RSP + 0xc8],RAX
MOV dword ptr [RSP + 0xc4],0x30
MOV dword ptr [RSP + 0xc0],0x10
MOV RDI,qword ptr [RSP + 0xe8]
MOV RDX,qword ptr [RSP + 0xe0]
MOV ESI,0x8
LEA RCX,[RSP + 0xc0]
CALL 0x0012d140
MOV qword ptr [RSP + 0xb0],RAX
MOV qword ptr [RSP + 0xb8],RDX
MOVUPS XMM0,xmmword ptr [RSP + 0xb0]
MOVAPS xmmword ptr [RSP + 0xf0],XMM0
MOV RAX,qword ptr [RSP + 0xf0]
MOV RDX,qword ptr [RSP + 0xf8]
ADD RSP,0x108
RET
|
int1 [16]
JS_ThrowPlainError(int4 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int8 param_9,int8 param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
int1 auVar1 [16];
char in_AL;
int1 auStack_108 [16];
int8 local_f8;
int8 local_f0;
int8 local_e8;
int8 local_e0;
int4 local_d8;
int8 local_c8;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int4 local_48;
int4 local_44;
int1 *local_40;
int1 *local_38;
int8 local_28;
int8 local_20;
local_38 = auStack_108;
if (in_AL != '\0') {
local_d8 = param_1;
local_c8 = param_2;
local_b8 = param_3;
local_a8 = param_4;
local_98 = param_5;
local_88 = param_6;
local_78 = param_7;
local_68 = param_8;
}
local_40 = &stack0x00000008;
local_44 = 0x30;
local_48 = 0x10;
local_f8 = param_11;
local_f0 = param_12;
local_e8 = param_13;
local_e0 = param_14;
local_28 = param_10;
local_20 = param_9;
auVar1 = JS_ThrowError(param_9,8,param_10,&local_48);
return auVar1;
}
| |
41,586 | JS_ThrowPlainError | bluesky950520[P]quickjs/quickjs.c | JSValue __attribute__((format(printf, 2, 3))) JS_ThrowPlainError(JSContext *ctx, const char *fmt, ...)
{
JSValue val;
va_list ap;
va_start(ap, fmt);
val = JS_ThrowError(ctx, JS_PLAIN_ERROR, fmt, ap);
va_end(ap);
return val;
} | O1 | c | JS_ThrowPlainError:
subq $0xd8, %rsp
movq %rsi, %r10
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x22414
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rcx
movq %rsi, 0x10(%rcx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax # imm = 0x3000000010
movq %rax, (%rcx)
movl $0x8, %esi
movq %r10, %rdx
callq 0x22450
movl $0x6, %edx
xorl %eax, %eax
addq $0xd8, %rsp
retq
| JS_ThrowPlainError:
sub rsp, 0D8h
mov r10, rsi
lea rsi, [rsp+0D8h+var_B8]
mov [rsi+10h], rdx
mov [rsi+18h], rcx
mov [rsi+20h], r8
mov [rsi+28h], r9
test al, al
jz short loc_22414
movaps [rsp+0D8h+var_88], xmm0
movaps [rsp+0D8h+var_78], xmm1
movaps [rsp+0D8h+var_68], xmm2
movaps [rsp+0D8h+var_58], xmm3
movaps [rsp+0D8h+var_48], xmm4
movaps [rsp+0D8h+var_38], xmm5
movaps [rsp+0D8h+var_28], xmm6
movaps [rsp+0D8h+var_18], xmm7
loc_22414:
mov rcx, rsp
mov [rcx+10h], rsi
lea rax, [rsp+0D8h+arg_0]
mov [rcx+8], rax
mov rax, 3000000010h
mov [rcx], rax
mov esi, 8
mov rdx, r10
call JS_ThrowError
mov edx, 6
xor eax, eax
add rsp, 0D8h
retn
| long long JS_ThrowPlainError(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
_QWORD v16[4]; // [rsp+0h] [rbp-D8h] BYREF
char v17; // [rsp+20h] [rbp-B8h] BYREF
long long v18; // [rsp+30h] [rbp-A8h]
long long v19; // [rsp+38h] [rbp-A0h]
long long v20; // [rsp+40h] [rbp-98h]
long long v21; // [rsp+48h] [rbp-90h]
__m128 v22; // [rsp+50h] [rbp-88h]
__m128 v23; // [rsp+60h] [rbp-78h]
__m128 v24; // [rsp+70h] [rbp-68h]
__m128 v25; // [rsp+80h] [rbp-58h]
__m128 v26; // [rsp+90h] [rbp-48h]
__m128 v27; // [rsp+A0h] [rbp-38h]
__m128 v28; // [rsp+B0h] [rbp-28h]
__m128 v29; // [rsp+C0h] [rbp-18h]
v22 = a7;
v23 = a8;
v24 = a9;
v25 = a10;
v26 = a11;
v27 = a12;
v28 = a13;
v29 = a14;
v18 = a3;
v19 = a4;
v20 = a5;
v21 = a6;
v16[2] = &v17;
v16[1] = &a15;
v16[0] = 0x3000000010LL;
((void ( *)(long long, long long, long long, _QWORD *, long long, long long))JS_ThrowError)(a1, 8LL, a2, v16, a5, a6);
return 0LL;
}
| |||
41,587 | convert_from_long | eloqsql/libmariadb/libmariadb/ma_stmt_codec.c | static void convert_from_long(MYSQL_BIND *r_param, const MYSQL_FIELD *field, longlong val, my_bool is_unsigned)
{
switch (r_param->buffer_type) {
case MYSQL_TYPE_TINY:
*(uchar *)r_param->buffer= (uchar)val;
*r_param->error= r_param->is_unsigned ? NUMERIC_TRUNCATION(val, 0, UINT_MAX8) : NUMERIC_TRUNCATION(val, INT_MIN8, INT_MAX8);
r_param->buffer_length= 1;
break;
case MYSQL_TYPE_SHORT:
case MYSQL_TYPE_YEAR:
shortstore(r_param->buffer, (short)val);
*r_param->error= r_param->is_unsigned ? NUMERIC_TRUNCATION(val, 0, UINT_MAX16) : NUMERIC_TRUNCATION(val, INT_MIN16, INT_MAX16);
r_param->buffer_length= 2;
break;
case MYSQL_TYPE_LONG:
longstore(r_param->buffer, (int32)val);
*r_param->error= r_param->is_unsigned ? NUMERIC_TRUNCATION(val, 0, UINT_MAX32) : NUMERIC_TRUNCATION(val, INT_MIN32, INT_MAX32);
r_param->buffer_length= 4;
break;
case MYSQL_TYPE_LONGLONG:
*r_param->error= (val < 0 && r_param->is_unsigned != is_unsigned);
longlongstore(r_param->buffer, val);
r_param->buffer_length= 8;
break;
case MYSQL_TYPE_DOUBLE:
{
volatile double dbl;
dbl= (is_unsigned) ? ulonglong2double((ulonglong)val) : (double)val;
doublestore(r_param->buffer, dbl);
*r_param->error = (dbl != ceil(dbl)) ||
(is_unsigned ? (ulonglong )dbl != (ulonglong)val :
(longlong)dbl != (longlong)val);
r_param->buffer_length= 8;
break;
}
case MYSQL_TYPE_FLOAT:
{
volatile float fval;
fval= is_unsigned ? (float)(ulonglong)(val) : (float)val;
floatstore((uchar *)r_param->buffer, fval);
*r_param->error= (fval != ceilf(fval)) ||
(is_unsigned ? (ulonglong)fval != (ulonglong)val :
(longlong)fval != val);
r_param->buffer_length= 4;
}
break;
default:
{
char *buffer;
char *endptr;
uint len;
my_bool zf_truncated= 0;
buffer= alloca(MAX(field->length, 22));
endptr= ma_ll2str(val, buffer, is_unsigned ? 10 : -10);
len= (uint)(endptr - buffer);
/* check if field flag is zerofill */
if (field->flags & ZEROFILL_FLAG)
{
uint display_width= MAX(field->length, len);
if (display_width < r_param->buffer_length)
{
ma_bmove_upp(buffer + display_width, buffer + len, len);
/* coverity[bad_memset] */
memset((void*) buffer, (int) '0', display_width - len);
len= display_width;
}
else
zf_truncated= 1;
}
convert_froma_string(r_param, buffer, len);
*r_param->error+= zf_truncated;
}
break;
}
} | O3 | c | convert_from_long:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r15d
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movl 0x60(%rdi), %eax
decl %eax
cmpl $0xc, %eax
ja 0x24ecb
leaq 0x1446a(%rip), %rcx # 0x392ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%r14), %rax
movb %bl, (%rax)
movq 0x10(%r14), %rax
movb %bh, 0x1(%rax)
xorl %eax, %eax
cmpq $0x10000, %rbx # imm = 0x10000
setae %al
movswq %bx, %rcx
xorl %edx, %edx
cmpq %rbx, %rcx
setne %dl
cmpb $0x0, 0x65(%r14)
cmovel %edx, %eax
movq 0x18(%r14), %rcx
movb %al, (%rcx)
movq $0x2, 0x40(%r14)
jmp 0x25196
movq 0x38(%r13), %rax
cmpq $0x17, %rax
movl $0x16, %ecx
cmovaeq %rax, %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %r12
subq %rcx, %r12
movq %r12, %rsp
testb %r15b, %r15b
movl $0xfffffff6, %eax # imm = 0xFFFFFFF6
movl $0xa, %edx
cmovel %eax, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x33364
subq %r12, %rax
testb $0x40, 0x64(%r13)
jne 0x24ffa
movl %eax, %ebx
jmp 0x2504e
testb %r15b, %r15b
je 0x25056
movq %rbx, %xmm1
punpckldq 0x1446d(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x14475(%rip), %xmm1 # 0x393b0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0 # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
jmp 0x2505b
testq %rbx, %rbx
js 0x25160
xorl %eax, %eax
jmp 0x25167
movq 0x10(%r14), %rax
movb %bl, (%rax)
xorl %eax, %eax
cmpq $0x100, %rbx # imm = 0x100
setae %al
movsbq %bl, %rcx
xorl %edx, %edx
cmpq %rbx, %rcx
setne %dl
cmpb $0x0, 0x65(%r14)
cmovel %edx, %eax
movq 0x18(%r14), %rcx
movb %al, (%rcx)
movq $0x1, 0x40(%r14)
jmp 0x25196
movq 0x10(%r14), %rax
movb %bl, (%rax)
movq 0x10(%r14), %rax
movb %bh, 0x1(%rax)
movl %ebx, %eax
shrl $0x10, %eax
movq 0x10(%r14), %rcx
movb %al, 0x2(%rcx)
movslq %ebx, %rax
movl %ebx, %ecx
shrl $0x18, %ecx
movq 0x10(%r14), %rdx
movb %cl, 0x3(%rdx)
xorl %ecx, %ecx
movq %rbx, %rdx
shrq $0x20, %rdx
setne %cl
xorl %edx, %edx
cmpq %rbx, %rax
setne %dl
cmpb $0x0, 0x65(%r14)
cmovel %edx, %ecx
movq 0x18(%r14), %rax
movb %cl, (%rax)
jmp 0x25156
cvtsi2ss %rbx, %xmm0
testq %rbx, %rbx
js 0x250cc
movaps %xmm0, %xmm1
jmp 0x250e3
movq 0x38(%r13), %rdx
movl %eax, %ecx
cmpq %rcx, %rdx
cmovbeq %rcx, %rdx
movl %edx, %ebx
movb $0x1, %r15b
cmpq 0x40(%r14), %rbx
jae 0x2517e
testq %rcx, %rcx
je 0x2503f
leaq (%rcx,%r12), %rsi
decq %rsi
negq %rcx
leaq (%rbx,%r12), %rdi
decq %rdi
xorl %r8d, %r8d
movb (%rsi,%r8), %r9b
movb %r9b, (%rdi,%r8)
decq %r8
cmpq %r8, %rcx
jne 0x2502f
subl %eax, %edx
movq %r12, %rdi
movl $0x30, %esi
callq 0x13260
xorl %r15d, %r15d
jmp 0x25181
cvtsi2sd %rbx, %xmm0
movsd %xmm0, -0x38(%rbp)
movq 0x10(%r14), %rax
movsd %xmm0, (%rax)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x130e0
movb $0x1, %al
movsd -0x40(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jne 0x250c1
jp 0x250c1
movsd -0x38(%rbp), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
cvttsd2si %xmm0, %rdx
subsd 0x13c13(%rip), %xmm0 # 0x38cb8
cvttsd2si %xmm0, %rsi
sarq $0x3f, %rcx
andq %rcx, %rsi
orq %rax, %rsi
testb %r15b, %r15b
cmoveq %rdx, %rsi
cmpq %rbx, %rsi
setne %al
movq 0x18(%r14), %rcx
movb %al, (%rcx)
jmp 0x25174
movq %rbx, %rax
shrq %rax
movl %ebx, %ecx
andl $0x1, %ecx
orq %rax, %rcx
cvtsi2ss %rcx, %xmm1
addss %xmm1, %xmm1
testb %r15b, %r15b
je 0x250eb
movaps %xmm1, %xmm0
movss %xmm0, -0x38(%rbp)
movq 0x10(%r14), %rax
movss %xmm0, (%rax)
movss -0x38(%rbp), %xmm0
movss %xmm0, -0x40(%rbp)
movss -0x38(%rbp), %xmm0
callq 0x13270
movb $0x1, %al
movss -0x40(%rbp), %xmm1
ucomiss %xmm0, %xmm1
jne 0x25150
jp 0x25150
movss -0x38(%rbp), %xmm0
cvttss2si %xmm0, %rax
movq %rax, %rcx
cvttss2si %xmm0, %rdx
subss 0xfed0(%rip), %xmm0 # 0x35004
cvttss2si %xmm0, %rsi
sarq $0x3f, %rcx
andq %rcx, %rsi
orq %rax, %rsi
testb %r15b, %r15b
cmoveq %rdx, %rsi
cmpq %rbx, %rsi
setne %al
movq 0x18(%r14), %rcx
movb %al, (%rcx)
movq $0x4, 0x40(%r14)
jmp 0x25196
cmpb %r15b, 0x65(%r14)
setne %al
movq 0x18(%r14), %rcx
movb %al, (%rcx)
movq 0x10(%r14), %rax
movq %rbx, (%rax)
movq $0x8, 0x40(%r14)
jmp 0x25196
movq %rcx, %rbx
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x251b9
movq 0x18(%r14), %rax
addb %r15b, (%rax)
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x251b4
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13500
| convert_from_long:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r15d, ecx
mov rbx, rdx
mov r13, rsi
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov eax, [rdi+60h]
dec eax; switch 13 cases
cmp eax, 0Ch
ja short def_24E89; jumptable 0000000000024E89 default case, cases 6,7,9-12
lea rcx, jpt_24E89
movsxd rax, ds:(jpt_24E89 - 392ECh)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_24E8B:
mov rax, [r14+10h]; jumptable 0000000000024E89 cases 2,13
mov [rax], bl
mov rax, [r14+10h]
mov [rax+1], bh
xor eax, eax
cmp rbx, 10000h
setnb al
movsx rcx, bx
xor edx, edx
cmp rcx, rbx
setnz dl
cmp byte ptr [r14+65h], 0
cmovz eax, edx
mov rcx, [r14+18h]
mov [rcx], al
mov qword ptr [r14+40h], 2
jmp loc_25196
def_24E89:
mov rax, [r13+38h]; jumptable 0000000000024E89 default case, cases 6,7,9-12
cmp rax, 17h
mov ecx, 16h
cmovnb rcx, rax
add rcx, 0Fh
and rcx, 0FFFFFFFFFFFFFFF0h
mov r12, rsp
sub r12, rcx
mov rsp, r12
test r15b, r15b
mov eax, 0FFFFFFF6h
mov edx, 0Ah
cmovz edx, eax
mov rdi, rbx
mov rsi, r12
call ma_ll2str
sub rax, r12
test byte ptr [r13+64h], 40h
jnz loc_24FFA
mov ebx, eax
jmp loc_2504E
loc_24F1D:
test r15b, r15b; jumptable 0000000000024E89 case 5
jz loc_25056
movq xmm1, rbx
punpckldq xmm1, cs:xmmword_393A0
subpd xmm1, cs:xmmword_393B0
movapd xmm0, xmm1
unpckhpd xmm0, xmm1
addsd xmm0, xmm1
jmp loc_2505B
loc_24F4C:
test rbx, rbx; jumptable 0000000000024E89 case 8
js loc_25160
xor eax, eax
jmp loc_25167
loc_24F5C:
mov rax, [r14+10h]; jumptable 0000000000024E89 case 1
mov [rax], bl
xor eax, eax
cmp rbx, 100h
setnb al
movsx rcx, bl
xor edx, edx
cmp rcx, rbx
setnz dl
cmp byte ptr [r14+65h], 0
cmovz eax, edx
mov rcx, [r14+18h]
mov [rcx], al
mov qword ptr [r14+40h], 1
jmp loc_25196
loc_24F95:
mov rax, [r14+10h]; jumptable 0000000000024E89 case 3
mov [rax], bl
mov rax, [r14+10h]
mov [rax+1], bh
mov eax, ebx
shr eax, 10h
mov rcx, [r14+10h]
mov [rcx+2], al
movsxd rax, ebx
mov ecx, ebx
shr ecx, 18h
mov rdx, [r14+10h]
mov [rdx+3], cl
xor ecx, ecx
mov rdx, rbx
shr rdx, 20h
setnz cl
xor edx, edx
cmp rax, rbx
setnz dl
cmp byte ptr [r14+65h], 0
cmovz ecx, edx
mov rax, [r14+18h]
mov [rax], cl
jmp loc_25156
loc_24FE4:
cvtsi2ss xmm0, rbx; jumptable 0000000000024E89 case 4
test rbx, rbx
js loc_250CC
movaps xmm1, xmm0
jmp loc_250E3
loc_24FFA:
mov rdx, [r13+38h]
mov ecx, eax
cmp rdx, rcx
cmovbe rdx, rcx
mov ebx, edx
mov r15b, 1
cmp rbx, [r14+40h]
jnb loc_2517E
test rcx, rcx
jz short loc_2503F
lea rsi, [rcx+r12]
dec rsi
neg rcx
lea rdi, [rbx+r12]
dec rdi
xor r8d, r8d
loc_2502F:
mov r9b, [rsi+r8]
mov [rdi+r8], r9b
dec r8
cmp rcx, r8
jnz short loc_2502F
loc_2503F:
sub edx, eax
mov rdi, r12
mov esi, 30h ; '0'
call _memset
loc_2504E:
xor r15d, r15d
jmp loc_25181
loc_25056:
cvtsi2sd xmm0, rbx
loc_2505B:
movsd [rbp+var_38], xmm0
mov rax, [r14+10h]
movsd qword ptr [rax], xmm0
movsd xmm0, [rbp+var_38]
movsd [rbp+var_40], xmm0
movsd xmm0, [rbp+var_38]
call _ceil
mov al, 1
movsd xmm1, [rbp+var_40]
ucomisd xmm1, xmm0
jnz short loc_250C1
jp short loc_250C1
movsd xmm0, [rbp+var_38]
cvttsd2si rax, xmm0
mov rcx, rax
cvttsd2si rdx, xmm0
subsd xmm0, cs:qword_38CB8
cvttsd2si rsi, xmm0
sar rcx, 3Fh
and rsi, rcx
or rsi, rax
test r15b, r15b
cmovz rsi, rdx
cmp rsi, rbx
setnz al
loc_250C1:
mov rcx, [r14+18h]
mov [rcx], al
jmp loc_25174
loc_250CC:
mov rax, rbx
shr rax, 1
mov ecx, ebx
and ecx, 1
or rcx, rax
cvtsi2ss xmm1, rcx
addss xmm1, xmm1
loc_250E3:
test r15b, r15b
jz short loc_250EB
movaps xmm0, xmm1
loc_250EB:
movss dword ptr [rbp+var_38], xmm0
mov rax, [r14+10h]
movss dword ptr [rax], xmm0
movss xmm0, dword ptr [rbp+var_38]
movss dword ptr [rbp+var_40], xmm0
movss xmm0, dword ptr [rbp+var_38]
call _ceilf
mov al, 1
movss xmm1, dword ptr [rbp+var_40]
ucomiss xmm1, xmm0
jnz short loc_25150
jp short loc_25150
movss xmm0, dword ptr [rbp+var_38]
cvttss2si rax, xmm0
mov rcx, rax
cvttss2si rdx, xmm0
subss xmm0, cs:dword_35004
cvttss2si rsi, xmm0
sar rcx, 3Fh
and rsi, rcx
or rsi, rax
test r15b, r15b
cmovz rsi, rdx
cmp rsi, rbx
setnz al
loc_25150:
mov rcx, [r14+18h]
mov [rcx], al
loc_25156:
mov qword ptr [r14+40h], 4
jmp short loc_25196
loc_25160:
cmp [r14+65h], r15b
setnz al
loc_25167:
mov rcx, [r14+18h]
mov [rcx], al
mov rax, [r14+10h]
mov [rax], rbx
loc_25174:
mov qword ptr [r14+40h], 8
jmp short loc_25196
loc_2517E:
mov rbx, rcx
loc_25181:
mov rdi, r14
mov rsi, r12
mov rdx, rbx
call convert_froma_string
mov rax, [r14+18h]
add [rax], r15b
loc_25196:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_251B4
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_251B4:
call ___stack_chk_fail
| unsigned long long convert_from_long(
long long a1,
long long a2,
unsigned long long a3,
unsigned __int8 a4,
double a5,
double a6)
{
bool v8; // al
bool v9; // dl
long long v10; // rcx
unsigned long long v11; // rcx
char *v12; // r12
long long v13; // rdx
unsigned int v14; // eax
long long v15; // rbx
__m128d v16; // xmm1
double v17; // xmm0_8
bool v18; // al
bool v19; // al
bool v20; // dl
bool v21; // cl
bool v22; // dl
unsigned long long v23; // rdx
char v24; // r15
long long v25; // r8
double v26; // xmm0_8
bool v27; // al
long long v28; // rsi
float v29; // xmm0_4
bool v30; // al
long long v31; // rsi
double v33; // [rsp+0h] [rbp-40h] BYREF
double v34; // [rsp+8h] [rbp-38h]
unsigned long long v35; // [rsp+10h] [rbp-30h]
v35 = __readfsqword(0x28u);
switch ( *(_DWORD *)(a1 + 96) )
{
case 1:
**(_BYTE **)(a1 + 16) = a3;
v19 = a3 >= 0x100;
v20 = (char)a3 != a3;
if ( !*(_BYTE *)(a1 + 101) )
v19 = v20;
**(_BYTE **)(a1 + 24) = v19;
*(_QWORD *)(a1 + 64) = 1LL;
return __readfsqword(0x28u);
case 2:
case 0xD:
**(_WORD **)(a1 + 16) = a3;
v8 = a3 >= 0x10000;
v9 = (__int16)a3 != a3;
if ( !*(_BYTE *)(a1 + 101) )
v8 = v9;
**(_BYTE **)(a1 + 24) = v8;
*(_QWORD *)(a1 + 64) = 2LL;
return __readfsqword(0x28u);
case 3:
**(_WORD **)(a1 + 16) = a3;
*(_BYTE *)(*(_QWORD *)(a1 + 16) + 2LL) = BYTE2(a3);
*(_BYTE *)(*(_QWORD *)(a1 + 16) + 3LL) = BYTE3(a3);
v21 = HIDWORD(a3) != 0;
v22 = (int)a3 != a3;
if ( !*(_BYTE *)(a1 + 101) )
v21 = v22;
**(_BYTE **)(a1 + 24) = v21;
goto LABEL_45;
case 4:
*(float *)&a5 = (float)(int)a3;
if ( (a3 & 0x8000000000000000LL) != 0LL )
*(float *)&a6 = (float)(int)((a3 >> 1) | a3 & 1) + (float)(int)((a3 >> 1) | a3 & 1);
else
a6 = a5;
if ( a4 )
LODWORD(a5) = LODWORD(a6);
LODWORD(v34) = LODWORD(a5);
**(_DWORD **)(a1 + 16) = LODWORD(a5);
LODWORD(v33) = LODWORD(v34);
v29 = ceilf(*(float *)&v34, a6);
v30 = 1;
if ( *(float *)&v34 == v29 )
{
v31 = (unsigned int)(int)*(float *)&v34;
if ( !a4 )
v31 = (unsigned int)(int)*(float *)&v34;
v30 = v31 != a3;
}
**(_BYTE **)(a1 + 24) = v30;
LABEL_45:
*(_QWORD *)(a1 + 64) = 4LL;
return __readfsqword(0x28u);
case 5:
if ( a4 )
{
v16 = _mm_sub_pd((__m128d)_mm_unpacklo_epi32((__m128i)a3, (__m128i)xmmword_393A0), (__m128d)xmmword_393B0);
v17 = _mm_unpackhi_pd(v16, v16).m128d_f64[0] + v16.m128d_f64[0];
}
else
{
v17 = (double)(int)a3;
}
v34 = v17;
**(double **)(a1 + 16) = v17;
v33 = v34;
v26 = ceil(v34);
v27 = 1;
if ( v34 == v26 )
{
v28 = (unsigned int)(int)v34;
if ( !a4 )
v28 = (unsigned int)(int)v34;
v27 = v28 != a3;
}
**(_BYTE **)(a1 + 24) = v27;
goto LABEL_48;
case 8:
v18 = (a3 & 0x8000000000000000LL) != 0LL && *(_BYTE *)(a1 + 101) != a4;
**(_BYTE **)(a1 + 24) = v18;
**(_QWORD **)(a1 + 16) = a3;
LABEL_48:
*(_QWORD *)(a1 + 64) = 8LL;
return __readfsqword(0x28u);
default:
v10 = 22LL;
if ( *(_QWORD *)(a2 + 56) >= 0x17uLL )
v10 = *(_QWORD *)(a2 + 56);
v11 = (v10 + 15) & 0xFFFFFFFFFFFFFFF0LL;
v12 = (char *)&v33 - v11;
v13 = 10LL;
if ( !a4 )
v13 = 4294967286LL;
v14 = ma_ll2str(a3, (char *)&v33 - v11, v13) - (_DWORD)v12;
if ( (*(_BYTE *)(a2 + 100) & 0x40) == 0 )
{
v15 = v14;
LABEL_30:
v24 = 0;
goto LABEL_50;
}
v23 = *(_QWORD *)(a2 + 56);
if ( v23 <= v14 )
LODWORD(v23) = v14;
v15 = (unsigned int)v23;
v24 = 1;
if ( (unsigned long long)(unsigned int)v23 < *(_QWORD *)(a1 + 64) )
{
if ( v14 )
{
v25 = 0LL;
do
{
v12[(unsigned int)v23 - 1 + v25] = v12[v14 - 1 + v25];
--v25;
}
while ( -(long long)v14 != v25 );
}
memset(v12, 48LL, (unsigned int)v23 - v14);
goto LABEL_30;
}
v15 = v14;
LABEL_50:
convert_froma_string(a1, v12, v15);
**(_BYTE **)(a1 + 24) += v24;
return __readfsqword(0x28u);
}
}
| convert_from_long:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R15D,ECX
MOV RBX,RDX
MOV R13,RSI
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV EAX,dword ptr [RDI + 0x60]
DEC EAX
CMP EAX,0xc
JA 0x00124ecb
LEA RCX,[0x1392ec]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_2:
MOV RAX,qword ptr [R14 + 0x10]
MOV byte ptr [RAX],BL
MOV RAX,qword ptr [R14 + 0x10]
MOV byte ptr [RAX + 0x1],BH
XOR EAX,EAX
CMP RBX,0x10000
SETNC AL
MOVSX RCX,BX
XOR EDX,EDX
CMP RCX,RBX
SETNZ DL
CMP byte ptr [R14 + 0x65],0x0
CMOVZ EAX,EDX
MOV RCX,qword ptr [R14 + 0x18]
MOV byte ptr [RCX],AL
MOV qword ptr [R14 + 0x40],0x2
JMP 0x00125196
caseD_6:
MOV RAX,qword ptr [R13 + 0x38]
CMP RAX,0x17
MOV ECX,0x16
CMOVNC RCX,RAX
ADD RCX,0xf
AND RCX,-0x10
MOV R12,RSP
SUB R12,RCX
MOV RSP,R12
TEST R15B,R15B
MOV EAX,0xfffffff6
MOV EDX,0xa
CMOVZ EDX,EAX
MOV RDI,RBX
MOV RSI,R12
CALL 0x00133364
SUB RAX,R12
TEST byte ptr [R13 + 0x64],0x40
JNZ 0x00124ffa
MOV EBX,EAX
JMP 0x0012504e
caseD_5:
TEST R15B,R15B
JZ 0x00125056
MOVQ XMM1,RBX
PUNPCKLDQ XMM1,xmmword ptr [0x001393a0]
SUBPD XMM1,xmmword ptr [0x001393b0]
MOVAPD XMM0,XMM1
UNPCKHPD XMM0,XMM1
ADDSD XMM0,XMM1
JMP 0x0012505b
caseD_8:
TEST RBX,RBX
JS 0x00125160
XOR EAX,EAX
JMP 0x00125167
caseD_1:
MOV RAX,qword ptr [R14 + 0x10]
MOV byte ptr [RAX],BL
XOR EAX,EAX
CMP RBX,0x100
SETNC AL
MOVSX RCX,BL
XOR EDX,EDX
CMP RCX,RBX
SETNZ DL
CMP byte ptr [R14 + 0x65],0x0
CMOVZ EAX,EDX
MOV RCX,qword ptr [R14 + 0x18]
MOV byte ptr [RCX],AL
MOV qword ptr [R14 + 0x40],0x1
JMP 0x00125196
caseD_3:
MOV RAX,qword ptr [R14 + 0x10]
MOV byte ptr [RAX],BL
MOV RAX,qword ptr [R14 + 0x10]
MOV byte ptr [RAX + 0x1],BH
MOV EAX,EBX
SHR EAX,0x10
MOV RCX,qword ptr [R14 + 0x10]
MOV byte ptr [RCX + 0x2],AL
MOVSXD RAX,EBX
MOV ECX,EBX
SHR ECX,0x18
MOV RDX,qword ptr [R14 + 0x10]
MOV byte ptr [RDX + 0x3],CL
XOR ECX,ECX
MOV RDX,RBX
SHR RDX,0x20
SETNZ CL
XOR EDX,EDX
CMP RAX,RBX
SETNZ DL
CMP byte ptr [R14 + 0x65],0x0
CMOVZ ECX,EDX
MOV RAX,qword ptr [R14 + 0x18]
MOV byte ptr [RAX],CL
JMP 0x00125156
caseD_4:
CVTSI2SS XMM0,RBX
TEST RBX,RBX
JS 0x001250cc
MOVAPS XMM1,XMM0
JMP 0x001250e3
LAB_00124ffa:
MOV RDX,qword ptr [R13 + 0x38]
MOV ECX,EAX
CMP RDX,RCX
CMOVBE RDX,RCX
MOV EBX,EDX
MOV R15B,0x1
CMP RBX,qword ptr [R14 + 0x40]
JNC 0x0012517e
TEST RCX,RCX
JZ 0x0012503f
LEA RSI,[RCX + R12*0x1]
DEC RSI
NEG RCX
LEA RDI,[RBX + R12*0x1]
DEC RDI
XOR R8D,R8D
LAB_0012502f:
MOV R9B,byte ptr [RSI + R8*0x1]
MOV byte ptr [RDI + R8*0x1],R9B
DEC R8
CMP RCX,R8
JNZ 0x0012502f
LAB_0012503f:
SUB EDX,EAX
MOV RDI,R12
MOV ESI,0x30
CALL 0x00113260
LAB_0012504e:
XOR R15D,R15D
JMP 0x00125181
LAB_00125056:
CVTSI2SD XMM0,RBX
LAB_0012505b:
MOVSD qword ptr [RBP + -0x38],XMM0
MOV RAX,qword ptr [R14 + 0x10]
MOVSD qword ptr [RAX],XMM0
MOVSD XMM0,qword ptr [RBP + -0x38]
MOVSD qword ptr [RBP + -0x40],XMM0
MOVSD XMM0,qword ptr [RBP + -0x38]
CALL 0x001130e0
MOV AL,0x1
MOVSD XMM1,qword ptr [RBP + -0x40]
UCOMISD XMM1,XMM0
JNZ 0x001250c1
JP 0x001250c1
MOVSD XMM0,qword ptr [RBP + -0x38]
CVTTSD2SI RAX,XMM0
MOV RCX,RAX
CVTTSD2SI RDX,XMM0
SUBSD XMM0,qword ptr [0x00138cb8]
CVTTSD2SI RSI,XMM0
SAR RCX,0x3f
AND RSI,RCX
OR RSI,RAX
TEST R15B,R15B
CMOVZ RSI,RDX
CMP RSI,RBX
SETNZ AL
LAB_001250c1:
MOV RCX,qword ptr [R14 + 0x18]
MOV byte ptr [RCX],AL
JMP 0x00125174
LAB_001250cc:
MOV RAX,RBX
SHR RAX,0x1
MOV ECX,EBX
AND ECX,0x1
OR RCX,RAX
CVTSI2SS XMM1,RCX
ADDSS XMM1,XMM1
LAB_001250e3:
TEST R15B,R15B
JZ 0x001250eb
MOVAPS XMM0,XMM1
LAB_001250eb:
MOVSS dword ptr [RBP + -0x38],XMM0
MOV RAX,qword ptr [R14 + 0x10]
MOVSS dword ptr [RAX],XMM0
MOVSS XMM0,dword ptr [RBP + -0x38]
MOVSS dword ptr [RBP + -0x40],XMM0
MOVSS XMM0,dword ptr [RBP + -0x38]
CALL 0x00113270
MOV AL,0x1
MOVSS XMM1,dword ptr [RBP + -0x40]
UCOMISS XMM1,XMM0
JNZ 0x00125150
JP 0x00125150
MOVSS XMM0,dword ptr [RBP + -0x38]
CVTTSS2SI RAX,XMM0
MOV RCX,RAX
CVTTSS2SI RDX,XMM0
SUBSS XMM0,dword ptr [0x00135004]
CVTTSS2SI RSI,XMM0
SAR RCX,0x3f
AND RSI,RCX
OR RSI,RAX
TEST R15B,R15B
CMOVZ RSI,RDX
CMP RSI,RBX
SETNZ AL
LAB_00125150:
MOV RCX,qword ptr [R14 + 0x18]
MOV byte ptr [RCX],AL
LAB_00125156:
MOV qword ptr [R14 + 0x40],0x4
JMP 0x00125196
LAB_00125160:
CMP byte ptr [R14 + 0x65],R15B
SETNZ AL
LAB_00125167:
MOV RCX,qword ptr [R14 + 0x18]
MOV byte ptr [RCX],AL
MOV RAX,qword ptr [R14 + 0x10]
MOV qword ptr [RAX],RBX
LAB_00125174:
MOV qword ptr [R14 + 0x40],0x8
JMP 0x00125196
LAB_0012517e:
MOV RBX,RCX
LAB_00125181:
MOV RDI,R14
MOV RSI,R12
MOV RDX,RBX
CALL 0x001251b9
MOV RAX,qword ptr [R14 + 0x18]
ADD byte ptr [RAX],R15B
LAB_00125196:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001251b4
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001251b4:
CALL 0x00113500
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void convert_from_long(long param_1,long param_2,ulong param_3,char param_4)
{
long lVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
int8 uVar5;
ulong uVar6;
char cVar7;
int1 uVar9;
ulong uVar8;
double *__s;
long in_FS_OFFSET;
bool bVar10;
float fVar11;
double dVar12;
int1 auVar13 [16];
int8 uStack_50;
double local_48;
double local_40;
long local_38;
__s = &local_48;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
cVar7 = (char)param_3;
uVar9 = (int1)(param_3 >> 8);
switch(*(int4 *)(param_1 + 0x60)) {
case 1:
**(char **)(param_1 + 0x10) = cVar7;
bVar10 = 0xff < param_3;
if (*(char *)(param_1 + 0x65) == '\0') {
bVar10 = (long)cVar7 != param_3;
}
**(int1 **)(param_1 + 0x18) = bVar10;
*(int8 *)(param_1 + 0x40) = 1;
break;
case 2:
case 0xd:
**(char **)(param_1 + 0x10) = cVar7;
*(int1 *)(*(long *)(param_1 + 0x10) + 1) = uVar9;
bVar10 = 0xffff < param_3;
if (*(char *)(param_1 + 0x65) == '\0') {
bVar10 = (long)(short)param_3 != param_3;
}
**(int1 **)(param_1 + 0x18) = bVar10;
*(int8 *)(param_1 + 0x40) = 2;
__s = &local_48;
break;
case 3:
**(char **)(param_1 + 0x10) = cVar7;
*(int1 *)(*(long *)(param_1 + 0x10) + 1) = uVar9;
*(char *)(*(long *)(param_1 + 0x10) + 2) = (char)(param_3 >> 0x10);
*(char *)(*(long *)(param_1 + 0x10) + 3) = (char)(param_3 >> 0x18);
bVar10 = param_3 >> 0x20 != 0;
if (*(char *)(param_1 + 0x65) == '\0') {
bVar10 = (long)(int)param_3 != param_3;
}
*(bool *)*(int8 *)(param_1 + 0x18) = bVar10;
goto LAB_00125156;
case 4:
fVar11 = (float)(long)param_3;
if (param_4 != '\0') {
fVar11 = (float)param_3;
}
local_40 = (double)CONCAT44(local_40._4_4_,fVar11);
**(float **)(param_1 + 0x10) = fVar11;
local_48 = (double)CONCAT44(local_48._4_4_,fVar11);
uStack_50 = 0x12510c;
fVar11 = ceilf(fVar11);
bVar10 = true;
if ((local_48._0_4_ == fVar11) && (!NAN(local_48._0_4_) && !NAN(fVar11))) {
uVar3 = (long)(local_40._0_4_ - _DAT_00135004) & (long)local_40._0_4_ >> 0x3f |
(long)local_40._0_4_;
if (param_4 == '\0') {
uVar3 = (long)local_40._0_4_;
}
bVar10 = uVar3 != param_3;
}
**(int1 **)(param_1 + 0x18) = bVar10;
LAB_00125156:
*(int8 *)(param_1 + 0x40) = 4;
__s = &local_48;
break;
case 5:
if (param_4 == '\0') {
local_48 = (double)(long)param_3;
}
else {
auVar13._8_4_ = (int)(param_3 >> 0x20);
auVar13._0_8_ = param_3;
auVar13._12_4_ = _UNK_001393a4;
local_48 = (auVar13._8_8_ - _UNK_001393b8) +
((double)CONCAT44(_DAT_001393a0,(int)param_3) - _DAT_001393b0);
}
**(double **)(param_1 + 0x10) = local_48;
uStack_50 = 0x12507c;
local_40 = local_48;
dVar12 = ceil(local_48);
bVar10 = true;
if ((local_48 == dVar12) && (!NAN(local_48) && !NAN(dVar12))) {
uVar3 = (long)(local_40 - _DAT_00138cb8) & (long)local_40 >> 0x3f | (long)local_40;
if (param_4 == '\0') {
uVar3 = (long)local_40;
}
bVar10 = uVar3 != param_3;
}
**(int1 **)(param_1 + 0x18) = bVar10;
goto LAB_00125174;
default:
uVar3 = 0x16;
if (0x16 < *(ulong *)(param_2 + 0x38)) {
uVar3 = *(ulong *)(param_2 + 0x38);
}
lVar1 = -(uVar3 + 0xf & 0xfffffffffffffff0);
__s = (double *)((long)&local_48 + lVar1);
uVar5 = 10;
if (param_4 == '\0') {
uVar5 = 0xfffffff6;
}
*(int8 *)((long)&uStack_50 + lVar1) = 0x124f08;
lVar2 = ma_ll2str(param_3,__s,uVar5);
uVar3 = lVar2 - (long)__s;
if ((*(byte *)(param_2 + 100) & 0x40) == 0) {
uVar4 = uVar3 & 0xffffffff;
LAB_0012504e:
cVar7 = '\0';
}
else {
uVar4 = uVar3 & 0xffffffff;
uVar6 = *(ulong *)(param_2 + 0x38);
if (*(ulong *)(param_2 + 0x38) <= uVar4) {
uVar6 = uVar4;
}
uVar8 = uVar6 & 0xffffffff;
cVar7 = '\x01';
if (uVar8 < *(ulong *)(param_1 + 0x40)) {
if (uVar4 != 0) {
lVar2 = 0;
do {
*(int1 *)((long)__s + lVar2 + (uVar8 - 1)) =
*(int1 *)((long)__s + lVar2 + (uVar4 - 1));
lVar2 = lVar2 + -1;
} while (-lVar2 != uVar4);
}
*(int8 *)((long)&uStack_50 + lVar1) = 0x12504e;
memset(__s,0x30,(ulong)(uint)((int)uVar6 - (int)uVar3));
uVar4 = uVar8;
goto LAB_0012504e;
}
}
*(int8 *)((long)&uStack_50 + lVar1) = 0x12518f;
convert_froma_string(param_1,__s,uVar4);
**(char **)(param_1 + 0x18) = **(char **)(param_1 + 0x18) + cVar7;
break;
case 8:
if ((long)param_3 < 0) {
bVar10 = *(char *)(param_1 + 0x65) != param_4;
}
else {
bVar10 = false;
}
**(int1 **)(param_1 + 0x18) = bVar10;
**(ulong **)(param_1 + 0x10) = param_3;
LAB_00125174:
*(int8 *)(param_1 + 0x40) = 8;
__s = &local_48;
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return;
}
/* WARNING: Subroutine does not return */
*(code **)((long)__s + -8) = convert_froma_string;
__stack_chk_fail();
}
| |
41,588 | inline_mysql_mutex_init | eloqsql/include/mysql/psi/mysql_thread.h | static inline int inline_mysql_mutex_init(
#ifdef HAVE_PSI_MUTEX_INTERFACE
PSI_mutex_key key,
#endif
mysql_mutex_t *that,
const pthread_mutexattr_t *attr
#ifdef SAFE_MUTEX
, const char *src_name, const char *src_file, uint src_line
#endif
)
{
#ifdef HAVE_PSI_MUTEX_INTERFACE
that->m_psi= PSI_MUTEX_CALL(init_mutex)(key, &that->m_mutex);
#else
that->m_psi= NULL;
#endif
#ifdef COROUTINE_ENABLED
that->l.data= that;
that->l.prev= that->l.next= NULL;
#endif
#ifdef SAFE_MUTEX
return safe_mutex_init(&that->m_mutex, attr, src_name, src_file, src_line);
#else
return pthread_mutex_init(&that->m_mutex, attr);
#endif
} | O0 | c | inline_mysql_mutex_init:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x1b94b6(%rip), %rax # 0x214320
movq (%rax), %rax
movq 0x40(%rax), %rax
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq *%rax
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x264f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| inline_mysql_mutex_init:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+40h]
mov edi, [rbp+var_4]
mov rsi, [rbp+var_10]
call rax
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax+40h], rcx
mov rcx, [rbp+var_10]
mov rax, [rbp+var_10]
mov [rax+38h], rcx
mov rax, [rbp+var_10]
mov qword ptr [rax+30h], 0
mov rax, [rbp+var_10]
mov qword ptr [rax+28h], 0
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call _pthread_mutex_init
add rsp, 20h
pop rbp
retn
| long long inline_mysql_mutex_init(unsigned int a1, _QWORD *a2, long long a3)
{
a2[8] = ((long long ( *)(_QWORD, _QWORD *))PSI_server[8])(a1, a2);
a2[7] = a2;
a2[6] = 0LL;
a2[5] = 0LL;
return pthread_mutex_init(a2, a3);
}
| inline_mysql_mutex_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
LEA RAX,[0x314320]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x40]
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x10]
CALL RAX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x40],RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x38],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x30],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x28],0x0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001264f0
ADD RSP,0x20
POP RBP
RET
|
void inline_mysql_mutex_init
(int4 param_1,pthread_mutex_t *param_2,pthread_mutexattr_t *param_3)
{
int8 uVar1;
uVar1 = (**(code **)(PSI_server + 0x40))(param_1,param_2);
*(int8 *)((long)param_2 + 0x40) = uVar1;
*(pthread_mutex_t **)((long)param_2 + 0x38) = param_2;
*(int8 *)((long)param_2 + 0x30) = 0;
param_2[1].__align = 0;
pthread_mutex_init(param_2,param_3);
return;
}
| |
41,589 | my_thread_init | eloqsql/mysys/my_thr_init.c | my_bool my_thread_init(void)
{
struct st_my_thread_var *tmp;
my_bool error=0;
if (!my_thread_global_init_done)
return 1; /* cannot proceed with uninitialized library */
#ifdef EXTRA_DEBUG_THREADS
fprintf(stderr,"my_thread_init(): pthread_self: %p\n", pthread_self());
#endif
if (my_thread_var)
{
#ifdef EXTRA_DEBUG_THREADS
fprintf(stderr,"my_thread_init() called more than once in thread 0x%lx\n",
(long) pthread_self());
#endif
goto end;
}
#ifdef _MSC_VER
install_sigabrt_handler();
#endif
if (!(tmp= (struct st_my_thread_var *) calloc(1, sizeof(*tmp))))
{
error= 1;
goto end;
}
set_mysys_var(tmp);
tmp->pthread_self= pthread_self();
my_thread_init_thr_mutex(tmp);
tmp->stack_ends_here= (char*)&tmp +
STACK_DIRECTION * (long)my_thread_stack_size;
mysql_mutex_lock(&THR_LOCK_threads);
tmp->id= tmp->dbug_id= ++thread_id;
++THR_thread_count;
mysql_mutex_unlock(&THR_LOCK_threads);
tmp->init= 1;
#ifndef DBUG_OFF
/* Generate unique name for thread */
(void) my_thread_name();
#endif
end:
return error;
} | O3 | c | my_thread_init:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movb $0x1, %bl
cmpb $0x1, 0x357c6c(%rip) # 0x3b6af0
jne 0x5ef5d
leaq 0x357c63(%rip), %r15 # 0x3b6af4
movl (%r15), %edi
callq 0x285e0
testq %rax, %rax
jne 0x5ef5b
movl $0x1, %edi
movl $0xf0, %esi
callq 0x28250
movq %rax, -0x20(%rbp)
testq %rax, %rax
je 0x5ef5d
movq %rax, %r14
movl (%r15), %edi
movq %rax, %rsi
callq 0x280b0
callq 0x28300
movq %rax, 0xc8(%r14)
movq %r14, %rdi
callq 0x5ed7b
leaq 0x2d4739(%rip), %rax # 0x333620
leaq -0x20(%rbp), %rcx
addq (%rax), %rcx
movq %rcx, 0xb8(%r14)
leaq 0x357b2c(%rip), %rbx # 0x3b6a28
cmpq $0x0, 0x40(%rbx)
jne 0x5ef6a
leaq 0x357b1e(%rip), %rdi # 0x3b6a28
callq 0x28570
movq 0x357be2(%rip), %rax # 0x3b6af8
incq %rax
movq %rax, 0x357bd8(%rip) # 0x3b6af8
movq -0x20(%rbp), %rcx
movq %rax, 0xd8(%rcx)
movq %rax, 0xd0(%rcx)
leaq 0x3578ef(%rip), %rax # 0x3b6828
incl (%rax)
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
jne 0x5ef71
leaq 0x357add(%rip), %rdi # 0x3b6a28
callq 0x28280
movq -0x20(%rbp), %rax
movb $0x1, 0xe8(%rax)
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x2a343
jmp 0x5ef0f
leaq 0x2d4ee8(%rip), %rax # 0x333e60
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x5ef44
| my_thread_init:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov bl, 1
cmp cs:my_thread_global_init_done, 1
jnz loc_5EF5D
lea r15, THR_KEY_mysys
mov edi, [r15]
call _pthread_getspecific
test rax, rax
jnz loc_5EF5B
mov edi, 1
mov esi, 0F0h
call _calloc
mov [rbp+var_20], rax
test rax, rax
jz loc_5EF5D
mov r14, rax
mov edi, [r15]
mov rsi, rax
call _pthread_setspecific
call _pthread_self
mov [r14+0C8h], rax
mov rdi, r14
call my_thread_init_thr_mutex
lea rax, my_thread_stack_size
lea rcx, [rbp+var_20]
add rcx, [rax]
mov [r14+0B8h], rcx
lea rbx, THR_LOCK_threads
cmp qword ptr [rbx+40h], 0
jnz short loc_5EF6A
lea rdi, THR_LOCK_threads
call _pthread_mutex_lock
loc_5EF0F:
mov rax, cs:thread_id
inc rax
mov cs:thread_id, rax
mov rcx, [rbp+var_20]
mov [rcx+0D8h], rax
mov [rcx+0D0h], rax
lea rax, THR_thread_count
inc dword ptr [rax]
mov rdi, [rbx+40h]
test rdi, rdi
jnz short loc_5EF71
loc_5EF44:
lea rdi, THR_LOCK_threads
call _pthread_mutex_unlock
mov rax, [rbp+var_20]
mov byte ptr [rax+0E8h], 1
loc_5EF5B:
xor ebx, ebx
loc_5EF5D:
mov eax, ebx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_5EF6A:
call my_thread_init_cold_1
jmp short loc_5EF0F
loc_5EF71:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_5EF44
| long long my_thread_init()
{
long long v0; // rax
unsigned int v1; // ebx
long long v2; // rax
long long v3; // r14
long long v4; // rax
long long v5; // rcx
_QWORD v7[4]; // [rsp+0h] [rbp-20h] BYREF
v7[0] = v0;
LOBYTE(v1) = 1;
if ( my_thread_global_init_done == 1 )
{
if ( pthread_getspecific(THR_KEY_mysys) )
return 0;
v2 = calloc(1LL, 240LL);
v7[0] = v2;
if ( v2 )
{
v3 = v2;
pthread_setspecific(THR_KEY_mysys, v2);
*(_QWORD *)(v3 + 200) = pthread_self();
my_thread_init_thr_mutex(v3);
*(_QWORD *)(v3 + 184) = (char *)v7 + my_thread_stack_size;
if ( THR_LOCK_threads[8] )
my_thread_init_cold_1();
else
pthread_mutex_lock(THR_LOCK_threads);
v4 = thread_id + 1;
thread_id = v4;
v5 = v7[0];
*(_QWORD *)(v7[0] + 216LL) = v4;
*(_QWORD *)(v5 + 208) = v4;
++THR_thread_count;
if ( THR_LOCK_threads[8] )
PSI_server[44]();
pthread_mutex_unlock(THR_LOCK_threads);
*(_BYTE *)(v7[0] + 232LL) = 1;
return 0;
}
}
return v1;
}
| my_thread_init:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV BL,0x1
CMP byte ptr [0x004b6af0],0x1
JNZ 0x0015ef5d
LEA R15,[0x4b6af4]
MOV EDI,dword ptr [R15]
CALL 0x001285e0
TEST RAX,RAX
JNZ 0x0015ef5b
MOV EDI,0x1
MOV ESI,0xf0
CALL 0x00128250
MOV qword ptr [RBP + -0x20],RAX
TEST RAX,RAX
JZ 0x0015ef5d
MOV R14,RAX
MOV EDI,dword ptr [R15]
MOV RSI,RAX
CALL 0x001280b0
CALL 0x00128300
MOV qword ptr [R14 + 0xc8],RAX
MOV RDI,R14
CALL 0x0015ed7b
LEA RAX,[0x433620]
LEA RCX,[RBP + -0x20]
ADD RCX,qword ptr [RAX]
MOV qword ptr [R14 + 0xb8],RCX
LEA RBX,[0x4b6a28]
CMP qword ptr [RBX + 0x40],0x0
JNZ 0x0015ef6a
LEA RDI,[0x4b6a28]
CALL 0x00128570
LAB_0015ef0f:
MOV RAX,qword ptr [0x004b6af8]
INC RAX
MOV qword ptr [0x004b6af8],RAX
MOV RCX,qword ptr [RBP + -0x20]
MOV qword ptr [RCX + 0xd8],RAX
MOV qword ptr [RCX + 0xd0],RAX
LEA RAX,[0x4b6828]
INC dword ptr [RAX]
MOV RDI,qword ptr [RBX + 0x40]
TEST RDI,RDI
JNZ 0x0015ef71
LAB_0015ef44:
LEA RDI,[0x4b6a28]
CALL 0x00128280
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0xe8],0x1
LAB_0015ef5b:
XOR EBX,EBX
LAB_0015ef5d:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0015ef6a:
CALL 0x0012a343
JMP 0x0015ef0f
LAB_0015ef71:
LEA RAX,[0x433e60]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0015ef44
|
ulong my_thread_init(void)
{
void *pvVar1;
pthread_t pVar2;
long lVar3;
int8 unaff_RBX;
ulong uVar4;
void *local_28;
uVar4 = CONCAT71((int7)((ulong)unaff_RBX >> 8),1);
if (my_thread_global_init_done == '\x01') {
pvVar1 = pthread_getspecific(THR_KEY_mysys);
if (pvVar1 == (void *)0x0) {
pvVar1 = calloc(1,0xf0);
if (pvVar1 == (void *)0x0) goto LAB_0015ef5d;
local_28 = pvVar1;
pthread_setspecific(THR_KEY_mysys,pvVar1);
pVar2 = pthread_self();
*(pthread_t *)((long)pvVar1 + 200) = pVar2;
my_thread_init_thr_mutex(pvVar1);
*(long *)((long)pvVar1 + 0xb8) = (long)&local_28 + my_thread_stack_size;
if (THR_LOCK_threads._64_8_ == 0) {
pthread_mutex_lock((pthread_mutex_t *)THR_LOCK_threads);
}
else {
my_thread_init_cold_1();
}
lVar3 = thread_id + 1;
thread_id = lVar3;
*(long *)((long)local_28 + 0xd8) = lVar3;
*(long *)((long)local_28 + 0xd0) = lVar3;
THR_thread_count = THR_thread_count + 1;
if (THR_LOCK_threads._64_8_ != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)THR_LOCK_threads);
*(int1 *)((long)local_28 + 0xe8) = 1;
}
uVar4 = 0;
}
LAB_0015ef5d:
return uVar4 & 0xffffffff;
}
| |
41,590 | sp_get_geometry_mbr | eloqsql/storage/maria/ma_sp_key.c | static int sp_get_geometry_mbr(uchar *(*wkb), uchar *end, uint n_dims,
double *mbr, int top)
{
int res;
uchar byte_order;
uint wkb_type;
byte_order = *(*wkb);
++(*wkb);
wkb_type = uint4korr((*wkb));
(*wkb) += 4;
switch ((enum wkbType) wkb_type)
{
case wkbPoint:
res = sp_get_point_mbr(wkb, end, n_dims, byte_order, mbr);
break;
case wkbLineString:
res = sp_get_linestring_mbr(wkb, end, n_dims, byte_order, mbr);
break;
case wkbPolygon:
res = sp_get_polygon_mbr(wkb, end, n_dims, byte_order, mbr);
break;
case wkbMultiPoint:
{
uint n_items;
n_items = uint4korr((*wkb));
(*wkb) += 4;
for (; n_items > 0; --n_items)
{
byte_order = *(*wkb);
++(*wkb);
(*wkb) += 4;
if (sp_get_point_mbr(wkb, end, n_dims, byte_order, mbr))
return -1;
}
res = 0;
break;
}
case wkbMultiLineString:
{
uint n_items;
n_items = uint4korr((*wkb));
(*wkb) += 4;
for (; n_items > 0; --n_items)
{
byte_order = *(*wkb);
++(*wkb);
(*wkb) += 4;
if (sp_get_linestring_mbr(wkb, end, n_dims, byte_order, mbr))
return -1;
}
res = 0;
break;
}
case wkbMultiPolygon:
{
uint n_items;
n_items = uint4korr((*wkb));
(*wkb) += 4;
for (; n_items > 0; --n_items)
{
byte_order = *(*wkb);
++(*wkb);
(*wkb) += 4;
if (sp_get_polygon_mbr(wkb, end, n_dims, byte_order, mbr))
return -1;
}
res = 0;
break;
}
case wkbGeometryCollection:
{
uint n_items;
if (!top)
return -1;
n_items = uint4korr((*wkb));
(*wkb) += 4;
for (; n_items > 0; --n_items)
{
if (sp_get_geometry_mbr(wkb, end, n_dims, mbr, 0))
return -1;
}
res = 0;
break;
}
default:
res = -1;
}
return res;
} | O3 | c | sp_get_geometry_mbr:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdi), %rdx
leaq 0x1(%rdx), %rax
movq %rax, (%rdi)
movl 0x1(%rdx), %eax
leaq 0x5(%rdx), %rsi
movq %rsi, (%rdi)
decl %eax
cmpl $0x6, %eax
ja 0x70d5f
movq %rdi, %r15
leaq 0x70b47(%rip), %rsi # 0xe1704
movslq (%rsi,%rax,4), %rax
addq %rsi, %rax
jmpq *%rax
addq $-0x8, %r14
movb $0x1, %al
xorl %ecx, %ecx
xorl %r12d, %r12d
movq (%r15), %rdx
cmpq %r14, %rdx
ja 0x70d5f
movsd (%rdx), %xmm0
addq $0x8, %rdx
movq %rdx, (%r15)
movsd (%rbx,%rcx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x70bf8
movsd %xmm0, (%rbx,%rcx)
ucomisd 0x8(%rbx,%rcx), %xmm0
jbe 0x70c09
orq $0x8, %rcx
movsd %xmm0, (%rbx,%rcx)
movl $0x10, %ecx
testb $0x1, %al
movl $0x0, %eax
jne 0x70bd1
jmp 0x70d65
movl 0x5(%rdx), %r13d
addq $0x9, %rdx
movq %rdx, (%r15)
xorl %r12d, %r12d
testl %r13d, %r13d
je 0x70d65
addq $0x5, (%r15)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x70d77
testl %eax, %eax
jne 0x70d5f
decl %r13d
jne 0x70c33
jmp 0x70d65
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x70df2
movl 0x5(%rdx), %eax
addq $0x9, %rdx
movq %rdx, (%r15)
testl %eax, %eax
je 0x70d5a
addq $-0x8, %r14
xorl %r12d, %r12d
addq $0x5, (%r15)
movb $0x1, %cl
xorl %edx, %edx
movq (%r15), %rsi
cmpq %r14, %rsi
ja 0x70d5f
movsd (%rsi), %xmm0
addq $0x8, %rsi
movq %rsi, (%r15)
movsd (%rbx,%rdx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x70cbb
movsd %xmm0, (%rbx,%rdx)
ucomisd 0x8(%rbx,%rdx), %xmm0
jbe 0x70ccc
orq $0x8, %rdx
movsd %xmm0, (%rbx,%rdx)
movl $0x10, %edx
testb $0x1, %cl
movl $0x0, %ecx
jne 0x70c94
decl %eax
jne 0x70c8c
jmp 0x70d65
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x70d77
movl 0x5(%rdx), %r13d
addq $0x9, %rdx
movq %rdx, (%r15)
xorl %r12d, %r12d
testl %r13d, %r13d
je 0x70d65
addq $0x5, (%r15)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x70df2
testl %eax, %eax
jne 0x70d5f
decl %r13d
jne 0x70d10
jmp 0x70d65
testl %ecx, %ecx
je 0x70d5f
movl 0x5(%rdx), %r12d
addq $0x9, %rdx
movq %rdx, (%r15)
testl %r12d, %r12d
je 0x70d5a
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x70b80
testl %eax, %eax
jne 0x70d5f
decl %r12d
jne 0x70d41
xorl %r12d, %r12d
jmp 0x70d65
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| sp_get_geometry_mbr:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdx
mov r14, rsi
mov rdx, [rdi]
lea rax, [rdx+1]
mov [rdi], rax
mov eax, [rdx+1]
lea rsi, [rdx+5]
mov [rdi], rsi
dec eax; switch 7 cases
cmp eax, 6
ja def_70BC4; jumptable 0000000000070BC4 default case
mov r15, rdi
lea rsi, jpt_70BC4
movsxd rax, ds:(jpt_70BC4 - 0E1704h)[rsi+rax*4]
add rax, rsi
jmp rax; switch jump
loc_70BC6:
add r14, 0FFFFFFFFFFFFFFF8h; jumptable 0000000000070BC4 case 1
mov al, 1
xor ecx, ecx
xor r12d, r12d
loc_70BD1:
mov rdx, [r15]
cmp rdx, r14
ja def_70BC4; jumptable 0000000000070BC4 default case
movsd xmm0, qword ptr [rdx]
add rdx, 8
mov [r15], rdx
movsd xmm1, qword ptr [rbx+rcx]
ucomisd xmm1, xmm0
jbe short loc_70BF8
movsd qword ptr [rbx+rcx], xmm0
loc_70BF8:
ucomisd xmm0, qword ptr [rbx+rcx+8]
jbe short loc_70C09
or rcx, 8
movsd qword ptr [rbx+rcx], xmm0
loc_70C09:
mov ecx, 10h
test al, 1
mov eax, 0
jnz short loc_70BD1
jmp loc_70D65
loc_70C1C:
mov r13d, [rdx+5]; jumptable 0000000000070BC4 case 5
add rdx, 9
mov [r15], rdx
xor r12d, r12d
test r13d, r13d
jz loc_70D65
loc_70C33:
add qword ptr [r15], 5
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call sp_get_linestring_mbr
test eax, eax
jnz def_70BC4; jumptable 0000000000070BC4 default case
dec r13d
jnz short loc_70C33
jmp loc_70D65
loc_70C57:
mov rdi, r15; jumptable 0000000000070BC4 case 3
mov rsi, r14
mov rdx, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp sp_get_polygon_mbr
loc_70C73:
mov eax, [rdx+5]; jumptable 0000000000070BC4 case 4
add rdx, 9
mov [r15], rdx
test eax, eax
jz loc_70D5A
add r14, 0FFFFFFFFFFFFFFF8h
xor r12d, r12d
loc_70C8C:
add qword ptr [r15], 5
mov cl, 1
xor edx, edx
loc_70C94:
mov rsi, [r15]
cmp rsi, r14
ja def_70BC4; jumptable 0000000000070BC4 default case
movsd xmm0, qword ptr [rsi]
add rsi, 8
mov [r15], rsi
movsd xmm1, qword ptr [rbx+rdx]
ucomisd xmm1, xmm0
jbe short loc_70CBB
movsd qword ptr [rbx+rdx], xmm0
loc_70CBB:
ucomisd xmm0, qword ptr [rbx+rdx+8]
jbe short loc_70CCC
or rdx, 8
movsd qword ptr [rbx+rdx], xmm0
loc_70CCC:
mov edx, 10h
test cl, 1
mov ecx, 0
jnz short loc_70C94
dec eax
jnz short loc_70C8C
jmp loc_70D65
loc_70CE4:
mov rdi, r15; jumptable 0000000000070BC4 case 2
mov rsi, r14
mov rdx, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp short sp_get_linestring_mbr
loc_70CFD:
mov r13d, [rdx+5]; jumptable 0000000000070BC4 case 6
add rdx, 9
mov [r15], rdx
xor r12d, r12d
test r13d, r13d
jz short loc_70D65
loc_70D10:
add qword ptr [r15], 5
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call sp_get_polygon_mbr
test eax, eax
jnz short def_70BC4; jumptable 0000000000070BC4 default case
dec r13d
jnz short loc_70D10
jmp short loc_70D65
loc_70D2D:
test ecx, ecx; jumptable 0000000000070BC4 case 7
jz short def_70BC4; jumptable 0000000000070BC4 default case
mov r12d, [rdx+5]
add rdx, 9
mov [r15], rdx
test r12d, r12d
jz short loc_70D5A
loc_70D41:
mov rdi, r15
mov rsi, r14
mov rdx, rbx
xor ecx, ecx
call sp_get_geometry_mbr
test eax, eax
jnz short def_70BC4; jumptable 0000000000070BC4 default case
dec r12d
jnz short loc_70D41
loc_70D5A:
xor r12d, r12d
jmp short loc_70D65
def_70BC4:
mov r12d, 0FFFFFFFFh; jumptable 0000000000070BC4 default case
loc_70D65:
mov eax, r12d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long sp_get_geometry_mbr(double **a1, long long a2, long long a3, int a4, long long a5, long long a6)
{
long long v6; // rax
double *v8; // rdx
int v9; // eax
char v10; // al
long long v11; // rcx
unsigned int v12; // r12d
double *v13; // rdx
double v14; // xmm0_8
bool v15; // zf
int v16; // r13d
int v18; // eax
unsigned long long v19; // r14
char v20; // cl
long long v21; // rdx
double *v22; // rsi
double v23; // xmm0_8
int v24; // r13d
int v25; // r12d
long long v26; // [rsp-8h] [rbp-30h]
long long v27; // [rsp+0h] [rbp-28h]
long long v28; // [rsp+8h] [rbp-20h]
long long v29; // [rsp+10h] [rbp-18h]
long long v30; // [rsp+18h] [rbp-10h]
v26 = v6;
v8 = *a1;
*a1 = (double *)((char *)*a1 + 1);
v9 = *(_DWORD *)((char *)v8 + 1);
*a1 = (double *)((char *)v8 + 5);
switch ( v9 )
{
case 1:
v10 = 1;
v11 = 0LL;
v12 = 0;
do
{
v13 = *a1;
if ( (unsigned long long)*a1 > a2 - 8 )
return (unsigned int)-1;
v14 = *v13;
*a1 = v13 + 1;
if ( *(double *)(a3 + v11) > v14 )
*(double *)(a3 + v11) = v14;
if ( v14 > *(double *)(a3 + v11 + 8) )
*(double *)(a3 + (v11 | 8)) = v14;
v11 = 16LL;
v15 = (v10 & 1) == 0;
v10 = 0;
}
while ( !v15 );
return v12;
case 2:
return sp_get_linestring_mbr(a1, a2, a3);
case 3:
return sp_get_polygon_mbr(a1, a2, a3);
case 4:
v18 = *(_DWORD *)((char *)v8 + 5);
*a1 = (double *)((char *)v8 + 9);
if ( !v18 )
return 0;
v19 = a2 - 8;
v12 = 0;
LABEL_17:
*a1 = (double *)((char *)*a1 + 5);
v20 = 1;
v21 = 0LL;
while ( 1 )
{
v22 = *a1;
if ( (unsigned long long)*a1 > v19 )
return (unsigned int)-1;
v23 = *v22;
*a1 = v22 + 1;
if ( *(double *)(a3 + v21) > v23 )
*(double *)(a3 + v21) = v23;
if ( v23 > *(double *)(a3 + v21 + 8) )
*(double *)(a3 + (v21 | 8)) = v23;
v21 = 16LL;
v15 = (v20 & 1) == 0;
v20 = 0;
if ( v15 )
{
if ( --v18 )
goto LABEL_17;
return v12;
}
}
case 5:
v16 = *(_DWORD *)((char *)v8 + 5);
*a1 = (double *)((char *)v8 + 9);
v12 = 0;
if ( !v16 )
return v12;
while ( 1 )
{
*a1 = (double *)((char *)*a1 + 5);
if ( (unsigned int)sp_get_linestring_mbr(a1, a2, a3) )
break;
if ( !--v16 )
return v12;
}
return (unsigned int)-1;
case 6:
v24 = *(_DWORD *)((char *)v8 + 5);
*a1 = (double *)((char *)v8 + 9);
v12 = 0;
if ( !v24 )
return v12;
while ( 1 )
{
*a1 = (double *)((char *)*a1 + 5);
if ( (unsigned int)sp_get_polygon_mbr(a1, a2, a3) )
break;
if ( !--v24 )
return v12;
}
return (unsigned int)-1;
case 7:
if ( !a4 )
return (unsigned int)-1;
v25 = *(_DWORD *)((char *)v8 + 5);
*a1 = (double *)((char *)v8 + 9);
if ( !v25 )
return 0;
break;
default:
return (unsigned int)-1;
}
while ( !(unsigned int)sp_get_geometry_mbr(a1, a2, a3, 0LL, a5, a6, v26, v27, v28, v29, v30) )
{
if ( !--v25 )
return 0;
}
return (unsigned int)-1;
}
| sp_get_geometry_mbr:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RSI
MOV RDX,qword ptr [RDI]
LEA RAX,[RDX + 0x1]
MOV qword ptr [RDI],RAX
MOV EAX,dword ptr [RDX + 0x1]
LEA RSI,[RDX + 0x5]
MOV qword ptr [RDI],RSI
DEC EAX
CMP EAX,0x6
JA 0x00170d5f
MOV R15,RDI
LEA RSI,[0x1e1704]
MOVSXD RAX,dword ptr [RSI + RAX*0x4]
ADD RAX,RSI
switchD:
JMP RAX
caseD_1:
ADD R14,-0x8
MOV AL,0x1
XOR ECX,ECX
XOR R12D,R12D
LAB_00170bd1:
MOV RDX,qword ptr [R15]
CMP RDX,R14
JA 0x00170d5f
MOVSD XMM0,qword ptr [RDX]
ADD RDX,0x8
MOV qword ptr [R15],RDX
MOVSD XMM1,qword ptr [RBX + RCX*0x1]
UCOMISD XMM1,XMM0
JBE 0x00170bf8
MOVSD qword ptr [RBX + RCX*0x1],XMM0
LAB_00170bf8:
UCOMISD XMM0,qword ptr [RBX + RCX*0x1 + 0x8]
JBE 0x00170c09
OR RCX,0x8
MOVSD qword ptr [RBX + RCX*0x1],XMM0
LAB_00170c09:
MOV ECX,0x10
TEST AL,0x1
MOV EAX,0x0
JNZ 0x00170bd1
JMP 0x00170d65
caseD_5:
MOV R13D,dword ptr [RDX + 0x5]
ADD RDX,0x9
MOV qword ptr [R15],RDX
XOR R12D,R12D
TEST R13D,R13D
JZ 0x00170d65
LAB_00170c33:
ADD qword ptr [R15],0x5
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x00170d77
TEST EAX,EAX
JNZ 0x00170d5f
DEC R13D
JNZ 0x00170c33
JMP 0x00170d65
caseD_3:
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00170df2
caseD_4:
MOV EAX,dword ptr [RDX + 0x5]
ADD RDX,0x9
MOV qword ptr [R15],RDX
TEST EAX,EAX
JZ 0x00170d5a
ADD R14,-0x8
XOR R12D,R12D
LAB_00170c8c:
ADD qword ptr [R15],0x5
MOV CL,0x1
XOR EDX,EDX
LAB_00170c94:
MOV RSI,qword ptr [R15]
CMP RSI,R14
JA 0x00170d5f
MOVSD XMM0,qword ptr [RSI]
ADD RSI,0x8
MOV qword ptr [R15],RSI
MOVSD XMM1,qword ptr [RBX + RDX*0x1]
UCOMISD XMM1,XMM0
JBE 0x00170cbb
MOVSD qword ptr [RBX + RDX*0x1],XMM0
LAB_00170cbb:
UCOMISD XMM0,qword ptr [RBX + RDX*0x1 + 0x8]
JBE 0x00170ccc
OR RDX,0x8
MOVSD qword ptr [RBX + RDX*0x1],XMM0
LAB_00170ccc:
MOV EDX,0x10
TEST CL,0x1
MOV ECX,0x0
JNZ 0x00170c94
DEC EAX
JNZ 0x00170c8c
JMP 0x00170d65
caseD_2:
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00170d77
caseD_6:
MOV R13D,dword ptr [RDX + 0x5]
ADD RDX,0x9
MOV qword ptr [R15],RDX
XOR R12D,R12D
TEST R13D,R13D
JZ 0x00170d65
LAB_00170d10:
ADD qword ptr [R15],0x5
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x00170df2
TEST EAX,EAX
JNZ 0x00170d5f
DEC R13D
JNZ 0x00170d10
JMP 0x00170d65
caseD_7:
TEST ECX,ECX
JZ 0x00170d5f
MOV R12D,dword ptr [RDX + 0x5]
ADD RDX,0x9
MOV qword ptr [R15],RDX
TEST R12D,R12D
JZ 0x00170d5a
LAB_00170d41:
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
XOR ECX,ECX
CALL 0x00170b80
TEST EAX,EAX
JNZ 0x00170d5f
DEC R12D
JNZ 0x00170d41
LAB_00170d5a:
XOR R12D,R12D
JMP 0x00170d65
default:
MOV R12D,0xffffffff
LAB_00170d65:
MOV EAX,R12D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 sp_get_geometry_mbr(long *param_1,long param_2,long param_3,int param_4)
{
double dVar1;
int4 uVar2;
long lVar3;
double *pdVar4;
bool bVar5;
bool bVar6;
int iVar7;
ulong uVar8;
int iVar9;
int8 uVar10;
lVar3 = *param_1;
*param_1 = lVar3 + 1;
uVar2 = *(int4 *)(lVar3 + 1);
*param_1 = lVar3 + 5;
switch(uVar2) {
case 1:
uVar8 = 0;
uVar10 = 0;
bVar5 = true;
do {
bVar6 = bVar5;
pdVar4 = (double *)*param_1;
if ((double *)(param_2 + -8) < pdVar4) goto switchD_00170bc4_default;
dVar1 = *pdVar4;
*param_1 = (long)(pdVar4 + 1);
if (dVar1 < *(double *)(param_3 + uVar8)) {
*(double *)(param_3 + uVar8) = dVar1;
}
pdVar4 = (double *)(param_3 + 8 + uVar8);
if (*pdVar4 <= dVar1 && dVar1 != *pdVar4) {
*(double *)(param_3 + (uVar8 | 8)) = dVar1;
}
uVar8 = 0x10;
bVar5 = false;
} while (bVar6);
break;
case 2:
uVar10 = sp_get_linestring_mbr(param_1,param_2,param_3);
return uVar10;
case 3:
uVar10 = sp_get_polygon_mbr(param_1,param_2,param_3);
return uVar10;
case 4:
iVar9 = *(int *)(lVar3 + 5);
*param_1 = lVar3 + 9;
if (iVar9 != 0) {
do {
*param_1 = *param_1 + 5;
uVar8 = 0;
bVar5 = true;
do {
bVar6 = bVar5;
pdVar4 = (double *)*param_1;
if ((double *)(param_2 + -8) < pdVar4) goto switchD_00170bc4_default;
dVar1 = *pdVar4;
*param_1 = (long)(pdVar4 + 1);
if (dVar1 < *(double *)(param_3 + uVar8)) {
*(double *)(param_3 + uVar8) = dVar1;
}
pdVar4 = (double *)(param_3 + 8 + uVar8);
if (*pdVar4 <= dVar1 && dVar1 != *pdVar4) {
*(double *)(param_3 + (uVar8 | 8)) = dVar1;
}
uVar8 = 0x10;
bVar5 = false;
} while (bVar6);
iVar9 = iVar9 + -1;
if (iVar9 == 0) {
return 0;
}
} while( true );
}
LAB_00170d5a:
uVar10 = 0;
break;
case 5:
iVar9 = *(int *)(lVar3 + 5);
*param_1 = lVar3 + 9;
uVar10 = 0;
for (; iVar9 != 0; iVar9 = iVar9 + -1) {
*param_1 = *param_1 + 5;
iVar7 = sp_get_linestring_mbr(param_1,param_2,param_3);
if (iVar7 != 0) goto switchD_00170bc4_default;
}
break;
case 6:
iVar9 = *(int *)(lVar3 + 5);
*param_1 = lVar3 + 9;
uVar10 = 0;
for (; iVar9 != 0; iVar9 = iVar9 + -1) {
*param_1 = *param_1 + 5;
iVar7 = sp_get_polygon_mbr(param_1,param_2,param_3);
if (iVar7 != 0) goto switchD_00170bc4_default;
}
break;
case 7:
if (param_4 != 0) {
iVar9 = *(int *)(lVar3 + 5);
*param_1 = lVar3 + 9;
for (; iVar9 != 0; iVar9 = iVar9 + -1) {
iVar7 = sp_get_geometry_mbr(param_1,param_2,param_3,0);
if (iVar7 != 0) goto switchD_00170bc4_default;
}
goto LAB_00170d5a;
}
default:
switchD_00170bc4_default:
uVar10 = 0xffffffff;
}
return uVar10;
}
| |
41,591 | google::protobuf::internal::VerifyVersion(int, int, char const*) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/stubs/common.cc | void VerifyVersion(int headerVersion,
int minLibraryVersion,
const char* filename) {
if (GOOGLE_PROTOBUF_VERSION < minLibraryVersion) {
// Library is too old for headers.
GOOGLE_LOG(FATAL)
<< "This program requires version " << VersionString(minLibraryVersion)
<< " of the Protocol Buffer runtime library, but the installed version "
"is " << VersionString(GOOGLE_PROTOBUF_VERSION) << ". Please update "
"your library. If you compiled the program yourself, make sure that "
"your headers are from the same version of Protocol Buffers as your "
"link-time library. (Version verification failed in \""
<< filename << "\".)";
}
if (headerVersion < kMinHeaderVersionForLibrary) {
// Headers are too old for library.
GOOGLE_LOG(FATAL)
<< "This program was compiled against version "
<< VersionString(headerVersion) << " of the Protocol Buffer runtime "
"library, which is not compatible with the installed version ("
<< VersionString(GOOGLE_PROTOBUF_VERSION) << "). Contact the program "
"author for an update. If you compiled the program yourself, make "
"sure that your headers are from the same version of Protocol Buffers "
"as your link-time library. (Version verification failed in \""
<< filename << "\".)";
}
} | O0 | cpp | google::protobuf::internal::VerifyVersion(int, int, char const*):
subq $0x1a8, %rsp # imm = 0x1A8
movl %edi, 0x1a4(%rsp)
movl %esi, 0x1a0(%rsp)
movq %rdx, 0x198(%rsp)
movl $0x2e18d4, %eax # imm = 0x2E18D4
cmpl 0x1a0(%rsp), %eax
jge 0x218c56
leaq 0x1e486f(%rip), %rdx # 0x3fd325
leaq 0x160(%rsp), %rdi
movq %rdi, 0x78(%rsp)
movl $0x3, %esi
movl $0x48, %ecx
callq 0x219560
movq 0x78(%rsp), %rdi
leaq 0x1e48b0(%rip), %rsi # 0x3fd38e
callq 0x218e20
movq %rax, 0x80(%rsp)
jmp 0x218aed
movl 0x1a0(%rsp), %esi
leaq 0x130(%rsp), %rdi
callq 0x218e80
jmp 0x218b03
movq 0x80(%rsp), %rdi
leaq 0x130(%rsp), %rsi
callq 0x218e50
movq %rax, 0x70(%rsp)
jmp 0x218b1f
movq 0x70(%rsp), %rdi
leaq 0x1e4882(%rip), %rsi # 0x3fd3ad
callq 0x218e20
movq %rax, 0x68(%rsp)
jmp 0x218b37
leaq 0x110(%rsp), %rdi
movl $0x2e18d4, %esi # imm = 0x2E18D4
callq 0x218e80
jmp 0x218b4b
movq 0x68(%rsp), %rdi
leaq 0x110(%rsp), %rsi
callq 0x218e50
movq %rax, 0x60(%rsp)
jmp 0x218b64
movq 0x60(%rsp), %rdi
leaq 0x1e4884(%rip), %rsi # 0x3fd3f4
callq 0x218e20
movq %rax, 0x58(%rsp)
jmp 0x218b7c
movq 0x58(%rsp), %rdi
movq 0x198(%rsp), %rsi
callq 0x218e20
movq %rax, 0x50(%rsp)
jmp 0x218b95
movq 0x50(%rsp), %rdi
leaq 0x1e4921(%rip), %rsi # 0x3fd4c2
callq 0x218e20
movq %rax, 0x48(%rsp)
jmp 0x218bad
movq 0x48(%rsp), %rsi
leaq 0x10f(%rsp), %rdi
callq 0x218fd0
jmp 0x218bc1
leaq 0x110(%rsp), %rdi
callq 0x21cc8
leaq 0x130(%rsp), %rdi
callq 0x21cc8
leaq 0x160(%rsp), %rdi
callq 0x2195a0
jmp 0x218c56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x158(%rsp)
movl %eax, 0x154(%rsp)
jmp 0x218c44
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x158(%rsp)
movl %eax, 0x154(%rsp)
jmp 0x218c37
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x158(%rsp)
movl %eax, 0x154(%rsp)
leaq 0x110(%rsp), %rdi
callq 0x21cc8
leaq 0x130(%rsp), %rdi
callq 0x21cc8
leaq 0x160(%rsp), %rdi
callq 0x2195a0
jmp 0x218e0d
cmpl $0x2e18c8, 0x1a4(%rsp) # imm = 0x2E18C8
jge 0x218e05
leaq 0x1e46b7(%rip), %rdx # 0x3fd325
leaq 0xd0(%rsp), %rdi
movq %rdi, 0x38(%rsp)
movl $0x3, %esi
movl $0x53, %ecx
callq 0x219560
movq 0x38(%rsp), %rdi
leaq 0x1e4830(%rip), %rsi # 0x3fd4c6
callq 0x218e20
movq %rax, 0x40(%rsp)
jmp 0x218ca2
movl 0x1a4(%rsp), %esi
leaq 0xb0(%rsp), %rdi
callq 0x218e80
jmp 0x218cb8
movq 0x40(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x218e50
movq %rax, 0x30(%rsp)
jmp 0x218cd1
movq 0x30(%rsp), %rdi
leaq 0x1e4814(%rip), %rsi # 0x3fd4f1
callq 0x218e20
movq %rax, 0x28(%rsp)
jmp 0x218ce9
leaq 0x90(%rsp), %rdi
movl $0x2e18d4, %esi # imm = 0x2E18D4
callq 0x218e80
jmp 0x218cfd
movq 0x28(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x218e50
movq %rax, 0x20(%rsp)
jmp 0x218d16
movq 0x20(%rsp), %rdi
leaq 0x1e482d(%rip), %rsi # 0x3fd54f
callq 0x218e20
movq %rax, 0x18(%rsp)
jmp 0x218d2e
movq 0x18(%rsp), %rdi
movq 0x198(%rsp), %rsi
callq 0x218e20
movq %rax, 0x10(%rsp)
jmp 0x218d47
movq 0x10(%rsp), %rdi
leaq 0x1e476f(%rip), %rsi # 0x3fd4c2
callq 0x218e20
movq %rax, 0x8(%rsp)
jmp 0x218d5f
movq 0x8(%rsp), %rsi
leaq 0x8f(%rsp), %rdi
callq 0x218fd0
jmp 0x218d73
leaq 0x90(%rsp), %rdi
callq 0x21cc8
leaq 0xb0(%rsp), %rdi
callq 0x21cc8
leaq 0xd0(%rsp), %rdi
callq 0x2195a0
jmp 0x218e05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x158(%rsp)
movl %eax, 0x154(%rsp)
jmp 0x218df6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x158(%rsp)
movl %eax, 0x154(%rsp)
jmp 0x218de9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x158(%rsp)
movl %eax, 0x154(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x21cc8
leaq 0xb0(%rsp), %rdi
callq 0x21cc8
leaq 0xd0(%rsp), %rdi
callq 0x2195a0
jmp 0x218e0d
addq $0x1a8, %rsp # imm = 0x1A8
retq
movq 0x158(%rsp), %rdi
callq 0x21700
nopw (%rax,%rax)
| _ZN6google8protobuf8internal13VerifyVersionEiiPKc:
sub rsp, 1A8h
mov [rsp+1A8h+var_4], edi
mov [rsp+1A8h+var_8], esi
mov [rsp+1A8h+var_10], rdx
mov eax, (offset algn_2E18D2+2)
cmp eax, [rsp+1A8h+var_8]
jge loc_218C56
lea rdx, aWorkspaceLlm4b_73; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+1A8h+var_48]
mov [rsp+1A8h+var_130], rdi
mov esi, 3
mov ecx, 48h ; 'H'
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+1A8h+var_130]
lea rsi, aThisProgramReq; "This program requires version "
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+1A8h+var_128], rax
jmp short $+2
loc_218AED:
mov esi, [rsp+1A8h+var_8]
lea rdi, [rsp+1A8h+var_78]
call _ZN6google8protobuf8internal13VersionStringB5cxx11Ei; google::protobuf::internal::VersionString(int)
jmp short $+2
loc_218B03:
mov rdi, [rsp+1A8h+var_128]
lea rsi, [rsp+1A8h+var_78]
call _ZN6google8protobuf8internal10LogMessagelsERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; google::protobuf::internal::LogMessage::operator<<(std::string const&)
mov [rsp+1A8h+var_138], rax
jmp short $+2
loc_218B1F:
mov rdi, [rsp+1A8h+var_138]
lea rsi, aOfTheProtocolB; " of the Protocol Buffer runtime library"...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+1A8h+var_140], rax
jmp short $+2
loc_218B37:
lea rdi, [rsp+1A8h+var_98]
mov esi, (offset algn_2E18D2+2)
call _ZN6google8protobuf8internal13VersionStringB5cxx11Ei; google::protobuf::internal::VersionString(int)
jmp short $+2
loc_218B4B:
mov rdi, [rsp+1A8h+var_140]
lea rsi, [rsp+1A8h+var_98]
call _ZN6google8protobuf8internal10LogMessagelsERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; google::protobuf::internal::LogMessage::operator<<(std::string const&)
mov [rsp+1A8h+var_148], rax
jmp short $+2
loc_218B64:
mov rdi, [rsp+1A8h+var_148]
lea rsi, aPleaseUpdateYo; ". Please update your library. If you "...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+1A8h+var_150], rax
jmp short $+2
loc_218B7C:
mov rdi, [rsp+1A8h+var_150]
mov rsi, [rsp+1A8h+var_10]
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+1A8h+var_158], rax
jmp short $+2
loc_218B95:
mov rdi, [rsp+1A8h+var_158]
lea rsi, asc_3FD4C2; "\".)"
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+1A8h+var_160], rax
jmp short $+2
loc_218BAD:
mov rsi, [rsp+1A8h+var_160]
lea rdi, [rsp+1A8h+var_99]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_218BC1:
lea rdi, [rsp+1A8h+var_98]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+1A8h+var_78]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+1A8h+var_48]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
jmp short loc_218C56
mov rcx, rax
mov eax, edx
mov [rsp+arg_150], rcx
mov [rsp+arg_14C], eax
jmp short loc_218C44
mov rcx, rax
mov eax, edx
mov [rsp+arg_150], rcx
mov [rsp+arg_14C], eax
jmp short loc_218C37
mov rcx, rax
mov eax, edx
mov [rsp+arg_150], rcx
mov [rsp+arg_14C], eax
lea rdi, [rsp+arg_108]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_218C37:
lea rdi, [rsp+arg_128]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_218C44:
lea rdi, [rsp+arg_158]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
jmp loc_218E0D
loc_218C56:
cmp [rsp+1A8h+var_4], offset loc_2E18C8
jge loc_218E05
lea rdx, aWorkspaceLlm4b_73; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+1A8h+var_D8]
mov [rsp+1A8h+var_170], rdi
mov esi, 3
mov ecx, 53h ; 'S'
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+1A8h+var_170]
lea rsi, aThisProgramWas; "This program was compiled against versi"...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+1A8h+var_168], rax
jmp short $+2
loc_218CA2:
mov esi, [rsp+1A8h+var_4]
lea rdi, [rsp+1A8h+var_F8]
call _ZN6google8protobuf8internal13VersionStringB5cxx11Ei; google::protobuf::internal::VersionString(int)
jmp short $+2
loc_218CB8:
mov rdi, [rsp+1A8h+var_168]
lea rsi, [rsp+1A8h+var_F8]
call _ZN6google8protobuf8internal10LogMessagelsERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; google::protobuf::internal::LogMessage::operator<<(std::string const&)
mov [rsp+1A8h+var_178], rax
jmp short $+2
loc_218CD1:
mov rdi, [rsp+1A8h+var_178]
lea rsi, aOfTheProtocolB_0; " of the Protocol Buffer runtime library"...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+1A8h+var_180], rax
jmp short $+2
loc_218CE9:
lea rdi, [rsp+1A8h+var_118]
mov esi, (offset algn_2E18D2+2)
call _ZN6google8protobuf8internal13VersionStringB5cxx11Ei; google::protobuf::internal::VersionString(int)
jmp short $+2
loc_218CFD:
mov rdi, [rsp+1A8h+var_180]
lea rsi, [rsp+1A8h+var_118]
call _ZN6google8protobuf8internal10LogMessagelsERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; google::protobuf::internal::LogMessage::operator<<(std::string const&)
mov [rsp+1A8h+var_188], rax
jmp short $+2
loc_218D16:
mov rdi, [rsp+1A8h+var_188]
lea rsi, aContactTheProg; "). Contact the program author for an u"...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+1A8h+var_190], rax
jmp short $+2
loc_218D2E:
mov rdi, [rsp+1A8h+var_190]
mov rsi, [rsp+1A8h+var_10]
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+1A8h+var_198], rax
jmp short $+2
loc_218D47:
mov rdi, [rsp+1A8h+var_198]
lea rsi, asc_3FD4C2; "\".)"
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+1A8h+var_1A0], rax
jmp short $+2
loc_218D5F:
mov rsi, [rsp+1A8h+var_1A0]
lea rdi, [rsp+1A8h+var_119]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_218D73:
lea rdi, [rsp+1A8h+var_118]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+1A8h+var_F8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+1A8h+var_D8]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
jmp short loc_218E05
mov rcx, rax
mov eax, edx
mov [rsp+arg_150], rcx
mov [rsp+arg_14C], eax
jmp short loc_218DF6
mov rcx, rax
mov eax, edx
mov [rsp+arg_150], rcx
mov [rsp+arg_14C], eax
jmp short loc_218DE9
mov rcx, rax
mov eax, edx
mov [rsp+arg_150], rcx
mov [rsp+arg_14C], eax
lea rdi, [rsp+arg_88]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_218DE9:
lea rdi, [rsp+arg_A8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_218DF6:
lea rdi, [rsp+arg_C8]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
jmp short loc_218E0D
loc_218E05:
add rsp, 1A8h
retn
loc_218E0D:
mov rdi, [rsp+arg_150]
call __Unwind_Resume
| void google::protobuf::internal::VerifyVersion(
google::protobuf::internal *this,
int a2,
long long a3,
const char *a4)
{
int v4; // edx
int v5; // ecx
int v6; // r8d
int v7; // r9d
int v8; // edx
int v9; // ecx
int v10; // r8d
int v11; // r9d
int v12; // edx
int v13; // ecx
int v14; // r8d
int v15; // r9d
int v16; // edx
int v17; // ecx
int v18; // r8d
int v19; // r9d
long long v20; // [rsp+8h] [rbp-1A0h]
long long v21; // [rsp+10h] [rbp-198h]
long long v22; // [rsp+18h] [rbp-190h]
long long v23; // [rsp+20h] [rbp-188h]
long long v24; // [rsp+28h] [rbp-180h]
long long v25; // [rsp+30h] [rbp-178h]
long long v26; // [rsp+40h] [rbp-168h]
long long v27; // [rsp+48h] [rbp-160h]
long long v28; // [rsp+50h] [rbp-158h]
long long v29; // [rsp+58h] [rbp-150h]
long long v30; // [rsp+60h] [rbp-148h]
long long v31; // [rsp+68h] [rbp-140h]
long long v32; // [rsp+70h] [rbp-138h]
long long v33; // [rsp+80h] [rbp-128h]
char v34; // [rsp+8Fh] [rbp-119h] BYREF
_BYTE v35[32]; // [rsp+90h] [rbp-118h] BYREF
_BYTE v36[32]; // [rsp+B0h] [rbp-F8h] BYREF
_BYTE v37[63]; // [rsp+D0h] [rbp-D8h] BYREF
char v38; // [rsp+10Fh] [rbp-99h] BYREF
_BYTE v39[32]; // [rsp+110h] [rbp-98h] BYREF
_BYTE v40[48]; // [rsp+130h] [rbp-78h] BYREF
_BYTE v41[56]; // [rsp+160h] [rbp-48h] BYREF
long long v42; // [rsp+198h] [rbp-10h]
int v43; // [rsp+1A0h] [rbp-8h]
int v44; // [rsp+1A4h] [rbp-4h]
v44 = (int)this;
v43 = a2;
v42 = a3;
if ( (int)&algn_2E18D2[2] < a2 )
{
google::protobuf::internal::LogMessage::LogMessage(
v41,
3LL,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/stubs/common.cc",
72LL);
v33 = google::protobuf::internal::LogMessage::operator<<(v41, "This program requires version ");
google::protobuf::internal::VersionString[abi:cxx11]((unsigned int)v40, v43, v4, v5, v6, v7);
v32 = google::protobuf::internal::LogMessage::operator<<(v33, v40);
v31 = google::protobuf::internal::LogMessage::operator<<(
v32,
" of the Protocol Buffer runtime library, but the installed version is ");
google::protobuf::internal::VersionString[abi:cxx11](
(unsigned int)v39,
(unsigned int)&algn_2E18D2[2],
v8,
v9,
v10,
v11);
v30 = google::protobuf::internal::LogMessage::operator<<(v31, v39);
v29 = google::protobuf::internal::LogMessage::operator<<(
v30,
". Please update your library. If you compiled the program yourself, make sure that your headers are from t"
"he same version of Protocol Buffers as your link-time library. (Version verification failed in \"");
v28 = google::protobuf::internal::LogMessage::operator<<(v29, v42);
v27 = google::protobuf::internal::LogMessage::operator<<(v28, "\".)");
google::protobuf::internal::LogFinisher::operator=(&v38, v27);
std::string::~string(v39);
std::string::~string(v40);
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v41);
}
if ( v44 < (int)&loc_2E18C8 )
{
google::protobuf::internal::LogMessage::LogMessage(
v37,
3LL,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/stubs/common.cc",
83LL);
v26 = google::protobuf::internal::LogMessage::operator<<(v37, "This program was compiled against version ");
google::protobuf::internal::VersionString[abi:cxx11]((unsigned int)v36, v44, v12, v13, v14, v15);
v25 = google::protobuf::internal::LogMessage::operator<<(v26, v36);
v24 = google::protobuf::internal::LogMessage::operator<<(
v25,
" of the Protocol Buffer runtime library, which is not compatible with the installed version (");
google::protobuf::internal::VersionString[abi:cxx11](
(unsigned int)v35,
(unsigned int)&algn_2E18D2[2],
v16,
v17,
v18,
v19);
v23 = google::protobuf::internal::LogMessage::operator<<(v24, v35);
v22 = google::protobuf::internal::LogMessage::operator<<(
v23,
"). Contact the program author for an update. If you compiled the program yourself, make sure that your hea"
"ders are from the same version of Protocol Buffers as your link-time library. (Version verification failed in \"");
v21 = google::protobuf::internal::LogMessage::operator<<(v22, v42);
v20 = google::protobuf::internal::LogMessage::operator<<(v21, "\".)");
google::protobuf::internal::LogFinisher::operator=(&v34, v20);
std::string::~string(v35);
std::string::~string(v36);
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v37);
}
}
| construct<std::vector<google::protobuf::FieldDescriptor_const*,std::allocator<google::protobuf::FieldDescriptor_const*>>,std::vector<google::protobuf::FieldDescriptor_const*,std::allocator<google::protobuf::FieldDescriptor_const*>>>:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x8],RSI
MOV qword ptr [RSP],RDX
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP]
CALL 0x00218ae0
ADD RSP,0x18
RET
|
/* void std::allocator_traits<std::allocator<std::vector<google::protobuf::FieldDescriptor const*,
std::allocator<google::protobuf::FieldDescriptor const*> > >
>::construct<std::vector<google::protobuf::FieldDescriptor const*,
std::allocator<google::protobuf::FieldDescriptor const*> >,
std::vector<google::protobuf::FieldDescriptor const*,
std::allocator<google::protobuf::FieldDescriptor const*> >
>(std::allocator<std::vector<google::protobuf::FieldDescriptor const*,
std::allocator<google::protobuf::FieldDescriptor const*> > >&,
std::vector<google::protobuf::FieldDescriptor const*,
std::allocator<google::protobuf::FieldDescriptor const*> >*,
std::vector<google::protobuf::FieldDescriptor const*,
std::allocator<google::protobuf::FieldDescriptor const*> >&&) */
void std::
allocator_traits<std::allocator<std::vector<google::protobuf::FieldDescriptor_const*,std::allocator<google::protobuf::FieldDescriptor_const*>>>>
::
construct<std::vector<google::protobuf::FieldDescriptor_const*,std::allocator<google::protobuf::FieldDescriptor_const*>>,std::vector<google::protobuf::FieldDescriptor_const*,std::allocator<google::protobuf::FieldDescriptor_const*>>>
(allocator *param_1,vector *param_2,vector *param_3)
{
__gnu_cxx::
new_allocator<std::vector<google::protobuf::FieldDescriptor_const*,std::allocator<google::protobuf::FieldDescriptor_const*>>>
::
construct<std::vector<google::protobuf::FieldDescriptor_const*,std::allocator<google::protobuf::FieldDescriptor_const*>>,std::vector<google::protobuf::FieldDescriptor_const*,std::allocator<google::protobuf::FieldDescriptor_const*>>>
((new_allocator<std::vector<google::protobuf::FieldDescriptor_const*,std::allocator<google::protobuf::FieldDescriptor_const*>>>
*)param_1,param_2,param_3);
return;
}
| |
41,592 | google::protobuf::internal::VerifyVersion(int, int, char const*) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/stubs/common.cc | void VerifyVersion(int headerVersion,
int minLibraryVersion,
const char* filename) {
if (GOOGLE_PROTOBUF_VERSION < minLibraryVersion) {
// Library is too old for headers.
GOOGLE_LOG(FATAL)
<< "This program requires version " << VersionString(minLibraryVersion)
<< " of the Protocol Buffer runtime library, but the installed version "
"is " << VersionString(GOOGLE_PROTOBUF_VERSION) << ". Please update "
"your library. If you compiled the program yourself, make sure that "
"your headers are from the same version of Protocol Buffers as your "
"link-time library. (Version verification failed in \""
<< filename << "\".)";
}
if (headerVersion < kMinHeaderVersionForLibrary) {
// Headers are too old for library.
GOOGLE_LOG(FATAL)
<< "This program was compiled against version "
<< VersionString(headerVersion) << " of the Protocol Buffer runtime "
"library, which is not compatible with the installed version ("
<< VersionString(GOOGLE_PROTOBUF_VERSION) << "). Contact the program "
"author for an update. If you compiled the program yourself, make "
"sure that your headers are from the same version of Protocol Buffers "
"as your link-time library. (Version verification failed in \""
<< filename << "\".)";
}
} | O3 | cpp | google::protobuf::internal::VerifyVersion(int, int, char const*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdx, %rbx
movl %edi, %ebp
cmpl $0x2e18d5, %esi # imm = 0x2E18D5
jl 0x106c0d
movl %esi, %r15d
leaq 0x60(%rsp), %r14
movl $0x3, -0x18(%r14)
leaq 0xe62ec(%rip), %rax # 0x1ece0f
movq %rax, -0x10(%r14)
movl $0x48, -0x8(%r14)
leaq 0x70(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0xe632a(%rip), %rsi # 0x1ece78
movq %r14, %rdi
callq 0x1f8e0
leaq 0x28(%rsp), %rdi
movl %r15d, %esi
callq 0x106de6
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r14, %rdi
callq 0x1f150
leaq 0xe631b(%rip), %rsi # 0x1ece97
movq %r14, %rdi
callq 0x1f8e0
leaq 0x8(%rsp), %rdi
movl $0x2e18d4, %esi # imm = 0x2E18D4
callq 0x106de6
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x1f150
leaq 0xe6332(%rip), %rsi # 0x1ecede
movq %r14, %rdi
callq 0x1f8e0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1f8e0
leaq 0xe63e6(%rip), %rsi # 0x1ecfac
movq %r14, %rdi
callq 0x1f8e0
leaq 0x48(%rsp), %rdi
callq 0x1072ee
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x106beb
callq 0x1f4a0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x106bfe
callq 0x1f4a0
movq 0x60(%rsp), %rdi
cmpq %r12, %rdi
je 0x106c0d
callq 0x1f4a0
cmpl $0x2e18c7, %ebp # imm = 0x2E18C7
jg 0x106d13
leaq 0x60(%rsp), %r14
movl $0x3, -0x18(%r14)
leaq 0xe61e2(%rip), %rax # 0x1ece0f
movq %rax, -0x10(%r14)
movl $0x53, -0x8(%r14)
leaq 0x70(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0xe635b(%rip), %rsi # 0x1ecfb0
movq %r14, %rdi
callq 0x1f8e0
leaq 0x28(%rsp), %rdi
movl %ebp, %esi
callq 0x106de6
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r14, %rdi
callq 0x1f150
leaq 0xe6359(%rip), %rsi # 0x1ecfdb
movq %r14, %rdi
callq 0x1f8e0
leaq 0x8(%rsp), %rdi
movl $0x2e18d4, %esi # imm = 0x2E18D4
callq 0x106de6
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x1f150
leaq 0xe6387(%rip), %rsi # 0x1ed039
movq %r14, %rdi
callq 0x1f8e0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1f8e0
leaq 0xe62e0(%rip), %rsi # 0x1ecfac
movq %r14, %rdi
callq 0x1f8e0
leaq 0x48(%rsp), %rdi
callq 0x1072ee
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x106cf1
callq 0x1f4a0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x106d04
callq 0x1f4a0
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x106d13
callq 0x1f4a0
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x106d43
jmp 0x106d39
jmp 0x106d78
jmp 0x106d2b
movq %rax, %rbx
jmp 0x106d6c
jmp 0x106d3e
jmp 0x106d34
movq %rax, %rbx
jmp 0x106da1
movq %rax, %rbx
jmp 0x106d59
movq %rax, %rbx
jmp 0x106d8e
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x106d59
callq 0x1f4a0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x106d6c
callq 0x1f4a0
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
jne 0x106dab
jmp 0x106db0
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x106d8e
callq 0x1f4a0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x106da1
callq 0x1f4a0
movq 0x60(%rsp), %rdi
cmpq %r12, %rdi
je 0x106db0
callq 0x1f4a0
movq %rbx, %rdi
callq 0x1f860
| _ZN6google8protobuf8internal13VerifyVersionEiiPKc:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 80h
mov rbx, rdx
mov ebp, edi
cmp esi, 2E18D5h
jl loc_106C0D
mov r15d, esi
lea r14, [rsp+0A8h+var_48]
mov dword ptr [r14-18h], 3
lea rax, aWorkspaceLlm4b_56; "/workspace/llm4binary/github2025/aimrt_"...
mov [r14-10h], rax
mov dword ptr [r14-8], 48h ; 'H'
lea r12, [rsp+0A8h+var_38]
mov [r12-10h], r12
mov qword ptr [r12-8], 0
mov byte ptr [r12], 0
lea rsi, aThisProgramReq; "This program requires version "
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rdi, [rsp+0A8h+var_80]
mov esi, r15d
call _ZN6google8protobuf8internal13VersionStringB5cxx11Ei; google::protobuf::internal::VersionString(int)
mov rsi, [rsp+0A8h+var_80]
mov rdx, [rsp+0A8h+var_78]
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
lea rsi, aOfTheProtocolB; " of the Protocol Buffer runtime library"...
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rdi, [rsp+0A8h+var_A0]
mov esi, 2E18D4h
call _ZN6google8protobuf8internal13VersionStringB5cxx11Ei; google::protobuf::internal::VersionString(int)
mov rsi, [rsp+0A8h+var_A0]
mov rdx, [rsp+0A8h+var_98]
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
lea rsi, aPleaseUpdateYo; ". Please update your library. If you "...
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rdi, r14
mov rsi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rsi, asc_1ECFAC; "\".)"
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rdi, [rsp+0A8h+var_60]; this
call _ZN6google8protobuf8internal10LogMessage6FinishEv; google::protobuf::internal::LogMessage::Finish(void)
lea rax, [rsp+0A8h+var_90]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_106BEB
call __ZdlPv; operator delete(void *)
loc_106BEB:
lea rax, [rsp+0A8h+var_70]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_106BFE
call __ZdlPv; operator delete(void *)
loc_106BFE:
mov rdi, [rsp+0A8h+var_48]; void *
cmp rdi, r12
jz short loc_106C0D
call __ZdlPv; operator delete(void *)
loc_106C0D:
cmp ebp, 2E18C7h
jg loc_106D13
lea r14, [rsp+0A8h+var_48]
mov dword ptr [r14-18h], 3
lea rax, aWorkspaceLlm4b_56; "/workspace/llm4binary/github2025/aimrt_"...
mov [r14-10h], rax
mov dword ptr [r14-8], 53h ; 'S'
lea r15, [rsp+0A8h+var_38]
mov [r15-10h], r15
mov qword ptr [r15-8], 0
mov byte ptr [r15], 0
lea rsi, aThisProgramWas; "This program was compiled against versi"...
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rdi, [rsp+0A8h+var_80]
mov esi, ebp
call _ZN6google8protobuf8internal13VersionStringB5cxx11Ei; google::protobuf::internal::VersionString(int)
mov rsi, [rsp+0A8h+var_80]
mov rdx, [rsp+0A8h+var_78]
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
lea rsi, aOfTheProtocolB_0; " of the Protocol Buffer runtime library"...
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rdi, [rsp+0A8h+var_A0]
mov esi, 2E18D4h
call _ZN6google8protobuf8internal13VersionStringB5cxx11Ei; google::protobuf::internal::VersionString(int)
mov rsi, [rsp+0A8h+var_A0]
mov rdx, [rsp+0A8h+var_98]
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
lea rsi, aContactTheProg; "). Contact the program author for an u"...
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rdi, r14
mov rsi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rsi, asc_1ECFAC; "\".)"
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rdi, [rsp+0A8h+var_60]; this
call _ZN6google8protobuf8internal10LogMessage6FinishEv; google::protobuf::internal::LogMessage::Finish(void)
lea rax, [rsp+0A8h+var_90]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_106CF1
call __ZdlPv; operator delete(void *)
loc_106CF1:
lea rax, [rsp+0A8h+var_70]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_106D04
call __ZdlPv; operator delete(void *)
loc_106D04:
mov rdi, [rsp+0A8h+var_48]; void *
cmp rdi, r15
jz short loc_106D13
call __ZdlPv; operator delete(void *)
loc_106D13:
add rsp, 80h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
jmp short loc_106D43
jmp short loc_106D39
jmp short loc_106D78
jmp short $+2
loc_106D2B:
mov rbx, rax
jmp short loc_106D6C
jmp short loc_106D3E
jmp short $+2
loc_106D34:
mov rbx, rax
jmp short loc_106DA1
loc_106D39:
mov rbx, rax
jmp short loc_106D59
loc_106D3E:
mov rbx, rax
jmp short loc_106D8E
loc_106D43:
mov rbx, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_106D59
call __ZdlPv; operator delete(void *)
loc_106D59:
lea rax, [rsp+arg_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_106D6C
call __ZdlPv; operator delete(void *)
loc_106D6C:
mov rdi, [rsp+arg_58]
cmp rdi, r15
jnz short loc_106DAB
jmp short loc_106DB0
loc_106D78:
mov rbx, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_106D8E
call __ZdlPv; operator delete(void *)
loc_106D8E:
lea rax, [rsp+arg_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_106DA1
call __ZdlPv; operator delete(void *)
loc_106DA1:
mov rdi, [rsp+arg_58]; void *
cmp rdi, r12
jz short loc_106DB0
loc_106DAB:
call __ZdlPv; operator delete(void *)
loc_106DB0:
mov rdi, rbx
call __Unwind_Resume
| void google::protobuf::internal::VerifyVersion(
google::protobuf::internal *this,
int a2,
long long a3,
const char *a4)
{
_BYTE *v5; // [rsp+8h] [rbp-A0h] BYREF
long long v6; // [rsp+10h] [rbp-98h]
_BYTE v7[16]; // [rsp+18h] [rbp-90h] BYREF
_BYTE *v8; // [rsp+28h] [rbp-80h] BYREF
long long v9; // [rsp+30h] [rbp-78h]
_BYTE v10[16]; // [rsp+38h] [rbp-70h] BYREF
int v11; // [rsp+48h] [rbp-60h] BYREF
const char *v12; // [rsp+50h] [rbp-58h]
int v13; // [rsp+58h] [rbp-50h]
void *v14; // [rsp+60h] [rbp-48h] BYREF
long long v15; // [rsp+68h] [rbp-40h]
_BYTE v16[56]; // [rsp+70h] [rbp-38h] BYREF
if ( a2 >= 3021013 )
{
v11 = 3;
v12 = "/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/stubs/common.cc";
v13 = 72;
v14 = v16;
v15 = 0LL;
v16[0] = 0;
std::string::append(&v14, "This program requires version ");
google::protobuf::internal::VersionString[abi:cxx11](&v8, (unsigned int)a2);
std::string::_M_append(&v14, v8, v9);
std::string::append(&v14, " of the Protocol Buffer runtime library, but the installed version is ");
google::protobuf::internal::VersionString[abi:cxx11](&v5, 3021012LL);
std::string::_M_append(&v14, v5, v6);
std::string::append(
&v14,
". Please update your library. If you compiled the program yourself, make sure that your headers are from the sam"
"e version of Protocol Buffers as your link-time library. (Version verification failed in \"");
std::string::append(&v14, a3);
std::string::append(&v14, "\".)");
google::protobuf::internal::LogMessage::Finish((google::protobuf::internal::LogMessage *)&v11);
if ( v5 != v7 )
operator delete(v5);
if ( v8 != v10 )
operator delete(v8);
if ( v14 != v16 )
operator delete(v14);
}
if ( (int)this <= 3020999 )
{
v11 = 3;
v12 = "/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/stubs/common.cc";
v13 = 83;
v14 = v16;
v15 = 0LL;
v16[0] = 0;
std::string::append(&v14, "This program was compiled against version ");
google::protobuf::internal::VersionString[abi:cxx11](&v8, (unsigned int)this);
std::string::_M_append(&v14, v8, v9);
std::string::append(
&v14,
" of the Protocol Buffer runtime library, which is not compatible with the installed version (");
google::protobuf::internal::VersionString[abi:cxx11](&v5, 3021012LL);
std::string::_M_append(&v14, v5, v6);
std::string::append(
&v14,
"). Contact the program author for an update. If you compiled the program yourself, make sure that your headers a"
"re from the same version of Protocol Buffers as your link-time library. (Version verification failed in \"");
std::string::append(&v14, a3);
std::string::append(&v14, "\".)");
google::protobuf::internal::LogMessage::Finish((google::protobuf::internal::LogMessage *)&v11);
if ( v5 != v7 )
operator delete(v5);
if ( v8 != v10 )
operator delete(v8);
if ( v14 != v16 )
operator delete(v14);
}
}
| |||
41,593 | mi_write_keypage | eloqsql/storage/myisam/mi_page.c | int _mi_write_keypage(register MI_INFO *info, register MI_KEYDEF *keyinfo,
my_off_t page, int level, uchar *buff)
{
reg3 uint length;
DBUG_ENTER("_mi_write_keypage");
#ifndef FAST /* Safety check */
if (page < info->s->base.keystart ||
page+keyinfo->block_length > info->state->key_file_length ||
(page & (MI_MIN_KEY_BLOCK_LENGTH-1)))
{
DBUG_PRINT("error",("Trying to write inside key status region: key_start: %lu length: %lu page: %lu",
(long) info->s->base.keystart,
(long) info->state->key_file_length,
(long) page));
my_errno=EINVAL;
DBUG_RETURN((-1));
}
DBUG_PRINT("page",("write page at: %lu",(long) page));
DBUG_DUMP("buff",(uchar*) buff,mi_getint(buff));
#endif
if ((length=keyinfo->block_length) > IO_SIZE*2 &&
info->state->key_file_length != page+length)
length= ((mi_getint(buff)+IO_SIZE-1) & (uint) ~(IO_SIZE-1));
DBUG_RETURN((key_cache_write(info->s->key_cache,
info->s->kfile, &info->s->dirty_part_map,
page, level, (uchar*) buff, length,
(uint) keyinfo->block_length,
(int) ((info->lock_type != F_UNLCK) ||
info->s->delay_key_write))));
} | O0 | c | mi_write_keypage:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
cmpq 0x108(%rcx), %rax
jb 0xc5b0f
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movzwl 0xe(%rcx), %ecx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpq 0x20(%rcx), %rax
ja 0xc5b0f
movq -0x20(%rbp), %rax
andq $0x3ff, %rax # imm = 0x3FF
cmpq $0x0, %rax
je 0xc5b2a
jmp 0xc5b11
jmp 0xc5b13
callq 0xfdd30
movl $0x16, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc5c52
jmp 0xc5b2c
jmp 0xc5b2e
jmp 0xc5b30
jmp 0xc5b32
movq -0x18(%rbp), %rax
movzwl 0xe(%rax), %eax
movl %eax, -0x34(%rbp)
cmpl $0x2000, %eax # imm = 0x2000
jbe 0xc5b91
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movq -0x20(%rbp), %rcx
movl -0x34(%rbp), %edx
addq %rdx, %rcx
cmpq %rcx, %rax
je 0xc5b91
movq -0x30(%rbp), %rax
movzbl 0x1(%rax), %eax
movzwl %ax, %eax
movq -0x30(%rbp), %rcx
movzbl (%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %eax
andl $0x7fff, %eax # imm = 0x7FFF
addl $0x1000, %eax # imm = 0x1000
subl $0x1, %eax
andl $0xfffff000, %eax # imm = 0xFFFFF000
movl %eax, -0x34(%rbp)
jmp 0xc5b93
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x278(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x350(%rax), %eax
movl %eax, -0x64(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x280, %rax # imm = 0x280
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movzwl 0xe(%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rcx
movb $0x1, %al
cmpl $0x2, 0x1f4(%rcx)
movb %al, -0x35(%rbp)
jne 0xc5c16
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x383(%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x35(%rbp)
movl -0x3c(%rbp), %r10d
movl -0x40(%rbp), %r11d
movq -0x48(%rbp), %r9
movl -0x4c(%rbp), %r8d
movq -0x58(%rbp), %rcx
movq -0x60(%rbp), %rdx
movl -0x64(%rbp), %esi
movq -0x70(%rbp), %rdi
movb -0x35(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
callq 0xec750
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nop
| _mi_write_keypage:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov [rbp+var_30], r8
mov rax, [rbp+var_20]
mov rcx, [rbp+var_10]
mov rcx, [rcx]
cmp rax, [rcx+108h]
jb short loc_C5B0F
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
movzx ecx, word ptr [rcx+0Eh]
add rax, rcx
mov rcx, [rbp+var_10]
mov rcx, [rcx+8]
cmp rax, [rcx+20h]
ja short loc_C5B0F
mov rax, [rbp+var_20]
and rax, 3FFh
cmp rax, 0
jz short loc_C5B2A
loc_C5B0F:
jmp short $+2
loc_C5B11:
jmp short $+2
loc_C5B13:
call _my_thread_var
mov dword ptr [rax], 16h
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_C5C52
loc_C5B2A:
jmp short $+2
loc_C5B2C:
jmp short $+2
loc_C5B2E:
jmp short $+2
loc_C5B30:
jmp short $+2
loc_C5B32:
mov rax, [rbp+var_18]
movzx eax, word ptr [rax+0Eh]
mov [rbp+var_34], eax
cmp eax, 2000h
jbe short loc_C5B91
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov rax, [rax+20h]
mov rcx, [rbp+var_20]
mov edx, [rbp+var_34]
add rcx, rdx
cmp rax, rcx
jz short loc_C5B91
mov rax, [rbp+var_30]
movzx eax, byte ptr [rax+1]
movzx eax, ax
mov rcx, [rbp+var_30]
movzx ecx, byte ptr [rcx]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx eax, ax
and eax, 7FFFh
add eax, 1000h
sub eax, 1
and eax, 0FFFFF000h
mov [rbp+var_34], eax
loc_C5B91:
jmp short $+2
loc_C5B93:
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+278h]
mov [rbp+var_70], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov eax, [rax+350h]
mov [rbp+var_64], eax
mov rax, [rbp+var_10]
mov rax, [rax]
add rax, 280h
mov [rbp+var_60], rax
mov rax, [rbp+var_20]
mov [rbp+var_58], rax
mov eax, [rbp+var_24]
mov [rbp+var_4C], eax
mov rax, [rbp+var_30]
mov [rbp+var_48], rax
mov eax, [rbp+var_34]
mov [rbp+var_40], eax
mov rax, [rbp+var_18]
movzx eax, word ptr [rax+0Eh]
mov [rbp+var_3C], eax
mov rcx, [rbp+var_10]
mov al, 1
cmp dword ptr [rcx+1F4h], 2
mov [rbp+var_35], al
jnz short loc_C5C16
mov rax, [rbp+var_10]
mov rax, [rax]
movsx eax, byte ptr [rax+383h]
cmp eax, 0
setnz al
mov [rbp+var_35], al
loc_C5C16:
mov r10d, [rbp+var_3C]
mov r11d, [rbp+var_40]
mov r9, [rbp+var_48]
mov r8d, [rbp+var_4C]
mov rcx, [rbp+var_58]
mov rdx, [rbp+var_60]
mov esi, [rbp+var_64]
mov rdi, [rbp+var_70]
mov al, [rbp+var_35]
and al, 1
movzx eax, al
mov [rsp+90h+var_90], r11d
mov [rsp+90h+var_88], r10d
mov [rsp+90h+var_80], eax
call key_cache_write
mov [rbp+var_4], eax
loc_C5C52:
mov eax, [rbp+var_4]
add rsp, 90h
pop rbp
retn
| long long mi_write_keypage(_QWORD *a1, long long a2, unsigned long long a3, int a4, unsigned __int16 *a5)
{
bool v6; // [rsp+5Bh] [rbp-35h]
unsigned int v7; // [rsp+5Ch] [rbp-34h]
if ( a3 < *(_QWORD *)(*a1 + 264LL)
|| *(unsigned __int16 *)(a2 + 14) + a3 > *(_QWORD *)(a1[1] + 32LL)
|| (a3 & 0x3FF) != 0 )
{
*(_DWORD *)my_thread_var(a1, (const char *)a2) = 22;
return (unsigned int)-1;
}
else
{
v7 = *(unsigned __int16 *)(a2 + 14);
if ( v7 > 0x2000 && *(_QWORD *)(a1[1] + 32LL) != *(unsigned __int16 *)(a2 + 14) + a3 )
v7 = ((_byteswap_ushort(*a5) & 0x7FFF) + 4095) & 0xFFFFF000;
v6 = 1;
if ( *((_DWORD *)a1 + 125) == 2 )
v6 = *(_BYTE *)(*a1 + 899LL) != 0;
return (unsigned int)key_cache_write(
*(_QWORD *)(*a1 + 632LL),
*(_DWORD *)(*a1 + 848LL),
*(_DWORD *)a1 + 640,
a3,
a4,
(_DWORD)a5,
v7,
*(unsigned __int16 *)(a2 + 14),
v6);
}
}
| _mi_write_keypage:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV qword ptr [RBP + -0x30],R8
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX]
CMP RAX,qword ptr [RCX + 0x108]
JC 0x001c5b0f
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,word ptr [RCX + 0xe]
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x8]
CMP RAX,qword ptr [RCX + 0x20]
JA 0x001c5b0f
MOV RAX,qword ptr [RBP + -0x20]
AND RAX,0x3ff
CMP RAX,0x0
JZ 0x001c5b2a
LAB_001c5b0f:
JMP 0x001c5b11
LAB_001c5b11:
JMP 0x001c5b13
LAB_001c5b13:
CALL 0x001fdd30
MOV dword ptr [RAX],0x16
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001c5c52
LAB_001c5b2a:
JMP 0x001c5b2c
LAB_001c5b2c:
JMP 0x001c5b2e
LAB_001c5b2e:
JMP 0x001c5b30
LAB_001c5b30:
JMP 0x001c5b32
LAB_001c5b32:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX + 0xe]
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x2000
JBE 0x001c5b91
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x34]
ADD RCX,RDX
CMP RAX,RCX
JZ 0x001c5b91
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX + 0x1]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x30]
MOVZX ECX,byte ptr [RCX]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX EAX,AX
AND EAX,0x7fff
ADD EAX,0x1000
SUB EAX,0x1
AND EAX,0xfffff000
MOV dword ptr [RBP + -0x34],EAX
LAB_001c5b91:
JMP 0x001c5b93
LAB_001c5b93:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x278]
MOV qword ptr [RBP + -0x70],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x350]
MOV dword ptr [RBP + -0x64],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
ADD RAX,0x280
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x58],RAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4c],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x48],RAX
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x40],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX + 0xe]
MOV dword ptr [RBP + -0x3c],EAX
MOV RCX,qword ptr [RBP + -0x10]
MOV AL,0x1
CMP dword ptr [RCX + 0x1f4],0x2
MOV byte ptr [RBP + -0x35],AL
JNZ 0x001c5c16
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOVSX EAX,byte ptr [RAX + 0x383]
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x35],AL
LAB_001c5c16:
MOV R10D,dword ptr [RBP + -0x3c]
MOV R11D,dword ptr [RBP + -0x40]
MOV R9,qword ptr [RBP + -0x48]
MOV R8D,dword ptr [RBP + -0x4c]
MOV RCX,qword ptr [RBP + -0x58]
MOV RDX,qword ptr [RBP + -0x60]
MOV ESI,dword ptr [RBP + -0x64]
MOV RDI,qword ptr [RBP + -0x70]
MOV AL,byte ptr [RBP + -0x35]
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RSP],R11D
MOV dword ptr [RSP + 0x8],R10D
MOV dword ptr [RSP + 0x10],EAX
CALL 0x001ec750
MOV dword ptr [RBP + -0x4],EAX
LAB_001c5c52:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x90
POP RBP
RET
|
int4
_mi_write_keypage(long *param_1,long param_2,ulong param_3,int4 param_4,byte *param_5)
{
int4 *puVar1;
bool local_3d;
uint local_3c;
int4 local_c;
if (((param_3 < *(ulong *)(*param_1 + 0x108)) ||
(*(ulong *)(param_1[1] + 0x20) < param_3 + *(ushort *)(param_2 + 0xe))) ||
((param_3 & 0x3ff) != 0)) {
puVar1 = (int4 *)_my_thread_var();
*puVar1 = 0x16;
local_c = 0xffffffff;
}
else {
local_3c = (uint)*(ushort *)(param_2 + 0xe);
if ((0x2000 < local_3c) && (*(long *)(param_1[1] + 0x20) != param_3 + local_3c)) {
local_3c = ((uint)param_5[1] | (*param_5 & 0x7f) << 8) + 0xfff & 0xfffff000;
}
local_3d = true;
if (*(int *)((long)param_1 + 500) == 2) {
local_3d = *(char *)(*param_1 + 899) != '\0';
}
local_c = key_cache_write(*(int8 *)(*param_1 + 0x278),*(int4 *)(*param_1 + 0x350),
*param_1 + 0x280,param_3,param_4,param_5,local_3c,
*(int2 *)(param_2 + 0xe),local_3d);
}
return local_c;
}
| |
41,594 | thr_lock_data_init | eloqsql/mysys/thr_lock.c | void thr_lock_data_init(THR_LOCK *lock,THR_LOCK_DATA *data, void *param)
{
data->lock=lock;
data->type=TL_UNLOCK;
data->owner= 0; /* no owner yet */
data->status_param=param;
data->cond=0;
data->priority= 0;
data->debug_print_param= 0;
} | O0 | c | thr_lock_data_init:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x48(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
| thr_lock_data_init:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rcx, [rbp+var_8]
mov rax, [rbp+var_10]
mov [rax+18h], rcx
mov rax, [rbp+var_10]
mov dword ptr [rax+40h], 0
mov rax, [rbp+var_10]
mov qword ptr [rax], 0
mov rcx, [rbp+var_18]
mov rax, [rbp+var_10]
mov [rax+28h], rcx
mov rax, [rbp+var_10]
mov qword ptr [rax+20h], 0
mov rax, [rbp+var_10]
mov dword ptr [rax+48h], 0
mov rax, [rbp+var_10]
mov qword ptr [rax+30h], 0
pop rbp
retn
| long long thr_lock_data_init(long long a1, long long a2, long long a3)
{
long long result; // rax
*(_QWORD *)(a2 + 24) = a1;
*(_DWORD *)(a2 + 64) = 0;
*(_QWORD *)a2 = 0LL;
*(_QWORD *)(a2 + 40) = a3;
*(_QWORD *)(a2 + 32) = 0LL;
*(_DWORD *)(a2 + 72) = 0;
result = a2;
*(_QWORD *)(a2 + 48) = 0LL;
return result;
}
| thr_lock_data_init:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RCX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x40],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],0x0
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x28],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x20],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x48],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x30],0x0
POP RBP
RET
|
void thr_lock_data_init(int8 param_1,int8 *param_2,int8 param_3)
{
param_2[3] = param_1;
*(int4 *)(param_2 + 8) = 0;
*param_2 = 0;
param_2[5] = param_3;
param_2[4] = 0;
*(int4 *)(param_2 + 9) = 0;
param_2[6] = 0;
return;
}
| |
41,595 | my_strntoull_mb2_or_mb4 | eloqsql/strings/ctype-ucs2.c | static ulonglong
my_strntoull_mb2_or_mb4(CHARSET_INFO *cs,
const char *nptr, size_t l, int base,
char **endptr, int *err)
{
int negative= 0;
int overflow;
int cnv;
my_wc_t wc;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
register ulonglong cutoff;
register unsigned int cutlim;
register ulonglong res;
register const uchar *s= (const uchar*) nptr;
register const uchar *e= (const uchar*) nptr + l;
const uchar *save;
*err= 0;
do
{
if ((cnv= mb_wc(cs, &wc, s, e)) > 0)
{
switch (wc)
{
case ' ' : break;
case '\t': break;
case '-' : negative= !negative; break;
case '+' : break;
default : goto bs;
}
}
else /* No more characters or bad multibyte sequence */
{
if (endptr !=NULL )
*endptr = (char*)s;
err[0]= (cnv==MY_CS_ILSEQ) ? EILSEQ : EDOM;
return 0;
}
s+=cnv;
} while (1);
bs:
overflow = 0;
res = 0;
save = s;
cutoff = (~(ulonglong) 0) / (unsigned long int) base;
cutlim = (uint) ((~(ulonglong) 0) % (unsigned long int) base);
do
{
if ((cnv= mb_wc(cs, &wc, s, e)) > 0)
{
s+=cnv;
if ( wc>='0' && wc<='9')
wc -= '0';
else if ( wc>='A' && wc<='Z')
wc = wc - 'A' + 10;
else if ( wc>='a' && wc<='z')
wc = wc - 'a' + 10;
else
break;
if ((int)wc >= base)
break;
if (res > cutoff || (res == cutoff && wc > cutlim))
overflow = 1;
else
{
res *= (ulonglong) base;
res += wc;
}
}
else if (cnv==MY_CS_ILSEQ)
{
if (endptr !=NULL )
*endptr = (char*)s;
err[0]= EILSEQ;
return 0;
}
else
{
/* No more characters */
break;
}
} while(1);
if (endptr != NULL)
*endptr = (char *) s;
if (s == save)
{
err[0]= EDOM;
return 0L;
}
if (overflow)
{
err[0]= ERANGE;
return (~(ulonglong) 0);
}
return (negative ? -((longlong) res) : (longlong) res);
} | O3 | c | my_strntoull_mb2_or_mb4:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, -0x40(%rbp)
movl %ecx, -0x44(%rbp)
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r14
movq 0xb8(%rdi), %rax
movq 0x28(%rax), %r12
addq %rsi, %r13
movq %r9, -0x50(%rbp)
movl $0x0, (%r9)
leaq -0x30(%rbp), %rsi
movq %r15, %rdx
movq %r13, %rcx
callq *%r12
testl %eax, %eax
jle 0xc3c6a
movl $0x0, -0x34(%rbp)
leaq -0x30(%rbp), %rbx
movq -0x30(%rbp), %rcx
cmpq $0x2a, %rcx
jg 0xc3c3a
cmpq $0x9, %rcx
je 0xc3c52
cmpq $0x20, %rcx
je 0xc3c52
jmp 0xc3c9c
cmpq $0x2b, %rcx
je 0xc3c52
cmpq $0x2d, %rcx
jne 0xc3c9c
xorl %ecx, %ecx
cmpl $0x0, -0x34(%rbp)
sete %cl
movl %ecx, -0x34(%rbp)
movl %eax, %eax
addq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq *%r12
testl %eax, %eax
jg 0xc3c22
movq -0x40(%rbp), %rcx
testq %rcx, %rcx
je 0xc3c76
movq %r15, (%rcx)
testl %eax, %eax
movl $0x54, %eax
movl $0x21, %ecx
cmovel %eax, %ecx
movq -0x50(%rbp), %rax
movl %ecx, (%rax)
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movslq -0x44(%rbp), %rcx
movq $-0x1, %rax
xorl %edx, %edx
movq %rcx, -0x60(%rbp)
divq %rcx
movq %rdx, %rbx
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
movq %r15, %rdx
movq %r13, %rcx
callq *%r12
testl %eax, %eax
jle 0xc3d76
movq %r12, -0x70(%rbp)
movl %ebx, %ecx
movq %rcx, -0x68(%rbp)
xorl %ecx, %ecx
movq %r15, %rbx
xorl %edi, %edi
movq %rbx, %rsi
movl %eax, %ebx
addq %rsi, %rbx
movq -0x30(%rbp), %rsi
leaq -0x30(%rsi), %rax
cmpq $0x9, %rax
ja 0xc3cfc
movq %rax, -0x30(%rbp)
jmp 0xc3d21
leaq -0x41(%rsi), %rax
cmpq $0x19, %rax
ja 0xc3d0c
addq $-0x37, %rsi
jmp 0xc3d1a
leaq -0x61(%rsi), %rax
cmpq $0x19, %rax
ja 0xc3d87
addq $-0x57, %rsi
movq %rsi, -0x30(%rbp)
movq %rsi, %rax
cmpl -0x44(%rbp), %eax
jge 0xc3d87
movl $0x1, %esi
cmpq -0x58(%rbp), %rcx
jbe 0xc3d36
movq %rcx, %r12
jmp 0xc3d4f
jne 0xc3d42
movq -0x58(%rbp), %r12
cmpq -0x68(%rbp), %rax
ja 0xc3d4f
imulq -0x60(%rbp), %rcx
addq %rcx, %rax
movl %edi, %esi
movq %rax, %r12
movq %rsi, -0x78(%rbp)
movq %r14, %rdi
leaq -0x30(%rbp), %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq *-0x70(%rbp)
movq -0x78(%rbp), %rsi
movq %r12, %rcx
movl %esi, %edi
testl %eax, %eax
jg 0xc3ce0
jmp 0xc3d7e
xorl %r12d, %r12d
movq %r15, %rbx
xorl %esi, %esi
testl %eax, %eax
je 0xc3dc1
movl %esi, %edi
movq %r12, %rcx
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0xc3d93
movq %rbx, (%rax)
cmpq %r15, %rbx
je 0xc3db2
testl %edi, %edi
je 0xc3ddc
movq -0x50(%rbp), %rax
movl $0x22, (%rax)
movq $-0x1, %rax
jmp 0xc3c8d
movq -0x50(%rbp), %rax
movl $0x21, (%rax)
jmp 0xc3c8b
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0xc3dcd
movq %rbx, (%rax)
movq -0x50(%rbp), %rax
movl $0x54, (%rax)
jmp 0xc3c8b
movq %rcx, %rax
negq %rax
cmpl $0x0, -0x34(%rbp)
cmoveq %rcx, %rax
jmp 0xc3c8d
| my_strntoull_mb2_or_mb4:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov [rbp+var_40], r8
mov [rbp+var_44], ecx
mov r13, rdx
mov r15, rsi
mov r14, rdi
mov rax, [rdi+0B8h]
mov r12, [rax+28h]
add r13, rsi
mov [rbp+var_50], r9
mov dword ptr [r9], 0
lea rsi, [rbp+var_30]
mov rdx, r15
mov rcx, r13
call r12
test eax, eax
jle short loc_C3C6A
mov [rbp+var_34], 0
lea rbx, [rbp+var_30]
loc_C3C22:
mov rcx, [rbp+var_30]
cmp rcx, 2Ah ; '*'
jg short loc_C3C3A
cmp rcx, 9
jz short loc_C3C52
cmp rcx, 20h ; ' '
jz short loc_C3C52
jmp short loc_C3C9C
loc_C3C3A:
cmp rcx, 2Bh ; '+'
jz short loc_C3C52
cmp rcx, 2Dh ; '-'
jnz short loc_C3C9C
xor ecx, ecx
cmp [rbp+var_34], 0
setz cl
mov [rbp+var_34], ecx
loc_C3C52:
mov eax, eax
add r15, rax
mov rdi, r14
mov rsi, rbx
mov rdx, r15
mov rcx, r13
call r12
test eax, eax
jg short loc_C3C22
loc_C3C6A:
mov rcx, [rbp+var_40]
test rcx, rcx
jz short loc_C3C76
mov [rcx], r15
loc_C3C76:
test eax, eax
mov eax, 54h ; 'T'
mov ecx, 21h ; '!'
cmovz ecx, eax
mov rax, [rbp+var_50]
mov [rax], ecx
loc_C3C8B:
xor eax, eax
loc_C3C8D:
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_C3C9C:
movsxd rcx, [rbp+var_44]
mov rax, 0FFFFFFFFFFFFFFFFh
xor edx, edx
mov [rbp+var_60], rcx
div rcx
mov rbx, rdx
mov [rbp+var_58], rax
lea rsi, [rbp+var_30]
mov rdi, r14
mov rdx, r15
mov rcx, r13
call r12
test eax, eax
jle loc_C3D76
mov [rbp+var_70], r12
mov ecx, ebx
mov [rbp+var_68], rcx
xor ecx, ecx
mov rbx, r15
xor edi, edi
loc_C3CE0:
mov rsi, rbx
mov ebx, eax
add rbx, rsi
mov rsi, [rbp+var_30]
lea rax, [rsi-30h]
cmp rax, 9
ja short loc_C3CFC
mov [rbp+var_30], rax
jmp short loc_C3D21
loc_C3CFC:
lea rax, [rsi-41h]
cmp rax, 19h
ja short loc_C3D0C
add rsi, 0FFFFFFFFFFFFFFC9h
jmp short loc_C3D1A
loc_C3D0C:
lea rax, [rsi-61h]
cmp rax, 19h
ja short loc_C3D87
add rsi, 0FFFFFFFFFFFFFFA9h
loc_C3D1A:
mov [rbp+var_30], rsi
mov rax, rsi
loc_C3D21:
cmp eax, [rbp+var_44]
jge short loc_C3D87
mov esi, 1
cmp rcx, [rbp+var_58]
jbe short loc_C3D36
mov r12, rcx
jmp short loc_C3D4F
loc_C3D36:
jnz short loc_C3D42
mov r12, [rbp+var_58]
cmp rax, [rbp+var_68]
ja short loc_C3D4F
loc_C3D42:
imul rcx, [rbp+var_60]
add rax, rcx
mov esi, edi
mov r12, rax
loc_C3D4F:
mov [rbp+var_78], rsi
mov rdi, r14
lea rsi, [rbp+var_30]
mov rdx, rbx
mov rcx, r13
call [rbp+var_70]
mov rsi, [rbp+var_78]
mov rcx, r12
mov edi, esi
test eax, eax
jg loc_C3CE0
jmp short loc_C3D7E
loc_C3D76:
xor r12d, r12d
mov rbx, r15
xor esi, esi
loc_C3D7E:
test eax, eax
jz short loc_C3DC1
mov edi, esi
mov rcx, r12
loc_C3D87:
mov rax, [rbp+var_40]
test rax, rax
jz short loc_C3D93
mov [rax], rbx
loc_C3D93:
cmp rbx, r15
jz short loc_C3DB2
test edi, edi
jz short loc_C3DDC
mov rax, [rbp+var_50]
mov dword ptr [rax], 22h ; '"'
mov rax, 0FFFFFFFFFFFFFFFFh
jmp loc_C3C8D
loc_C3DB2:
mov rax, [rbp+var_50]
mov dword ptr [rax], 21h ; '!'
jmp loc_C3C8B
loc_C3DC1:
mov rax, [rbp+var_40]
test rax, rax
jz short loc_C3DCD
mov [rax], rbx
loc_C3DCD:
mov rax, [rbp+var_50]
mov dword ptr [rax], 54h ; 'T'
jmp loc_C3C8B
loc_C3DDC:
mov rax, rcx
neg rax
cmp [rbp+var_34], 0
cmovz rax, rcx
jmp loc_C3C8D
| long long my_strntoull_mb2_or_mb4(long long a1, long long a2, long long a3, int a4, _QWORD *a5, int *a6)
{
long long v6; // r15
long long ( *v8)(long long, _QWORD *, long long, long long); // r12
long long v9; // r13
int v10; // eax
int v11; // ecx
long long result; // rax
int v13; // eax
unsigned long long v14; // rcx
long long v15; // rbx
int v16; // edi
unsigned long long v17; // rax
long long v18; // rsi
int v19; // esi
unsigned long long v20; // r12
long long ( *v21)(long long, _QWORD *, long long, long long); // [rsp+10h] [rbp-70h]
unsigned long long v22; // [rsp+28h] [rbp-58h]
BOOL v26; // [rsp+4Ch] [rbp-34h]
_QWORD v27[6]; // [rsp+50h] [rbp-30h] BYREF
v6 = a2;
v8 = *(long long ( **)(long long, _QWORD *, long long, long long))(*(_QWORD *)(a1 + 184) + 40LL);
v9 = a2 + a3;
*a6 = 0;
v10 = v8(a1, v27, a2, a2 + a3);
if ( v10 <= 0 )
{
LABEL_11:
if ( a5 )
*a5 = v6;
v11 = 33;
if ( !v10 )
v11 = 84;
*a6 = v11;
return 0LL;
}
v26 = 0;
while ( v27[0] > 42LL )
{
if ( v27[0] != 43LL )
{
if ( v27[0] != 45LL )
goto LABEL_17;
v26 = !v26;
}
LABEL_10:
v6 += (unsigned int)v10;
v10 = v8(a1, v27, v6, v9);
if ( v10 <= 0 )
goto LABEL_11;
}
if ( v27[0] == 9LL || v27[0] == 32LL )
goto LABEL_10;
LABEL_17:
v22 = 0xFFFFFFFFFFFFFFFFLL / a4;
v13 = v8(a1, v27, v6, v9);
if ( v13 <= 0 )
{
v20 = 0LL;
v15 = v6;
v19 = 0;
LABEL_35:
if ( v13 )
{
v16 = v19;
v14 = v20;
goto LABEL_37;
}
if ( a5 )
*a5 = v15;
*a6 = 84;
return 0LL;
}
v21 = v8;
v14 = 0LL;
v15 = v6;
v16 = 0;
while ( 1 )
{
v15 += (unsigned int)v13;
v17 = v27[0] - 48LL;
if ( (unsigned long long)(v27[0] - 48LL) > 9 )
{
if ( (unsigned long long)(v27[0] - 65LL) > 0x19 )
{
if ( (unsigned long long)(v27[0] - 97LL) > 0x19 )
break;
v18 = v27[0] - 87LL;
}
else
{
v18 = v27[0] - 55LL;
}
v27[0] = v18;
v17 = v18;
}
else
{
v27[0] -= 48LL;
}
if ( (int)v17 >= a4 )
break;
v19 = 1;
if ( v14 <= v22 )
{
if ( v14 != v22 || (v20 = 0xFFFFFFFFFFFFFFFFLL / a4, v17 <= (unsigned int)(0xFFFFFFFFFFFFFFFFLL % a4)) )
{
v19 = v16;
v20 = a4 * v14 + v17;
}
}
else
{
v20 = v14;
}
v13 = v21(a1, v27, v15, v9);
v14 = v20;
v16 = v19;
if ( v13 <= 0 )
goto LABEL_35;
}
LABEL_37:
if ( a5 )
*a5 = v15;
if ( v15 == v6 )
{
*a6 = 33;
return 0LL;
}
if ( v16 )
{
*a6 = 34;
return -1LL;
}
else
{
result = -(long long)v14;
if ( !v26 )
return v14;
}
return result;
}
| my_strntoull_mb2_or_mb4:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x40],R8
MOV dword ptr [RBP + -0x44],ECX
MOV R13,RDX
MOV R15,RSI
MOV R14,RDI
MOV RAX,qword ptr [RDI + 0xb8]
MOV R12,qword ptr [RAX + 0x28]
ADD R13,RSI
MOV qword ptr [RBP + -0x50],R9
MOV dword ptr [R9],0x0
LEA RSI,[RBP + -0x30]
MOV RDX,R15
MOV RCX,R13
CALL R12
TEST EAX,EAX
JLE 0x001c3c6a
MOV dword ptr [RBP + -0x34],0x0
LEA RBX,[RBP + -0x30]
LAB_001c3c22:
MOV RCX,qword ptr [RBP + -0x30]
CMP RCX,0x2a
JG 0x001c3c3a
CMP RCX,0x9
JZ 0x001c3c52
CMP RCX,0x20
JZ 0x001c3c52
JMP 0x001c3c9c
LAB_001c3c3a:
CMP RCX,0x2b
JZ 0x001c3c52
CMP RCX,0x2d
JNZ 0x001c3c9c
XOR ECX,ECX
CMP dword ptr [RBP + -0x34],0x0
SETZ CL
MOV dword ptr [RBP + -0x34],ECX
LAB_001c3c52:
MOV EAX,EAX
ADD R15,RAX
MOV RDI,R14
MOV RSI,RBX
MOV RDX,R15
MOV RCX,R13
CALL R12
TEST EAX,EAX
JG 0x001c3c22
LAB_001c3c6a:
MOV RCX,qword ptr [RBP + -0x40]
TEST RCX,RCX
JZ 0x001c3c76
MOV qword ptr [RCX],R15
LAB_001c3c76:
TEST EAX,EAX
MOV EAX,0x54
MOV ECX,0x21
CMOVZ ECX,EAX
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX],ECX
LAB_001c3c8b:
XOR EAX,EAX
LAB_001c3c8d:
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001c3c9c:
MOVSXD RCX,dword ptr [RBP + -0x44]
MOV RAX,-0x1
XOR EDX,EDX
MOV qword ptr [RBP + -0x60],RCX
DIV RCX
MOV RBX,RDX
MOV qword ptr [RBP + -0x58],RAX
LEA RSI,[RBP + -0x30]
MOV RDI,R14
MOV RDX,R15
MOV RCX,R13
CALL R12
TEST EAX,EAX
JLE 0x001c3d76
MOV qword ptr [RBP + -0x70],R12
MOV ECX,EBX
MOV qword ptr [RBP + -0x68],RCX
XOR ECX,ECX
MOV RBX,R15
XOR EDI,EDI
LAB_001c3ce0:
MOV RSI,RBX
MOV EBX,EAX
ADD RBX,RSI
MOV RSI,qword ptr [RBP + -0x30]
LEA RAX,[RSI + -0x30]
CMP RAX,0x9
JA 0x001c3cfc
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001c3d21
LAB_001c3cfc:
LEA RAX,[RSI + -0x41]
CMP RAX,0x19
JA 0x001c3d0c
ADD RSI,-0x37
JMP 0x001c3d1a
LAB_001c3d0c:
LEA RAX,[RSI + -0x61]
CMP RAX,0x19
JA 0x001c3d87
ADD RSI,-0x57
LAB_001c3d1a:
MOV qword ptr [RBP + -0x30],RSI
MOV RAX,RSI
LAB_001c3d21:
CMP EAX,dword ptr [RBP + -0x44]
JGE 0x001c3d87
MOV ESI,0x1
CMP RCX,qword ptr [RBP + -0x58]
JBE 0x001c3d36
MOV R12,RCX
JMP 0x001c3d4f
LAB_001c3d36:
JNZ 0x001c3d42
MOV R12,qword ptr [RBP + -0x58]
CMP RAX,qword ptr [RBP + -0x68]
JA 0x001c3d4f
LAB_001c3d42:
IMUL RCX,qword ptr [RBP + -0x60]
ADD RAX,RCX
MOV ESI,EDI
MOV R12,RAX
LAB_001c3d4f:
MOV qword ptr [RBP + -0x78],RSI
MOV RDI,R14
LEA RSI,[RBP + -0x30]
MOV RDX,RBX
MOV RCX,R13
CALL qword ptr [RBP + -0x70]
MOV RSI,qword ptr [RBP + -0x78]
MOV RCX,R12
MOV EDI,ESI
TEST EAX,EAX
JG 0x001c3ce0
JMP 0x001c3d7e
LAB_001c3d76:
XOR R12D,R12D
MOV RBX,R15
XOR ESI,ESI
LAB_001c3d7e:
TEST EAX,EAX
JZ 0x001c3dc1
MOV EDI,ESI
MOV RCX,R12
LAB_001c3d87:
MOV RAX,qword ptr [RBP + -0x40]
TEST RAX,RAX
JZ 0x001c3d93
MOV qword ptr [RAX],RBX
LAB_001c3d93:
CMP RBX,R15
JZ 0x001c3db2
TEST EDI,EDI
JZ 0x001c3ddc
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX],0x22
MOV RAX,-0x1
JMP 0x001c3c8d
LAB_001c3db2:
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX],0x21
JMP 0x001c3c8b
LAB_001c3dc1:
MOV RAX,qword ptr [RBP + -0x40]
TEST RAX,RAX
JZ 0x001c3dcd
MOV qword ptr [RAX],RBX
LAB_001c3dcd:
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX],0x54
JMP 0x001c3c8b
LAB_001c3ddc:
MOV RAX,RCX
NEG RAX
CMP dword ptr [RBP + -0x34],0x0
CMOVZ RAX,RCX
JMP 0x001c3c8d
|
ulong my_strntoull_mb2_or_mb4
(long param_1,long param_2,long param_3,int param_4,long *param_5,
int4 *param_6)
{
code *pcVar1;
int1 auVar2 [16];
int1 auVar3 [16];
bool bVar4;
bool bVar5;
ulong uVar6;
bool bVar7;
uint uVar8;
ulong uVar9;
int4 uVar10;
ulong uVar11;
long lVar12;
ulong uVar13;
ulong local_38;
pcVar1 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
param_3 = param_3 + param_2;
*param_6 = 0;
uVar8 = (*pcVar1)(param_1,&local_38,param_2,param_3);
if (0 < (int)uVar8) {
bVar4 = false;
do {
if ((long)local_38 < 0x2b) {
if ((local_38 != 9) && (local_38 != 0x20)) {
LAB_001c3c9c:
auVar2._8_8_ = 0;
auVar2._0_8_ = (long)param_4;
auVar3 = ZEXT816(0) << 0x40 | ZEXT816(0xffffffffffffffff);
uVar9 = SUB168(auVar3 / auVar2,0);
uVar8 = (*pcVar1)(param_1,&local_38,param_2,param_3);
lVar12 = param_2;
if ((int)uVar8 < 1) {
uVar11 = 0;
bVar5 = false;
goto LAB_001c3d7e;
}
uVar11 = 0;
bVar5 = false;
goto LAB_001c3ce0;
}
}
else if (local_38 != 0x2b) {
if (local_38 != 0x2d) goto LAB_001c3c9c;
bVar4 = !bVar4;
}
param_2 = param_2 + (ulong)uVar8;
uVar8 = (*pcVar1)(param_1,&local_38,param_2,param_3);
} while (0 < (int)uVar8);
}
if (param_5 != (long *)0x0) {
*param_5 = param_2;
}
uVar10 = 0x21;
if (uVar8 == 0) {
uVar10 = 0x54;
}
*param_6 = uVar10;
return 0;
while( true ) {
if (param_4 <= (int)uVar13) goto LAB_001c3d87;
uVar6 = uVar11;
bVar7 = true;
if ((uVar11 <= uVar9) &&
((uVar11 != uVar9 || (uVar6 = uVar9, uVar13 <= (SUB168(auVar3 % auVar2,0) & 0xffffffff))))) {
uVar6 = uVar13 + uVar11 * (long)param_4;
bVar7 = bVar5;
}
bVar5 = bVar7;
uVar11 = uVar6;
local_38 = uVar13;
uVar8 = (*pcVar1)(param_1,&local_38,lVar12,param_3);
if ((int)uVar8 < 1) break;
LAB_001c3ce0:
lVar12 = (ulong)uVar8 + lVar12;
uVar13 = local_38 - 0x30;
if (9 < uVar13) {
if (local_38 - 0x41 < 0x1a) {
uVar13 = local_38 - 0x37;
}
else {
if (0x19 < local_38 - 0x61) goto LAB_001c3d87;
uVar13 = local_38 - 0x57;
}
}
}
LAB_001c3d7e:
if (uVar8 == 0) {
if (param_5 != (long *)0x0) {
*param_5 = lVar12;
}
*param_6 = 0x54;
}
else {
LAB_001c3d87:
if (param_5 != (long *)0x0) {
*param_5 = lVar12;
}
if (lVar12 != param_2) {
if (bVar5) {
*param_6 = 0x22;
return 0xffffffffffffffff;
}
if (!bVar4) {
return uVar11;
}
return -uVar11;
}
*param_6 = 0x21;
}
return 0;
}
| |
41,596 | 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>::basic_json<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 0>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | zkingston[P]unknot/build_O1/_deps/json-src/include/nlohmann/json.hpp | basic_json(CompatibleType && val) noexcept(noexcept( // NOLINT(bugprone-forwarding-reference-overload,bugprone-exception-escape)
JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
std::forward<CompatibleType>(val))))
{
JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
set_parents();
assert_invariant();
} | O1 | 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>::basic_json<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 0>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, (%rdi)
movq %r14, %rdi
xorl %esi, %esi
callq 0x2bc86
movb $0x3, (%rbx)
movq %r15, %rdi
callq 0x2c930
movq %rax, (%r14)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2c524
movq %r14, %rdi
callq 0x101c0
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_:
push r15
push r14
push rbx
mov r15, rsi
mov rbx, rdi
lea r14, [rdi+8]
vxorps xmm0, xmm0, xmm0
vmovups xmmword ptr [rdi], xmm0
mov rdi, r14
xor esi, esi
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10json_value7destroyENS0_6detail7value_tE; 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>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t)
mov byte ptr [rbx], 3
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createIS9_JRKS9_EEEPT_DpOT0_; 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>::create<std::string,std::string const&>(std::string const&)
mov [r14], rax
pop rbx
pop r14
pop r15
retn
mov r14, rax
mov rdi, rbx
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 rdi, r14
call __Unwind_Resume
| _QWORD * ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_(
long long _RDI,
long long a2,
__m128 _XMM0)
{
_QWORD *result; // rax
__asm
{
vxorps xmm0, xmm0, xmm0
vmovups xmmword ptr [rdi], xmm0
}
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(
(void **)(_RDI + 8),
0,
_XMM0);
*(_BYTE *)_RDI = 3;
result = 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>::create<std::string,std::string const&>(a2);
*(_QWORD *)(_RDI + 8) = result;
return result;
}
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_:
PUSH R15
PUSH R14
PUSH RBX
MOV R15,RSI
MOV RBX,RDI
LEA R14,[RDI + 0x8]
VXORPS XMM0,XMM0,XMM0
VMOVUPS xmmword ptr [RDI],XMM0
LAB_00135df3:
MOV RDI,R14
XOR ESI,ESI
CALL 0x0012bc86
MOV byte ptr [RBX],0x3
MOV RDI,R15
CALL 0x0012c930
LAB_00135e08:
MOV qword ptr [R14],RAX
POP RBX
POP R14
POP R15
RET
|
void _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
(int8 *param_1,string *param_2)
{
string *psVar1;
*param_1 = 0;
param_1[1] = 0;
/* try { // try from 00135df3 to 00135e07 has its CatchHandler @ 00135e11 */
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 *)(param_1 + 1),0);
*(int1 *)param_1 = 3;
psVar1 = 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>
::create<std::__cxx11::string,std::__cxx11::string_const&>(param_2);
*(string **)(param_1 + 1) = psVar1;
return;
}
| |
41,597 | Rpl_filter::add_string_list(I_List<i_string>*, char const*) | eloqsql/sql/rpl_filter.cc | int
Rpl_filter::add_string_list(I_List<i_string> *list, const char* spec)
{
char *str;
i_string *node;
if (! (str= my_strdup(key_memory_rpl_filter, spec, MYF(MY_WME))))
return true;
if (! (node= new i_string(str)))
{
my_free(str);
return true;
}
list->push_back(node);
return false;
} | O3 | cpp | Rpl_filter::add_string_list(I_List<i_string>*, char const*):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rax
movq %rsi, %rbx
movl $0x10, %edx
xorl %edi, %edi
movq %rax, %rsi
callq 0x847c8
movl $0x1, %r14d
testq %rax, %rax
je 0x552be
movq %rax, %r15
movl $0x20, %edi
callq 0x56d5e
testq %rax, %rax
je 0x552b6
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
leaq 0x3073c0(%rip), %rcx # 0x35c648
movq %rcx, (%rax)
movq %r15, 0x18(%rax)
leaq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rdx
movq %rax, (%rdx)
movq %rax, %rdx
addq $0x10, %rdx
movq %rcx, 0x10(%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rdx, 0x10(%rbx)
xorl %r14d, %r14d
jmp 0x552be
movq %r15, %rdi
callq 0x84732
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| _ZN10Rpl_filter15add_string_listEP6I_ListI8i_stringEPKc:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rax, rdx
mov rbx, rsi
mov edx, 10h
xor edi, edi
mov rsi, rax; unsigned __int64
call my_strdup
mov r14d, 1
test rax, rax
jz short loc_552BE
mov r15, rax
mov edi, offset qword_20; this
call _ZN5ilinknwEm; ilink::operator new(ulong)
test rax, rax
jz short loc_552B6
xorps xmm0, xmm0
movups xmmword ptr [rax+8], xmm0
lea rcx, off_35C648
mov [rax], rcx
mov [rax+18h], r15
lea rcx, [rbx+8]
mov rdx, [rbx+10h]
mov [rdx], rax
mov rdx, rax
add rdx, 10h
mov [rax+10h], rcx
mov rcx, [rbx+10h]
mov [rax+8], rcx
mov [rbx+10h], rdx
xor r14d, r14d
jmp short loc_552BE
loc_552B6:
mov rdi, r15
call my_free
loc_552BE:
mov eax, r14d
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long Rpl_filter::add_string_list(long long a1, long long a2, unsigned long long a3)
{
long long v5; // rax
unsigned int v6; // r14d
long long v7; // r15
long long v8; // rax
v5 = my_strdup(0LL, a3, 16LL);
v6 = 1;
if ( v5 )
{
v7 = v5;
v8 = ilink::operator new((ilink *)&qword_20, a3);
if ( v8 )
{
*(_OWORD *)(v8 + 8) = 0LL;
*(_QWORD *)v8 = off_35C648;
*(_QWORD *)(v8 + 24) = v7;
**(_QWORD **)(a2 + 16) = v8;
*(_QWORD *)(v8 + 16) = a2 + 8;
*(_QWORD *)(v8 + 8) = *(_QWORD *)(a2 + 16);
*(_QWORD *)(a2 + 16) = v8 + 16;
return 0;
}
else
{
my_free(v7);
}
}
return v6;
}
| add_string_list:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RAX,RDX
MOV RBX,RSI
MOV EDX,0x10
XOR EDI,EDI
MOV RSI,RAX
CALL 0x001847c8
MOV R14D,0x1
TEST RAX,RAX
JZ 0x001552be
MOV R15,RAX
MOV EDI,0x20
CALL 0x00156d5e
TEST RAX,RAX
JZ 0x001552b6
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX + 0x8],XMM0
LEA RCX,[0x45c648]
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x18],R15
LEA RCX,[RBX + 0x8]
MOV RDX,qword ptr [RBX + 0x10]
MOV qword ptr [RDX],RAX
MOV RDX,RAX
ADD RDX,0x10
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RBX + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [RBX + 0x10],RDX
XOR R14D,R14D
JMP 0x001552be
LAB_001552b6:
MOV RDI,R15
CALL 0x00184732
LAB_001552be:
MOV EAX,R14D
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* Rpl_filter::add_string_list(I_List<i_string>*, char const*) */
int8 __thiscall Rpl_filter::add_string_list(Rpl_filter *this,I_List *param_1,char *param_2)
{
long lVar1;
int8 *puVar2;
int8 uVar3;
lVar1 = my_strdup(0,param_2,0x10);
uVar3 = 1;
if (lVar1 != 0) {
puVar2 = (int8 *)ilink::operator_new((ilink *)0x20,(ulong)param_2);
if (puVar2 == (int8 *)0x0) {
my_free(lVar1);
}
else {
puVar2[1] = 0;
puVar2[2] = 0;
*puVar2 = &PTR__ilink_0045c648;
puVar2[3] = lVar1;
**(int8 **)(param_1 + 0x10) = puVar2;
puVar2[2] = param_1 + 8;
puVar2[1] = *(int8 *)(param_1 + 0x10);
*(int8 **)(param_1 + 0x10) = puVar2 + 2;
uVar3 = 0;
}
}
return uVar3;
}
| |
41,598 | coro::detail::when_all_task<void> coro::detail::make_when_all_task<coro::task<void>, void>(coro::task<void>) (.resume) | AlayaLite/build_O3/_deps/libcoro-src/include/coro/when_all.hpp | static auto make_when_all_task(awaitable a) -> when_all_task<return_type>
{
if constexpr (std::is_void_v<return_type>)
{
co_await static_cast<awaitable&&>(a);
co_return;
}
else
{
co_yield co_await static_cast<awaitable&&>(a);
}
} | O3 | cpp | coro::detail::when_all_task<void> coro::detail::make_when_all_task<coro::task<void>, void>(coro::task<void>) (.resume):
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, 0x30(%rdi)
je 0x28eb5
movq 0x20(%rbx), %rdi
leaq 0x10(%rbx), %r14
addq $0x10, %rdi
callq 0x295c8
movq $0x0, (%rbx)
movb $0x2, 0x30(%rbx)
movq 0x10(%rbx), %rax
lock
decq (%rax)
jne 0x28ead
movq 0x8(%rax), %rdi
callq *(%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x28(%rbx), %rdi
movq %rdi, 0x20(%rbx)
cmpq $0x0, (%rdi)
je 0x28e85
movb $0x1, 0x30(%rbx)
movq %rbx, 0x10(%rdi)
movq 0x20(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *(%rdi)
movq %rax, %rdi
callq 0x18a8f
movq %rax, %rdi
callq 0x11070
movq %r14, %rdi
callq 0x29746
callq 0x11920
jmp 0x28e92
movq $0x0, (%rbx)
movb $0x2, 0x30(%rbx)
movq %rax, %rdi
callq 0x11760
| _ZN4coro6detailL18make_when_all_taskITkNS_8concepts9awaitableENS_4taskIvEEvEENS0_13when_all_taskIT0_EET__resume:
push r14
push rbx
push rax
mov rbx, rdi
cmp byte ptr [rdi+30h], 0
jz short loc_28EB5
mov rdi, [rbx+20h]
loc_28E85:
lea r14, [rbx+10h]
add rdi, 10h
call _ZN4coro6detail7promiseIvE6resultEv; coro::detail::promise<void>::result(void)
loc_28E92:
mov qword ptr [rbx], 0
mov byte ptr [rbx+30h], 2
mov rax, [rbx+10h]
lock dec qword ptr [rax]
jnz short loc_28EAD
mov rdi, [rax+8]
call qword ptr [rdi]
loc_28EAD:
add rsp, 8
pop rbx
pop r14
retn
loc_28EB5:
mov rdi, [rbx+28h]
mov [rbx+20h], rdi
cmp qword ptr [rdi], 0
jz short loc_28E85
mov byte ptr [rbx+30h], 1
mov [rdi+10h], rbx
mov rdi, [rbx+20h]
add rsp, 8
pop rbx
pop r14
jmp qword ptr [rdi]
mov rdi, rax
call __clang_call_terminate
mov rdi, rax; void *
call ___cxa_begin_catch
mov rdi, r14
call _ZN4coro6detail21when_all_task_promiseIvE19unhandled_exceptionEv; coro::detail::when_all_task_promise<void>::unhandled_exception(void)
call ___cxa_end_catch
jmp short loc_28E92
mov qword ptr [rbx], 0
mov byte ptr [rbx+30h], 2
mov rdi, rax
call __Unwind_Resume
| long long ZN4coro6detailL18make_when_all_taskITkNS_8concepts9awaitableENS_4taskIvEEvEENS0_13when_all_taskIT0_EET__resume(
long long a1)
{
_QWORD *v2; // rdi
long long result; // rax
if ( *(_BYTE *)(a1 + 48) )
{
v2 = *(_QWORD **)(a1 + 32);
}
else
{
v2 = *(_QWORD **)(a1 + 40);
*(_QWORD *)(a1 + 32) = v2;
if ( *v2 )
{
*(_BYTE *)(a1 + 48) = 1;
v2[2] = a1;
return (**(long long (***)(void))(a1 + 32))();
}
}
coro::detail::promise<void>::result(v2 + 2);
*(_QWORD *)a1 = 0LL;
*(_BYTE *)(a1 + 48) = 2;
result = *(_QWORD *)(a1 + 16);
if ( !_InterlockedDecrement64((volatile signed long long *)result) )
return (**(long long ( ***)(_QWORD))(result + 8))(*(_QWORD *)(result + 8));
return result;
}
| _ZN4coro6detailL18make_when_all_taskITkNS_8concepts9awaitableENS_4taskIvEEvEENS0_13when_all_taskIT0_EET_.resume:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
CMP byte ptr [RDI + 0x30],0x0
JZ 0x00128eb5
MOV RDI,qword ptr [RBX + 0x20]
LAB_00128e85:
LEA R14,[RBX + 0x10]
ADD RDI,0x10
LAB_00128e8d:
CALL 0x001295c8
LAB_00128e92:
MOV qword ptr [RBX],0x0
MOV byte ptr [RBX + 0x30],0x2
MOV RAX,qword ptr [RBX + 0x10]
DEC.LOCK qword ptr [RAX]
JNZ 0x00128ead
MOV RDI,qword ptr [RAX + 0x8]
LAB_00128eab:
CALL qword ptr [RDI]
LAB_00128ead:
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_00128eb5:
MOV RDI,qword ptr [RBX + 0x28]
MOV qword ptr [RBX + 0x20],RDI
CMP qword ptr [RDI],0x0
JZ 0x00128e85
MOV byte ptr [RBX + 0x30],0x1
MOV qword ptr [RDI + 0x10],RBX
MOV RDI,qword ptr [RBX + 0x20]
ADD RSP,0x8
POP RBX
POP R14
JMP qword ptr [RDI]
|
void _ZN4coro6detailL18make_when_all_taskITkNS_8concepts9awaitableENS_4taskIvEEvEENS0_13when_all_taskIT0_EET__resume
(int8 *param_1)
{
long *plVar1;
if (*(char *)(param_1 + 6) == '\0') {
plVar1 = (long *)param_1[5];
param_1[4] = plVar1;
if (*plVar1 != 0) {
*(int1 *)(param_1 + 6) = 1;
plVar1[2] = (long)param_1;
/* WARNING: Could not recover jumptable at 0x00128ed6. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)param_1[4])();
return;
}
}
else {
plVar1 = (long *)param_1[4];
}
/* try { // try from 00128e8d to 00128e91 has its CatchHandler @ 00128ee0 */
coro::detail::promise<void>::result((promise<void> *)(plVar1 + 2));
*param_1 = 0;
*(int1 *)(param_1 + 6) = 2;
plVar1 = (long *)param_1[2];
LOCK();
*plVar1 = *plVar1 + -1;
UNLOCK();
if (*plVar1 == 0) {
/* try { // try from 00128eab to 00128eac has its CatchHandler @ 00128ed8 */
(**(code **)plVar1[1])();
}
return;
}
| |
41,599 | tbb::detail::r1::arena_slot::acquire_task_pool() | aimrt_mujoco_sim/_deps/tbb-src/src/tbb/arena_slot.h | void acquire_task_pool() {
if (!is_task_pool_published()) {
return; // we are not in arena - nothing to lock
}
bool sync_prepare_done = false;
for( atomic_backoff b;;b.pause() ) {
#if TBB_USE_ASSERT
// Local copy of the arena slot task pool pointer is necessary for the next
// assertion to work correctly to exclude asynchronous state transition effect.
d1::task** tp = task_pool.load(std::memory_order_relaxed);
__TBB_ASSERT( tp == LockedTaskPool || tp == task_pool_ptr, "slot ownership corrupt?" );
#endif
d1::task** expected = task_pool_ptr;
if( task_pool.load(std::memory_order_relaxed) != LockedTaskPool &&
task_pool.compare_exchange_strong(expected, LockedTaskPool ) ) {
// We acquired our own slot
break;
} else if( !sync_prepare_done ) {
// Start waiting
sync_prepare_done = true;
}
// Someone else acquired a lock, so pause and do exponential backoff.
}
__TBB_ASSERT( task_pool.load(std::memory_order_relaxed) == LockedTaskPool, "not really acquired task pool" );
} | O0 | c | tbb::detail::r1::arena_slot::acquire_task_pool():
subq $0x38, %rsp
movq %fs:0x28, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x38c350
testb $0x1, %al
jne 0x3994cc
jmp 0x399546
movb $0x0, 0x17(%rsp)
leaq 0x2c(%rsp), %rdi
callq 0x22b7e0
movq 0x8(%rsp), %rdi
movq 0xa0(%rdi), %rax
movq %rax, 0x20(%rsp)
addq $0x8, %rdi
xorl %esi, %esi
callq 0x38deb0
movq $-0x1, %rcx
cmpq %rcx, %rax
je 0x39952a
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
leaq 0x20(%rsp), %rsi
movq $-0x1, %rdx
movl $0x5, %ecx
callq 0x399870
testb $0x1, %al
jne 0x399528
jmp 0x39952a
jmp 0x399546
testb $0x1, 0x17(%rsp)
jne 0x399536
movb $0x1, 0x17(%rsp)
jmp 0x399538
jmp 0x39953a
leaq 0x2c(%rsp), %rdi
callq 0x22b820
jmp 0x3994db
movq %fs:0x28, %rax
movq 0x30(%rsp), %rcx
cmpq %rcx, %rax
jne 0x39955e
addq $0x38, %rsp
retq
callq 0x190f00
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZN3tbb6detail2r110arena_slot17acquire_task_poolEv:
sub rsp, 38h
mov rax, fs:28h
mov [rsp+38h+var_8], rax
mov [rsp+38h+var_20], rdi
mov rdi, [rsp+38h+var_20]; this
mov [rsp+38h+var_30], rdi
call _ZNK3tbb6detail2r110arena_slot22is_task_pool_publishedEv; tbb::detail::r1::arena_slot::is_task_pool_published(void)
test al, 1
jnz short loc_3994CC
jmp short loc_399546
loc_3994CC:
mov [rsp+38h+var_21], 0
lea rdi, [rsp+38h+var_C]; this
call _ZN3tbb6detail2d014atomic_backoffC2Ev; tbb::detail::d0::atomic_backoff::atomic_backoff(void)
loc_3994DB:
mov rdi, [rsp+38h+var_30]
mov rax, [rdi+0A0h]
mov [rsp+38h+var_18], rax
add rdi, 8
xor esi, esi
call _ZNKSt6atomicIPPN3tbb6detail2d14taskEE4loadESt12memory_order; std::atomic<tbb::detail::d1::task **>::load(std::memory_order)
mov rcx, 0FFFFFFFFFFFFFFFFh
cmp rax, rcx
jz short loc_39952A
mov rdi, [rsp+38h+var_30]
add rdi, 8
lea rsi, [rsp+38h+var_18]
mov rdx, 0FFFFFFFFFFFFFFFFh
mov ecx, 5
call _ZNSt6atomicIPPN3tbb6detail2d14taskEE23compare_exchange_strongERS5_S5_St12memory_order; std::atomic<tbb::detail::d1::task **>::compare_exchange_strong(tbb::detail::d1::task **&,tbb::detail::d1::task **,std::memory_order)
test al, 1
jnz short loc_399528
jmp short loc_39952A
loc_399528:
jmp short loc_399546
loc_39952A:
test [rsp+38h+var_21], 1
jnz short loc_399536
mov [rsp+38h+var_21], 1
loc_399536:
jmp short $+2
loc_399538:
jmp short $+2
loc_39953A:
lea rdi, [rsp+38h+var_C]; this
call _ZN3tbb6detail2d014atomic_backoff5pauseEv; tbb::detail::d0::atomic_backoff::pause(void)
jmp short loc_3994DB
loc_399546:
mov rax, fs:28h
mov rcx, [rsp+38h+var_8]
cmp rax, rcx
jnz short loc_39955E
add rsp, 38h
retn
loc_39955E:
call ___stack_chk_fail
| unsigned long long tbb::detail::r1::arena_slot::acquire_task_pool(tbb::detail::r1::arena_slot *this)
{
char v2; // [rsp+17h] [rbp-21h]
long long v3; // [rsp+20h] [rbp-18h] BYREF
_BYTE v4[4]; // [rsp+2Ch] [rbp-Ch] BYREF
unsigned long long v5; // [rsp+30h] [rbp-8h]
v5 = __readfsqword(0x28u);
if ( tbb::detail::r1::arena_slot::is_task_pool_published(this) )
{
v2 = 0;
tbb::detail::d0::atomic_backoff::atomic_backoff((tbb::detail::d0::atomic_backoff *)v4);
while ( 1 )
{
v3 = *((_QWORD *)this + 20);
if ( std::atomic<tbb::detail::d1::task **>::load((long long)this + 8, 0) != -1
&& (std::atomic<tbb::detail::d1::task **>::compare_exchange_strong((char *)this + 8, &v3, -1LL, 5LL) & 1) != 0 )
{
break;
}
if ( (v2 & 1) == 0 )
v2 = 1;
tbb::detail::d0::atomic_backoff::pause((tbb::detail::d0::atomic_backoff *)v4);
}
}
return __readfsqword(0x28u);
}
| _M_find_node_tr<std::basic_string_view<char,std::char_traits<char>>>:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RDI
MOV qword ptr [RSP + 0x20],RSI
MOV qword ptr [RSP + 0x18],RDX
MOV qword ptr [RSP + 0x10],RCX
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x10]
CALL 0x00399570
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
JZ 0x003994ed
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0x30],RAX
JMP 0x003994f6
LAB_003994ed:
MOV qword ptr [RSP + 0x30],0x0
LAB_003994f6:
MOV RAX,qword ptr [RSP + 0x30]
ADD RSP,0x38
RET
|
/* std::__detail::_Hash_node<std::pair<std::__cxx11::string const, std::vector<std::__cxx11::string,
std::allocator<std::__cxx11::string > > >, true>* std::_Hashtable<std::__cxx11::string,
std::pair<std::__cxx11::string const, std::vector<std::__cxx11::string,
std::allocator<std::__cxx11::string > > >, std::allocator<std::pair<std::__cxx11::string const,
std::vector<std::__cxx11::string, std::allocator<std::__cxx11::string > > > >,
std::__detail::_Select1st, std::equal_to<void>, aimrt::common::util::StringHash,
std::__detail::_Mod_range_hashing, std::__detail::_Default_ranged_hash,
std::__detail::_Prime_rehash_policy, std::__detail::_Hashtable_traits<true, false, true>
>::_M_find_node_tr<std::basic_string_view<char, std::char_traits<char> > >(unsigned long,
std::basic_string_view<char, std::char_traits<char> > const&, unsigned long) const */
_Hash_node * __thiscall
std::
_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>,std::allocator<std::pair<std::__cxx11::string_const,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>>,std::__detail::_Select1st,std::equal_to<void>,aimrt::common::util::StringHash,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
::_M_find_node_tr<std::basic_string_view<char,std::char_traits<char>>>
(_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>,std::allocator<std::pair<std::__cxx11::string_const,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>>,std::__detail::_Select1st,std::equal_to<void>,aimrt::common::util::StringHash,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
*this,ulong param_1,basic_string_view *param_2,ulong param_3)
{
_Hash_node_base *p_Var1;
int8 local_8;
p_Var1 = _M_find_before_node_tr<std::basic_string_view<char,std::char_traits<char>>>
(this,param_1,param_2,param_3);
if (p_Var1 == (_Hash_node_base *)0x0) {
local_8 = (_Hash_node *)0x0;
}
else {
local_8 = *(_Hash_node **)p_Var1;
}
return local_8;
}
|
Subsets and Splits
C++ Functions With Standard Library Dependencies
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ Standard Library Function Analysis
Filters C++ code examples that use standard library containers and types, providing useful insights into common programming patterns and data structures in the dataset.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.