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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
24,800 | gguf_kv::gguf_kv<unsigned char>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<unsigned char, std::allocator<unsigned char>> const&) | monkey531[P]llama/ggml/src/gguf.cpp | gguf_kv(const std::string & key, const std::vector<T> & value)
: key(key), is_array(true), type(type_to_gguf_type<T>::value) {
GGML_ASSERT(!key.empty());
data.resize(value.size()*sizeof(T));
for (size_t i = 0; i < value.size(); ++i) {
const T tmp = value[i];
memcpy(data.data() + i*sizeof(T), &tmp, sizeof(T));
}
} | O0 | cpp | gguf_kv::gguf_kv<unsigned char>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<unsigned char, std::allocator<unsigned char>> const&):
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0x58(%rsp), %rsi
callq 0x41850
movq 0x20(%rsp), %rdi
movb $0x1, 0x20(%rdi)
movl $0x0, 0x24(%rdi)
addq $0x28, %rdi
movq %rdi, 0x18(%rsp)
callq 0x40520
movq 0x20(%rsp), %rdi
addq $0x40, %rdi
movq %rdi, 0x28(%rsp)
callq 0x46e00
movq 0x58(%rsp), %rdi
callq 0x466c0
testb $0x1, %al
jne 0x9d2d8
jmp 0x9d32c
leaq 0x26732(%rip), %rdi # 0xc3a11
leaq 0x1731b(%rip), %rdx # 0xb4601
leaq 0x26ed3(%rip), %rcx # 0xc41c0
xorl %eax, %eax
movl $0x8c, %esi
callq 0x46770
jmp 0x9d2fb
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x42c10
movq 0x18(%rsp), %rdi
callq 0x42a30
movq 0x20(%rsp), %rdi
callq 0x42530
jmp 0x9d3c5
movq 0x20(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rdi
callq 0x461d0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x40470
jmp 0x9d353
movq $0x0, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
callq 0x461d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x9d3c0
movq 0x50(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x40830
movq 0x20(%rsp), %rdi
movb (%rax), %al
movb %al, 0x37(%rsp)
addq $0x28, %rdi
callq 0x44010
movq 0x38(%rsp), %rcx
shlq $0x0, %rcx
movb 0x37(%rsp), %dl
movb %dl, (%rax,%rcx)
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x9d35c
addq $0x68, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x46d10
nop
| _ZN7gguf_kvC2IhEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorIT_SaISA_EE:
sub rsp, 68h
mov [rsp+68h+var_8], rdi
mov [rsp+68h+var_10], rsi
mov [rsp+68h+var_18], rdx
mov rdi, [rsp+68h+var_8]
mov [rsp+68h+var_48], rdi
mov rsi, [rsp+68h+var_10]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1ERKS4_; std::string::basic_string(std::string const&)
mov rdi, [rsp+68h+var_48]
mov byte ptr [rdi+20h], 1
mov dword ptr [rdi+24h], 0
add rdi, 28h ; '('
mov [rsp+68h+var_50], rdi
call __ZNSt6vectorIaSaIaEEC2Ev; std::vector<signed char>::vector(void)
mov rdi, [rsp+68h+var_48]
add rdi, 40h ; '@'
mov [rsp+68h+var_40], rdi
call __ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2Ev; std::vector<std::string>::vector(void)
mov rdi, [rsp+68h+var_10]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
test al, 1
jnz short loc_9D2D8
jmp short loc_9D32C
loc_9D2D8:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeyEmpty; "!key.empty()"
xor eax, eax
mov esi, 8Ch
call _ggml_abort
jmp short $+2
loc_9D2FB:
mov rdi, [rsp+68h+var_40]
mov rcx, rax
mov eax, edx
mov [rsp+48h], rcx
mov [rsp+44h], eax
call __ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, [rsp+68h+var_50]
call __ZNSt6vectorIaSaIaEED2Ev; std::vector<signed char>::~vector()
mov rdi, [rsp+68h+var_48]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp loc_9D3C5
loc_9D32C:
mov rax, [rsp+68h+var_48]
add rax, 28h ; '('
mov [rsp+68h+var_58], rax
mov rdi, [rsp+68h+var_18]
call __ZNKSt6vectorIhSaIhEE4sizeEv; std::vector<uchar>::size(void)
mov rdi, [rsp+68h+var_58]
mov rsi, rax
call __ZNSt6vectorIaSaIaEE6resizeEm; std::vector<signed char>::resize(ulong)
jmp short $+2
loc_9D353:
mov [rsp+68h+var_30], 0
loc_9D35C:
mov rax, [rsp+68h+var_30]
mov [rsp+68h+var_60], rax
mov rdi, [rsp+68h+var_18]
call __ZNKSt6vectorIhSaIhEE4sizeEv; std::vector<uchar>::size(void)
mov rcx, rax
mov rax, [rsp+68h+var_60]
cmp rax, rcx
jnb short loc_9D3C0
mov rdi, [rsp+68h+var_18]
mov rsi, [rsp+68h+var_30]
call __ZNKSt6vectorIhSaIhEEixEm; std::vector<uchar>::operator[](ulong)
mov rdi, [rsp+68h+var_48]
mov al, [rax]
mov [rsp+68h+var_31], al
add rdi, 28h ; '('
call __ZNSt6vectorIaSaIaEE4dataEv; std::vector<signed char>::data(void)
mov rcx, [rsp+68h+var_30]
shl rcx, 0
mov dl, [rsp+68h+var_31]
mov [rax+rcx], dl
mov rax, [rsp+68h+var_30]
add rax, 1
mov [rsp+68h+var_30], rax
jmp short loc_9D35C
loc_9D3C0:
add rsp, 68h
retn
loc_9D3C5:
mov rdi, [rsp+48h]
call __Unwind_Resume
| unsigned long long gguf_kv::gguf_kv<unsigned char>(long long a1, long long a2, long long a3)
{
long long v3; // rax
unsigned long long v4; // rcx
unsigned long long result; // rax
char v6; // [rsp+37h] [rbp-31h]
unsigned long long i; // [rsp+38h] [rbp-30h]
std::string::basic_string(a1, a2);
*(_BYTE *)(a1 + 32) = 1;
*(_DWORD *)(a1 + 36) = 0;
std::vector<signed char>::vector();
std::vector<std::string>::vector();
if ( (std::string::empty(a2) & 1) != 0 )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/gguf.cpp",
140,
(long long)"GGML_ASSERT(%s) failed",
"!key.empty()");
v3 = std::vector<unsigned char>::size(a3);
std::vector<signed char>::resize(a1 + 40, v3);
for ( i = 0LL; ; ++i )
{
v4 = std::vector<unsigned char>::size(a3);
result = i;
if ( i >= v4 )
break;
v6 = *(_BYTE *)std::vector<unsigned char>::operator[](a3, i);
*(_BYTE *)(std::vector<signed char>::data(a1 + 40) + i) = v6;
}
return result;
}
| gguf_kv<unsigned_char>:
SUB RSP,0x68
MOV qword ptr [RSP + 0x60],RDI
MOV qword ptr [RSP + 0x58],RSI
MOV qword ptr [RSP + 0x50],RDX
MOV RDI,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x20],RDI
MOV RSI,qword ptr [RSP + 0x58]
CALL 0x00141850
MOV RDI,qword ptr [RSP + 0x20]
MOV byte ptr [RDI + 0x20],0x1
MOV dword ptr [RDI + 0x24],0x0
ADD RDI,0x28
MOV qword ptr [RSP + 0x18],RDI
CALL 0x00140520
MOV RDI,qword ptr [RSP + 0x20]
ADD RDI,0x40
MOV qword ptr [RSP + 0x28],RDI
CALL 0x00146e00
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x001466c0
TEST AL,0x1
JNZ 0x0019d2d8
JMP 0x0019d32c
LAB_0019d2d8:
LEA RDI,[0x1c3a11]
LEA RDX,[0x1b4601]
LEA RCX,[0x1c41c0]
XOR EAX,EAX
MOV ESI,0x8c
CALL 0x00146770
JMP 0x0019d2fb
LAB_0019d2fb:
MOV RDI,qword ptr [RSP + 0x28]
MOV RCX,RAX
MOV EAX,EDX
MOV qword ptr [RSP + 0x48],RCX
MOV dword ptr [RSP + 0x44],EAX
CALL 0x00142c10
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x00142a30
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x00142530
JMP 0x0019d3c5
LAB_0019d32c:
MOV RAX,qword ptr [RSP + 0x20]
ADD RAX,0x28
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0x50]
CALL 0x001461d0
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,RAX
CALL 0x00140470
LAB_0019d351:
JMP 0x0019d353
LAB_0019d353:
MOV qword ptr [RSP + 0x38],0x0
LAB_0019d35c:
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x50]
CALL 0x001461d0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
CMP RAX,RCX
JNC 0x0019d3c0
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x38]
CALL 0x00140830
MOV RDI,qword ptr [RSP + 0x20]
MOV AL,byte ptr [RAX]
MOV byte ptr [RSP + 0x37],AL
ADD RDI,0x28
CALL 0x00144010
MOV RCX,qword ptr [RSP + 0x38]
SHL RCX,0x0
MOV DL,byte ptr [RSP + 0x37]
MOV byte ptr [RAX + RCX*0x1],DL
MOV RAX,qword ptr [RSP + 0x38]
ADD RAX,0x1
MOV qword ptr [RSP + 0x38],RAX
JMP 0x0019d35c
LAB_0019d3c0:
ADD RSP,0x68
RET
LAB_0019d3c5:
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x00146d10
|
/* gguf_kv::gguf_kv<unsigned char>(std::__cxx11::string const&, std::vector<unsigned char,
std::allocator<unsigned char> > const&) */
void __thiscall gguf_kv::gguf_kv<unsigned_char>(gguf_kv *this,string *param_1,vector *param_2)
{
int1 uVar1;
ulong uVar2;
int8 uVar3;
int1 *puVar4;
long lVar5;
ulong local_30;
std::__cxx11::string::string((string *)this,param_1);
this[0x20] = (gguf_kv)0x1;
*(int4 *)(this + 0x24) = 0;
std::vector<signed_char,std::allocator<signed_char>>::vector
((vector<signed_char,std::allocator<signed_char>> *)(this + 0x28));
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)(this + 0x40));
uVar2 = std::__cxx11::string::empty();
if ((uVar2 & 1) == 0) {
uVar2 = std::vector<unsigned_char,std::allocator<unsigned_char>>::size
((vector<unsigned_char,std::allocator<unsigned_char>> *)param_2);
std::vector<signed_char,std::allocator<signed_char>>::resize
((vector<signed_char,std::allocator<signed_char>> *)(this + 0x28),uVar2);
local_30 = 0;
while( true ) {
uVar2 = std::vector<unsigned_char,std::allocator<unsigned_char>>::size
((vector<unsigned_char,std::allocator<unsigned_char>> *)param_2);
if (uVar2 <= local_30) break;
puVar4 = (int1 *)
std::vector<unsigned_char,std::allocator<unsigned_char>>::operator[]
((vector<unsigned_char,std::allocator<unsigned_char>> *)param_2,local_30);
uVar1 = *puVar4;
lVar5 = std::vector<signed_char,std::allocator<signed_char>>::data
((vector<signed_char,std::allocator<signed_char>> *)(this + 0x28));
*(int1 *)(lVar5 + local_30) = uVar1;
local_30 = local_30 + 1;
}
return;
}
/* try { // try from 0019d2d8 to 0019d350 has its CatchHandler @ 0019d2fb */
uVar3 = ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/gguf.cpp",
0x8c,"GGML_ASSERT(%s) failed","!key.empty()");
/* catch() { ... } // from try @ 0019d2d8 with catch @ 0019d2fb */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)(this + 0x40));
std::vector<signed_char,std::allocator<signed_char>>::~vector
((vector<signed_char,std::allocator<signed_char>> *)(this + 0x28));
std::__cxx11::string::~string((string *)this);
/* WARNING: Subroutine does not return */
_Unwind_Resume(uVar3);
}
| |
24,801 | gguf_kv::gguf_kv<unsigned char>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<unsigned char, std::allocator<unsigned char>> const&) | monkey531[P]llama/ggml/src/gguf.cpp | gguf_kv(const std::string & key, const std::vector<T> & value)
: key(key), is_array(true), type(type_to_gguf_type<T>::value) {
GGML_ASSERT(!key.empty());
data.resize(value.size()*sizeof(T));
for (size_t i = 0; i < value.size(); ++i) {
const T tmp = value[i];
memcpy(data.data() + i*sizeof(T), &tmp, sizeof(T));
}
} | O1 | cpp | gguf_kv::gguf_kv<unsigned char>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<unsigned char, std::allocator<unsigned char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %r15
leaq 0x10(%rdi), %rbx
movq %rbx, (%rdi)
movq (%rsi), %rsi
movq 0x8(%rbp), %rdx
addq %rsi, %rdx
callq 0x16630
movb $0x1, 0x20(%r15)
movl $0x2, 0x24(%r15)
leaq 0x28(%r15), %r14
leaq 0x40(%r15), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r15)
movups %xmm0, 0x38(%r15)
movups %xmm0, 0x48(%r15)
cmpq $0x0, 0x8(%rbp)
je 0x43211
movq 0x8(%r12), %rsi
subq (%r12), %rsi
movq %r14, %rdi
callq 0x16130
movq (%r12), %rax
cmpq %rax, 0x8(%r12)
je 0x43202
xorl %ecx, %ecx
movzwl (%rax,%rcx,2), %eax
movq (%r14), %rdx
movw %ax, (%rdx,%rcx,2)
incq %rcx
movq (%r12), %rax
movq 0x8(%r12), %rdx
subq %rax, %rdx
sarq %rdx
cmpq %rdx, %rcx
jb 0x431e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16afd(%rip), %rdi # 0x59d15
leaq 0x743a(%rip), %rdx # 0x4a659
leaq 0x1729e(%rip), %rcx # 0x5a4c4
movl $0x8c, %esi
xorl %eax, %eax
callq 0x17c70
movq %rax, %r12
movq %r13, %rdi
callq 0x16c50
movq (%r14), %rdi
testq %rdi, %rdi
je 0x43251
movq 0x38(%r15), %rsi
subq %rdi, %rsi
callq 0x17080
movq %r15, %rdi
movq %rbx, %rsi
callq 0x188e3
movq %r12, %rdi
callq 0x17e30
| _ZN7gguf_kvC2ItEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorIT_SaISA_EE:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r12, rdx
mov rbp, rsi
mov r15, rdi
lea rbx, [rdi+10h]
mov [rdi], rbx
mov rsi, [rsi]
mov rdx, [rbp+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 [r15+20h], 1
mov dword ptr [r15+24h], 2
lea r14, [r15+28h]
lea r13, [r15+40h]
xorps xmm0, xmm0
movups xmmword ptr [r15+28h], xmm0
movups xmmword ptr [r15+38h], xmm0
movups xmmword ptr [r15+48h], xmm0
cmp qword ptr [rbp+8], 0
jz short loc_43211
mov rsi, [r12+8]
sub rsi, [r12]
mov rdi, r14
call __ZNSt6vectorIaSaIaEE6resizeEm; std::vector<signed char>::resize(ulong)
mov rax, [r12]
cmp [r12+8], rax
jz short loc_43202
xor ecx, ecx
loc_431E0:
movzx eax, word ptr [rax+rcx*2]
mov rdx, [r14]
mov [rdx+rcx*2], ax
inc rcx
mov rax, [r12]
mov rdx, [r12+8]
sub rdx, rax
sar rdx, 1
cmp rcx, rdx
jb short loc_431E0
loc_43202:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_43211:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeyEmpty; "!key.empty()"
mov esi, 8Ch
xor eax, eax
call _ggml_abort
mov r12, rax
mov rdi, r13
call __ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, [r14]; void *
test rdi, rdi
jz short loc_43251
mov rsi, [r15+38h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_43251:
mov rdi, r15
mov rsi, rbx
call _ZN7gguf_kvC2ItEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorIT_SaISA_EE_cold_1; gguf_kv::gguf_kv<ushort>(std::string const&,std::vector<ushort> const&) [clone]
mov rdi, r12
call __Unwind_Resume
| long long gguf_kv::gguf_kv<unsigned short>(long long a1, _QWORD *a2, long long *a3)
{
int v4; // r8d
int v5; // r9d
long long result; // rax
unsigned long long v7; // rcx
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<char *>(a1, *a2, *a2 + a2[1]);
*(_BYTE *)(a1 + 32) = 1;
*(_DWORD *)(a1 + 36) = 2;
*(_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",
140,
(unsigned int)"GGML_ASSERT(%s) failed",
(unsigned int)"!key.empty()",
v4,
v5);
std::vector<signed char>::resize(a1 + 40, a3[1] - *a3);
result = *a3;
if ( a3[1] != *a3 )
{
v7 = 0LL;
do
{
*(_WORD *)(*(_QWORD *)(a1 + 40) + 2 * v7) = *(_WORD *)(result + 2 * v7);
++v7;
result = *a3;
}
while ( v7 < (a3[1] - *a3) >> 1 );
}
return result;
}
| gguf_kv<unsigned_short>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R12,RDX
MOV RBP,RSI
MOV R15,RDI
LEA RBX,[RDI + 0x10]
MOV qword ptr [RDI],RBX
MOV RSI,qword ptr [RSI]
MOV RDX,qword ptr [RBP + 0x8]
ADD RDX,RSI
CALL 0x00116630
MOV byte ptr [R15 + 0x20],0x1
MOV dword ptr [R15 + 0x24],0x2
LEA R14,[R15 + 0x28]
LEA R13,[R15 + 0x40]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R15 + 0x28],XMM0
MOVUPS xmmword ptr [R15 + 0x38],XMM0
MOVUPS xmmword ptr [R15 + 0x48],XMM0
CMP qword ptr [RBP + 0x8],0x0
JZ 0x00143211
MOV RSI,qword ptr [R12 + 0x8]
SUB RSI,qword ptr [R12]
LAB_001431cb:
MOV RDI,R14
CALL 0x00116130
MOV RAX,qword ptr [R12]
CMP qword ptr [R12 + 0x8],RAX
JZ 0x00143202
XOR ECX,ECX
LAB_001431e0:
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV RDX,qword ptr [R14]
MOV word ptr [RDX + RCX*0x2],AX
INC RCX
MOV RAX,qword ptr [R12]
MOV RDX,qword ptr [R12 + 0x8]
SUB RDX,RAX
SAR RDX,0x1
CMP RCX,RDX
JC 0x001431e0
LAB_00143202:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00143211:
LEA RDI,[0x159d15]
LEA RDX,[0x14a659]
LEA RCX,[0x15a4c4]
MOV ESI,0x8c
XOR EAX,EAX
CALL 0x00117c70
|
/* gguf_kv::gguf_kv<unsigned short>(std::__cxx11::string const&, std::vector<unsigned short,
std::allocator<unsigned short> > const&) */
void __thiscall gguf_kv::gguf_kv<unsigned_short>(gguf_kv *this,string *param_1,vector *param_2)
{
long lVar1;
ulong uVar2;
*(gguf_kv **)this = this + 0x10;
std::__cxx11::string::_M_construct<char*>
(this,*(long *)param_1,*(long *)(param_1 + 8) + *(long *)param_1);
this[0x20] = (gguf_kv)0x1;
*(int4 *)(this + 0x24) = 2;
*(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 001431cb to 00143231 has its CatchHandler @ 00143232 */
std::vector<signed_char,std::allocator<signed_char>>::resize
((vector<signed_char,std::allocator<signed_char>> *)(this + 0x28),
*(long *)(param_2 + 8) - *(long *)param_2);
lVar1 = *(long *)param_2;
if (*(long *)(param_2 + 8) != lVar1) {
uVar2 = 0;
do {
*(int2 *)(*(long *)(this + 0x28) + uVar2 * 2) = *(int2 *)(lVar1 + uVar2 * 2);
uVar2 = uVar2 + 1;
lVar1 = *(long *)param_2;
} while (uVar2 < (ulong)(*(long *)(param_2 + 8) - lVar1 >> 1));
}
return;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/gguf.cpp",0x8c,
"GGML_ASSERT(%s) failed","!key.empty()");
}
| |
24,802 | gguf_kv::gguf_kv<unsigned char>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<unsigned char, std::allocator<unsigned char>> const&) | monkey531[P]llama/ggml/src/gguf.cpp | gguf_kv(const std::string & key, const std::vector<T> & value)
: key(key), is_array(true), type(type_to_gguf_type<T>::value) {
GGML_ASSERT(!key.empty());
data.resize(value.size()*sizeof(T));
for (size_t i = 0; i < value.size(); ++i) {
const T tmp = value[i];
memcpy(data.data() + i*sizeof(T), &tmp, sizeof(T));
}
} | O2 | cpp | gguf_kv::gguf_kv<unsigned char>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<unsigned char, std::allocator<unsigned char>> const&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x1e010
movb $0x1, 0x20(%r14)
movl $0x5, 0x24(%r14)
leaq 0x28(%r14), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x48(%r14)
cmpq $0x0, 0x8(%r12)
je 0x45b13
movq 0x8(%r15), %rsi
subq (%r15), %rsi
movq %rbx, %rdi
callq 0x1c200
xorl %eax, %eax
movq (%r15), %rcx
movq 0x8(%r15), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rdx, %rax
jae 0x45b07
movl (%rcx,%rax,4), %ecx
movq (%rbx), %rdx
movl %ecx, (%rdx,%rax,4)
incq %rax
jmp 0x45ae6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x14ceb(%rip), %rdi # 0x5a805
leaq 0x5aac(%rip), %rdx # 0x4b5cd
leaq 0x1548c(%rip), %rcx # 0x5afb4
movl $0x8c, %esi
xorl %eax, %eax
callq 0x1e760
movq %rax, %r15
leaq 0x40(%r14), %rdi
callq 0x1d0b0
movq %rbx, %rdi
callq 0x1e680
movq %r14, %rdi
callq 0x1c990
movq %r15, %rdi
callq 0x1e9a0
| _ZN7gguf_kvC2IiEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorIT_SaISA_EE:
push r15
push r14
push r12
push rbx
push rax
mov r15, rdx
mov r12, rsi
mov r14, rdi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
mov byte ptr [r14+20h], 1
mov dword ptr [r14+24h], 5
lea rbx, [r14+28h]
xorps xmm0, xmm0
movups xmmword ptr [r14+28h], xmm0
movups xmmword ptr [r14+38h], xmm0
movups xmmword ptr [r14+48h], xmm0
cmp qword ptr [r12+8], 0
jz short loc_45B13
mov rsi, [r15+8]
sub rsi, [r15]
mov rdi, rbx
call __ZNSt6vectorIaSaIaEE6resizeEm; std::vector<signed char>::resize(ulong)
xor eax, eax
loc_45AE6:
mov rcx, [r15]
mov rdx, [r15+8]
sub rdx, rcx
sar rdx, 2
cmp rax, rdx
jnb short loc_45B07
mov ecx, [rcx+rax*4]
mov rdx, [rbx]
mov [rdx+rax*4], ecx
inc rax
jmp short loc_45AE6
loc_45B07:
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
loc_45B13:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeyEmpty; "!key.empty()"
mov esi, 8Ch
xor eax, eax
call _ggml_abort
mov r15, rax
lea rdi, [r14+40h]
call __ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, rbx
call __ZNSt12_Vector_baseIaSaIaEED2Ev; std::_Vector_base<signed char>::~_Vector_base()
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r15
call __Unwind_Resume
| unsigned long long gguf_kv::gguf_kv<int>(
long long a1,
long long a2,
_QWORD *a3,
double a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
char v11; // al
long long v13; // r8
long long v14; // r9
__m128 v15; // xmm4
__m128 v16; // xmm5
unsigned long long result; // rax
char v18; // [rsp-8h] [rbp-28h]
v18 = v11;
std::string::basic_string();
*(_BYTE *)(a1 + 32) = 1;
*(_DWORD *)(a1 + 36) = 5;
*(_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",
140,
(long long)"GGML_ASSERT(%s) failed",
(long long)"!key.empty()",
v13,
v14,
(__m128)0LL,
a5,
a6,
a7,
v15,
v16,
a10,
a11,
v18);
std::vector<signed char>::resize(a1 + 40, a3[1] - *a3);
for ( result = 0LL; result < (long long)(a3[1] - *a3) >> 2; ++result )
*(_DWORD *)(*(_QWORD *)(a1 + 40) + 4 * result) = *(_DWORD *)(*a3 + 4 * result);
return result;
}
| gguf_kv<int>:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDX
MOV R12,RSI
MOV R14,RDI
CALL 0x0011e010
MOV byte ptr [R14 + 0x20],0x1
MOV dword ptr [R14 + 0x24],0x5
LEA RBX,[R14 + 0x28]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x28],XMM0
MOVUPS xmmword ptr [R14 + 0x38],XMM0
MOVUPS xmmword ptr [R14 + 0x48],XMM0
CMP qword ptr [R12 + 0x8],0x0
JZ 0x00145b13
MOV RSI,qword ptr [R15 + 0x8]
SUB RSI,qword ptr [R15]
LAB_00145adc:
MOV RDI,RBX
CALL 0x0011c200
XOR EAX,EAX
LAB_00145ae6:
MOV RCX,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
SUB RDX,RCX
SAR RDX,0x2
CMP RAX,RDX
JNC 0x00145b07
MOV ECX,dword ptr [RCX + RAX*0x4]
MOV RDX,qword ptr [RBX]
MOV dword ptr [RDX + RAX*0x4],ECX
INC RAX
JMP 0x00145ae6
LAB_00145b07:
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
LAB_00145b13:
LEA RDI,[0x15a805]
LEA RDX,[0x14b5cd]
LEA RCX,[0x15afb4]
MOV ESI,0x8c
XOR EAX,EAX
CALL 0x0011e760
|
/* gguf_kv::gguf_kv<int>(std::__cxx11::string const&, std::vector<int, std::allocator<int> > const&)
*/
void __thiscall gguf_kv::gguf_kv<int>(gguf_kv *this,string *param_1,vector *param_2)
{
ulong uVar1;
std::__cxx11::string::string((string *)this,param_1);
this[0x20] = (gguf_kv)0x1;
*(int4 *)(this + 0x24) = 5;
*(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 00145adc to 00145b33 has its CatchHandler @ 00145b34 */
std::vector<signed_char,std::allocator<signed_char>>::resize
((vector<signed_char,std::allocator<signed_char>> *)(this + 0x28),
*(long *)(param_2 + 8) - *(long *)param_2);
for (uVar1 = 0; uVar1 < (ulong)(*(long *)(param_2 + 8) - *(long *)param_2 >> 2);
uVar1 = uVar1 + 1) {
*(int4 *)(*(long *)(this + 0x28) + uVar1 * 4) =
*(int4 *)(*(long *)param_2 + uVar1 * 4);
}
return;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/gguf.cpp",0x8c,
"GGML_ASSERT(%s) failed","!key.empty()");
}
| |
24,803 | gguf_kv::gguf_kv<unsigned char>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<unsigned char, std::allocator<unsigned char>> const&) | monkey531[P]llama/ggml/src/gguf.cpp | gguf_kv(const std::string & key, const std::vector<T> & value)
: key(key), is_array(true), type(type_to_gguf_type<T>::value) {
GGML_ASSERT(!key.empty());
data.resize(value.size()*sizeof(T));
for (size_t i = 0; i < value.size(); ++i) {
const T tmp = value[i];
memcpy(data.data() + i*sizeof(T), &tmp, sizeof(T));
}
} | O3 | cpp | gguf_kv::gguf_kv<unsigned char>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<unsigned char, std::allocator<unsigned char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
movq %rbx, (%rdi)
movq (%rsi), %rsi
movq 0x8(%rbp), %rdx
addq %rsi, %rdx
callq 0x16630
movb $0x1, 0x20(%r14)
movl $0x1, 0x24(%r14)
leaq 0x28(%r14), %r15
leaq 0x40(%r14), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x48(%r14)
cmpq $0x0, 0x8(%rbp)
je 0x42a92
movq 0x8(%r12), %rsi
subq (%r12), %rsi
movq %r15, %rdi
callq 0x16130
movq (%r12), %rax
cmpq %rax, 0x8(%r12)
je 0x42a83
xorl %ecx, %ecx
movb (%rax,%rcx), %al
movq (%r15), %rdx
movb %al, (%rdx,%rcx)
incq %rcx
movq (%r12), %rax
movq 0x8(%r12), %rdx
subq %rax, %rdx
cmpq %rdx, %rcx
jb 0x42a66
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1723c(%rip), %rdi # 0x59cd5
leaq 0x7bbd(%rip), %rdx # 0x4a65d
leaq 0x179dd(%rip), %rcx # 0x5a484
movl $0x8c, %esi
xorl %eax, %eax
callq 0x17c60
movq %rax, %r12
movq %r13, %rdi
callq 0x16c50
movq (%r15), %rdi
testq %rdi, %rdi
je 0x42ad2
movq 0x38(%r14), %rsi
subq %rdi, %rsi
callq 0x17070
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1884f
movq %r12, %rdi
callq 0x17e20
nop
| _ZN7gguf_kvC2IaEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorIT_SaISA_EE:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r12, rdx
mov rbp, rsi
mov r14, rdi
lea rbx, [rdi+10h]
mov [rdi], rbx
mov rsi, [rsi]
mov rdx, [rbp+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], 1
mov dword ptr [r14+24h], 1
lea r15, [r14+28h]
lea r13, [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 [rbp+8], 0
jz short loc_42A92
mov rsi, [r12+8]
sub rsi, [r12]
mov rdi, r15
call __ZNSt6vectorIaSaIaEE6resizeEm; std::vector<signed char>::resize(ulong)
mov rax, [r12]
cmp [r12+8], rax
jz short loc_42A83
xor ecx, ecx
loc_42A66:
mov al, [rax+rcx]
mov rdx, [r15]
mov [rdx+rcx], al
inc rcx
mov rax, [r12]
mov rdx, [r12+8]
sub rdx, rax
cmp rcx, rdx
jb short loc_42A66
loc_42A83:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_42A92:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeyEmpty; "!key.empty()"
mov esi, 8Ch
xor eax, eax
call _ggml_abort
mov r12, rax
mov rdi, r13
call __ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, [r15]; void *
test rdi, rdi
jz short loc_42AD2
mov rsi, [r14+38h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_42AD2:
mov rdi, r14
mov rsi, rbx
call _ZN7gguf_kvC2IaEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorIT_SaISA_EE_cold_1; gguf_kv::gguf_kv<signed char>(std::string const&,std::vector<signed char> const&) [clone]
mov rdi, r12
call __Unwind_Resume
| long long gguf_kv::gguf_kv<signed char>(long long a1, _QWORD *a2, long long *a3)
{
int v4; // r8d
int v5; // r9d
long long result; // rax
unsigned long long v7; // rcx
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<char *>(a1, *a2, *a2 + a2[1]);
*(_BYTE *)(a1 + 32) = 1;
*(_DWORD *)(a1 + 36) = 1;
*(_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",
140,
(unsigned int)"GGML_ASSERT(%s) failed",
(unsigned int)"!key.empty()",
v4,
v5);
std::vector<signed char>::resize(a1 + 40, a3[1] - *a3);
result = *a3;
if ( a3[1] != *a3 )
{
v7 = 0LL;
do
{
*(_BYTE *)(*(_QWORD *)(a1 + 40) + v7) = *(_BYTE *)(result + v7);
++v7;
result = *a3;
}
while ( v7 < a3[1] - *a3 );
}
return result;
}
| gguf_kv<signed_char>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R12,RDX
MOV RBP,RSI
MOV R14,RDI
LEA RBX,[RDI + 0x10]
MOV qword ptr [RDI],RBX
MOV RSI,qword ptr [RSI]
MOV RDX,qword ptr [RBP + 0x8]
ADD RDX,RSI
CALL 0x00116630
MOV byte ptr [R14 + 0x20],0x1
MOV dword ptr [R14 + 0x24],0x1
LEA R15,[R14 + 0x28]
LEA R13,[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 [RBP + 0x8],0x0
JZ 0x00142a92
MOV RSI,qword ptr [R12 + 0x8]
SUB RSI,qword ptr [R12]
LAB_00142a51:
MOV RDI,R15
CALL 0x00116130
MOV RAX,qword ptr [R12]
CMP qword ptr [R12 + 0x8],RAX
JZ 0x00142a83
XOR ECX,ECX
LAB_00142a66:
MOV AL,byte ptr [RAX + RCX*0x1]
MOV RDX,qword ptr [R15]
MOV byte ptr [RDX + RCX*0x1],AL
INC RCX
MOV RAX,qword ptr [R12]
MOV RDX,qword ptr [R12 + 0x8]
SUB RDX,RAX
CMP RCX,RDX
JC 0x00142a66
LAB_00142a83:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00142a92:
LEA RDI,[0x159cd5]
LEA RDX,[0x14a65d]
LEA RCX,[0x15a484]
MOV ESI,0x8c
XOR EAX,EAX
CALL 0x00117c60
|
/* gguf_kv::gguf_kv<signed char>(std::__cxx11::string const&, std::vector<signed char,
std::allocator<signed char> > const&) */
void __thiscall gguf_kv::gguf_kv<signed_char>(gguf_kv *this,string *param_1,vector *param_2)
{
long lVar1;
ulong uVar2;
*(gguf_kv **)this = this + 0x10;
std::__cxx11::string::_M_construct<char*>
(this,*(long *)param_1,*(long *)(param_1 + 8) + *(long *)param_1);
this[0x20] = (gguf_kv)0x1;
*(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 (*(long *)(param_1 + 8) != 0) {
/* try { // try from 00142a51 to 00142ab2 has its CatchHandler @ 00142ab3 */
std::vector<signed_char,std::allocator<signed_char>>::resize
((vector<signed_char,std::allocator<signed_char>> *)(this + 0x28),
*(long *)(param_2 + 8) - *(long *)param_2);
lVar1 = *(long *)param_2;
if (*(long *)(param_2 + 8) != lVar1) {
uVar2 = 0;
do {
*(int1 *)(*(long *)(this + 0x28) + uVar2) = *(int1 *)(lVar1 + uVar2);
uVar2 = uVar2 + 1;
lVar1 = *(long *)param_2;
} while (uVar2 < (ulong)(*(long *)(param_2 + 8) - lVar1));
}
return;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/gguf.cpp",0x8c,
"GGML_ASSERT(%s) failed","!key.empty()");
}
| |
24,804 | mi_nommap_pread | eloqsql/storage/myisam/mi_dynrec.c | size_t mi_nommap_pread(MI_INFO *info, uchar *Buffer,
size_t Count, my_off_t offset, myf MyFlags)
{
return mysql_file_pread(info->dfile, Buffer, Count, offset, MyFlags);
} | O3 | c | mi_nommap_pread:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, -0x30(%rbp)
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r13
movl 0x1c0(%rdi), %ebx
leaq 0x305b01(%rip), %rax # 0x3368c8
movq (%rax), %rax
leaq -0x78(%rbp), %rdi
movl %ebx, %esi
movl $0x6, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x30e09
movl %ebx, %edi
movq %r13, %rsi
movq %r14, %rdx
movq %r12, %rcx
movq -0x30(%rbp), %r8
callq 0x5d8e0
movq %rax, %rbx
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
leaq 0x305ab5(%rip), %rax # 0x3368c8
movq (%rax), %rax
leaq 0x64958(%rip), %rdx # 0x95775
movq %r15, %rdi
movq %r14, %rsi
movl $0xca, %ecx
callq *0x210(%rax)
movl %ebx, %edi
movq %r13, %rsi
movq %r14, %rdx
movq %r12, %rcx
movq -0x30(%rbp), %r12
movq %r12, %r8
callq 0x5d8e0
movq %rax, %rbx
xorl %esi, %esi
testq %rax, %rax
cmovneq %rsi, %r14
cmpq $-0x1, %rax
cmovneq %rax, %rsi
testb $0x6, %r12b
cmovneq %r14, %rsi
leaq 0x305a60(%rip), %rax # 0x3368c8
movq (%rax), %rax
movq %r15, %rdi
callq *0x218(%rax)
jmp 0x30df7
| mi_nommap_pread:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov [rbp+var_30], r8
mov r12, rcx
mov r14, rdx
mov r13, rsi
mov ebx, [rdi+1C0h]
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_78]
mov esi, ebx
mov edx, 6
call qword ptr [rax+158h]
test rax, rax
jnz short loc_30E09
mov edi, ebx
mov rsi, r13
mov rdx, r14
mov rcx, r12
mov r8, [rbp+var_30]
call my_pread
mov rbx, rax
loc_30DF7:
mov rax, rbx
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_30E09:
mov r15, rax
lea rax, PSI_server
mov rax, [rax]
lea rdx, aWorkspaceLlm4b_1; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r15
mov rsi, r14
mov ecx, 0CAh
call qword ptr [rax+210h]
mov edi, ebx
mov rsi, r13
mov rdx, r14
mov rcx, r12
mov r12, [rbp+var_30]
mov r8, r12
call my_pread
mov rbx, rax
xor esi, esi
test rax, rax
cmovnz r14, rsi
cmp rax, 0FFFFFFFFFFFFFFFFh
cmovnz rsi, rax
test r12b, 6
cmovnz rsi, r14
lea rax, PSI_server
mov rax, [rax]
mov rdi, r15
call qword ptr [rax+218h]
jmp short loc_30DF7
| long long mi_nommap_pread(long long a1, long long a2, long long a3, long long a4, long long a5)
{
unsigned int v7; // ebx
long long v8; // rax
long long v9; // rbx
long long v11; // r15
_BYTE v12[72]; // [rsp+8h] [rbp-78h] BYREF
long long v13; // [rsp+50h] [rbp-30h]
v13 = a5;
v7 = *(_DWORD *)(a1 + 448);
v8 = (*((long long ( **)(_BYTE *, _QWORD, long long))PSI_server + 43))(v12, v7, 6LL);
if ( !v8 )
return my_pread(v7, a2, a3, a4, v13);
v11 = v8;
(*((void ( **)(long long, long long, const char *, long long))PSI_server + 66))(
v8,
a3,
"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_dynrec.c",
202LL);
v9 = my_pread(v7, a2, a3, a4, v13);
(*((void ( **)(long long))PSI_server + 67))(v11);
return v9;
}
| mi_nommap_pread:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x30],R8
MOV R12,RCX
MOV R14,RDX
MOV R13,RSI
MOV EBX,dword ptr [RDI + 0x1c0]
LEA RAX,[0x4368c8]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x78]
MOV ESI,EBX
MOV EDX,0x6
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x00130e09
MOV EDI,EBX
MOV RSI,R13
MOV RDX,R14
MOV RCX,R12
MOV R8,qword ptr [RBP + -0x30]
CALL 0x0015d8e0
MOV RBX,RAX
LAB_00130df7:
MOV RAX,RBX
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00130e09:
MOV R15,RAX
LEA RAX,[0x4368c8]
MOV RAX,qword ptr [RAX]
LEA RDX,[0x195775]
MOV RDI,R15
MOV RSI,R14
MOV ECX,0xca
CALL qword ptr [RAX + 0x210]
MOV EDI,EBX
MOV RSI,R13
MOV RDX,R14
MOV RCX,R12
MOV R12,qword ptr [RBP + -0x30]
MOV R8,R12
CALL 0x0015d8e0
MOV RBX,RAX
XOR ESI,ESI
TEST RAX,RAX
CMOVNZ R14,RSI
CMP RAX,-0x1
CMOVNZ RSI,RAX
TEST R12B,0x6
CMOVNZ RSI,R14
LEA RAX,[0x4368c8]
MOV RAX,qword ptr [RAX]
MOV RDI,R15
CALL qword ptr [RAX + 0x218]
JMP 0x00130df7
|
long mi_nommap_pread(long param_1,int8 param_2,long param_3,int8 param_4,ulong param_5)
{
int4 uVar1;
ulong uVar2;
long lVar3;
long lVar4;
long lVar5;
int1 local_80 [72];
ulong local_38;
uVar1 = *(int4 *)(param_1 + 0x1c0);
local_38 = param_5;
lVar3 = (**(code **)(PSI_server + 0x158))(local_80,uVar1,6);
if (lVar3 == 0) {
lVar4 = my_pread(uVar1,param_2,param_3,param_4,local_38);
}
else {
(**(code **)(PSI_server + 0x210))
(lVar3,param_3,"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_dynrec.c",
0xca);
uVar2 = local_38;
lVar4 = my_pread(uVar1,param_2,param_3,param_4,local_38);
if (lVar4 != 0) {
param_3 = 0;
}
lVar5 = 0;
if (lVar4 != -1) {
lVar5 = lVar4;
}
if ((uVar2 & 6) != 0) {
lVar5 = param_3;
}
(**(code **)(PSI_server + 0x218))(lVar3,lVar5);
}
return lVar4;
}
| |
24,805 | internalize_json_property | bluesky950520[P]quickjs/quickjs.c | static JSValue internalize_json_property(JSContext *ctx, JSValue holder,
JSAtom name, JSValue reviver)
{
JSValue val, new_el, name_val, res;
JSValue args[2];
int ret, is_array;
uint32_t i, len = 0;
JSAtom prop;
JSPropertyEnum *atoms = NULL;
if (js_check_stack_overflow(ctx->rt, 0)) {
return JS_ThrowStackOverflow(ctx);
}
val = JS_GetProperty(ctx, holder, name);
if (JS_IsException(val))
return val;
if (JS_IsObject(val)) {
is_array = JS_IsArray(ctx, val);
if (is_array < 0)
goto fail;
if (is_array) {
if (js_get_length32(ctx, &len, val))
goto fail;
} else {
ret = JS_GetOwnPropertyNamesInternal(ctx, &atoms, &len, JS_VALUE_GET_OBJ(val), JS_GPN_ENUM_ONLY | JS_GPN_STRING_MASK);
if (ret < 0)
goto fail;
}
for(i = 0; i < len; i++) {
if (is_array) {
prop = JS_NewAtomUInt32(ctx, i);
if (prop == JS_ATOM_NULL)
goto fail;
} else {
prop = JS_DupAtom(ctx, atoms[i].atom);
}
new_el = internalize_json_property(ctx, val, prop, reviver);
if (JS_IsException(new_el)) {
JS_FreeAtom(ctx, prop);
goto fail;
}
if (JS_IsUndefined(new_el)) {
ret = JS_DeleteProperty(ctx, val, prop, 0);
} else {
ret = JS_DefinePropertyValue(ctx, val, prop, new_el, JS_PROP_C_W_E);
}
JS_FreeAtom(ctx, prop);
if (ret < 0)
goto fail;
}
}
js_free_prop_enum(ctx, atoms, len);
atoms = NULL;
name_val = JS_AtomToValue(ctx, name);
if (JS_IsException(name_val))
goto fail;
args[0] = name_val;
args[1] = val;
res = JS_Call(ctx, reviver, holder, 2, args);
JS_FreeValue(ctx, name_val);
JS_FreeValue(ctx, val);
return res;
fail:
js_free_prop_enum(ctx, atoms, len);
JS_FreeValue(ctx, val);
return JS_EXCEPTION;
} | O1 | c | internalize_json_property:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %r15
movl $0x0, -0x2c(%rbp)
movq $0x0, -0x38(%rbp)
movq 0x18(%rdi), %rax
cmpq %rbp, 0xe8(%rax)
jbe 0x4d1db
leaq 0x5070a(%rip), %rsi # 0x9d8ce
xorl %ebx, %ebx
movq %r15, %rdi
xorl %eax, %eax
callq 0x1fec9
movl $0x6, %r14d
jmp 0x4d44e
movq %r9, %r12
movq %rdx, %r13
movq %r8, -0x48(%rbp)
movl $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
movq %r15, %rdi
movl %ecx, -0x50(%rbp)
movq %rsi, -0x78(%rbp)
movq %rsi, %r8
movq %rdx, %r9
callq 0x2238f
movq %rax, %rbx
movq %rdx, %r14
movq %rax, -0x80(%rbp)
cmpl $0x6, %r14d
je 0x4d44e
movq %r13, -0x70(%rbp)
movq %r12, -0x40(%rbp)
cmpl $-0x1, %r14d
jne 0x4d364
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x276be
movl %eax, -0x4c(%rbp)
testl %eax, %eax
js 0x4d391
je 0x4d267
leaq -0x2c(%rbp), %rsi
movq %r15, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x409fb
testl %eax, %eax
jne 0x4d391
jmp 0x4d289
movq -0x80(%rbp), %rcx
leaq -0x38(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
movq %r15, %rdi
movl $0x11, %r8d
callq 0x229a9
testl %eax, %eax
js 0x4d391
movl -0x2c(%rbp), %eax
movq %rax, -0x68(%rbp)
testq %rax, %rax
je 0x4d364
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
xorl %r13d, %r13d
movq %rbx, -0x60(%rbp)
cmpl $0x0, -0x4c(%rbp)
je 0x4d2c5
movq %r15, %rdi
movl %r13d, %esi
callq 0x1f56e
movl %eax, %r12d
testl %eax, %eax
jne 0x4d2e5
jmp 0x4d391
movq -0x58(%rbp), %rax
movslq 0x4(%rax,%r13,8), %r12
cmpq $0xe0, %r12
jl 0x4d2e5
movq 0x18(%r15), %rax
movq 0x68(%rax), %rax
movq (%rax,%r12,8), %rax
incl (%rax)
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl %r12d, %ecx
movq -0x48(%rbp), %r8
movq -0x40(%rbp), %r9
callq 0x4d18a
movq %rdx, %r9
cmpl $0x3, %r9d
je 0x4d32e
cmpl $0x6, %r9d
je 0x4d466
movl $0x7, (%rsp)
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl %r12d, %ecx
movq %rax, %r8
callq 0x25ea7
jmp 0x4d342
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl %r12d, %ecx
xorl %r8d, %r8d
callq 0x26127
movl %eax, %ebx
movq %r15, %rdi
movl %r12d, %esi
callq 0x1fbc4
testl %ebx, %ebx
movq -0x60(%rbp), %rbx
js 0x4d391
incq %r13
cmpq %r13, -0x68(%rbp)
jne 0x4d2a8
movq -0x38(%rbp), %rsi
movl -0x2c(%rbp), %edx
movq %r15, %rdi
callq 0x23265
movq $0x0, -0x38(%rbp)
movq %r15, %rdi
movl -0x50(%rbp), %esi
xorl %edx, %edx
callq 0x1fb46
movq %rdx, %r13
cmpl $0x6, %r13d
jne 0x4d3bc
movq -0x38(%rbp), %rsi
movl -0x2c(%rbp), %edx
movq %r15, %rdi
callq 0x23265
movq 0x18(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1ccb2
movl $0x6, %r14d
xorl %ebx, %ebx
jmp 0x4d44e
movq %rax, %r12
leaq -0xb0(%rbp), %rax
movq %r12, (%rax)
movq %r13, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %r14, 0x18(%rax)
movl $0x0, -0x90(%rbp)
movq $0x3, -0x88(%rbp)
movups -0x90(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rax, 0x10(%rsp)
movl $0x2, 0x18(%rsp)
movq %r15, %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x78(%rbp), %rcx
movq -0x70(%rbp), %r8
movl $0x2, %r9d
callq 0x278b6
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq 0x18(%r15), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1ccb2
movq 0x18(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1ccb2
movq -0x48(%rbp), %rbx
movq -0x40(%rbp), %r14
movq %rbx, %rax
movq %r14, %rdx
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movl %r12d, %esi
callq 0x1fbc4
jmp 0x4d391
| internalize_json_property:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0A8h
mov r15, rdi
mov [rbp+var_2C], 0
mov [rbp+var_38], 0
mov rax, [rdi+18h]
cmp [rax+0E8h], rbp
jbe short loc_4D1DB
lea rsi, aMaximumCallSta; "Maximum call stack size exceeded"
xor ebx, ebx
mov rdi, r15
xor eax, eax
call JS_ThrowRangeError
mov r14d, 6
jmp loc_4D44E
loc_4D1DB:
mov r12, r9
mov r13, rdx
mov [rbp+var_48], r8
mov dword ptr [rsp+0D0h+var_D0+8], 0
mov qword ptr [rsp+0D0h+var_D0], 0
mov rdi, r15
mov [rbp+var_50], ecx
mov [rbp+var_78], rsi
mov r8, rsi
mov r9, rdx
call JS_GetPropertyInternal2
mov rbx, rax
mov r14, rdx
mov [rbp+var_80], rax
cmp r14d, 6
jz loc_4D44E
mov [rbp+var_70], r13
mov [rbp+var_40], r12
cmp r14d, 0FFFFFFFFh
jnz loc_4D364
mov rdi, r15
mov rsi, rbx
mov rdx, r14
call JS_IsArray
mov [rbp+var_4C], eax
test eax, eax
js loc_4D391
jz short loc_4D267
lea rsi, [rbp+var_2C]
mov rdi, r15
mov rdx, rbx
mov rcx, r14
call js_get_length32
test eax, eax
jnz loc_4D391
jmp short loc_4D289
loc_4D267:
mov rcx, [rbp+var_80]
lea rsi, [rbp+var_38]
lea rdx, [rbp+var_2C]
mov rdi, r15
mov r8d, 11h
call JS_GetOwnPropertyNamesInternal
test eax, eax
js loc_4D391
loc_4D289:
mov eax, [rbp+var_2C]
mov [rbp+var_68], rax
test rax, rax
jz loc_4D364
mov rax, [rbp+var_38]
mov [rbp+var_58], rax
xor r13d, r13d
mov [rbp+var_60], rbx
loc_4D2A8:
cmp [rbp+var_4C], 0
jz short loc_4D2C5
mov rdi, r15
mov esi, r13d
call JS_NewAtomUInt32
mov r12d, eax
test eax, eax
jnz short loc_4D2E5
jmp loc_4D391
loc_4D2C5:
mov rax, [rbp+var_58]
movsxd r12, dword ptr [rax+r13*8+4]
cmp r12, 0E0h
jl short loc_4D2E5
mov rax, [r15+18h]
mov rax, [rax+68h]
mov rax, [rax+r12*8]
inc dword ptr [rax]
loc_4D2E5:
mov rdi, r15
mov rsi, rbx
mov rdx, r14
mov ecx, r12d
mov r8, [rbp+var_48]
mov r9, [rbp+var_40]
call internalize_json_property
mov r9, rdx
cmp r9d, 3
jz short loc_4D32E
cmp r9d, 6
jz loc_4D466
mov dword ptr [rsp+0D0h+var_D0], 7
mov rdi, r15
mov rsi, rbx
mov rdx, r14
mov ecx, r12d
mov r8, rax
call JS_DefinePropertyValue
jmp short loc_4D342
loc_4D32E:
mov rdi, r15
mov rsi, rbx
mov rdx, r14
mov ecx, r12d
xor r8d, r8d
call JS_DeleteProperty
loc_4D342:
mov ebx, eax
mov rdi, r15
mov esi, r12d
call JS_FreeAtom
test ebx, ebx
mov rbx, [rbp+var_60]
js short loc_4D391
inc r13
cmp [rbp+var_68], r13
jnz loc_4D2A8
loc_4D364:
mov rsi, [rbp+var_38]
mov edx, [rbp+var_2C]
mov rdi, r15
call js_free_prop_enum
mov [rbp+var_38], 0
mov rdi, r15
mov esi, [rbp+var_50]
xor edx, edx
call __JS_AtomToValue
mov r13, rdx
cmp r13d, 6
jnz short loc_4D3BC
loc_4D391:
mov rsi, [rbp+var_38]
mov edx, [rbp+var_2C]
mov rdi, r15
call js_free_prop_enum
mov rdi, [r15+18h]
mov rsi, rbx
mov rdx, r14
call JS_FreeValueRT
mov r14d, 6
xor ebx, ebx
jmp loc_4D44E
loc_4D3BC:
mov r12, rax
lea rax, [rbp+var_B0]
mov [rax], r12
mov [rax+8], r13
mov [rax+10h], rbx
mov [rax+18h], r14
mov dword ptr [rbp+var_90], 0
mov qword ptr [rbp+var_90+8], 3
movups xmm0, [rbp+var_90]
movups [rsp+0D0h+var_D0], xmm0
mov [rsp+0D0h+var_C0], rax
mov [rsp+0D0h+var_B8], 2
mov rdi, r15
mov rsi, [rbp+var_48]
mov rdx, [rbp+var_40]
mov rcx, [rbp+var_78]
mov r8, [rbp+var_70]
mov r9d, 2
call JS_CallInternal
mov [rbp+var_48], rax
mov [rbp+var_40], rdx
mov rdi, [r15+18h]
mov rsi, r12
mov rdx, r13
call JS_FreeValueRT
mov rdi, [r15+18h]
mov rsi, rbx
mov rdx, r14
call JS_FreeValueRT
mov rbx, [rbp+var_48]
mov r14, [rbp+var_40]
loc_4D44E:
mov rax, rbx
mov rdx, r14
add rsp, 0A8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4D466:
mov rdi, r15
mov esi, r12d
call JS_FreeAtom
jmp loc_4D391
| unsigned long long internalize_json_property(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
_DWORD *v14; // rbx
unsigned long long PropertyInternal2; // rax
long long v18; // rdx
long long v19; // r14
int IsArray; // eax
long long v21; // r13
long long v22; // r12
_DWORD *v23; // rax
_DWORD *v24; // rax
long long v25; // rdx
__m128 v26; // xmm4
__m128 v27; // xmm5
int v28; // eax
int v29; // ebx
bool v30; // sf
long long v31; // rax
long long v32; // rdx
__m128 v33; // xmm4
__m128 v34; // xmm5
long long v35; // r13
_DWORD *v36; // r12
long long v37; // rdx
char v39; // [rsp+0h] [rbp-D0h]
_QWORD v40[4]; // [rsp+20h] [rbp-B0h] BYREF
__m128 v41; // [rsp+40h] [rbp-90h]
unsigned long long v42; // [rsp+50h] [rbp-80h]
long long v43; // [rsp+58h] [rbp-78h]
long long v44; // [rsp+60h] [rbp-70h]
long long v45; // [rsp+68h] [rbp-68h]
_DWORD *v46; // [rsp+70h] [rbp-60h]
long long v47; // [rsp+78h] [rbp-58h]
int v48; // [rsp+80h] [rbp-50h]
int v49; // [rsp+84h] [rbp-4Ch]
unsigned long long v50; // [rsp+88h] [rbp-48h]
long long v51; // [rsp+90h] [rbp-40h]
long long v52; // [rsp+98h] [rbp-38h] BYREF
int v53[11]; // [rsp+A4h] [rbp-2Ch] BYREF
long long savedregs; // [rsp+D0h] [rbp+0h] BYREF
v53[0] = 0;
v52 = 0LL;
if ( *(_QWORD *)(*(_QWORD *)(a1 + 24) + 232LL) > (unsigned long long)&savedregs )
{
v14 = 0LL;
JS_ThrowRangeError(
a1,
(long long)"Maximum call stack size exceeded",
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v39);
return (unsigned long long)v14;
}
v50 = a5;
v48 = a4;
v43 = a2;
PropertyInternal2 = JS_GetPropertyInternal2(a1, a2, a3, a4, a2, a3, 0LL, 0);
v14 = (_DWORD *)PropertyInternal2;
v19 = v18;
v42 = PropertyInternal2;
if ( (_DWORD)v18 == 6 )
return (unsigned long long)v14;
v44 = a3;
v51 = a6;
if ( (_DWORD)v18 == -1 )
{
IsArray = JS_IsArray(a1, PropertyInternal2, -1);
v49 = IsArray;
if ( IsArray < 0 )
goto LABEL_24;
if ( IsArray )
{
if ( (unsigned int)js_get_length32(a1, v53, (long long)v14, v19) )
goto LABEL_24;
}
else if ( (int)JS_GetOwnPropertyNamesInternal(a1, &v52, v53, v42, 17) < 0 )
{
goto LABEL_24;
}
v45 = (unsigned int)v53[0];
if ( v53[0] )
{
v47 = v52;
v21 = 0LL;
v46 = v14;
do
{
if ( v49 )
{
LODWORD(v22) = JS_NewAtomUInt32(a1, v21);
if ( !(_DWORD)v22 )
goto LABEL_24;
}
else
{
v22 = *(int *)(v47 + 8 * v21 + 4);
if ( v22 >= 224 )
{
v23 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 104LL) + 8 * v22);
++*v23;
}
}
v24 = (_DWORD *)internalize_json_property(a1, v14, v19, (unsigned int)v22, v50, v51);
if ( (_DWORD)v25 == 3 )
{
v28 = JS_DeleteProperty(
a1,
(long long)v14,
v19,
v22,
0,
a7,
a8,
a9,
a10,
*(double *)v26.m128_u64,
*(double *)v27.m128_u64,
a13,
a14);
}
else
{
if ( (_DWORD)v25 == 6 )
{
JS_FreeAtom(a1, v22);
LABEL_24:
js_free_prop_enum(a1, v52, v53[0]);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v14, v19);
return 0LL;
}
v28 = JS_DefinePropertyValue(
a1,
(unsigned long long)v14,
v19,
(unsigned int)v22,
v24,
v25,
*(double *)a7.m128_u64,
a8,
a9,
a10,
v26,
v27,
a13,
a14,
7);
}
v29 = v28;
JS_FreeAtom(a1, v22);
v30 = v29 < 0;
v14 = v46;
if ( v30 )
goto LABEL_24;
++v21;
}
while ( v45 != v21 );
}
}
js_free_prop_enum(a1, v52, v53[0]);
v52 = 0LL;
v31 = _JS_AtomToValue(a1, v48, 0);
v35 = v32;
if ( (_DWORD)v32 == 6 )
goto LABEL_24;
v36 = (_DWORD *)v31;
v40[0] = v31;
v40[1] = v32;
v40[2] = v14;
v40[3] = v19;
v41.m128_i32[0] = 0;
v41.m128_u64[1] = 3LL;
v50 = JS_CallInternal(a1, v50, v51, v43, v44, 2LL, v41, a8, a9, a10, v33, v34, a13, a14, 0, 3, (long long)v40, 2u);
v51 = v37;
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v36, v35);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v14, v19);
return v50;
}
| internalize_json_property:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xa8
MOV R15,RDI
MOV dword ptr [RBP + -0x2c],0x0
MOV qword ptr [RBP + -0x38],0x0
MOV RAX,qword ptr [RDI + 0x18]
CMP qword ptr [RAX + 0xe8],RBP
JBE 0x0014d1db
LEA RSI,[0x19d8ce]
XOR EBX,EBX
MOV RDI,R15
XOR EAX,EAX
CALL 0x0011fec9
MOV R14D,0x6
JMP 0x0014d44e
LAB_0014d1db:
MOV R12,R9
MOV R13,RDX
MOV qword ptr [RBP + -0x48],R8
MOV dword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP],0x0
MOV RDI,R15
MOV dword ptr [RBP + -0x50],ECX
MOV qword ptr [RBP + -0x78],RSI
MOV R8,RSI
MOV R9,RDX
CALL 0x0012238f
MOV RBX,RAX
MOV R14,RDX
MOV qword ptr [RBP + -0x80],RAX
CMP R14D,0x6
JZ 0x0014d44e
MOV qword ptr [RBP + -0x70],R13
MOV qword ptr [RBP + -0x40],R12
CMP R14D,-0x1
JNZ 0x0014d364
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R14
CALL 0x001276be
MOV dword ptr [RBP + -0x4c],EAX
TEST EAX,EAX
JS 0x0014d391
JZ 0x0014d267
LEA RSI,[RBP + -0x2c]
MOV RDI,R15
MOV RDX,RBX
MOV RCX,R14
CALL 0x001409fb
TEST EAX,EAX
JNZ 0x0014d391
JMP 0x0014d289
LAB_0014d267:
MOV RCX,qword ptr [RBP + -0x80]
LEA RSI,[RBP + -0x38]
LEA RDX,[RBP + -0x2c]
MOV RDI,R15
MOV R8D,0x11
CALL 0x001229a9
TEST EAX,EAX
JS 0x0014d391
LAB_0014d289:
MOV EAX,dword ptr [RBP + -0x2c]
MOV qword ptr [RBP + -0x68],RAX
TEST RAX,RAX
JZ 0x0014d364
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x58],RAX
XOR R13D,R13D
MOV qword ptr [RBP + -0x60],RBX
LAB_0014d2a8:
CMP dword ptr [RBP + -0x4c],0x0
JZ 0x0014d2c5
MOV RDI,R15
MOV ESI,R13D
CALL 0x0011f56e
MOV R12D,EAX
TEST EAX,EAX
JNZ 0x0014d2e5
JMP 0x0014d391
LAB_0014d2c5:
MOV RAX,qword ptr [RBP + -0x58]
MOVSXD R12,dword ptr [RAX + R13*0x8 + 0x4]
CMP R12,0xe0
JL 0x0014d2e5
MOV RAX,qword ptr [R15 + 0x18]
MOV RAX,qword ptr [RAX + 0x68]
MOV RAX,qword ptr [RAX + R12*0x8]
INC dword ptr [RAX]
LAB_0014d2e5:
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R14
MOV ECX,R12D
MOV R8,qword ptr [RBP + -0x48]
MOV R9,qword ptr [RBP + -0x40]
CALL 0x0014d18a
MOV R9,RDX
CMP R9D,0x3
JZ 0x0014d32e
CMP R9D,0x6
JZ 0x0014d466
MOV dword ptr [RSP],0x7
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R14
MOV ECX,R12D
MOV R8,RAX
CALL 0x00125ea7
JMP 0x0014d342
LAB_0014d32e:
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R14
MOV ECX,R12D
XOR R8D,R8D
CALL 0x00126127
LAB_0014d342:
MOV EBX,EAX
MOV RDI,R15
MOV ESI,R12D
CALL 0x0011fbc4
TEST EBX,EBX
MOV RBX,qword ptr [RBP + -0x60]
JS 0x0014d391
INC R13
CMP qword ptr [RBP + -0x68],R13
JNZ 0x0014d2a8
LAB_0014d364:
MOV RSI,qword ptr [RBP + -0x38]
MOV EDX,dword ptr [RBP + -0x2c]
MOV RDI,R15
CALL 0x00123265
MOV qword ptr [RBP + -0x38],0x0
MOV RDI,R15
MOV ESI,dword ptr [RBP + -0x50]
XOR EDX,EDX
CALL 0x0011fb46
MOV R13,RDX
CMP R13D,0x6
JNZ 0x0014d3bc
LAB_0014d391:
MOV RSI,qword ptr [RBP + -0x38]
MOV EDX,dword ptr [RBP + -0x2c]
MOV RDI,R15
CALL 0x00123265
MOV RDI,qword ptr [R15 + 0x18]
MOV RSI,RBX
MOV RDX,R14
CALL 0x0011ccb2
MOV R14D,0x6
XOR EBX,EBX
JMP 0x0014d44e
LAB_0014d3bc:
MOV R12,RAX
LEA RAX,[RBP + -0xb0]
MOV qword ptr [RAX],R12
MOV qword ptr [RAX + 0x8],R13
MOV qword ptr [RAX + 0x10],RBX
MOV qword ptr [RAX + 0x18],R14
MOV dword ptr [RBP + -0x90],0x0
MOV qword ptr [RBP + -0x88],0x3
MOVUPS XMM0,xmmword ptr [RBP + -0x90]
MOVUPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],RAX
MOV dword ptr [RSP + 0x18],0x2
MOV RDI,R15
MOV RSI,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x78]
MOV R8,qword ptr [RBP + -0x70]
MOV R9D,0x2
CALL 0x001278b6
MOV qword ptr [RBP + -0x48],RAX
MOV qword ptr [RBP + -0x40],RDX
MOV RDI,qword ptr [R15 + 0x18]
MOV RSI,R12
MOV RDX,R13
CALL 0x0011ccb2
MOV RDI,qword ptr [R15 + 0x18]
MOV RSI,RBX
MOV RDX,R14
CALL 0x0011ccb2
MOV RBX,qword ptr [RBP + -0x48]
MOV R14,qword ptr [RBP + -0x40]
LAB_0014d44e:
MOV RAX,RBX
MOV RDX,R14
ADD RSP,0xa8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0014d466:
MOV RDI,R15
MOV ESI,R12D
CALL 0x0011fbc4
JMP 0x0014d391
|
int1 [16]
internalize_json_property
(long param_1,int8 param_2,int8 param_3,int4 param_4,int8 param_5,
int8 param_6)
{
int *piVar1;
int iVar2;
uint uVar3;
int8 uVar4;
int8 uVar5;
int8 uVar6;
int8 uVar7;
ulong uVar8;
ulong uVar9;
int1 auVar10 [16];
int1 local_b8 [16];
int8 local_a8;
int8 local_a0;
int4 local_98;
uint uStack_94;
int8 uStack_90;
int8 local_88;
int8 local_80;
int8 local_78;
ulong local_70;
int8 local_68;
long local_60;
int4 local_58;
int local_54;
int1 local_50 [16];
long local_40;
uint local_34;
local_34 = 0;
local_40 = 0;
if (&stack0xfffffffffffffff8 < *(int1 **)(*(long *)(param_1 + 0x18) + 0xe8)) {
JS_ThrowRangeError(param_1,"Maximum call stack size exceeded");
return ZEXT816(6) << 0x40;
}
local_80 = param_2;
local_58 = param_4;
local_50._0_8_ = param_5;
auVar10 = JS_GetPropertyInternal2(param_1);
uVar5 = auVar10._8_8_;
uVar7 = auVar10._0_8_;
if (auVar10._8_4_ == 6) {
return auVar10;
}
local_88 = uVar7;
local_78 = param_3;
local_50._8_8_ = param_6;
if (auVar10._8_4_ == -1) {
local_54 = JS_IsArray(param_1,uVar7,uVar5);
if (local_54 < 0) goto LAB_0014d391;
if (local_54 == 0) {
iVar2 = JS_GetOwnPropertyNamesInternal(param_1,&local_40,&local_34,local_88,0x11);
if (iVar2 < 0) goto LAB_0014d391;
}
else {
iVar2 = js_get_length32(param_1,&local_34,uVar7,uVar5);
if (iVar2 != 0) goto LAB_0014d391;
}
local_70 = (ulong)local_34;
if (local_70 != 0) {
local_60 = local_40;
uVar9 = 0;
local_68 = uVar7;
do {
uVar7 = local_68;
if (local_54 == 0) {
uVar8 = (ulong)*(int *)(local_60 + 4 + uVar9 * 8);
if (0xdf < (long)uVar8) {
piVar1 = *(int **)(*(long *)(*(long *)(param_1 + 0x18) + 0x68) + uVar8 * 8);
*piVar1 = *piVar1 + 1;
}
}
else {
uVar3 = JS_NewAtomUInt32(param_1,uVar9 & 0xffffffff);
uVar8 = (ulong)uVar3;
if (uVar3 == 0) goto LAB_0014d391;
}
auVar10 = internalize_json_property
(param_1,uVar7,uVar5,uVar8 & 0xffffffff,local_50._0_8_,local_50._8_8_);
if (auVar10._8_4_ == 3) {
iVar2 = JS_DeleteProperty(param_1,uVar7,uVar5,uVar8 & 0xffffffff,0);
}
else {
if (auVar10._8_4_ == 6) {
JS_FreeAtom(param_1,uVar8 & 0xffffffff);
goto LAB_0014d391;
}
iVar2 = JS_DefinePropertyValue
(param_1,uVar7,uVar5,uVar8 & 0xffffffff,auVar10._0_8_,auVar10._8_8_,7);
}
JS_FreeAtom(param_1,uVar8 & 0xffffffff);
uVar7 = local_68;
if (iVar2 < 0) goto LAB_0014d391;
uVar9 = uVar9 + 1;
} while (local_70 != uVar9);
}
}
js_free_prop_enum(param_1,local_40,local_34);
local_40 = 0;
local_b8 = __JS_AtomToValue(param_1,local_58,0);
uVar6 = local_b8._8_8_;
uVar4 = local_b8._0_8_;
if (local_b8._8_4_ != 6) {
local_98 = 0;
uStack_90 = 3;
local_a8 = uVar7;
local_a0 = uVar5;
local_50 = JS_CallInternal(param_1,local_50._0_8_,local_50._8_8_,local_80,local_78,2,
(ulong)uStack_94 << 0x20,3,local_b8,2);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),uVar4,uVar6);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),uVar7,uVar5);
return local_50;
}
LAB_0014d391:
js_free_prop_enum(param_1,local_40,local_34);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),uVar7,uVar5);
return ZEXT816(6) << 0x40;
}
| |
24,806 | internalize_json_property | bluesky950520[P]quickjs/quickjs.c | static JSValue internalize_json_property(JSContext *ctx, JSValue holder,
JSAtom name, JSValue reviver)
{
JSValue val, new_el, name_val, res;
JSValue args[2];
int ret, is_array;
uint32_t i, len = 0;
JSAtom prop;
JSPropertyEnum *atoms = NULL;
if (js_check_stack_overflow(ctx->rt, 0)) {
return JS_ThrowStackOverflow(ctx);
}
val = JS_GetProperty(ctx, holder, name);
if (JS_IsException(val))
return val;
if (JS_IsObject(val)) {
is_array = JS_IsArray(ctx, val);
if (is_array < 0)
goto fail;
if (is_array) {
if (js_get_length32(ctx, &len, val))
goto fail;
} else {
ret = JS_GetOwnPropertyNamesInternal(ctx, &atoms, &len, JS_VALUE_GET_OBJ(val), JS_GPN_ENUM_ONLY | JS_GPN_STRING_MASK);
if (ret < 0)
goto fail;
}
for(i = 0; i < len; i++) {
if (is_array) {
prop = JS_NewAtomUInt32(ctx, i);
if (prop == JS_ATOM_NULL)
goto fail;
} else {
prop = JS_DupAtom(ctx, atoms[i].atom);
}
new_el = internalize_json_property(ctx, val, prop, reviver);
if (JS_IsException(new_el)) {
JS_FreeAtom(ctx, prop);
goto fail;
}
if (JS_IsUndefined(new_el)) {
ret = JS_DeleteProperty(ctx, val, prop, 0);
} else {
ret = JS_DefinePropertyValue(ctx, val, prop, new_el, JS_PROP_C_W_E);
}
JS_FreeAtom(ctx, prop);
if (ret < 0)
goto fail;
}
}
js_free_prop_enum(ctx, atoms, len);
atoms = NULL;
name_val = JS_AtomToValue(ctx, name);
if (JS_IsException(name_val))
goto fail;
args[0] = name_val;
args[1] = val;
res = JS_Call(ctx, reviver, holder, 2, args);
JS_FreeValue(ctx, name_val);
JS_FreeValue(ctx, val);
return res;
fail:
js_free_prop_enum(ctx, atoms, len);
JS_FreeValue(ctx, val);
return JS_EXCEPTION;
} | O2 | c | internalize_json_property:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
andl $0x0, -0x2c(%rbp)
andq $0x0, -0x78(%rbp)
movq %rdi, %r15
movq 0x18(%rdi), %rax
cmpq %rbp, 0xe8(%rax)
jbe 0x420b5
movq %r15, %rdi
callq 0x35215
jmp 0x4215e
movq %r9, %r12
movq %r8, -0x48(%rbp)
movq %r15, %rdi
movq %rsi, -0x68(%rbp)
movq %rdx, -0x70(%rbp)
movl %ecx, -0x58(%rbp)
callq 0x1a4c7
movq %rax, %r14
movq %rdx, %rbx
cmpl $0x6, %ebx
je 0x42164
cmpl $-0x1, %ebx
jne 0x4211f
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x21185
movl %eax, -0x54(%rbp)
testl %eax, %eax
js 0x42143
movq %r14, -0x50(%rbp)
je 0x421e3
leaq -0x2c(%rbp), %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x38976
xorl %esi, %esi
testl %eax, %eax
jne 0x42145
jmp 0x4220d
movq %r12, -0x40(%rbp)
xorl %edx, %edx
xorl %esi, %esi
movq %r15, %rdi
callq 0x1d247
movq %r15, %rdi
movl -0x58(%rbp), %esi
callq 0x19da2
movq %rdx, %r13
cmpl $0x6, %r13d
jne 0x4217c
xorl %esi, %esi
movl -0x2c(%rbp), %edx
movq %r15, %rdi
callq 0x1d247
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x174a2
pushq $0x6
popq %rbx
xorl %r14d, %r14d
movq %r14, %rax
movq %rbx, %rdx
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
leaq -0xa0(%rbp), %rax
movq %r12, (%rax)
movq %r13, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq %rax, (%rsp)
pushq $0x2
popq %r9
movq %r15, %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x68(%rbp), %rcx
movq -0x70(%rbp), %r8
callq 0x2133a
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x174a2
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x174a2
movq -0x48(%rbp), %r14
movq -0x40(%rbp), %rbx
jmp 0x42164
leaq -0x78(%rbp), %r14
leaq -0x2c(%rbp), %rdx
pushq $0x11
popq %r8
movq %r15, %rdi
movq %r14, %rsi
movq -0x50(%rbp), %rcx
callq 0x1ca73
movq (%r14), %rsi
movq -0x50(%rbp), %r14
testl %eax, %eax
js 0x42145
movq %rsi, -0x38(%rbp)
movq %r12, -0x40(%rbp)
movl -0x2c(%rbp), %edx
xorl %r12d, %r12d
movq %rdx, -0x60(%rbp)
cmpq %r12, %rdx
je 0x422e2
cmpl $0x0, -0x54(%rbp)
je 0x42245
movq %r15, %rdi
movl %r12d, %esi
callq 0x1991c
movl %eax, %r13d
testl %eax, %eax
jne 0x42265
jmp 0x422f6
movq -0x38(%rbp), %rax
movslq 0x4(%rax,%r12,8), %r13
cmpq $0xe0, %r13
jl 0x42265
movq 0x18(%r15), %rax
movq 0x68(%rax), %rax
movq (%rax,%r13,8), %rax
incl (%rax)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %r13d, %ecx
movq -0x48(%rbp), %r8
movq -0x40(%rbp), %r9
callq 0x4207b
movq %rdx, %r9
cmpl $0x3, %r9d
je 0x422aa
cmpl $0x6, %r9d
je 0x422eb
movl $0x7, (%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %r13d, %ecx
movq %rax, %r8
callq 0x1fcf6
jmp 0x422be
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %r13d, %ecx
xorl %r8d, %r8d
callq 0x1ff7b
movl %eax, %r14d
movq %r15, %rdi
movl %r13d, %esi
callq 0x19e19
incq %r12
testl %r14d, %r14d
movq -0x50(%rbp), %r14
movq -0x60(%rbp), %rdx
jns 0x4221f
jmp 0x422f6
movq -0x38(%rbp), %rsi
jmp 0x42127
movq %r15, %rdi
movl %r13d, %esi
callq 0x19e19
movq -0x38(%rbp), %rsi
jmp 0x42145
| internalize_json_property:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 88h
and [rbp+var_2C], 0
and [rbp+var_78], 0
mov r15, rdi
mov rax, [rdi+18h]
cmp [rax+0E8h], rbp
jbe short loc_420B5
mov rdi, r15
call JS_ThrowStackOverflow
jmp loc_4215E
loc_420B5:
mov r12, r9
mov [rbp+var_48], r8
mov rdi, r15
mov [rbp+var_68], rsi
mov [rbp+var_70], rdx
mov [rbp+var_58], ecx
call JS_GetProperty
mov r14, rax
mov rbx, rdx
cmp ebx, 6
jz loc_42164
cmp ebx, 0FFFFFFFFh
jnz short loc_4211F
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call JS_IsArray
mov [rbp+var_54], eax
test eax, eax
js short loc_42143
mov [rbp+var_50], r14
jz loc_421E3
lea rsi, [rbp+var_2C]
mov rdi, r15
mov rdx, r14
mov rcx, rbx
call js_get_length32
xor esi, esi
test eax, eax
jnz short loc_42145
jmp loc_4220D
loc_4211F:
mov [rbp+var_40], r12
xor edx, edx
xor esi, esi
loc_42127:
mov rdi, r15
call js_free_prop_enum
mov rdi, r15
mov esi, [rbp+var_58]
call JS_AtomToValue
mov r13, rdx
cmp r13d, 6
jnz short loc_4217C
loc_42143:
xor esi, esi
loc_42145:
mov edx, [rbp+var_2C]
mov rdi, r15
call js_free_prop_enum
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call JS_FreeValue
loc_4215E:
push 6
pop rbx
xor r14d, r14d
loc_42164:
mov rax, r14
mov rdx, rbx
add rsp, 88h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4217C:
mov r12, rax
lea rax, [rbp+var_A0]
mov [rax], r12
mov [rax+8], r13
mov [rax+10h], r14
mov [rax+18h], rbx
mov [rsp+0B0h+var_B0], rax
push 2
pop r9
mov rdi, r15
mov rsi, [rbp+var_48]
mov rdx, [rbp+var_40]
mov rcx, [rbp+var_68]
mov r8, [rbp+var_70]
call JS_Call
mov [rbp+var_48], rax
mov [rbp+var_40], rdx
mov rdi, r15
mov rsi, r12
mov rdx, r13
call JS_FreeValue
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call JS_FreeValue
mov r14, [rbp+var_48]
mov rbx, [rbp+var_40]
jmp short loc_42164
loc_421E3:
lea r14, [rbp+var_78]
lea rdx, [rbp+var_2C]
push 11h
pop r8
mov rdi, r15
mov rsi, r14
mov rcx, [rbp+var_50]
call JS_GetOwnPropertyNamesInternal
mov rsi, [r14]
mov r14, [rbp+var_50]
test eax, eax
js loc_42145
loc_4220D:
mov [rbp+var_38], rsi
mov [rbp+var_40], r12
mov edx, [rbp+var_2C]
xor r12d, r12d
mov [rbp+var_60], rdx
loc_4221F:
cmp rdx, r12
jz loc_422E2
cmp [rbp+var_54], 0
jz short loc_42245
mov rdi, r15
mov esi, r12d
call JS_NewAtomUInt32
mov r13d, eax
test eax, eax
jnz short loc_42265
jmp loc_422F6
loc_42245:
mov rax, [rbp+var_38]
movsxd r13, dword ptr [rax+r12*8+4]
cmp r13, 0E0h
jl short loc_42265
mov rax, [r15+18h]
mov rax, [rax+68h]
mov rax, [rax+r13*8]
inc dword ptr [rax]
loc_42265:
mov rdi, r15
mov rsi, r14
mov rdx, rbx
mov ecx, r13d
mov r8, [rbp+var_48]
mov r9, [rbp+var_40]
call internalize_json_property
mov r9, rdx
cmp r9d, 3
jz short loc_422AA
cmp r9d, 6
jz short loc_422EB
mov dword ptr [rsp+0B0h+var_B0], 7
mov rdi, r15
mov rsi, r14
mov rdx, rbx
mov ecx, r13d
mov r8, rax
call JS_DefinePropertyValue
jmp short loc_422BE
loc_422AA:
mov rdi, r15
mov rsi, r14
mov rdx, rbx
mov ecx, r13d
xor r8d, r8d
call JS_DeleteProperty
loc_422BE:
mov r14d, eax
mov rdi, r15
mov esi, r13d
call JS_FreeAtom
inc r12
test r14d, r14d
mov r14, [rbp+var_50]
mov rdx, [rbp+var_60]
jns loc_4221F
jmp short loc_422F6
loc_422E2:
mov rsi, [rbp+var_38]
jmp loc_42127
loc_422EB:
mov rdi, r15
mov esi, r13d
call JS_FreeAtom
loc_422F6:
mov rsi, [rbp+var_38]
jmp loc_42145
| long long internalize_json_property(
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 Property; // rax
long long v16; // rdx
long long v17; // r14
long long v18; // rbx
int IsArray; // eax
long long v20; // rsi
long long v21; // rdx
long long v22; // rsi
long long v23; // rax
long long v24; // rdx
long long v25; // r13
long long v27; // r12
long long v28; // rdx
int OwnPropertyNamesInternal; // eax
long long v30; // r12
long long v31; // r13
_DWORD *v32; // rax
_DWORD *v33; // rax
long long v34; // rdx
__m128 v35; // xmm4
__m128 v36; // xmm5
int v37; // eax
int v38; // r14d
bool v39; // sf
char v40; // [rsp+0h] [rbp-B0h]
_QWORD v41[5]; // [rsp+10h] [rbp-A0h] BYREF
long long v42; // [rsp+38h] [rbp-78h] BYREF
long long v43; // [rsp+40h] [rbp-70h]
long long v44; // [rsp+48h] [rbp-68h]
long long v45; // [rsp+50h] [rbp-60h]
unsigned int v46; // [rsp+58h] [rbp-58h]
int v47; // [rsp+5Ch] [rbp-54h]
long long v48; // [rsp+60h] [rbp-50h]
long long v49; // [rsp+68h] [rbp-48h]
long long v50; // [rsp+70h] [rbp-40h]
long long v51; // [rsp+78h] [rbp-38h]
int v52[11]; // [rsp+84h] [rbp-2Ch] BYREF
long long savedregs; // [rsp+B0h] [rbp+0h] BYREF
v52[0] = 0;
v42 = 0LL;
if ( *(_QWORD *)(*(_QWORD *)(a1 + 24) + 232LL) > (unsigned long long)&savedregs )
{
JS_ThrowStackOverflow(a1, a7, a8, a9, a10, a11, a12, a13, a14, a2, a3, a4, a5, a6, v40);
return 0LL;
}
v49 = a5;
v44 = a2;
v43 = a3;
v46 = a4;
Property = JS_GetProperty(a1, a2, a3, a4);
v17 = Property;
v18 = v16;
if ( (_DWORD)v16 != 6 )
{
if ( (_DWORD)v16 == -1 )
{
IsArray = JS_IsArray(a1, Property, -1);
v47 = IsArray;
if ( IsArray >= 0 )
{
v48 = v17;
if ( IsArray )
{
v20 = 0LL;
if ( (unsigned int)js_get_length32(a1, v52, v17, -1) )
goto LABEL_12;
}
else
{
OwnPropertyNamesInternal = JS_GetOwnPropertyNamesInternal(a1, &v42, v52, v48, 17);
v20 = v42;
v17 = v48;
if ( OwnPropertyNamesInternal < 0 )
goto LABEL_12;
}
v51 = v20;
v50 = a6;
v21 = (unsigned int)v52[0];
v30 = 0LL;
v45 = (unsigned int)v52[0];
while ( 1 )
{
if ( v21 == v30 )
{
v22 = v51;
goto LABEL_10;
}
if ( v47 )
{
LODWORD(v31) = JS_NewAtomUInt32(a1, v30);
if ( !(_DWORD)v31 )
goto LABEL_32;
}
else
{
v31 = *(int *)(v51 + 8 * v30 + 4);
if ( v31 >= 224 )
{
v32 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 104LL) + 8 * v31);
++*v32;
}
}
v33 = (_DWORD *)internalize_json_property(a1, v17, v18, (unsigned int)v31, v49, v50);
if ( (_DWORD)v34 == 3 )
{
v37 = JS_DeleteProperty(
a1,
a7,
a8,
a9,
a10,
*(double *)v35.m128_u64,
*(double *)v36.m128_u64,
a13,
a14,
v17,
v18,
v31,
0);
}
else
{
if ( (_DWORD)v34 == 6 )
{
JS_FreeAtom(a1, v31);
LABEL_32:
v20 = v51;
LABEL_12:
js_free_prop_enum(a1, v20, v52[0]);
JS_FreeValue(a1, v17, v18);
return 0LL;
}
v37 = JS_DefinePropertyValue(
a1,
v17,
v18,
(unsigned int)v31,
v33,
v34,
*(double *)a7.m128_u64,
a8,
a9,
a10,
v35,
v36,
a13,
a14,
7);
}
v38 = v37;
JS_FreeAtom(a1, v31);
++v30;
v39 = v38 < 0;
v17 = v48;
v21 = v45;
if ( v39 )
goto LABEL_32;
}
}
}
else
{
v50 = a6;
LODWORD(v21) = 0;
v22 = 0LL;
LABEL_10:
js_free_prop_enum(a1, v22, v21);
v23 = JS_AtomToValue(a1, v46);
v25 = v24;
if ( (_DWORD)v24 != 6 )
{
v27 = v23;
v41[0] = v23;
v41[1] = v24;
v41[2] = v17;
v41[3] = v18;
v49 = JS_Call(a1, v49, v50, v44, v43, 2, (long long)v41);
v50 = v28;
JS_FreeValue(a1, v27, v25);
JS_FreeValue(a1, v17, v18);
return v49;
}
}
v20 = 0LL;
goto LABEL_12;
}
return v17;
}
| internalize_json_property:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x88
AND dword ptr [RBP + -0x2c],0x0
AND qword ptr [RBP + -0x78],0x0
MOV R15,RDI
MOV RAX,qword ptr [RDI + 0x18]
CMP qword ptr [RAX + 0xe8],RBP
JBE 0x001420b5
MOV RDI,R15
CALL 0x00135215
JMP 0x0014215e
LAB_001420b5:
MOV R12,R9
MOV qword ptr [RBP + -0x48],R8
MOV RDI,R15
MOV qword ptr [RBP + -0x68],RSI
MOV qword ptr [RBP + -0x70],RDX
MOV dword ptr [RBP + -0x58],ECX
CALL 0x0011a4c7
MOV R14,RAX
MOV RBX,RDX
CMP EBX,0x6
JZ 0x00142164
CMP EBX,-0x1
JNZ 0x0014211f
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x00121185
MOV dword ptr [RBP + -0x54],EAX
TEST EAX,EAX
JS 0x00142143
MOV qword ptr [RBP + -0x50],R14
JZ 0x001421e3
LEA RSI,[RBP + -0x2c]
MOV RDI,R15
MOV RDX,R14
MOV RCX,RBX
CALL 0x00138976
XOR ESI,ESI
TEST EAX,EAX
JNZ 0x00142145
JMP 0x0014220d
LAB_0014211f:
MOV qword ptr [RBP + -0x40],R12
XOR EDX,EDX
XOR ESI,ESI
LAB_00142127:
MOV RDI,R15
CALL 0x0011d247
MOV RDI,R15
MOV ESI,dword ptr [RBP + -0x58]
CALL 0x00119da2
MOV R13,RDX
CMP R13D,0x6
JNZ 0x0014217c
LAB_00142143:
XOR ESI,ESI
LAB_00142145:
MOV EDX,dword ptr [RBP + -0x2c]
MOV RDI,R15
CALL 0x0011d247
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x001174a2
LAB_0014215e:
PUSH 0x6
POP RBX
XOR R14D,R14D
LAB_00142164:
MOV RAX,R14
MOV RDX,RBX
ADD RSP,0x88
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0014217c:
MOV R12,RAX
LEA RAX,[RBP + -0xa0]
MOV qword ptr [RAX],R12
MOV qword ptr [RAX + 0x8],R13
MOV qword ptr [RAX + 0x10],R14
MOV qword ptr [RAX + 0x18],RBX
MOV qword ptr [RSP],RAX
PUSH 0x2
POP R9
MOV RDI,R15
MOV RSI,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x68]
MOV R8,qword ptr [RBP + -0x70]
CALL 0x0012133a
MOV qword ptr [RBP + -0x48],RAX
MOV qword ptr [RBP + -0x40],RDX
MOV RDI,R15
MOV RSI,R12
MOV RDX,R13
CALL 0x001174a2
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x001174a2
MOV R14,qword ptr [RBP + -0x48]
MOV RBX,qword ptr [RBP + -0x40]
JMP 0x00142164
LAB_001421e3:
LEA R14,[RBP + -0x78]
LEA RDX,[RBP + -0x2c]
PUSH 0x11
POP R8
MOV RDI,R15
MOV RSI,R14
MOV RCX,qword ptr [RBP + -0x50]
CALL 0x0011ca73
MOV RSI,qword ptr [R14]
MOV R14,qword ptr [RBP + -0x50]
TEST EAX,EAX
JS 0x00142145
LAB_0014220d:
MOV qword ptr [RBP + -0x38],RSI
MOV qword ptr [RBP + -0x40],R12
MOV EDX,dword ptr [RBP + -0x2c]
XOR R12D,R12D
MOV qword ptr [RBP + -0x60],RDX
LAB_0014221f:
CMP RDX,R12
JZ 0x001422e2
CMP dword ptr [RBP + -0x54],0x0
JZ 0x00142245
MOV RDI,R15
MOV ESI,R12D
CALL 0x0011991c
MOV R13D,EAX
TEST EAX,EAX
JNZ 0x00142265
JMP 0x001422f6
LAB_00142245:
MOV RAX,qword ptr [RBP + -0x38]
MOVSXD R13,dword ptr [RAX + R12*0x8 + 0x4]
CMP R13,0xe0
JL 0x00142265
MOV RAX,qword ptr [R15 + 0x18]
MOV RAX,qword ptr [RAX + 0x68]
MOV RAX,qword ptr [RAX + R13*0x8]
INC dword ptr [RAX]
LAB_00142265:
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
MOV ECX,R13D
MOV R8,qword ptr [RBP + -0x48]
MOV R9,qword ptr [RBP + -0x40]
CALL 0x0014207b
MOV R9,RDX
CMP R9D,0x3
JZ 0x001422aa
CMP R9D,0x6
JZ 0x001422eb
MOV dword ptr [RSP],0x7
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
MOV ECX,R13D
MOV R8,RAX
CALL 0x0011fcf6
JMP 0x001422be
LAB_001422aa:
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
MOV ECX,R13D
XOR R8D,R8D
CALL 0x0011ff7b
LAB_001422be:
MOV R14D,EAX
MOV RDI,R15
MOV ESI,R13D
CALL 0x00119e19
INC R12
TEST R14D,R14D
MOV R14,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x60]
JNS 0x0014221f
JMP 0x001422f6
LAB_001422e2:
MOV RSI,qword ptr [RBP + -0x38]
JMP 0x00142127
LAB_001422eb:
MOV RDI,R15
MOV ESI,R13D
CALL 0x00119e19
LAB_001422f6:
MOV RSI,qword ptr [RBP + -0x38]
JMP 0x00142145
|
int1 [16]
internalize_json_property
(long param_1,int8 param_2,int8 param_3,int4 param_4,int8 param_5,
int8 param_6)
{
int *piVar1;
int iVar2;
uint uVar3;
int8 uVar4;
int8 uVar5;
int8 uVar6;
long lVar7;
ulong uVar8;
ulong uVar9;
int8 uVar10;
int1 auVar11 [16];
int1 local_a8 [16];
int8 local_98;
int8 local_90;
long local_80;
int8 local_78;
int8 local_70;
ulong local_68;
int4 local_60;
int local_5c;
int8 local_58;
int1 local_50 [16];
long local_40;
uint local_34;
local_34 = 0;
local_80 = 0;
if (&stack0xfffffffffffffff8 < *(int1 **)(*(long *)(param_1 + 0x18) + 0xe8)) {
JS_ThrowStackOverflow(param_1);
goto LAB_0014215e;
}
local_78 = param_3;
local_70 = param_2;
local_60 = param_4;
local_50._0_8_ = param_5;
auVar11 = JS_GetProperty(param_1);
uVar5 = auVar11._8_8_;
uVar10 = auVar11._0_8_;
if (auVar11._8_4_ == 6) {
return auVar11;
}
if (auVar11._8_4_ == -1) {
local_5c = JS_IsArray(param_1,uVar10,uVar5);
if (local_5c < 0) goto LAB_00142143;
local_58 = uVar10;
if (local_5c == 0) {
iVar2 = JS_GetOwnPropertyNamesInternal(param_1,&local_80,&local_34,uVar10,0x11);
lVar7 = local_80;
uVar10 = local_58;
if (-1 < iVar2) goto LAB_0014220d;
}
else {
iVar2 = js_get_length32(param_1,&local_34,uVar10,uVar5);
lVar7 = 0;
if (iVar2 == 0) {
LAB_0014220d:
local_68 = (ulong)local_34;
uVar8 = 0;
local_50._8_8_ = param_6;
local_40 = lVar7;
do {
uVar9 = local_68;
lVar7 = local_40;
if (local_68 == uVar8) goto LAB_00142127;
if (local_5c == 0) {
uVar9 = (ulong)*(int *)(local_40 + 4 + uVar8 * 8);
if (0xdf < (long)uVar9) {
piVar1 = *(int **)(*(long *)(*(long *)(param_1 + 0x18) + 0x68) + uVar9 * 8);
*piVar1 = *piVar1 + 1;
}
}
else {
uVar3 = JS_NewAtomUInt32(param_1,uVar8 & 0xffffffff);
uVar9 = (ulong)uVar3;
lVar7 = local_40;
if (uVar3 == 0) break;
}
auVar11 = internalize_json_property
(param_1,uVar10,uVar5,uVar9 & 0xffffffff,local_50._0_8_,local_50._8_8_
);
if (auVar11._8_4_ == 3) {
iVar2 = JS_DeleteProperty(param_1,uVar10,uVar5,uVar9 & 0xffffffff,0);
}
else {
if (auVar11._8_4_ == 6) {
JS_FreeAtom(param_1,uVar9 & 0xffffffff);
lVar7 = local_40;
break;
}
iVar2 = JS_DefinePropertyValue
(param_1,uVar10,uVar5,uVar9 & 0xffffffff,auVar11._0_8_,auVar11._8_8_,7
);
}
JS_FreeAtom(param_1,uVar9 & 0xffffffff);
uVar8 = uVar8 + 1;
lVar7 = local_40;
uVar10 = local_58;
} while (-1 < iVar2);
}
}
}
else {
uVar9 = 0;
lVar7 = 0;
local_50._8_8_ = param_6;
LAB_00142127:
js_free_prop_enum(param_1,lVar7,uVar9);
local_a8 = JS_AtomToValue(param_1,local_60);
uVar6 = local_a8._8_8_;
uVar4 = local_a8._0_8_;
if (local_a8._8_4_ != 6) {
local_98 = uVar10;
local_90 = uVar5;
local_50 = JS_Call(param_1,local_50._0_8_,local_50._8_8_,local_70,local_78,2,local_a8);
JS_FreeValue(param_1,uVar4,uVar6);
JS_FreeValue(param_1,uVar10,uVar5);
return local_50;
}
LAB_00142143:
lVar7 = 0;
}
js_free_prop_enum(param_1,lVar7,local_34);
JS_FreeValue(param_1,uVar10,uVar5);
LAB_0014215e:
return ZEXT816(6) << 0x40;
}
| |
24,807 | google::protobuf::DescriptorProto_ExtensionRange::~DescriptorProto_ExtensionRange() | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.pb.cc | DescriptorProto_ExtensionRange::~DescriptorProto_ExtensionRange() {
// @@protoc_insertion_point(destructor:google.protobuf.DescriptorProto.ExtensionRange)
if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
(void)arena;
return;
}
SharedDtor();
} | O3 | cpp | google::protobuf::DescriptorProto_ExtensionRange::~DescriptorProto_ExtensionRange():
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq 0x8(%rdi), %rax
testb $0x1, %al
jne 0x49a36
andq $-0x4, %rax
jmp 0x49a3e
movq %rbx, %rdi
callq 0x59746
leaq 0xb89eb(%rip), %rcx # 0x102430
cmpq %rcx, %r14
je 0x49a68
testq %rax, %rax
jne 0x49a68
movq 0x18(%r14), %r15
testq %r15, %r15
je 0x49a60
movq %r15, %rdi
callq 0x4bd02
movq %r15, %rdi
callq 0xf330
leaq 0xb78b1(%rip), %rax # 0x101320
addq $0x10, %rax
movq %rax, (%r14)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x59494
movq %rax, %rdi
callq 0x13387
nop
| _ZN6google8protobuf30DescriptorProto_ExtensionRangeD2Ev:
push r15; Alternative name is 'google::protobuf::DescriptorProto_ExtensionRange::~DescriptorProto_ExtensionRange()'
push r14
push rbx
mov r14, rdi
lea rbx, [rdi+8]
mov rax, [rdi+8]
test al, 1
jnz short loc_49A36
and rax, 0FFFFFFFFFFFFFFFCh
jmp short loc_49A3E
loc_49A36:
mov rdi, rbx
call _ZN6google8protobuf8internal16InternalMetadata21DeleteOutOfLineHelperINS0_15UnknownFieldSetEEEPNS0_5ArenaEv; google::protobuf::internal::InternalMetadata::DeleteOutOfLineHelper<google::protobuf::UnknownFieldSet>(void)
loc_49A3E:
lea rcx, _ZN6google8protobuf49_DescriptorProto_ExtensionRange_default_instance_E; google::protobuf::_DescriptorProto_ExtensionRange_default_instance_
cmp r14, rcx
jz short loc_49A68
test rax, rax
jnz short loc_49A68
mov r15, [r14+18h]
test r15, r15
jz short loc_49A60
mov rdi, r15; this
call _ZN6google8protobuf21ExtensionRangeOptionsD2Ev; google::protobuf::ExtensionRangeOptions::~ExtensionRangeOptions()
loc_49A60:
mov rdi, r15; void *
call __ZdlPv; operator delete(void *)
loc_49A68:
lea rax, _ZTVN6google8protobuf11MessageLiteE; `vtable for'google::protobuf::MessageLite
add rax, 10h
mov [r14], rax
mov rdi, rbx; this
pop rbx
pop r14
pop r15
jmp _ZN6google8protobuf8internal16InternalMetadataD2Ev; google::protobuf::internal::InternalMetadata::~InternalMetadata()
mov rdi, rax
call __clang_call_terminate
| void google::protobuf::DescriptorProto_ExtensionRange::~DescriptorProto_ExtensionRange(
void ( ***this)(google::protobuf::DescriptorProto_ExtensionRange *__hidden this))
{
unsigned long long v1; // rax
unsigned long long v2; // rax
void ( **v3)(google::protobuf::DescriptorProto_ExtensionRange *__hidden); // r15
v1 = (unsigned long long)this[1];
if ( (v1 & 1) != 0 )
v2 = google::protobuf::internal::InternalMetadata::DeleteOutOfLineHelper<google::protobuf::UnknownFieldSet>(this + 1);
else
v2 = v1 & 0xFFFFFFFFFFFFFFFCLL;
if ( this != &google::protobuf::_DescriptorProto_ExtensionRange_default_instance_ && !v2 )
{
v3 = this[3];
if ( v3 )
google::protobuf::ExtensionRangeOptions::~ExtensionRangeOptions((google::protobuf::ExtensionRangeOptions *)this[3]);
operator delete(v3);
}
*this = (void ( **)(google::protobuf::DescriptorProto_ExtensionRange *__hidden))(&`vtable for'google::protobuf::MessageLite
+ 2);
google::protobuf::internal::InternalMetadata::~InternalMetadata((google::protobuf::internal::InternalMetadata *)(this + 1));
}
| ~DescriptorProto_ExtensionRange:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RDI
LEA RBX,[RDI + 0x8]
MOV RAX,qword ptr [RDI + 0x8]
TEST AL,0x1
JNZ 0x00149a36
AND RAX,-0x4
JMP 0x00149a3e
LAB_00149a36:
MOV RDI,RBX
CALL 0x00159746
LAB_00149a3e:
LEA RCX,[0x202430]
CMP R14,RCX
JZ 0x00149a68
TEST RAX,RAX
JNZ 0x00149a68
MOV R15,qword ptr [R14 + 0x18]
TEST R15,R15
JZ 0x00149a60
MOV RDI,R15
CALL 0x0014bd02
LAB_00149a60:
MOV RDI,R15
CALL 0x0010f330
LAB_00149a68:
LEA RAX,[0x201320]
ADD RAX,0x10
MOV qword ptr [R14],RAX
MOV RDI,RBX
POP RBX
POP R14
POP R15
JMP 0x00159494
|
/* google::protobuf::DescriptorProto_ExtensionRange::~DescriptorProto_ExtensionRange() */
void __thiscall
google::protobuf::DescriptorProto_ExtensionRange::~DescriptorProto_ExtensionRange
(DescriptorProto_ExtensionRange *this)
{
ExtensionRangeOptions *this_00;
Arena *pAVar1;
if ((*(ulong *)(this + 8) & 1) == 0) {
pAVar1 = (Arena *)(*(ulong *)(this + 8) & 0xfffffffffffffffc);
}
else {
/* try { // try from 00149a36 to 00149a3d has its CatchHandler @ 00149a83 */
pAVar1 = internal::InternalMetadata::DeleteOutOfLineHelper<google::protobuf::UnknownFieldSet>
((InternalMetadata *)(this + 8));
}
if ((this != (DescriptorProto_ExtensionRange *)_DescriptorProto_ExtensionRange_default_instance_)
&& (pAVar1 == (Arena *)0x0)) {
this_00 = *(ExtensionRangeOptions **)(this + 0x18);
if (this_00 != (ExtensionRangeOptions *)0x0) {
ExtensionRangeOptions::~ExtensionRangeOptions(this_00);
}
operator_delete(this_00);
}
*(int ***)this = &PTR__MessageLite_00201330;
internal::InternalMetadata::~InternalMetadata((InternalMetadata *)(this + 8));
return;
}
| |
24,808 | mysql_stmt_execute_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_stmt_execute_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_stmt_execute,
(parms->stmt),
parms->stmt->mysql,
int,
r_int)
} | O3 | c | mysql_stmt_execute_start_internal:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rdi
movq 0x38(%rdi), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rbx
callq 0x224a9
movl %eax, 0x8(%rbx)
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| mysql_stmt_execute_start_internal:
push rbp
mov rbp, rsp
push rbx
push rax
mov rdi, [rdi]
mov rax, [rdi+38h]
mov rax, [rax+480h]
mov rbx, [rax+28h]
call mysql_stmt_execute
mov [rbx+8], eax
mov dword ptr [rbx], 0
add rsp, 8
pop rbx
pop rbp
retn
| long long mysql_stmt_execute_start_internal(long long *a1)
{
long long v1; // rdi
_DWORD *v2; // rbx
long long result; // rax
v1 = *a1;
v2 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(v1 + 56) + 1152LL) + 40LL);
result = mysql_stmt_execute(v1);
v2[2] = result;
*v2 = 0;
return result;
}
| mysql_stmt_execute_start_internal:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RDI,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x38]
MOV RAX,qword ptr [RAX + 0x480]
MOV RBX,qword ptr [RAX + 0x28]
CALL 0x001224a9
MOV dword ptr [RBX + 0x8],EAX
MOV dword ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void mysql_stmt_execute_start_internal(long *param_1)
{
int4 *puVar1;
int4 uVar2;
puVar1 = *(int4 **)(*(long *)(*(long *)(*param_1 + 0x38) + 0x480) + 0x28);
uVar2 = mysql_stmt_execute();
puVar1[2] = uVar2;
*puVar1 = 0;
return;
}
| |
24,809 | mysql_set_character_set@libmariadbclient_18 | eloqsql/libmariadb/libmariadb/mariadb_lib.c | int STDCALL mysql_set_character_set(MYSQL *mysql, const char *csname)
{
const MARIADB_CHARSET_INFO *cs;
if (!csname)
goto error;
if ((cs= mysql_find_charset_name(csname)))
{
char buff[64];
snprintf(buff, 63, "SET NAMES %s", cs->csname);
if (!mysql_real_query(mysql, buff, (unsigned long)strlen(buff)))
{
mysql->charset= cs;
return(0);
}
return(mysql->net.last_errno);
}
error:
my_set_error(mysql, CR_CANT_READ_CHARSET, SQLSTATE_UNKNOWN,
0, csname, "compiled_in");
return(mysql->net.last_errno);
} | O3 | c | mysql_set_character_set@libmariadbclient_18:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
testq %rsi, %rsi
je 0x2134c
movq %rsi, %r14
movq %rsi, %rdi
callq 0x1a3ce
testq %rax, %rax
je 0x2136c
movq %rax, %r15
movq 0x8(%rax), %r9
leaq 0x19cc6(%rip), %r8 # 0x3afcf
xorl %r14d, %r14d
leaq -0x70(%rbp), %r12
movl $0x3f, %esi
movl $0x40, %ecx
movq %r12, %rdi
movl $0x1, %edx
xorl %eax, %eax
callq 0x17380
movq %r12, %rdi
callq 0x17250
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x17190
testl %eax, %eax
jne 0x21391
movq %r15, 0x2f0(%rbx)
jmp 0x21398
leaq 0x2a9fd(%rip), %rax # 0x4bd50
movq (%rax), %rdx
leaq 0x19ba6(%rip), %r9 # 0x3af03
movq %rbx, %rdi
movl $0x7e3, %esi # imm = 0x7E3
xorl %ecx, %ecx
xorl %r8d, %r8d
jmp 0x2138a
leaq 0x2a9dd(%rip), %rax # 0x4bd50
movq (%rax), %rdx
leaq 0x19b86(%rip), %r9 # 0x3af03
movq %rbx, %rdi
movl $0x7e3, %esi # imm = 0x7E3
xorl %ecx, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0x1cbd5
movl 0x90(%rbx), %r14d
movq %fs:0x28, %rax
cmpq -0x28(%rbp), %rax
jne 0x213b7
movl %r14d, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x17690
| mysql_set_character_set@libmariadbclient_18:
push rbp; Alternative name is 'mysql_set_character_set'
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 50h
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_28], rax
test rsi, rsi
jz short loc_2134C
mov r14, rsi
mov rdi, rsi
call mysql_find_charset_name
test rax, rax
jz short loc_2136C
mov r15, rax
mov r9, [rax+8]
lea r8, aSetNamesS; "SET NAMES %s"
xor r14d, r14d
lea r12, [rbp+var_70]
mov esi, 3Fh ; '?'
mov ecx, 40h ; '@'
mov rdi, r12
mov edx, 1
xor eax, eax
call ___snprintf_chk
mov rdi, r12
call _strlen
mov rdi, rbx
mov rsi, r12
mov rdx, rax
call _mysql_real_query@libmariadbclient_18
test eax, eax
jnz short loc_21391
mov [rbx+2F0h], r15
jmp short loc_21398
loc_2134C:
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea r9, aCompiledIn; "compiled_in"
mov rdi, rbx
mov esi, 7E3h
xor ecx, ecx
xor r8d, r8d
jmp short loc_2138A
loc_2136C:
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea r9, aCompiledIn; "compiled_in"
mov rdi, rbx
mov esi, 7E3h
xor ecx, ecx
mov r8, r14
loc_2138A:
xor eax, eax
call my_set_error
loc_21391:
mov r14d, [rbx+90h]
loc_21398:
mov rax, fs:28h
cmp rax, [rbp+var_28]
jnz short loc_213B7
mov eax, r14d
add rsp, 50h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_213B7:
call ___stack_chk_fail
| long long mysql_set_character_set_libmariadbclient_18(long long a1, long long a2)
{
const char **charset_name; // rax
const char **v3; // r15
unsigned int v4; // r14d
long long v5; // rdx
long long v6; // rcx
long long v7; // rax
_BYTE v9[72]; // [rsp+0h] [rbp-70h] BYREF
unsigned long long v10; // [rsp+48h] [rbp-28h]
v10 = __readfsqword(0x28u);
if ( !a2 )
{
my_set_error(a1, 2019, (long long)SQLSTATE_UNKNOWN, 0LL, 0LL, "compiled_in");
return *(unsigned int *)(a1 + 144);
}
charset_name = (const char **)mysql_find_charset_name(a2);
if ( !charset_name )
{
my_set_error(a1, 2019, (long long)SQLSTATE_UNKNOWN, 0LL, a2, "compiled_in");
return *(unsigned int *)(a1 + 144);
}
v3 = charset_name;
v4 = 0;
__snprintf_chk(v9, 63LL, 1LL, 64LL, "SET NAMES %s", charset_name[1]);
v7 = strlen(v9, 63LL, v5, v6);
if ( (unsigned int)mysql_real_query_libmariadbclient_18(a1, v9, v7) )
return *(unsigned int *)(a1 + 144);
*(_QWORD *)(a1 + 752) = v3;
return v4;
}
| mysql_set_character_set:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x50
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
TEST RSI,RSI
JZ 0x0012134c
MOV R14,RSI
MOV RDI,RSI
CALL 0x0011a3ce
TEST RAX,RAX
JZ 0x0012136c
MOV R15,RAX
MOV R9,qword ptr [RAX + 0x8]
LEA R8,[0x13afcf]
XOR R14D,R14D
LEA R12,[RBP + -0x70]
MOV ESI,0x3f
MOV ECX,0x40
MOV RDI,R12
MOV EDX,0x1
XOR EAX,EAX
CALL 0x00117380
MOV RDI,R12
CALL 0x00117250
MOV RDI,RBX
MOV RSI,R12
MOV RDX,RAX
CALL 0x00117190
TEST EAX,EAX
JNZ 0x00121391
MOV qword ptr [RBX + 0x2f0],R15
JMP 0x00121398
LAB_0012134c:
LEA RAX,[0x14bd50]
MOV RDX,qword ptr [RAX]
LEA R9,[0x13af03]
MOV RDI,RBX
MOV ESI,0x7e3
XOR ECX,ECX
XOR R8D,R8D
JMP 0x0012138a
LAB_0012136c:
LEA RAX,[0x14bd50]
MOV RDX,qword ptr [RAX]
LEA R9,[0x13af03]
MOV RDI,RBX
MOV ESI,0x7e3
XOR ECX,ECX
MOV R8,R14
LAB_0012138a:
XOR EAX,EAX
CALL 0x0011cbd5
LAB_00121391:
MOV R14D,dword ptr [RBX + 0x90]
LAB_00121398:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x28]
JNZ 0x001213b7
MOV EAX,R14D
ADD RSP,0x50
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001213b7:
CALL 0x00117690
|
int4 mysql_set_character_set(long param_1,long param_2)
{
int iVar1;
long lVar2;
size_t sVar3;
int4 uVar4;
long in_FS_OFFSET;
char local_78 [72];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
if (param_2 == 0) {
param_2 = 0;
LAB_0012138a:
my_set_error(param_1,0x7e3,SQLSTATE_UNKNOWN,0,param_2,"compiled_in");
}
else {
lVar2 = mysql_find_charset_name(param_2);
if (lVar2 == 0) goto LAB_0012138a;
uVar4 = 0;
__snprintf_chk(local_78,0x3f,1,0x40,"SET NAMES %s",*(int8 *)(lVar2 + 8));
sVar3 = strlen(local_78);
iVar1 = mysql_real_query(param_1,local_78,sVar3);
if (iVar1 == 0) {
*(long *)(param_1 + 0x2f0) = lVar2;
goto LAB_00121398;
}
}
uVar4 = *(int4 *)(param_1 + 0x90);
LAB_00121398:
if (*(long *)(in_FS_OFFSET + 0x28) != local_30) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar4;
}
| |
24,810 | mysql_list_dbs_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_list_dbs_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_list_dbs,
(parms->mysql, parms->wild),
parms->mysql,
MYSQL_RES *,
r_ptr)
} | O3 | c | mysql_list_dbs_start_internal:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rsi
movq 0x480(%rax), %rcx
movq 0x28(%rcx), %rbx
movq %rax, %rdi
callq 0x8c4c1
movq %rax, 0x8(%rbx)
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| mysql_list_dbs_start_internal:
push rbp
mov rbp, rsp
push rbx
push rax
mov rax, [rdi]
mov rsi, [rdi+8]
mov rcx, [rax+480h]
mov rbx, [rcx+28h]
mov rdi, rax
call mysql_list_dbs
mov [rbx+8], rax
mov dword ptr [rbx], 0
add rsp, 8
pop rbx
pop rbp
retn
| long long mysql_list_dbs_start_internal(long long a1)
{
long long v1; // rbx
long long result; // rax
v1 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 1152LL) + 40LL);
result = mysql_list_dbs(*(_QWORD *)a1, *(const char **)(a1 + 8));
*(_QWORD *)(v1 + 8) = result;
*(_DWORD *)v1 = 0;
return result;
}
| mysql_list_dbs_start_internal:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RAX,qword ptr [RDI]
MOV RSI,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RAX + 0x480]
MOV RBX,qword ptr [RCX + 0x28]
MOV RDI,RAX
CALL 0x0018c4c1
MOV qword ptr [RBX + 0x8],RAX
MOV dword ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void mysql_list_dbs_start_internal(long *param_1)
{
int4 *puVar1;
int8 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_list_dbs(*param_1,param_1[1]);
*(int8 *)(puVar1 + 2) = uVar2;
*puVar1 = 0;
return;
}
| |
24,811 | ma_ft_add | eloqsql/storage/maria/ma_ft_update.c | int _ma_ft_add(MARIA_HA *info, uint keynr, uchar *keybuf, const uchar *record,
my_off_t pos)
{
int error= -1;
FT_WORD *wlist;
DBUG_ENTER("_ma_ft_add");
DBUG_PRINT("enter",("keynr: %d",keynr));
if ((wlist= _ma_ft_parserecord(info, keynr, record, &info->ft_memroot)))
error= _ma_ft_store(info,keynr,keybuf,wlist,pos);
free_root(&info->ft_memroot, MYF(MY_MARK_BLOCKS_FREE));
DBUG_PRINT("exit",("Return: %d",error));
DBUG_RETURN(error);
} | O3 | c | ma_ft_add:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
leaq 0x328(%rdi), %rbx
movq %rcx, %rdx
movq %rbx, %rcx
callq 0x6a4a8
testq %rax, %rax
je 0x6a9e5
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movq %rax, %rcx
movq %r14, %r8
callq 0x6a922
movl %eax, %r14d
jmp 0x6a9eb
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
movl $0x2, %esi
movq %rbx, %rdi
callq 0x9cdf7
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ma_ft_add:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, r8
mov r15, rdx
mov r12d, esi
mov r13, rdi
lea rbx, [rdi+328h]
mov rdx, rcx
mov rcx, rbx
call _ma_ft_parserecord
test rax, rax
jz short loc_6A9E5
mov rdi, r13
mov esi, r12d
mov rdx, r15
mov rcx, rax
mov r8, r14
call _ma_ft_store
mov r14d, eax
jmp short loc_6A9EB
loc_6A9E5:
mov r14d, 0FFFFFFFFh
loc_6A9EB:
mov esi, 2
mov rdi, rbx
call free_root
mov eax, r14d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ma_ft_add(_QWORD *a1, unsigned int a2, char *a3, long long a4, long long a5, __m128i a6)
{
_QWORD *v8; // rax
unsigned int v9; // r14d
v8 = ma_ft_parserecord(a1, a2, a4, (long long)(a1 + 101));
if ( v8 )
v9 = ma_ft_store(a1, a2, a3, v8, a5, a6);
else
v9 = -1;
free_root(a1 + 101, 2LL);
return v9;
}
| _ma_ft_add:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,R8
MOV R15,RDX
MOV R12D,ESI
MOV R13,RDI
LEA RBX,[RDI + 0x328]
MOV RDX,RCX
MOV RCX,RBX
CALL 0x0016a4a8
TEST RAX,RAX
JZ 0x0016a9e5
MOV RDI,R13
MOV ESI,R12D
MOV RDX,R15
MOV RCX,RAX
MOV R8,R14
CALL 0x0016a922
MOV R14D,EAX
JMP 0x0016a9eb
LAB_0016a9e5:
MOV R14D,0xffffffff
LAB_0016a9eb:
MOV ESI,0x2
MOV RDI,RBX
CALL 0x0019cdf7
MOV EAX,R14D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int4
_ma_ft_add(long param_1,ulong param_2,int8 param_3,int8 param_4,int8 param_5)
{
int4 uVar1;
long lVar2;
lVar2 = _ma_ft_parserecord(param_1,param_2,param_4,param_1 + 0x328);
if (lVar2 == 0) {
uVar1 = 0xffffffff;
}
else {
uVar1 = _ma_ft_store(param_1,param_2 & 0xffffffff,param_3,lVar2,param_5);
}
free_root(param_1 + 0x328,2);
return uVar1;
}
| |
24,812 | test_proxy_header | eloqsql/tests/mysql_client_test.c | static void test_proxy_header()
{
myheader("test_proxy_header");
test_proxy_header_tcp("192.0.2.1",3333);
test_proxy_header_tcp("2001:db8:85a3::8a2e:370:7334",2222);
test_proxy_header_tcp("::ffff:192.0.2.1",2222);
test_proxy_header_localhost();
test_proxy_header_ignore();
} | O0 | c | test_proxy_header:
pushq %rbp
movq %rsp, %rbp
jmp 0x98e86
jmp 0x98e88
movsbl 0x3d1642(%rip), %eax # 0x46a4d1
cmpl $0x2, %eax
jge 0x98f10
movq 0x21613d(%rip), %rax # 0x2aefd8
movq (%rax), %rdi
leaq 0x9547f(%rip), %rsi # 0x12e324
movb $0x0, %al
callq 0x3a1c0
movq 0x216125(%rip), %rax # 0x2aefd8
movq (%rax), %rdi
movl 0x3d1860(%rip), %edx # 0x46a71c
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x3d1855(%rip) # 0x46a71c
movl 0x3d184b(%rip), %ecx # 0x46a718
movl 0x3d1628(%rip), %r8d # 0x46a4fc
leaq 0x96751(%rip), %rsi # 0x12f62c
leaq 0x9662c(%rip), %r9 # 0x12f50e
movb $0x0, %al
callq 0x3a1c0
movq 0x2160e8(%rip), %rax # 0x2aefd8
movq (%rax), %rdi
leaq 0x95462(%rip), %rsi # 0x12e35c
movb $0x0, %al
callq 0x3a1c0
movq 0x2160d0(%rip), %rax # 0x2aefd8
movq (%rax), %rdi
callq 0x3a4a0
leaq 0xac896(%rip), %rdi # 0x1457ad
movl $0xd05, %esi # imm = 0xD05
callq 0x98f50
leaq 0xac861(%rip), %rdi # 0x145789
movl $0x8ae, %esi # imm = 0x8AE
callq 0x98f50
leaq 0xac86d(%rip), %rdi # 0x1457a6
movl $0x8ae, %esi # imm = 0x8AE
callq 0x98f50
callq 0x995b0
callq 0x99950
popq %rbp
retq
nop
| test_proxy_header:
push rbp
mov rbp, rsp
jmp short $+2
loc_98E86:
jmp short $+2
loc_98E88:
movsx eax, cs:opt_silent
cmp eax, 2
jge short loc_98F10
mov rax, cs:stdout_ptr
mov rdi, [rax]
lea rsi, asc_12E324; "\n\n###################################"...
mov al, 0
call _fprintf
mov rax, cs:stdout_ptr
mov rdi, [rax]
mov edx, cs:test_count
mov eax, edx
add eax, 1
mov cs:test_count, eax
mov ecx, cs:iter_count
mov r8d, cs:opt_count
lea rsi, aUOfUUS; "%u of (%u/%u): %s"
lea r9, aTestProxyHeade; "test_proxy_header"
mov al, 0
call _fprintf
mov rax, cs:stdout_ptr
mov rdi, [rax]
lea rsi, asc_12E35C; " \n###################################"...
mov al, 0
call _fprintf
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
loc_98F10:
lea rdi, aFfff192021+7; "192.0.2.1"
mov esi, 0D05h
call test_proxy_header_tcp
lea rdi, a2001Db885a38a2; "2001:db8:85a3::8a2e:370:7334"
mov esi, 8AEh
call test_proxy_header_tcp
lea rdi, aFfff192021; "::ffff:192.0.2.1"
mov esi, 8AEh
call test_proxy_header_tcp
call test_proxy_header_localhost
call test_proxy_header_ignore
pop rbp
retn
| long long test_proxy_header()
{
int v0; // edx
if ( opt_silent < 2 )
{
fprintf(stdout, "\n\n#####################################\n");
v0 = test_count++;
fprintf(stdout, "%u of (%u/%u): %s", v0, iter_count, opt_count, "test_proxy_header");
fprintf(stdout, " \n#####################################\n");
fflush(stdout);
}
test_proxy_header_tcp("192.0.2.1", 3333LL);
test_proxy_header_tcp("2001:db8:85a3::8a2e:370:7334", 2222LL);
test_proxy_header_tcp("::ffff:192.0.2.1", 2222LL);
test_proxy_header_localhost();
return test_proxy_header_ignore();
}
| test_proxy_header:
PUSH RBP
MOV RBP,RSP
JMP 0x00198e86
LAB_00198e86:
JMP 0x00198e88
LAB_00198e88:
MOVSX EAX,byte ptr [0x0056a4d1]
CMP EAX,0x2
JGE 0x00198f10
MOV RAX,qword ptr [0x003aefd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x22e324]
MOV AL,0x0
CALL 0x0013a1c0
MOV RAX,qword ptr [0x003aefd8]
MOV RDI,qword ptr [RAX]
MOV EDX,dword ptr [0x0056a71c]
MOV EAX,EDX
ADD EAX,0x1
MOV dword ptr [0x0056a71c],EAX
MOV ECX,dword ptr [0x0056a718]
MOV R8D,dword ptr [0x0056a4fc]
LEA RSI,[0x22f62c]
LEA R9,[0x22f50e]
MOV AL,0x0
CALL 0x0013a1c0
MOV RAX,qword ptr [0x003aefd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x22e35c]
MOV AL,0x0
CALL 0x0013a1c0
MOV RAX,qword ptr [0x003aefd8]
MOV RDI,qword ptr [RAX]
CALL 0x0013a4a0
LAB_00198f10:
LEA RDI,[0x2457ad]
MOV ESI,0xd05
CALL 0x00198f50
LEA RDI,[0x245789]
MOV ESI,0x8ae
CALL 0x00198f50
LEA RDI,[0x2457a6]
MOV ESI,0x8ae
CALL 0x00198f50
CALL 0x001995b0
CALL 0x00199950
POP RBP
RET
|
void test_proxy_header(void)
{
ulong uVar1;
if (opt_silent < '\x02') {
fprintf(*(FILE **)PTR_stdout_003aefd8,"\n\n#####################################\n");
uVar1 = (ulong)test_count;
test_count = test_count + 1;
fprintf(*(FILE **)PTR_stdout_003aefd8,"%u of (%u/%u): %s",uVar1,(ulong)iter_count,
(ulong)opt_count,"test_proxy_header");
fprintf(*(FILE **)PTR_stdout_003aefd8," \n#####################################\n");
fflush(*(FILE **)PTR_stdout_003aefd8);
}
test_proxy_header_tcp(&DAT_002457ad,0xd05);
test_proxy_header_tcp("2001:db8:85a3::8a2e:370:7334",0x8ae);
test_proxy_header_tcp(&DAT_002457a6,0x8ae);
test_proxy_header_localhost();
test_proxy_header_ignore();
return;
}
| |
24,813 | pagecache_unlock | eloqsql/storage/maria/ma_pagecache.c | void pagecache_unlock(PAGECACHE *pagecache,
PAGECACHE_FILE *file,
pgcache_page_no_t pageno,
enum pagecache_page_lock lock,
enum pagecache_page_pin pin,
LSN first_REDO_LSN_for_page,
LSN lsn, my_bool was_changed)
{
PAGECACHE_BLOCK_LINK *block;
int page_st;
DBUG_ENTER("pagecache_unlock");
DBUG_PRINT("enter", ("fd: %u page: %lu %s %s",
(uint) file->file, (ulong) pageno,
page_cache_page_lock_str[lock],
page_cache_page_pin_str[pin]));
/* we do not allow any lock/pin increasing here */
DBUG_ASSERT(pin != PAGECACHE_PIN);
DBUG_ASSERT(lock != PAGECACHE_LOCK_READ && lock != PAGECACHE_LOCK_WRITE);
pagecache_pthread_mutex_lock(&pagecache->cache_lock);
/*
As soon as we keep lock cache can be used, and we have lock because want
to unlock.
*/
DBUG_ASSERT(pagecache->can_be_used);
inc_counter_for_resize_op(pagecache);
/* See NOTE for pagecache_unlock about registering requests */
block= find_block(pagecache, file, pageno, 0, 0, 0,
pin == PAGECACHE_PIN_LEFT_UNPINNED, FALSE, &page_st);
PCBLOCK_INFO(block);
DBUG_ASSERT(block != 0 && page_st == PAGE_READ);
if (first_REDO_LSN_for_page)
{
DBUG_ASSERT(lock == PAGECACHE_LOCK_WRITE_UNLOCK);
DBUG_ASSERT(pin == PAGECACHE_UNPIN);
pagecache_set_block_rec_lsn(block, first_REDO_LSN_for_page);
}
if (lsn != LSN_IMPOSSIBLE)
check_and_set_lsn(pagecache, lsn, block);
/* if we lock for write we must link the block to changed blocks */
DBUG_ASSERT((block->status & PCBLOCK_DIRECT_W) == 0 ||
(lock == PAGECACHE_LOCK_WRITE_UNLOCK ||
lock == PAGECACHE_LOCK_WRITE_TO_READ ||
lock == PAGECACHE_LOCK_LEFT_WRITELOCKED));
/*
if was_changed then status should be PCBLOCK_DIRECT_W or marked
as dirty
*/
DBUG_ASSERT(!was_changed || (block->status & PCBLOCK_DIRECT_W) ||
(block->status & PCBLOCK_CHANGED));
if ((block->status & PCBLOCK_DIRECT_W) &&
(lock == PAGECACHE_LOCK_WRITE_UNLOCK ||
lock == PAGECACHE_LOCK_WRITE_TO_READ))
{
if (!(block->status & PCBLOCK_CHANGED) && was_changed)
link_to_changed_list(pagecache, block);
block->status&= ~PCBLOCK_DIRECT_W;
DBUG_PRINT("info", ("Drop PCBLOCK_DIRECT_W for block: %p", block));
}
if (make_lock_and_pin(pagecache, block, lock, pin, FALSE))
{
DBUG_ASSERT(0); /* should not happend */
}
remove_reader(block);
/*
Link the block into the LRU chain if it's the last submitted request
for the block and block will not be pinned.
See NOTE for pagecache_unlock about registering requests.
*/
if (pin != PAGECACHE_PIN_LEFT_PINNED)
unreg_request(pagecache, block, 1);
dec_counter_for_resize_op(pagecache);
pagecache_pthread_mutex_unlock(&pagecache->cache_lock);
DBUG_VOID_RETURN;
} | O0 | c | pagecache_unlock:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb 0x18(%rbp), %al
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
jmp 0x57738
jmp 0x5773a
jmp 0x5773c
jmp 0x5773e
jmp 0x57740
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
leaq 0xf9e75(%rip), %rsi # 0x1515c7
movl $0xc97, %edx # imm = 0xC97
callq 0x57500
jmp 0x5775e
movq -0x8(%rbp), %rdi
callq 0x578b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
cmpl $0x1, -0x20(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movb %al, %r10b
xorl %r9d, %r9d
leaq -0x34(%rbp), %rax
movl %r9d, %ecx
movl %r9d, %r8d
movsbl %r10b, %r10d
movl %r10d, (%rsp)
movl $0x0, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x578d0
movq %rax, -0x30(%rbp)
jmp 0x577af
jmp 0x577b1
jmp 0x577b3
cmpq $0x0, -0x28(%rbp)
je 0x577cf
jmp 0x577bc
jmp 0x577be
jmp 0x577c0
jmp 0x577c2
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x580e0
cmpq $0x0, 0x10(%rbp)
je 0x577e7
movq -0x8(%rbp), %rdi
movq 0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x58120
jmp 0x577e9
jmp 0x577eb
jmp 0x577ed
jmp 0x577ef
movq -0x30(%rbp), %rax
movzwl 0x74(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x57844
cmpl $0x6, -0x1c(%rbp)
je 0x5780b
cmpl $0x7, -0x1c(%rbp)
jne 0x57844
movq -0x30(%rbp), %rax
movzwl 0x74(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
jne 0x57831
movsbl 0x18(%rbp), %eax
cmpl $0x0, %eax
je 0x57831
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x58230
movq -0x30(%rbp), %rax
movzwl 0x74(%rax), %ecx
andl $-0x41, %ecx
movw %cx, 0x74(%rax)
jmp 0x57842
jmp 0x57844
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
xorl %r8d, %r8d
callq 0x582c0
cmpb $0x0, %al
je 0x57864
jmp 0x57860
jmp 0x57862
jmp 0x57864
movq -0x30(%rbp), %rdi
callq 0x58410
cmpl $0x0, -0x20(%rbp)
je 0x57885
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl $0x1, %edx
callq 0x58460
movq -0x8(%rbp), %rdi
callq 0x585e0
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
callq 0x57570
jmp 0x578a0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| pagecache_unlock:
push rbp
mov rbp, rsp
sub rsp, 50h
mov al, [rbp+arg_8]
mov rax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov [rbp+var_20], r8d
mov [rbp+var_28], r9
jmp short $+2
loc_57738:
jmp short $+2
loc_5773A:
jmp short $+2
loc_5773C:
jmp short $+2
loc_5773E:
jmp short $+2
loc_57740:
mov rdi, [rbp+var_8]
add rdi, 0C8h
lea rsi, aWorkspaceLlm4b_11; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0C97h
call inline_mysql_mutex_lock_8
jmp short $+2
loc_5775E:
mov rdi, [rbp+var_8]
call inc_counter_for_resize_op
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
cmp [rbp+var_20], 1
setz al
and al, 1
movzx eax, al
mov r10b, al
xor r9d, r9d
lea rax, [rbp+var_34]
mov ecx, r9d
mov r8d, r9d
movsx r10d, r10b
mov [rsp+50h+var_50], r10d
mov [rsp+50h+var_48], 0
mov [rsp+50h+var_40], rax
call find_block
mov [rbp+var_30], rax
jmp short $+2
loc_577AF:
jmp short $+2
loc_577B1:
jmp short $+2
loc_577B3:
cmp [rbp+var_28], 0
jz short loc_577CF
jmp short $+2
loc_577BC:
jmp short $+2
loc_577BE:
jmp short $+2
loc_577C0:
jmp short $+2
loc_577C2:
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_28]
call pagecache_set_block_rec_lsn
loc_577CF:
cmp [rbp+arg_0], 0
jz short loc_577E7
mov rdi, [rbp+var_8]
mov rsi, [rbp+arg_0]
mov rdx, [rbp+var_30]
call check_and_set_lsn
loc_577E7:
jmp short $+2
loc_577E9:
jmp short $+2
loc_577EB:
jmp short $+2
loc_577ED:
jmp short $+2
loc_577EF:
mov rax, [rbp+var_30]
movzx eax, word ptr [rax+74h]
and eax, 40h
cmp eax, 0
jz short loc_57844
cmp [rbp+var_1C], 6
jz short loc_5780B
cmp [rbp+var_1C], 7
jnz short loc_57844
loc_5780B:
mov rax, [rbp+var_30]
movzx eax, word ptr [rax+74h]
and eax, 20h
cmp eax, 0
jnz short loc_57831
movsx eax, [rbp+arg_8]
cmp eax, 0
jz short loc_57831
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_30]
call link_to_changed_list
loc_57831:
mov rax, [rbp+var_30]
movzx ecx, word ptr [rax+74h]
and ecx, 0FFFFFFBFh
mov [rax+74h], cx
jmp short $+2
loc_57842:
jmp short $+2
loc_57844:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_30]
mov edx, [rbp+var_1C]
mov ecx, [rbp+var_20]
xor r8d, r8d
call make_lock_and_pin
cmp al, 0
jz short loc_57864
jmp short $+2
loc_57860:
jmp short $+2
loc_57862:
jmp short $+2
loc_57864:
mov rdi, [rbp+var_30]
call remove_reader
cmp [rbp+var_20], 0
jz short loc_57885
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_30]
mov edx, 1
call unreg_request
loc_57885:
mov rdi, [rbp+var_8]
call dec_counter_for_resize_op
mov rdi, [rbp+var_8]
add rdi, 0C8h
call inline_mysql_mutex_unlock_8
jmp short $+2
loc_578A0:
add rsp, 50h
pop rbp
retn
| long long pagecache_unlock(
long long a1,
long long a2,
long long a3,
unsigned int a4,
unsigned int a5,
long long a6,
long long a7,
char a8)
{
_BYTE v9[4]; // [rsp+1Ch] [rbp-34h] BYREF
long long block; // [rsp+20h] [rbp-30h]
long long v11; // [rsp+28h] [rbp-28h]
unsigned int v12; // [rsp+30h] [rbp-20h]
unsigned int v13; // [rsp+34h] [rbp-1Ch]
long long v14; // [rsp+38h] [rbp-18h]
long long v15; // [rsp+40h] [rbp-10h]
long long v16; // [rsp+48h] [rbp-8h]
v16 = a1;
v15 = a2;
v14 = a3;
v13 = a4;
v12 = a5;
v11 = a6;
inline_mysql_mutex_lock_8(
a1 + 200,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0xC97u);
inc_counter_for_resize_op(a1);
block = find_block(a1, a2, v14, 0, 0, 0, v12 == 1, 0, (long long)v9);
if ( v11 )
pagecache_set_block_rec_lsn(block, v11);
if ( a7 )
check_and_set_lsn(v16, a7, block);
if ( (*(_WORD *)(block + 116) & 0x40) != 0 && (v13 == 6 || v13 == 7) )
{
if ( (*(_WORD *)(block + 116) & 0x20) == 0 && a8 )
link_to_changed_list(v16, block);
*(_WORD *)(block + 116) &= ~0x40u;
}
make_lock_and_pin(v16, block, v13, v12, 0LL);
remove_reader(block);
if ( v12 )
unreg_request(v16, block, 1LL);
dec_counter_for_resize_op(v16);
return inline_mysql_mutex_unlock_8(v16 + 200);
}
| pagecache_unlock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV AL,byte ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV dword ptr [RBP + -0x20],R8D
MOV qword ptr [RBP + -0x28],R9
JMP 0x00157738
LAB_00157738:
JMP 0x0015773a
LAB_0015773a:
JMP 0x0015773c
LAB_0015773c:
JMP 0x0015773e
LAB_0015773e:
JMP 0x00157740
LAB_00157740:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc8
LEA RSI,[0x2515c7]
MOV EDX,0xc97
CALL 0x00157500
JMP 0x0015775e
LAB_0015775e:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001578b0
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CMP dword ptr [RBP + -0x20],0x1
SETZ AL
AND AL,0x1
MOVZX EAX,AL
MOV R10B,AL
XOR R9D,R9D
LEA RAX,[RBP + -0x34]
MOV ECX,R9D
MOV R8D,R9D
MOVSX R10D,R10B
MOV dword ptr [RSP],R10D
MOV dword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x10],RAX
CALL 0x001578d0
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001577af
LAB_001577af:
JMP 0x001577b1
LAB_001577b1:
JMP 0x001577b3
LAB_001577b3:
CMP qword ptr [RBP + -0x28],0x0
JZ 0x001577cf
JMP 0x001577bc
LAB_001577bc:
JMP 0x001577be
LAB_001577be:
JMP 0x001577c0
LAB_001577c0:
JMP 0x001577c2
LAB_001577c2:
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x001580e0
LAB_001577cf:
CMP qword ptr [RBP + 0x10],0x0
JZ 0x001577e7
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + 0x10]
MOV RDX,qword ptr [RBP + -0x30]
CALL 0x00158120
LAB_001577e7:
JMP 0x001577e9
LAB_001577e9:
JMP 0x001577eb
LAB_001577eb:
JMP 0x001577ed
LAB_001577ed:
JMP 0x001577ef
LAB_001577ef:
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,word ptr [RAX + 0x74]
AND EAX,0x40
CMP EAX,0x0
JZ 0x00157844
CMP dword ptr [RBP + -0x1c],0x6
JZ 0x0015780b
CMP dword ptr [RBP + -0x1c],0x7
JNZ 0x00157844
LAB_0015780b:
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,word ptr [RAX + 0x74]
AND EAX,0x20
CMP EAX,0x0
JNZ 0x00157831
MOVSX EAX,byte ptr [RBP + 0x18]
CMP EAX,0x0
JZ 0x00157831
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x30]
CALL 0x00158230
LAB_00157831:
MOV RAX,qword ptr [RBP + -0x30]
MOVZX ECX,word ptr [RAX + 0x74]
AND ECX,0xffffffbf
MOV word ptr [RAX + 0x74],CX
JMP 0x00157842
LAB_00157842:
JMP 0x00157844
LAB_00157844:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x30]
MOV EDX,dword ptr [RBP + -0x1c]
MOV ECX,dword ptr [RBP + -0x20]
XOR R8D,R8D
CALL 0x001582c0
CMP AL,0x0
JZ 0x00157864
JMP 0x00157860
LAB_00157860:
JMP 0x00157862
LAB_00157862:
JMP 0x00157864
LAB_00157864:
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00158410
CMP dword ptr [RBP + -0x20],0x0
JZ 0x00157885
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x30]
MOV EDX,0x1
CALL 0x00158460
LAB_00157885:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001585e0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc8
CALL 0x00157570
JMP 0x001578a0
LAB_001578a0:
ADD RSP,0x50
POP RBP
RET
|
void pagecache_unlock(long param_1,int8 param_2,int8 param_3,int param_4,int param_5,
long param_6,long param_7,char param_8)
{
int1 local_3c [4];
long local_38;
long local_30;
int local_28;
int local_24;
int8 local_20;
int8 local_18;
long local_10;
local_30 = param_6;
local_28 = param_5;
local_24 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
inline_mysql_mutex_lock
(param_1 + 200,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0xc97);
inc_counter_for_resize_op(local_10);
local_38 = find_block(local_10,local_18,local_20,0,0,0,local_28 == 1,0,local_3c);
if (local_30 != 0) {
pagecache_set_block_rec_lsn(local_38,local_30);
}
if (param_7 != 0) {
check_and_set_lsn(local_10,param_7,local_38);
}
if (((*(ushort *)(local_38 + 0x74) & 0x40) != 0) && ((local_24 == 6 || (local_24 == 7)))) {
if (((*(ushort *)(local_38 + 0x74) & 0x20) == 0) && (param_8 != '\0')) {
link_to_changed_list(local_10,local_38);
}
*(ushort *)(local_38 + 0x74) = *(ushort *)(local_38 + 0x74) & 0xffbf;
}
make_lock_and_pin(local_10,local_38,local_24,local_28,0);
remove_reader(local_38);
if (local_28 != 0) {
unreg_request(local_10,local_38,1);
}
dec_counter_for_resize_op(local_10);
inline_mysql_mutex_unlock(local_10 + 200);
return;
}
| |
24,814 | lf_alloc_init | eloqsql/mysys/lf_alloc-pin.c | void lf_alloc_init(LF_ALLOCATOR *allocator, uint size, uint free_ptr_offset)
{
lf_pinbox_init(&allocator->pinbox, free_ptr_offset,
(lf_pinbox_free_func *)alloc_free, allocator);
allocator->top= 0;
allocator->mallocs= 0;
allocator->element_size= size;
allocator->constructor= 0;
allocator->destructor= 0;
DBUG_ASSERT(size >= sizeof(void*) + free_ptr_offset);
} | O3 | c | lf_alloc_init:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
movl $0x78, %esi
callq 0xa5b28
xorl %eax, %eax
movl %eax, 0x3c(%r15)
movl %eax, 0x40(%r15)
movl %ebx, 0x38(%r15)
leaq 0x2b(%rip), %rcx # 0xa5936
movq %rcx, 0x28(%r15)
movq %r15, 0x30(%r15)
movq $0x0, 0x48(%r15)
movl %eax, 0x54(%r15)
movl %r14d, 0x50(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| lf_alloc_init:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov ebx, edx
mov r14d, esi
mov r15, rdi
mov esi, 78h ; 'x'
call lf_dynarray_init
xor eax, eax
mov [r15+3Ch], eax
mov [r15+40h], eax
mov [r15+38h], ebx
lea rcx, alloc_free
mov [r15+28h], rcx
mov [r15+30h], r15
mov qword ptr [r15+48h], 0
mov [r15+54h], eax
mov [r15+50h], r14d
xorps xmm0, xmm0
movups xmmword ptr [r15+58h], xmm0
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long lf_alloc_init(long long a1, int a2, int a3)
{
long long result; // rax
lf_dynarray_init(a1, 120LL);
result = 0LL;
*(_DWORD *)(a1 + 60) = 0;
*(_DWORD *)(a1 + 64) = 0;
*(_DWORD *)(a1 + 56) = a3;
*(_QWORD *)(a1 + 40) = alloc_free;
*(_QWORD *)(a1 + 48) = a1;
*(_QWORD *)(a1 + 72) = 0LL;
*(_DWORD *)(a1 + 84) = 0;
*(_DWORD *)(a1 + 80) = a2;
*(_OWORD *)(a1 + 88) = 0LL;
return result;
}
| lf_alloc_init:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EBX,EDX
MOV R14D,ESI
MOV R15,RDI
MOV ESI,0x78
CALL 0x001a5b28
XOR EAX,EAX
MOV dword ptr [R15 + 0x3c],EAX
MOV dword ptr [R15 + 0x40],EAX
MOV dword ptr [R15 + 0x38],EBX
LEA RCX,[0x1a5936]
MOV qword ptr [R15 + 0x28],RCX
MOV qword ptr [R15 + 0x30],R15
MOV qword ptr [R15 + 0x48],0x0
MOV dword ptr [R15 + 0x54],EAX
MOV dword ptr [R15 + 0x50],R14D
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R15 + 0x58],XMM0
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void lf_alloc_init(long param_1,int4 param_2,int4 param_3)
{
lf_dynarray_init(param_1,0x78);
*(int4 *)(param_1 + 0x3c) = 0;
*(int4 *)(param_1 + 0x40) = 0;
*(int4 *)(param_1 + 0x38) = param_3;
*(code **)(param_1 + 0x28) = alloc_free;
*(long *)(param_1 + 0x30) = param_1;
*(int8 *)(param_1 + 0x48) = 0;
*(int4 *)(param_1 + 0x54) = 0;
*(int4 *)(param_1 + 0x50) = param_2;
*(int8 *)(param_1 + 0x58) = 0;
*(int8 *)(param_1 + 0x60) = 0;
return;
}
| |
24,815 | pvio_socket_close | eloqsql/libmariadb/plugins/pvio/pvio_socket.c | my_bool pvio_socket_close(MARIADB_PVIO *pvio)
{
struct st_pvio_socket *csock= NULL;
int r= 0;
if (!pvio)
return 1;
if (pvio->data)
{
csock= (struct st_pvio_socket *)pvio->data;
if (csock && csock->socket != INVALID_SOCKET)
{
r= closesocket(csock->socket);
csock->socket= INVALID_SOCKET;
}
free((gptr)pvio->data);
pvio->data= NULL;
}
return r;
} | O3 | c | pvio_socket_close:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x19547
movq %rdi, %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0x1954c
movl (%r15), %edi
cmpl $-0x1, %edi
je 0x19551
callq 0x17b40
movl %eax, %r14d
movl $0xffffffff, (%r15) # imm = 0xFFFFFFFF
movq (%rbx), %r15
jmp 0x19554
movb $0x1, %r14b
jmp 0x19563
xorl %r14d, %r14d
jmp 0x19563
xorl %r14d, %r14d
movq %r15, %rdi
callq 0x17710
movq $0x0, (%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| pvio_socket_close:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
test rdi, rdi
jz short loc_19547
mov rbx, rdi
mov r15, [rdi]
test r15, r15
jz short loc_1954C
mov edi, [r15]
cmp edi, 0FFFFFFFFh
jz short loc_19551
call _close
mov r14d, eax
mov dword ptr [r15], 0FFFFFFFFh
mov r15, [rbx]
jmp short loc_19554
loc_19547:
mov r14b, 1
jmp short loc_19563
loc_1954C:
xor r14d, r14d
jmp short loc_19563
loc_19551:
xor r14d, r14d
loc_19554:
mov rdi, r15
call _free
mov qword ptr [rbx], 0
loc_19563:
mov eax, r14d
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long pvio_socket_close(_DWORD **a1)
{
unsigned int v1; // r14d
_DWORD *v3; // r15
long long v4; // rdi
if ( a1 )
{
v3 = *a1;
if ( *a1 )
{
v4 = (unsigned int)*v3;
if ( (_DWORD)v4 == -1 )
{
v1 = 0;
}
else
{
v1 = close(v4);
*v3 = -1;
v3 = *a1;
}
free(v3);
*a1 = 0LL;
}
else
{
return 0;
}
}
else
{
LOBYTE(v1) = 1;
}
return v1;
}
| pvio_socket_close:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
TEST RDI,RDI
JZ 0x00119547
MOV RBX,RDI
MOV R15,qword ptr [RDI]
TEST R15,R15
JZ 0x0011954c
MOV EDI,dword ptr [R15]
CMP EDI,-0x1
JZ 0x00119551
CALL 0x00117b40
MOV R14D,EAX
MOV dword ptr [R15],0xffffffff
MOV R15,qword ptr [RBX]
JMP 0x00119554
LAB_00119547:
MOV R14B,0x1
JMP 0x00119563
LAB_0011954c:
XOR R14D,R14D
JMP 0x00119563
LAB_00119551:
XOR R14D,R14D
LAB_00119554:
MOV RDI,R15
CALL 0x00117710
MOV qword ptr [RBX],0x0
LAB_00119563:
MOV EAX,R14D
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
ulong pvio_socket_close(int8 *param_1)
{
uint uVar1;
int8 unaff_R14;
ulong uVar2;
int *__ptr;
if (param_1 == (int8 *)0x0) {
uVar2 = CONCAT71((int7)((ulong)unaff_R14 >> 8),1);
}
else {
__ptr = (int *)*param_1;
if (__ptr == (int *)0x0) {
uVar2 = 0;
}
else {
if (*__ptr == -1) {
uVar2 = 0;
}
else {
uVar1 = close(*__ptr);
uVar2 = (ulong)uVar1;
*__ptr = -1;
__ptr = (int *)*param_1;
}
free(__ptr);
*param_1 = 0;
}
}
return uVar2 & 0xffffffff;
}
| |
24,816 | void OpenSubdiv::v3_6_0::Vtr::internal::(anonymous namespace)::printIndexArray<int>(OpenSubdiv::v3_6_0::Vtr::ConstArray<int> const&) | NVIDIA-RTX[P]OSD-Lite/opensubdiv/vtr/level.cpp | void
printIndexArray(ConstArray<INT_TYPE> const& array) {
printf("%d [%d", array.size(), array[0]);
for (int i = 1; i < array.size(); ++i) {
printf(" %d", array[i]);
}
printf("]\n");
} | O1 | cpp | void OpenSubdiv::v3_6_0::Vtr::internal::(anonymous namespace)::printIndexArray<int>(OpenSubdiv::v3_6_0::Vtr::ConstArray<int> const&):
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %esi
movq (%rdi), %rax
movl (%rax), %edx
leaq 0x70ab9(%rip), %rdi # 0xb3773
xorl %eax, %eax
callq 0x38100
cmpl $0x2, 0x8(%rbx)
jl 0x42cf1
movl $0x1, %r15d
leaq 0x702f1(%rip), %r14 # 0xb2fc5
movq (%rbx), %rax
movl (%rax,%r15,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x38100
incq %r15
movslq 0x8(%rbx), %rax
cmpq %rax, %r15
jl 0x42cd4
leaq 0x832a2(%rip), %rdi # 0xc5f9a
popq %rbx
popq %r14
popq %r15
jmp 0x3b430
| _ZN10OpenSubdiv6v3_6_03Vtr8internal12_GLOBAL__N_115printIndexArrayIiEEvRKNS1_10ConstArrayIT_EE:
push r15
push r14
push rbx
mov rbx, rdi
mov esi, [rdi+8]
mov rax, [rdi]
mov edx, [rax]
lea rdi, aDD; "%d [%d"
xor eax, eax
call _printf
cmp dword ptr [rbx+8], 2
jl short loc_42CF1
mov r15d, 1
lea r14, aNonmanifoldD+0Fh; " %d"
loc_42CD4:
mov rax, [rbx]
mov esi, [rax+r15*4]
mov rdi, r14
xor eax, eax
call _printf
inc r15
movsxd rax, dword ptr [rbx+8]
cmp r15, rax
jl short loc_42CD4
loc_42CF1:
lea rdi, aPlanstable0+0Eh; "]"
pop rbx
pop r14
pop r15
jmp _puts
| long long OpenSubdiv::v3_6_0::Vtr::internal::`anonymous namespace'::printIndexArray<int>(long long a1)
{
long long v1; // r15
printf("%d [%d", *(_DWORD *)(a1 + 8), **(_DWORD **)a1);
if ( *(int *)(a1 + 8) >= 2 )
{
v1 = 1LL;
do
printf(" %d", *(_DWORD *)(*(_QWORD *)a1 + 4 * v1++));
while ( v1 < *(int *)(a1 + 8) );
}
return puts("]");
}
| printIndexArray<int>:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV ESI,dword ptr [RDI + 0x8]
MOV RAX,qword ptr [RDI]
MOV EDX,dword ptr [RAX]
LEA RDI,[0x1b3773]
XOR EAX,EAX
CALL 0x00138100
CMP dword ptr [RBX + 0x8],0x2
JL 0x00142cf1
MOV R15D,0x1
LEA R14,[0x1b2fc5]
LAB_00142cd4:
MOV RAX,qword ptr [RBX]
MOV ESI,dword ptr [RAX + R15*0x4]
MOV RDI,R14
XOR EAX,EAX
CALL 0x00138100
INC R15
MOVSXD RAX,dword ptr [RBX + 0x8]
CMP R15,RAX
JL 0x00142cd4
LAB_00142cf1:
LEA RDI,[0x1c5f9a]
POP RBX
POP R14
POP R15
JMP 0x0013b430
|
/* void OpenSubdiv::v3_6_0::Vtr::internal::(anonymous
namespace)::printIndexArray<int>(OpenSubdiv::v3_6_0::Vtr::ConstArray<int> const&) */
void OpenSubdiv::v3_6_0::Vtr::internal::(anonymous_namespace)::printIndexArray<int>
(ConstArray *param_1)
{
long lVar1;
printf("%d [%d",(ulong)*(uint *)(param_1 + 8),(ulong)**(uint **)param_1);
if (1 < *(int *)(param_1 + 8)) {
lVar1 = 1;
do {
printf(" %d",(ulong)*(uint *)(*(long *)param_1 + lVar1 * 4));
lVar1 = lVar1 + 1;
} while (lVar1 < *(int *)(param_1 + 8));
}
puts("]");
return;
}
| |
24,817 | void OpenSubdiv::v3_6_0::Vtr::internal::(anonymous namespace)::printIndexArray<int>(OpenSubdiv::v3_6_0::Vtr::ConstArray<int> const&) | NVIDIA-RTX[P]OSD-Lite/opensubdiv/vtr/level.cpp | void
printIndexArray(ConstArray<INT_TYPE> const& array) {
printf("%d [%d", array.size(), array[0]);
for (int i = 1; i < array.size(); ++i) {
printf(" %d", array[i]);
}
printf("]\n");
} | O2 | cpp | void OpenSubdiv::v3_6_0::Vtr::internal::(anonymous namespace)::printIndexArray<int>(OpenSubdiv::v3_6_0::Vtr::ConstArray<int> const&):
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %esi
movq (%rdi), %rax
movl (%rax), %edx
leaq 0x61ecf(%rip), %rdi # 0xbd773
xorl %eax, %eax
callq 0x4f1b0
pushq $0x1
popq %r15
leaq 0x6170f(%rip), %r14 # 0xbcfc5
movslq 0x8(%rbx), %rax
cmpq %rax, %r15
jge 0x5b8d5
movq (%rbx), %rax
movl (%rax,%r15,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x4f1b0
incq %r15
jmp 0x5b8b6
leaq 0x7540e(%rip), %rdi # 0xd0cea
popq %rbx
popq %r14
popq %r15
jmp 0x544b0
| _ZN10OpenSubdiv6v3_6_03Vtr8internal12_GLOBAL__N_115printIndexArrayIiEEvRKNS1_10ConstArrayIT_EE:
push r15
push r14
push rbx
mov rbx, rdi
mov esi, [rdi+8]
mov rax, [rdi]
mov edx, [rax]
lea rdi, aDD; "%d [%d"
xor eax, eax
call _printf
push 1
pop r15
lea r14, aNonmanifoldD+0Fh; " %d"
loc_5B8B6:
movsxd rax, dword ptr [rbx+8]
cmp r15, rax
jge short loc_5B8D5
mov rax, [rbx]
mov esi, [rax+r15*4]
mov rdi, r14
xor eax, eax
call _printf
inc r15
jmp short loc_5B8B6
loc_5B8D5:
lea rdi, aPlanstable0+0Eh; "]"
pop rbx
pop r14
pop r15
jmp _puts
| long long OpenSubdiv::v3_6_0::Vtr::internal::`anonymous namespace'::printIndexArray<int>(long long a1)
{
long long i; // r15
printf("%d [%d", *(_DWORD *)(a1 + 8), **(_DWORD **)a1);
for ( i = 1LL; i < *(int *)(a1 + 8); ++i )
printf(" %d", *(_DWORD *)(*(_QWORD *)a1 + 4 * i));
return puts("]");
}
| printIndexArray<int>:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV ESI,dword ptr [RDI + 0x8]
MOV RAX,qword ptr [RDI]
MOV EDX,dword ptr [RAX]
LEA RDI,[0x1bd773]
XOR EAX,EAX
CALL 0x0014f1b0
PUSH 0x1
POP R15
LEA R14,[0x1bcfc5]
LAB_0015b8b6:
MOVSXD RAX,dword ptr [RBX + 0x8]
CMP R15,RAX
JGE 0x0015b8d5
MOV RAX,qword ptr [RBX]
MOV ESI,dword ptr [RAX + R15*0x4]
MOV RDI,R14
XOR EAX,EAX
CALL 0x0014f1b0
INC R15
JMP 0x0015b8b6
LAB_0015b8d5:
LEA RDI,[0x1d0cea]
POP RBX
POP R14
POP R15
JMP 0x001544b0
|
/* void OpenSubdiv::v3_6_0::Vtr::internal::(anonymous
namespace)::printIndexArray<int>(OpenSubdiv::v3_6_0::Vtr::ConstArray<int> const&) */
void OpenSubdiv::v3_6_0::Vtr::internal::(anonymous_namespace)::printIndexArray<int>
(ConstArray *param_1)
{
long lVar1;
printf("%d [%d",(ulong)*(uint *)(param_1 + 8),(ulong)**(uint **)param_1);
for (lVar1 = 1; lVar1 < *(int *)(param_1 + 8); lVar1 = lVar1 + 1) {
printf(" %d",(ulong)*(uint *)(*(long *)param_1 + lVar1 * 4));
}
puts("]");
return;
}
| |
24,818 | void OpenSubdiv::v3_6_0::Vtr::internal::(anonymous namespace)::printIndexArray<int>(OpenSubdiv::v3_6_0::Vtr::ConstArray<int> const&) | NVIDIA-RTX[P]OSD-Lite/opensubdiv/vtr/level.cpp | void
printIndexArray(ConstArray<INT_TYPE> const& array) {
printf("%d [%d", array.size(), array[0]);
for (int i = 1; i < array.size(); ++i) {
printf(" %d", array[i]);
}
printf("]\n");
} | O3 | cpp | void OpenSubdiv::v3_6_0::Vtr::internal::(anonymous namespace)::printIndexArray<int>(OpenSubdiv::v3_6_0::Vtr::ConstArray<int> const&):
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %esi
movq (%rdi), %rax
movzwl (%rax), %edx
leaq 0x72663(%rip), %rdi # 0xb67cf
xorl %eax, %eax
callq 0x38100
cmpl $0x2, 0x8(%rbx)
jl 0x441a4
movl $0x1, %r15d
leaq 0x71eb3(%rip), %r14 # 0xb6039
movq (%rbx), %rax
movzwl (%rax,%r15,2), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x38100
incq %r15
movslq 0x8(%rbx), %rax
cmpq %rax, %r15
jl 0x44186
leaq 0x85606(%rip), %rdi # 0xc97b1
popq %rbx
popq %r14
popq %r15
jmp 0x3b3f0
nop
| _ZN10OpenSubdiv6v3_6_03Vtr8internal12_GLOBAL__N_115printIndexArrayItEEvRKNS1_10ConstArrayIT_EE:
push r15
push r14
push rbx
mov rbx, rdi
mov esi, [rdi+8]
mov rax, [rdi]
movzx edx, word ptr [rax]
lea rdi, aDD; "%d [%d"
xor eax, eax
call _printf
cmp dword ptr [rbx+8], 2
jl short loc_441A4
mov r15d, 1
lea r14, aNonmanifoldD+0Fh; " %d"
loc_44186:
mov rax, [rbx]
movzx esi, word ptr [rax+r15*2]
mov rdi, r14
xor eax, eax
call _printf
inc r15
movsxd rax, dword ptr [rbx+8]
cmp r15, rax
jl short loc_44186
loc_441A4:
lea rdi, aPlanstable0+0Eh; "]"
pop rbx
pop r14
pop r15
jmp _puts
| long long OpenSubdiv::v3_6_0::Vtr::internal::`anonymous namespace'::printIndexArray<unsigned short>(
unsigned __int16 **a1)
{
long long v1; // r15
printf("%d [%d", *((_DWORD *)a1 + 2), **a1);
if ( *((int *)a1 + 2) >= 2 )
{
v1 = 1LL;
do
printf(" %d", (*a1)[v1++]);
while ( v1 < *((int *)a1 + 2) );
}
return puts("]");
}
| printIndexArray<unsigned_short>:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV ESI,dword ptr [RDI + 0x8]
MOV RAX,qword ptr [RDI]
MOVZX EDX,word ptr [RAX]
LEA RDI,[0x1b67cf]
XOR EAX,EAX
CALL 0x00138100
CMP dword ptr [RBX + 0x8],0x2
JL 0x001441a4
MOV R15D,0x1
LEA R14,[0x1b6039]
LAB_00144186:
MOV RAX,qword ptr [RBX]
MOVZX ESI,word ptr [RAX + R15*0x2]
MOV RDI,R14
XOR EAX,EAX
CALL 0x00138100
INC R15
MOVSXD RAX,dword ptr [RBX + 0x8]
CMP R15,RAX
JL 0x00144186
LAB_001441a4:
LEA RDI,[0x1c97b1]
POP RBX
POP R14
POP R15
JMP 0x0013b3f0
|
/* void OpenSubdiv::v3_6_0::Vtr::internal::(anonymous namespace)::printIndexArray<unsigned
short>(OpenSubdiv::v3_6_0::Vtr::ConstArray<unsigned short> const&) */
void OpenSubdiv::v3_6_0::Vtr::internal::(anonymous_namespace)::printIndexArray<unsigned_short>
(ConstArray *param_1)
{
long lVar1;
printf("%d [%d",(ulong)*(uint *)(param_1 + 8),(ulong)**(ushort **)param_1);
if (1 < *(int *)(param_1 + 8)) {
lVar1 = 1;
do {
printf(" %d",(ulong)*(ushort *)(*(long *)param_1 + lVar1 * 2));
lVar1 = lVar1 + 1;
} while (lVar1 < *(int *)(param_1 + 8));
}
puts("]");
return;
}
| |
24,819 | testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::operator=(testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&&) | AlayaLite/build_O3/_deps/googletest-src/googletest/include/gtest/gtest-matchers.h | MatcherBase& operator=(MatcherBase&& other) {
if (this == &other) return *this;
Destroy();
vtable_ = other.vtable_;
buffer_ = other.buffer_;
other.vtable_ = nullptr;
return *this;
} | O3 | c | testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::operator=(testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&&):
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x77c77
movq %rsi, %r14
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x77c5f
cmpq $0x0, 0x18(%rax)
je 0x77c5f
movq 0x10(%rbx), %rax
lock
decl (%rax)
jne 0x77c5f
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rdi
callq *0x18(%rax)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movq $0x0, 0x8(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _ZN7testing8internal11MatcherBaseIRKSt17basic_string_viewIcSt11char_traitsIcEEEaSEOS8_:
push r14
push rbx
push rax
mov rbx, rdi
cmp rdi, rsi
jz short loc_77C77
mov r14, rsi
mov rax, [rbx+8]
test rax, rax
jz short loc_77C5F
cmp qword ptr [rax+18h], 0
jz short loc_77C5F
mov rax, [rbx+10h]
lock dec dword ptr [rax]
jnz short loc_77C5F
mov rax, [rbx+8]
mov rdi, [rbx+10h]
call qword ptr [rax+18h]
loc_77C5F:
mov rax, [r14+8]
mov [rbx+8], rax
mov rax, [r14+10h]
mov [rbx+10h], rax
mov qword ptr [r14+8], 0
loc_77C77:
mov rax, rbx
add rsp, 8
pop rbx
pop r14
retn
| long long testing::internal::MatcherBase<std::string_view const&>::operator=(long long a1, long long a2)
{
long long v2; // rax
if ( a1 != a2 )
{
v2 = *(_QWORD *)(a1 + 8);
if ( v2 && *(_QWORD *)(v2 + 24) && !_InterlockedDecrement(*(volatile signed __int32 **)(a1 + 16)) )
(*(void ( **)(_QWORD))(*(_QWORD *)(a1 + 8) + 24LL))(*(_QWORD *)(a1 + 16));
*(_QWORD *)(a1 + 8) = *(_QWORD *)(a2 + 8);
*(_QWORD *)(a1 + 16) = *(_QWORD *)(a2 + 16);
*(_QWORD *)(a2 + 8) = 0LL;
}
return a1;
}
| operator=:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
CMP RDI,RSI
JZ 0x00177c77
MOV R14,RSI
MOV RAX,qword ptr [RBX + 0x8]
TEST RAX,RAX
JZ 0x00177c5f
CMP qword ptr [RAX + 0x18],0x0
JZ 0x00177c5f
MOV RAX,qword ptr [RBX + 0x10]
DEC.LOCK dword ptr [RAX]
JNZ 0x00177c5f
MOV RAX,qword ptr [RBX + 0x8]
MOV RDI,qword ptr [RBX + 0x10]
CALL qword ptr [RAX + 0x18]
LAB_00177c5f:
MOV RAX,qword ptr [R14 + 0x8]
MOV qword ptr [RBX + 0x8],RAX
MOV RAX,qword ptr [R14 + 0x10]
MOV qword ptr [RBX + 0x10],RAX
MOV qword ptr [R14 + 0x8],0x0
LAB_00177c77:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char> >
const&>::TEMPNAMEPLACEHOLDERVALUE(testing::internal::MatcherBase<std::basic_string_view<char,
std::char_traits<char> > const&>&&) */
MatcherBase<std::basic_string_view<char,std::char_traits<char>>const&> * __thiscall
testing::internal::MatcherBase<std::basic_string_view<char,std::char_traits<char>>const&>::operator=
(MatcherBase<std::basic_string_view<char,std::char_traits<char>>const&> *this,
MatcherBase *param_1)
{
int *piVar1;
if (this != (MatcherBase<std::basic_string_view<char,std::char_traits<char>>const&> *)param_1) {
if ((*(long *)(this + 8) != 0) && (*(long *)(*(long *)(this + 8) + 0x18) != 0)) {
piVar1 = *(int **)(this + 0x10);
LOCK();
*piVar1 = *piVar1 + -1;
UNLOCK();
if (*piVar1 == 0) {
(**(code **)(*(long *)(this + 8) + 0x18))(*(int8 *)(this + 0x10));
}
}
*(int8 *)(this + 8) = *(int8 *)(param_1 + 8);
*(int8 *)(this + 0x10) = *(int8 *)(param_1 + 0x10);
*(int8 *)(param_1 + 8) = 0;
}
return this;
}
| |
24,820 | mi_writeinfo | eloqsql/storage/myisam/mi_locking.c | int _mi_writeinfo(register MI_INFO *info, uint operation)
{
int error,olderror;
MYISAM_SHARE *share=info->s;
DBUG_ENTER("_mi_writeinfo");
DBUG_PRINT("info",("operation: %u tot_locks: %u", operation,
share->tot_locks));
error=0;
if (share->tot_locks == 0)
{
olderror=my_errno; /* Remember last error */
if (operation)
{ /* Two threads can't be here */
share->state.process= share->last_process= share->this_process;
share->state.unique= info->last_unique= info->this_unique;
share->state.update_count= info->last_loop= ++info->this_loop;
if ((error=mi_state_info_write(share->kfile, &share->state, 1)))
olderror=my_errno;
#ifdef _WIN32
if (myisam_flush)
{
if (share->file_map)
my_msync(info->dfile, share->file_map, share->mmaped_length, MS_SYNC);
mysql_file_sync(share->kfile, 0);
mysql_file_sync(info->dfile, 0);
}
#endif
}
if (!(operation & WRITEINFO_NO_UNLOCK) &&
my_lock(share->kfile,F_UNLCK,0L,F_TO_EOF,
MYF(MY_WME | MY_SEEK_NOT_DONE)) && !error)
DBUG_RETURN(1);
my_errno=olderror;
}
else if (operation)
share->changed= 1; /* Mark keyfile changed */
DBUG_RETURN(error);
} | O0 | c | mi_writeinfo:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xb123c
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x368(%rax)
jne 0xb134d
callq 0xf6090
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xb12f9
movq -0x28(%rbp), %rax
movq 0x300(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x308(%rax)
movq -0x28(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rax
movq 0x150(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x158(%rax)
movq -0x28(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x10(%rbp), %rax
movq 0x160(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x160(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0x168(%rax)
movq -0x28(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x28(%rbp), %rax
movl 0x350(%rax), %edi
movq -0x28(%rbp), %rsi
movl $0x1, %edx
callq 0xb70d0
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
je 0xb12f7
callq 0xf6090
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0xb12f9
movl -0x14(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0xb133b
movq -0x28(%rbp), %rax
movl 0x350(%rax), %edi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %ecx
movl $0x30, %r8d
movq %rcx, %rdx
callq 0xf3500
cmpl $0x0, %eax
je 0xb133b
cmpl $0x0, -0x18(%rbp)
jne 0xb133b
jmp 0xb1332
movl $0x1, -0x4(%rbp)
jmp 0xb1368
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0xf6090
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
jmp 0xb1360
cmpl $0x0, -0x14(%rbp)
je 0xb135e
movq -0x28(%rbp), %rax
movb $0x1, 0x37f(%rax)
jmp 0xb1360
jmp 0xb1362
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _mi_writeinfo:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_28], rax
jmp short $+2
loc_B123C:
mov [rbp+var_18], 0
mov rax, [rbp+var_28]
cmp dword ptr [rax+368h], 0
jnz loc_B134D
call _my_thread_var
mov eax, [rax]
mov [rbp+var_1C], eax
cmp [rbp+var_14], 0
jz loc_B12F9
mov rax, [rbp+var_28]
mov rcx, [rax+300h]
mov rax, [rbp+var_28]
mov [rax+308h], rcx
mov rax, [rbp+var_28]
mov [rax+68h], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+150h]
mov rax, [rbp+var_10]
mov [rax+158h], rcx
mov rax, [rbp+var_28]
mov [rax+70h], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+160h]
add rcx, 1
mov [rax+160h], rcx
mov rax, [rbp+var_10]
mov [rax+168h], rcx
mov rax, [rbp+var_28]
mov [rax+78h], rcx
mov rax, [rbp+var_28]
mov edi, [rax+350h]
mov rsi, [rbp+var_28]
mov edx, 1
call mi_state_info_write
mov [rbp+var_18], eax
cmp eax, 0
jz short loc_B12F7
call _my_thread_var
mov eax, [rax]
mov [rbp+var_1C], eax
loc_B12F7:
jmp short $+2
loc_B12F9:
mov eax, [rbp+var_14]
and eax, 2
cmp eax, 0
jnz short loc_B133B
mov rax, [rbp+var_28]
mov edi, [rax+350h]
mov esi, 2
xor eax, eax
mov ecx, eax
mov r8d, 30h ; '0'
mov rdx, rcx
call my_lock
cmp eax, 0
jz short loc_B133B
cmp [rbp+var_18], 0
jnz short loc_B133B
jmp short $+2
loc_B1332:
mov [rbp+var_4], 1
jmp short loc_B1368
loc_B133B:
mov eax, [rbp+var_1C]
mov [rbp+var_2C], eax
call _my_thread_var
mov ecx, [rbp+var_2C]
mov [rax], ecx
jmp short loc_B1360
loc_B134D:
cmp [rbp+var_14], 0
jz short loc_B135E
mov rax, [rbp+var_28]
mov byte ptr [rax+37Fh], 1
loc_B135E:
jmp short $+2
loc_B1360:
jmp short $+2
loc_B1362:
mov eax, [rbp+var_18]
mov [rbp+var_4], eax
loc_B1368:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long mi_writeinfo(_QWORD *a1, const char *a2)
{
long long v2; // rcx
long long v3; // rcx
long long v4; // rcx
long long v6; // [rsp+8h] [rbp-28h]
int v7; // [rsp+14h] [rbp-1Ch]
unsigned int v8; // [rsp+18h] [rbp-18h]
char v9; // [rsp+1Ch] [rbp-14h]
v9 = (char)a2;
v6 = *a1;
v8 = 0;
if ( *(_DWORD *)(*a1 + 872LL) )
{
if ( (_DWORD)a2 )
*(_BYTE *)(v6 + 895) = 1;
return v8;
}
v7 = *(_DWORD *)my_thread_var(a1, a2);
if ( (_DWORD)a2 )
{
v2 = *(_QWORD *)(v6 + 768);
*(_QWORD *)(v6 + 776) = v2;
*(_QWORD *)(v6 + 104) = v2;
v3 = a1[42];
a1[43] = v3;
*(_QWORD *)(v6 + 112) = v3;
v4 = a1[44] + 1LL;
a1[44] = v4;
a1[45] = v4;
*(_QWORD *)(v6 + 120) = v4;
a1 = (_QWORD *)*(unsigned int *)(v6 + 848);
a2 = (const char *)v6;
v8 = mi_state_info_write(a1, v6, 1LL);
if ( v8 )
v7 = *(_DWORD *)my_thread_var(a1, (const char *)v6);
}
if ( (v9 & 2) != 0
|| (a1 = (_QWORD *)*(unsigned int *)(v6 + 848),
a2 = (_BYTE *)(&dword_0 + 2),
!(unsigned int)my_lock(a1, 2LL, 0LL, 0LL, 48LL))
|| v8 )
{
*(_DWORD *)my_thread_var(a1, a2) = v7;
return v8;
}
return 1;
}
| _mi_writeinfo:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001b123c
LAB_001b123c:
MOV dword ptr [RBP + -0x18],0x0
MOV RAX,qword ptr [RBP + -0x28]
CMP dword ptr [RAX + 0x368],0x0
JNZ 0x001b134d
CALL 0x001f6090
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x1c],EAX
CMP dword ptr [RBP + -0x14],0x0
JZ 0x001b12f9
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RAX + 0x300]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x308],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x68],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x150]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x158],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x70],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x160]
ADD RCX,0x1
MOV qword ptr [RAX + 0x160],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x168],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x78],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV EDI,dword ptr [RAX + 0x350]
MOV RSI,qword ptr [RBP + -0x28]
MOV EDX,0x1
CALL 0x001b70d0
MOV dword ptr [RBP + -0x18],EAX
CMP EAX,0x0
JZ 0x001b12f7
CALL 0x001f6090
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x1c],EAX
LAB_001b12f7:
JMP 0x001b12f9
LAB_001b12f9:
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x2
CMP EAX,0x0
JNZ 0x001b133b
MOV RAX,qword ptr [RBP + -0x28]
MOV EDI,dword ptr [RAX + 0x350]
MOV ESI,0x2
XOR EAX,EAX
MOV ECX,EAX
MOV R8D,0x30
MOV RDX,RCX
CALL 0x001f3500
CMP EAX,0x0
JZ 0x001b133b
CMP dword ptr [RBP + -0x18],0x0
JNZ 0x001b133b
JMP 0x001b1332
LAB_001b1332:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001b1368
LAB_001b133b:
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x2c],EAX
CALL 0x001f6090
MOV ECX,dword ptr [RBP + -0x2c]
MOV dword ptr [RAX],ECX
JMP 0x001b1360
LAB_001b134d:
CMP dword ptr [RBP + -0x14],0x0
JZ 0x001b135e
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x37f],0x1
LAB_001b135e:
JMP 0x001b1360
LAB_001b1360:
JMP 0x001b1362
LAB_001b1362:
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x4],EAX
LAB_001b1368:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int _mi_writeinfo(long *param_1,uint param_2)
{
long lVar1;
int iVar2;
int4 *puVar3;
long lVar4;
int4 local_24;
int local_20;
lVar1 = *param_1;
local_20 = 0;
if (*(int *)(lVar1 + 0x368) == 0) {
puVar3 = (int4 *)_my_thread_var();
local_24 = *puVar3;
if (param_2 != 0) {
*(int8 *)(lVar1 + 0x308) = *(int8 *)(lVar1 + 0x300);
*(int8 *)(lVar1 + 0x68) = *(int8 *)(lVar1 + 0x300);
param_1[0x2b] = param_1[0x2a];
*(long *)(lVar1 + 0x70) = param_1[0x2a];
lVar4 = param_1[0x2c] + 1;
param_1[0x2c] = lVar4;
param_1[0x2d] = lVar4;
*(long *)(lVar1 + 0x78) = lVar4;
local_20 = mi_state_info_write(*(int4 *)(lVar1 + 0x350),lVar1,1);
if (local_20 != 0) {
puVar3 = (int4 *)_my_thread_var();
local_24 = *puVar3;
}
}
if ((((param_2 & 2) == 0) &&
(iVar2 = my_lock(*(int4 *)(lVar1 + 0x350),2,0,0,0x30), iVar2 != 0)) && (local_20 == 0)
) {
return 1;
}
puVar3 = (int4 *)_my_thread_var();
*puVar3 = local_24;
}
else if (param_2 != 0) {
*(int1 *)(lVar1 + 0x37f) = 1;
}
return local_20;
}
| |
24,821 | diagnostic_error | eshkol/src/core/diagnostics/diagnostics.c | void diagnostic_error(DiagnosticContext* context, int line, int column, const char* message) {
assert(context != NULL);
assert(message != NULL);
// Create source location
SourceLocation location = source_location_create(NULL, line, column, 0);
// Add diagnostic
diagnostic_context_add(context, DIAGNOSTIC_ERROR, location, message, NULL);
} | O3 | c | diagnostic_error:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
testq %rdi, %rdi
je 0x3ed7
testq %rcx, %rcx
je 0x3ef6
movq $0x0, -0x18(%rbp)
movl %esi, -0x10(%rbp)
movl %edx, -0xc(%rbp)
movl $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0x18(%rbp), %xmm0
movups %xmm0, (%rsp)
movl $0x2, %esi
movq %rcx, %rdx
xorl %ecx, %ecx
callq 0x3a9e
addq $0x30, %rsp
popq %rbp
retq
leaq 0x75c7(%rip), %rdi # 0xb4a5
leaq 0x753f(%rip), %rsi # 0xb424
leaq 0x7813(%rip), %rcx # 0xb6ff
movl $0xdd, %edx
callq 0x10b0
leaq 0x7629(%rip), %rdi # 0xb526
leaq 0x7520(%rip), %rsi # 0xb424
leaq 0x77f4(%rip), %rcx # 0xb6ff
movl $0xde, %edx
callq 0x10b0
| diagnostic_error:
push rbp
mov rbp, rsp
sub rsp, 30h
test rdi, rdi
jz short loc_3ED7
test rcx, rcx
jz short loc_3EF6
mov qword ptr [rbp+var_18], 0
mov dword ptr [rbp+var_18+8], esi
mov dword ptr [rbp+var_18+0Ch], edx
mov dword ptr [rbp+var_8], 0
mov rax, [rbp+var_8]
mov [rsp+30h+var_20], rax
movups xmm0, [rbp+var_18]
movups [rsp+30h+var_30], xmm0
mov esi, 2
mov rdx, rcx
xor ecx, ecx
call diagnostic_context_add
add rsp, 30h
pop rbp
retn
loc_3ED7:
lea rdi, aContextNull; "context != NULL"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github2025/eshkol"...
lea rcx, aVoidDiagnostic_1; "void diagnostic_error(DiagnosticContext"...
mov edx, 0DDh
call ___assert_fail
loc_3EF6:
lea rdi, aMessageNull; "message != NULL"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github2025/eshkol"...
lea rcx, aVoidDiagnostic_1; "void diagnostic_error(DiagnosticContext"...
mov edx, 0DEh
call ___assert_fail
| long long diagnostic_error(long long *a1, unsigned int a2, unsigned int a3, long long a4, long long a5, long long a6)
{
__int128 v7; // [rsp+18h] [rbp-18h]
long long v8; // [rsp+28h] [rbp-8h]
if ( !a1 )
__assert_fail(
"context != NULL",
"/workspace/llm4binary/github2025/eshkol/src/core/diagnostics/diagnostics.c",
221LL,
"void diagnostic_error(DiagnosticContext *, int, int, const char *)");
if ( !a4 )
__assert_fail(
"message != NULL",
"/workspace/llm4binary/github2025/eshkol/src/core/diagnostics/diagnostics.c",
222LL,
"void diagnostic_error(DiagnosticContext *, int, int, const char *)");
*(_QWORD *)&v7 = 0LL;
*((_QWORD *)&v7 + 1) = __PAIR64__(a3, a2);
LODWORD(v8) = 0;
return diagnostic_context_add(a1, 2, a4, 0LL, a5, a6, v7, v8);
}
| diagnostic_error:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
TEST RDI,RDI
JZ 0x00103ed7
TEST RCX,RCX
JZ 0x00103ef6
MOV qword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x10],ESI
MOV dword ptr [RBP + -0xc],EDX
MOV dword ptr [RBP + -0x8],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RBP + -0x18]
MOVUPS xmmword ptr [RSP],XMM0
MOV ESI,0x2
MOV RDX,RCX
XOR ECX,ECX
CALL 0x00103a9e
ADD RSP,0x30
POP RBP
RET
LAB_00103ed7:
LEA RDI,[0x10b4a5]
LEA RSI,[0x10b424]
LEA RCX,[0x10b6ff]
MOV EDX,0xdd
CALL 0x001010b0
LAB_00103ef6:
LEA RDI,[0x10b526]
LEA RSI,[0x10b424]
LEA RCX,[0x10b6ff]
MOV EDX,0xde
CALL 0x001010b0
|
void diagnostic_error(long param_1,int4 param_2,int8 param_3,long param_4,
int8 param_5,int8 param_6)
{
uint uStack_c;
if (param_1 == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("context != NULL",
"/workspace/llm4binary/github2025/eshkol/src/core/diagnostics/diagnostics.c",0xdd,
"void diagnostic_error(DiagnosticContext *, int, int, const char *)");
}
if (param_4 != 0) {
diagnostic_context_add(param_1,2,param_4,0,param_5,param_6,0,param_2,(ulong)uStack_c << 0x20);
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("message != NULL",
"/workspace/llm4binary/github2025/eshkol/src/core/diagnostics/diagnostics.c",0xde,
"void diagnostic_error(DiagnosticContext *, int, int, const char *)");
}
| |
24,822 | crcr32_reduce_128_to_64 | eloqsql/mysys/crc32/crc32_x86.c | static inline __m128i crcr32_reduce_128_to_64(__m128i data128, const __m128i precomp)
{
__m128i tmp0, tmp1, tmp2;
/* 64b fold */
tmp0= _mm_clmulepi64_si128(data128, precomp, 0x00);
tmp1= _mm_srli_si128(data128, 8);
tmp0= _mm_xor_si128(tmp0, tmp1);
/* 32b fold */
tmp2= _mm_slli_si128(tmp0, 4);
tmp1= _mm_clmulepi64_si128(tmp2, precomp, 0x10);
return _mm_xor_si128(tmp1, tmp0);
} | O0 | c | crcr32_reduce_128_to_64:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movaps %xmm0, -0x50(%rbp)
movaps %xmm1, -0x60(%rbp)
movaps -0x50(%rbp), %xmm0
movaps -0x60(%rbp), %xmm1
pclmulqdq $0x0, %xmm1, %xmm0
movaps %xmm0, -0x70(%rbp)
movaps -0x50(%rbp), %xmm0
psrldq $0x8, %xmm0 # xmm0 = xmm0[8,9,10,11,12,13,14,15],zero,zero,zero,zero,zero,zero,zero,zero
movaps %xmm0, -0x80(%rbp)
movaps -0x70(%rbp), %xmm1
movaps -0x80(%rbp), %xmm0
movaps %xmm1, -0x10(%rbp)
movaps %xmm0, -0x20(%rbp)
movaps -0x10(%rbp), %xmm0
movaps -0x20(%rbp), %xmm1
pxor %xmm1, %xmm0
movaps %xmm0, -0x70(%rbp)
movaps -0x70(%rbp), %xmm0
pslldq $0x4, %xmm0 # xmm0 = zero,zero,zero,zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11]
movdqa %xmm0, -0x90(%rbp)
movdqa -0x90(%rbp), %xmm0
movdqa -0x60(%rbp), %xmm1
pclmulqdq $0x10, %xmm1, %xmm0
movdqa %xmm0, -0x80(%rbp)
movdqa -0x80(%rbp), %xmm1
movdqa -0x70(%rbp), %xmm0
movdqa %xmm1, -0x30(%rbp)
movdqa %xmm0, -0x40(%rbp)
movdqa -0x30(%rbp), %xmm0
pxor -0x40(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| crcr32_reduce_128_to_64:
push rbp
mov rbp, rsp
sub rsp, 10h
movaps [rbp+var_50], xmm0
movaps [rbp+var_60], xmm1
movaps xmm0, [rbp+var_50]
movaps xmm1, [rbp+var_60]
pclmulqdq xmm0, xmm1, 0
movaps [rbp+var_70], xmm0
movaps xmm0, [rbp+var_50]
psrldq xmm0, 8
movaps [rbp+var_80], xmm0
movaps xmm1, [rbp+var_70]
movaps xmm0, [rbp+var_80]
movaps [rbp+var_10], xmm1
movaps [rbp+var_20], xmm0
movaps xmm0, [rbp+var_10]
movaps xmm1, [rbp+var_20]
pxor xmm0, xmm1
movaps [rbp+var_70], xmm0
movaps xmm0, [rbp+var_70]
pslldq xmm0, 4
movdqa [rbp+var_90], xmm0
movdqa xmm0, [rbp+var_90]
movdqa xmm1, [rbp+var_60]
pclmulqdq xmm0, xmm1, 10h
movdqa [rbp+var_80], xmm0
movdqa xmm1, [rbp+var_80]
movdqa xmm0, [rbp+var_70]
movdqa [rbp+var_30], xmm1
movdqa [rbp+var_40], xmm0
movdqa xmm0, [rbp+var_30]
pxor xmm0, [rbp+var_40]
add rsp, 10h
pop rbp
retn
| __m128i crcr32_reduce_128_to_64(__m128i _XMM0, __m128i _XMM1)
{
__m128i v6; // xmm0
__m128i v8; // [rsp+0h] [rbp-90h] BYREF
__m128i v9; // [rsp+10h] [rbp-80h] BYREF
__m128i v10; // [rsp+20h] [rbp-70h] BYREF
__m128i v11; // [rsp+30h] [rbp-60h] BYREF
__m128i v12; // [rsp+40h] [rbp-50h]
__m128i v13[3]; // [rsp+60h] [rbp-30h] BYREF
v12 = _XMM0;
v11 = _XMM1;
__asm { pclmulqdq xmm0, xmm1, 0 }
v9 = _mm_srli_si128(v12, 8);
v13[2] = _XMM0;
v13[1] = v9;
v10 = _mm_xor_si128(_XMM0, v9);
v8 = _mm_slli_si128(v10, 4);
_XMM0 = _mm_load_si128(&v8);
_XMM1 = _mm_load_si128(&v11);
__asm { pclmulqdq xmm0, xmm1, 10h }
v9 = _XMM0;
v6 = _mm_load_si128(&v10);
v13[0] = _mm_load_si128(&v9);
return _mm_xor_si128(_mm_load_si128(v13), v6);
}
| crcr32_reduce_128_to_64:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOVAPS xmmword ptr [RBP + -0x50],XMM0
MOVAPS xmmword ptr [RBP + -0x60],XMM1
MOVAPS XMM0,xmmword ptr [RBP + -0x50]
MOVAPS XMM1,xmmword ptr [RBP + -0x60]
PCLMULLQLQDQ XMM0,XMM1
MOVAPS xmmword ptr [RBP + -0x70],XMM0
MOVAPS XMM0,xmmword ptr [RBP + -0x50]
PSRLDQ XMM0,0x8
MOVAPS xmmword ptr [RBP + -0x80],XMM0
MOVAPS XMM1,xmmword ptr [RBP + -0x70]
MOVAPS XMM0,xmmword ptr [RBP + -0x80]
MOVAPS xmmword ptr [RBP + -0x10],XMM1
MOVAPS xmmword ptr [RBP + -0x20],XMM0
MOVAPS XMM0,xmmword ptr [RBP + -0x10]
MOVAPS XMM1,xmmword ptr [RBP + -0x20]
PXOR XMM0,XMM1
MOVAPS xmmword ptr [RBP + -0x70],XMM0
MOVAPS XMM0,xmmword ptr [RBP + -0x70]
PSLLDQ XMM0,0x4
MOVDQA xmmword ptr [RBP + -0x90],XMM0
MOVDQA XMM0,xmmword ptr [RBP + -0x90]
MOVDQA XMM1,xmmword ptr [RBP + -0x60]
PCLMULLQHQDQ XMM0,XMM1
MOVDQA xmmword ptr [RBP + -0x80],XMM0
MOVDQA XMM1,xmmword ptr [RBP + -0x80]
MOVDQA XMM0,xmmword ptr [RBP + -0x70]
MOVDQA xmmword ptr [RBP + -0x30],XMM1
MOVDQA xmmword ptr [RBP + -0x40],XMM0
MOVDQA XMM0,xmmword ptr [RBP + -0x30]
PXOR XMM0,xmmword ptr [RBP + -0x40]
ADD RSP,0x10
POP RBP
RET
|
/* WARNING: Removing unreachable block (ram,0x001c3283) */
ulong crcr32_reduce_128_to_64(ulong param_1,ulong param_2)
{
uint uVar1;
int1 auVar2 [16];
int1 auVar3 [16];
int1 auVar4 [16];
int1 auVar5 [16];
int1 auVar6 [16];
ulong in_XMM0_Qb;
ulong in_XMM1_Qb;
int8 uStack_88;
int8 uStack_78;
auVar3._8_8_ = 0;
auVar3._0_8_ = param_1;
auVar4._8_8_ = 0;
auVar4._0_8_ = param_2;
auVar2 = (int1 [16])0x0;
for (uVar1 = 0; uVar1 < 0x40; uVar1 = uVar1 + 1) {
if ((auVar3 & (int1 [16])0x1 << uVar1) != (int1 [16])0x0) {
auVar2 = auVar2 ^ auVar4 << uVar1;
}
}
uStack_78 = auVar2._0_8_;
auVar5._8_8_ = 0;
auVar5._0_8_ = (uStack_78 ^ in_XMM0_Qb) << 0x20;
auVar6._8_8_ = 0;
auVar6._0_8_ = in_XMM1_Qb;
auVar2 = (int1 [16])0x0;
for (uVar1 = 0; uVar1 < 0x40; uVar1 = uVar1 + 1) {
if ((auVar5 & (int1 [16])0x1 << uVar1) != (int1 [16])0x0) {
auVar2 = auVar2 ^ auVar6 << uVar1;
}
}
uStack_88 = auVar2._0_8_;
return uStack_88 ^ uStack_78 ^ in_XMM0_Qb;
}
| |
24,823 | ftxui::Render(ftxui::Screen&, ftxui::Node*) | Andrewchistyakov[P]flashcards_lyc/build_O1/_deps/ftxui-src/src/ftxui/dom/node.cpp | void Render(Screen& screen, Node* node) {
Box box;
box.x_min = 0;
box.y_min = 0;
box.x_max = screen.dimx() - 1;
box.y_max = screen.dimy() - 1;
Node::Status status;
node->Check(&status);
const int max_iterations = 20;
while (status.need_iteration && status.iteration < max_iterations) {
// Step 1: Find what dimension this elements wants to be.
node->ComputeRequirement();
// Step 2: Assign a dimension to the element.
node->SetBox(box);
// Check if the element needs another iteration of the layout algorithm.
status.need_iteration = false;
status.iteration++;
node->Check(&status);
}
// Step 3: Draw the element.
screen.stencil = box;
node->Render(screen);
// Step 4: Apply shaders
screen.ApplyShader();
} | O1 | cpp | ftxui::Render(ftxui::Screen&, ftxui::Node*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x10(%rdi), %ebp
movl 0x14(%rdi), %r15d
decl %ebp
decl %r15d
shlq $0x20, %r15
movq %rsp, %r12
movl $0x0, (%r12)
movb $0x0, 0x4(%r12)
movq (%rsi), %rax
movq %rsi, %rdi
movq %r12, %rsi
callq *0x28(%rax)
cmpb $0x1, 0x4(%r12)
jne 0x2429b
cmpl $0x13, (%rsp)
jg 0x2429b
movq %rbp, %r12
shlq $0x20, %r12
movq %rsp, %r13
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x18(%rax)
movb $0x0, 0x4(%rsp)
incl (%rsp)
movq (%r14), %rax
movq %r14, %rdi
movq %r13, %rsi
callq *0x28(%rax)
cmpb $0x1, 0x4(%rsp)
jne 0x2429b
cmpl $0x14, (%rsp)
jl 0x24262
shlq $0x20, %rbp
movq %rbp, (%rbx)
movq %r15, 0x8(%rbx)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
movq %rbx, %rdi
callq 0x3a884
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
| _ZN5ftxui6RenderERNS_6ScreenEPNS_4NodeE:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov ebp, [rdi+10h]
mov r15d, [rdi+14h]
dec ebp
dec r15d
shl r15, 20h
mov r12, rsp
mov dword ptr [r12], 0
mov byte ptr [r12+4], 0
mov rax, [rsi]
mov rdi, rsi
mov rsi, r12
call qword ptr [rax+28h]
cmp byte ptr [r12+4], 1
jnz short loc_2429B
cmp [rsp+38h+var_38], 13h
jg short loc_2429B
mov r12, rbp
shl r12, 20h
mov r13, rsp
loc_24262:
mov rax, [r14]
mov rdi, r14
call qword ptr [rax+10h]
mov rax, [r14]
mov rdi, r14
mov rsi, r12
mov rdx, r15
call qword ptr [rax+18h]
mov [rsp+38h+var_34], 0
inc [rsp+38h+var_38]
mov rax, [r14]
mov rdi, r14
mov rsi, r13
call qword ptr [rax+28h]
cmp [rsp+38h+var_34], 1
jnz short loc_2429B
cmp [rsp+38h+var_38], 14h
jl short loc_24262
loc_2429B:
shl rbp, 20h
mov [rbx], rbp
mov [rbx+8], r15
mov rax, [r14]
mov rdi, r14
mov rsi, rbx
call qword ptr [rax+20h]
mov rdi, rbx; this
call _ZN5ftxui6Screen11ApplyShaderEv; ftxui::Screen::ApplyShader(void)
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ftxui::Render(ftxui *this, ftxui::Screen *a2, ftxui::Node *a3)
{
long long v3; // rax
long long v4; // rbp
unsigned long long v5; // r15
_QWORD v7[7]; // [rsp+0h] [rbp-38h] BYREF
v7[0] = v3;
v4 = (unsigned int)(*((_DWORD *)this + 4) - 1);
v5 = (unsigned long long)(unsigned int)(*((_DWORD *)this + 5) - 1) << 32;
LODWORD(v7[0]) = 0;
BYTE4(v7[0]) = 0;
(*(void ( **)(ftxui::Screen *, _QWORD *, ftxui::Node *))(*(_QWORD *)a2 + 40LL))(a2, v7, a3);
if ( BYTE4(v7[0]) == 1 && SLODWORD(v7[0]) <= 19 )
{
do
{
(*(void ( **)(ftxui::Screen *))(*(_QWORD *)a2 + 16LL))(a2);
(*(void ( **)(ftxui::Screen *, long long, unsigned long long))(*(_QWORD *)a2 + 24LL))(a2, v4 << 32, v5);
BYTE4(v7[0]) = 0;
++LODWORD(v7[0]);
(*(void ( **)(ftxui::Screen *, _QWORD *))(*(_QWORD *)a2 + 40LL))(a2, v7);
}
while ( BYTE4(v7[0]) == 1 && SLODWORD(v7[0]) < 20 );
}
*(_QWORD *)this = v4 << 32;
*((_QWORD *)this + 1) = v5;
(*(void ( **)(ftxui::Screen *, ftxui *))(*(_QWORD *)a2 + 32LL))(a2, this);
return ftxui::Screen::ApplyShader(this);
}
| Render:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV EBP,dword ptr [RDI + 0x10]
MOV R15D,dword ptr [RDI + 0x14]
DEC EBP
DEC R15D
SHL R15,0x20
MOV R12,RSP
MOV dword ptr [R12],0x0
MOV byte ptr [R12 + 0x4],0x0
MOV RAX,qword ptr [RSI]
MOV RDI,RSI
MOV RSI,R12
CALL qword ptr [RAX + 0x28]
CMP byte ptr [R12 + 0x4],0x1
JNZ 0x0012429b
CMP dword ptr [RSP],0x13
JG 0x0012429b
MOV R12,RBP
SHL R12,0x20
MOV R13,RSP
LAB_00124262:
MOV RAX,qword ptr [R14]
MOV RDI,R14
CALL qword ptr [RAX + 0x10]
MOV RAX,qword ptr [R14]
MOV RDI,R14
MOV RSI,R12
MOV RDX,R15
CALL qword ptr [RAX + 0x18]
MOV byte ptr [RSP + 0x4],0x0
INC dword ptr [RSP]
MOV RAX,qword ptr [R14]
MOV RDI,R14
MOV RSI,R13
CALL qword ptr [RAX + 0x28]
CMP byte ptr [RSP + 0x4],0x1
JNZ 0x0012429b
CMP dword ptr [RSP],0x14
JL 0x00124262
LAB_0012429b:
SHL RBP,0x20
MOV qword ptr [RBX],RBP
MOV qword ptr [RBX + 0x8],R15
MOV RAX,qword ptr [R14]
MOV RDI,R14
MOV RSI,RBX
CALL qword ptr [RAX + 0x20]
MOV RDI,RBX
CALL 0x0013a884
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* ftxui::Render(ftxui::Screen&, ftxui::Node*) */
void ftxui::Render(Screen *param_1,Node *param_2)
{
int iVar1;
ulong in_RAX;
long lVar2;
int8 local_38;
iVar1 = *(int *)(param_1 + 0x10);
lVar2 = (ulong)(*(int *)(param_1 + 0x14) - 1) << 0x20;
local_38 = in_RAX & 0xffffff0000000000;
(**(code **)(*(long *)param_2 + 0x28))(param_2,&local_38);
if ((local_38._4_1_ == '\x01') && ((int)local_38 < 0x14)) {
do {
(**(code **)(*(long *)param_2 + 0x10))(param_2);
(**(code **)(*(long *)param_2 + 0x18))(param_2,(ulong)(iVar1 - 1) << 0x20,lVar2);
local_38 = CONCAT44((int)(local_38 >> 0x20),(int)local_38 + 1) & 0xffffff00ffffffff;
(**(code **)(*(long *)param_2 + 0x28))(param_2,&local_38);
if (local_38._4_1_ != '\x01') break;
} while ((int)local_38 < 0x14);
}
*(ulong *)param_1 = (ulong)(iVar1 - 1) << 0x20;
*(long *)(param_1 + 8) = lVar2;
(**(code **)(*(long *)param_2 + 0x20))(param_2,param_1);
Screen::ApplyShader(param_1);
return;
}
| |
24,824 | evmone::TermResult evmone::instr::core::return_impl<(evmc_status_code)0>(evmone::StackTop, long, evmone::ExecutionState&) | corpus-core[P]colibri-stateless/build_O0/_deps/evmone_external-src/lib/evmone/instructions.hpp | inline TermResult return_impl(StackTop stack, int64_t gas_left, ExecutionState& state) noexcept
{
const auto& offset = stack[0];
const auto& size = stack[1];
if (!check_memory(gas_left, state.memory, offset, size))
return {EVMC_OUT_OF_GAS, gas_left};
state.output_size = static_cast<size_t>(size);
if (state.output_size != 0)
state.output_offset = static_cast<size_t>(offset);
return {StatusCode, gas_left};
} | O0 | cpp | evmone::TermResult evmone::instr::core::return_impl<(evmc_status_code)0>(evmone::StackTop, long, evmone::ExecutionState&):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x603c0
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x603c0
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
leaq -0x20(%rbp), %rdi
callq 0x66e10
testb $0x1, %al
jne 0x70073
movl $0x3, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x700be
movq -0x38(%rbp), %rdi
callq 0x66f00
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x88(%rax)
je 0x700af
movq -0x30(%rbp), %rdi
callq 0x66f00
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x80(%rax)
movl $0x2, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ZN6evmone5instr4core11return_implIL16evmc_status_code2EEENS_10TermResultENS_8StackTopElRNS_14ExecutionStateE:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
lea rdi, [rbp+var_18]
xor esi, esi
call _ZN6evmone8StackTopixEi; evmone::StackTop::operator[](int)
mov [rbp+var_30], rax
lea rdi, [rbp+var_18]
mov esi, 1
call _ZN6evmone8StackTopixEi; evmone::StackTop::operator[](int)
mov [rbp+var_38], rax
mov rsi, [rbp+var_28]
add rsi, 8
mov rdx, [rbp+var_30]
mov rcx, [rbp+var_38]
lea rdi, [rbp+var_20]
call _ZN6evmone12check_memoryERlRNS_6MemoryERKN4intx4uintILj256EEES7_; evmone::check_memory(long &,evmone::Memory &,intx::uint<256u> const&,intx::uint<256u> const&)
test al, 1
jnz short loc_70073
mov [rbp+var_10], 3
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
jmp short loc_700BE
loc_70073:
mov rdi, [rbp+var_38]
call _ZNK4intx4uintILj256EEcvT_ImvEEv; intx::uint<256u>::operator ulong<ulong,void>(void)
mov rcx, rax
mov rax, [rbp+var_28]
mov [rax+88h], rcx
mov rax, [rbp+var_28]
cmp qword ptr [rax+88h], 0
jz short loc_700AF
mov rdi, [rbp+var_30]
call _ZNK4intx4uintILj256EEcvT_ImvEEv; intx::uint<256u>::operator ulong<ulong,void>(void)
mov rcx, rax
mov rax, [rbp+var_28]
mov [rax+80h], rcx
loc_700AF:
mov [rbp+var_10], 2
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
loc_700BE:
mov eax, [rbp+var_10]
mov rdx, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| long long evmone::instr::core::return_impl<(evmc_status_code)2>(long long a1, long long a2, long long a3)
{
long long v4; // [rsp+8h] [rbp-38h]
long long v5; // [rsp+10h] [rbp-30h]
long long v7; // [rsp+20h] [rbp-20h] BYREF
long long v8; // [rsp+28h] [rbp-18h] BYREF
unsigned int v9; // [rsp+30h] [rbp-10h]
long long v10; // [rsp+38h] [rbp-8h]
v8 = a1;
v7 = a2;
v5 = evmone::StackTop::operator[](&v8, 0);
v4 = evmone::StackTop::operator[](&v8, 1);
if ( (evmone::check_memory((long long)&v7, a3 + 8, v5, v4) & 1) != 0 )
{
*(_QWORD *)(a3 + 136) = intx::uint<256u>::operator unsigned long<unsigned long,void>(v4);
if ( *(_QWORD *)(a3 + 136) )
*(_QWORD *)(a3 + 128) = intx::uint<256u>::operator unsigned long<unsigned long,void>(v5);
v9 = 2;
v10 = v7;
}
else
{
v9 = 3;
v10 = v7;
}
return v9;
}
| return_impl<(evmc_status_code)2>:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
LEA RDI,[RBP + -0x18]
XOR ESI,ESI
CALL 0x001603c0
MOV qword ptr [RBP + -0x30],RAX
LEA RDI,[RBP + -0x18]
MOV ESI,0x1
CALL 0x001603c0
MOV qword ptr [RBP + -0x38],RAX
MOV RSI,qword ptr [RBP + -0x28]
ADD RSI,0x8
MOV RDX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x38]
LEA RDI,[RBP + -0x20]
CALL 0x00166e10
TEST AL,0x1
JNZ 0x00170073
MOV dword ptr [RBP + -0x10],0x3
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001700be
LAB_00170073:
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x00166f00
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x88],RCX
MOV RAX,qword ptr [RBP + -0x28]
CMP qword ptr [RAX + 0x88],0x0
JZ 0x001700af
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00166f00
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x80],RCX
LAB_001700af:
MOV dword ptr [RBP + -0x10],0x2
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
LAB_001700be:
MOV EAX,dword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
/* evmone::TermResult evmone::instr::core::return_impl<(evmc_status_code)2>(evmone::StackTop, long,
evmone::ExecutionState&) */
int1 [16]
evmone::instr::core::return_impl<(evmc_status_code)2>(int8 param_1,long param_2,long param_3)
{
uint *this;
uint *this_00;
ulong uVar1;
int1 auVar2 [16];
long local_28;
int8 local_20;
uint local_18;
long local_10;
local_28 = param_2;
local_20 = param_1;
this = (uint *)StackTop::operator[]((StackTop *)&local_20,0);
this_00 = (uint *)StackTop::operator[]((StackTop *)&local_20,1);
uVar1 = check_memory(&local_28,(Memory *)(param_3 + 8),this,this_00);
if ((uVar1 & 1) == 0) {
local_18 = 3;
local_10 = local_28;
}
else {
uVar1 = intx::uint::operator_cast_to_unsigned_long(this_00);
*(ulong *)(param_3 + 0x88) = uVar1;
if (*(long *)(param_3 + 0x88) != 0) {
uVar1 = intx::uint::operator_cast_to_unsigned_long(this);
*(ulong *)(param_3 + 0x80) = uVar1;
}
local_18 = 2;
local_10 = local_28;
}
auVar2._4_4_ = 0;
auVar2._0_4_ = local_18;
auVar2._8_8_ = local_10;
return auVar2;
}
| |
24,825 | my_strnncollsp_latin1_de | eloqsql/strings/ctype-latin1.c | static int my_strnncollsp_latin1_de(CHARSET_INFO *cs __attribute__((unused)),
const uchar *a, size_t a_length,
const uchar *b, size_t b_length)
{
const uchar *a_end= a + a_length, *b_end= b + b_length;
uchar a_char, a_extend= 0, b_char, b_extend= 0;
while ((a < a_end || a_extend) && (b < b_end || b_extend))
{
if (a_extend)
{
a_char=a_extend;
a_extend= 0;
}
else
{
a_extend= combo2map[*a];
a_char= combo1map[*a++];
}
if (b_extend)
{
b_char= b_extend;
b_extend= 0;
}
else
{
b_extend= combo2map[*b];
b_char= combo1map[*b++];
}
if (a_char != b_char)
return (int) a_char - (int) b_char;
}
/* Check if double character last */
if (a_extend)
return 1;
if (b_extend)
return -1;
if (a < a_end)
return my_strnncollsp_padspace_bin(a, a_end - a);
if (b < b_end)
return -my_strnncollsp_padspace_bin(b, b_end - b);
return 0;
} | O3 | c | my_strnncollsp_latin1_de:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
addq %rsi, %rdx
addq %rcx, %r8
xorl %edi, %edi
leaq 0x16bde9(%rip), %rax # 0x1a58a0
leaq 0x16bce2(%rip), %r9 # 0x1a57a0
xorl %r10d, %r10d
cmpq %rdx, %rsi
jb 0x39acb
testb %dil, %dil
je 0x39b1b
cmpq %r8, %rcx
jb 0x39ad5
testb %r10b, %r10b
je 0x39b27
testb %dil, %dil
je 0x39ae1
movl %edi, %r11d
xorl %edi, %edi
jmp 0x39af0
movzbl (%rsi), %r11d
movb (%r11,%rax), %dil
incq %rsi
movb (%r11,%r9), %r11b
testb %r10b, %r10b
je 0x39afd
movl %r10d, %ebx
xorl %r10d, %r10d
jmp 0x39b0b
movzbl (%rcx), %ebx
movb (%rbx,%rax), %r10b
incq %rcx
movb (%rbx,%r9), %bl
cmpb %bl, %r11b
je 0x39ac1
movzbl %bl, %ecx
movzbl %r11b, %eax
subl %ecx, %eax
jmp 0x39b61
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testb %r10b, %r10b
jne 0x39b61
jmp 0x39b4a
movl $0x1, %eax
testb %dil, %dil
jne 0x39b61
cmpq %rdx, %rsi
jae 0x39b4a
subq %rsi, %rdx
movq %rsi, %rdi
movq %rdx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x33139
xorl %eax, %eax
cmpq %r8, %rcx
jae 0x39b61
subq %rcx, %r8
movq %rcx, %rdi
movq %r8, %rsi
callq 0x33139
negl %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| my_strnncollsp_latin1_de:
push rbp
mov rbp, rsp
push rbx
push rax
add rdx, rsi
add r8, rcx
xor edi, edi
lea rax, combo2map
lea r9, combo1map
xor r10d, r10d
loc_39AC1:
cmp rsi, rdx
jb short loc_39ACB
test dil, dil
jz short loc_39B1B
loc_39ACB:
cmp rcx, r8
jb short loc_39AD5
test r10b, r10b
jz short loc_39B27
loc_39AD5:
test dil, dil
jz short loc_39AE1
mov r11d, edi
xor edi, edi
jmp short loc_39AF0
loc_39AE1:
movzx r11d, byte ptr [rsi]
mov dil, [r11+rax]
inc rsi
mov r11b, [r11+r9]
loc_39AF0:
test r10b, r10b
jz short loc_39AFD
mov ebx, r10d
xor r10d, r10d
jmp short loc_39B0B
loc_39AFD:
movzx ebx, byte ptr [rcx]
mov r10b, [rbx+rax]
inc rcx
mov bl, [rbx+r9]
loc_39B0B:
cmp r11b, bl
jz short loc_39AC1
movzx ecx, bl
movzx eax, r11b
sub eax, ecx
jmp short loc_39B61
loc_39B1B:
mov eax, 0FFFFFFFFh
test r10b, r10b
jnz short loc_39B61
jmp short loc_39B4A
loc_39B27:
mov eax, 1
test dil, dil
jnz short loc_39B61
cmp rsi, rdx
jnb short loc_39B4A
sub rdx, rsi
mov rdi, rsi
mov rsi, rdx
add rsp, 8
pop rbx
pop rbp
jmp my_strnncollsp_padspace_bin
loc_39B4A:
xor eax, eax
cmp rcx, r8
jnb short loc_39B61
sub r8, rcx
mov rdi, rcx
mov rsi, r8
call my_strnncollsp_padspace_bin
neg eax
loc_39B61:
add rsp, 8
pop rbx
pop rbp
retn
| long long my_strnncollsp_latin1_de(
long long a1,
unsigned __int8 *a2,
long long a3,
unsigned __int8 *a4,
long long a5)
{
unsigned __int8 *v5; // rdx
unsigned __int8 *v6; // r8
unsigned __int8 v7; // di
unsigned __int8 v8; // r10
unsigned __int8 v9; // r11
long long v10; // r11
unsigned __int8 v11; // bl
long long v12; // rbx
long long result; // rax
v5 = &a2[a3];
v6 = &a4[a5];
v7 = 0;
v8 = 0;
while ( 1 )
{
if ( a2 >= v5 && !v7 )
{
result = 0xFFFFFFFFLL;
if ( v8 )
return result;
goto LABEL_19;
}
if ( a4 >= v6 && !v8 )
break;
if ( v7 )
{
v9 = v7;
v7 = 0;
}
else
{
v10 = *a2;
v7 = combo2map[v10];
++a2;
v9 = combo1map[v10];
}
if ( v8 )
{
v11 = v8;
v8 = 0;
}
else
{
v12 = *a4;
v8 = combo2map[v12];
++a4;
v11 = combo1map[v12];
}
if ( v9 != v11 )
return v9 - (unsigned int)v11;
}
result = 1LL;
if ( v7 )
return result;
if ( a2 < v5 )
return my_strnncollsp_padspace_bin((long long)a2, v5 - a2);
LABEL_19:
result = 0LL;
if ( a4 < v6 )
return (unsigned int)-my_strnncollsp_padspace_bin((long long)a4, v6 - a4);
return result;
}
| my_strnncollsp_latin1_de:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
ADD RDX,RSI
ADD R8,RCX
XOR EDI,EDI
LEA RAX,[0x2a58a0]
LEA R9,[0x2a57a0]
XOR R10D,R10D
LAB_00139ac1:
CMP RSI,RDX
JC 0x00139acb
TEST DIL,DIL
JZ 0x00139b1b
LAB_00139acb:
CMP RCX,R8
JC 0x00139ad5
TEST R10B,R10B
JZ 0x00139b27
LAB_00139ad5:
TEST DIL,DIL
JZ 0x00139ae1
MOV R11D,EDI
XOR EDI,EDI
JMP 0x00139af0
LAB_00139ae1:
MOVZX R11D,byte ptr [RSI]
MOV DIL,byte ptr [R11 + RAX*0x1]
INC RSI
MOV R11B,byte ptr [R11 + R9*0x1]
LAB_00139af0:
TEST R10B,R10B
JZ 0x00139afd
MOV EBX,R10D
XOR R10D,R10D
JMP 0x00139b0b
LAB_00139afd:
MOVZX EBX,byte ptr [RCX]
MOV R10B,byte ptr [RBX + RAX*0x1]
INC RCX
MOV BL,byte ptr [RBX + R9*0x1]
LAB_00139b0b:
CMP R11B,BL
JZ 0x00139ac1
MOVZX ECX,BL
MOVZX EAX,R11B
SUB EAX,ECX
JMP 0x00139b61
LAB_00139b1b:
MOV EAX,0xffffffff
TEST R10B,R10B
JNZ 0x00139b61
JMP 0x00139b4a
LAB_00139b27:
MOV EAX,0x1
TEST DIL,DIL
JNZ 0x00139b61
CMP RSI,RDX
JNC 0x00139b4a
SUB RDX,RSI
MOV RDI,RSI
MOV RSI,RDX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x00133139
LAB_00139b4a:
XOR EAX,EAX
CMP RCX,R8
JNC 0x00139b61
SUB R8,RCX
MOV RDI,RCX
MOV RSI,R8
CALL 0x00133139
NEG EAX
LAB_00139b61:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
ulong my_strnncollsp_latin1_de
(int8 param_1,byte *param_2,long param_3,byte *param_4,long param_5)
{
int iVar1;
ulong uVar2;
byte *pbVar3;
byte bVar4;
byte bVar5;
byte *pbVar6;
byte bVar7;
byte bVar8;
pbVar3 = param_2 + param_3;
pbVar6 = param_4 + param_5;
bVar5 = 0;
bVar7 = 0;
do {
if ((pbVar3 <= param_2) && (bVar5 == 0)) {
if (bVar7 != 0) {
return 0xffffffff;
}
LAB_00139b4a:
if (pbVar6 <= param_4) {
return 0;
}
iVar1 = my_strnncollsp_padspace_bin(param_4,(long)pbVar6 - (long)param_4);
return (ulong)(uint)-iVar1;
}
if ((pbVar6 <= param_4) && (bVar7 == 0)) {
if (bVar5 != 0) {
return 1;
}
if (param_2 < pbVar3) {
uVar2 = my_strnncollsp_padspace_bin(param_2,(long)pbVar3 - (long)param_2);
return uVar2;
}
goto LAB_00139b4a;
}
if (bVar5 == 0) {
bVar8 = *param_2;
bVar5 = combo2map[bVar8];
param_2 = param_2 + 1;
bVar8 = combo1map[bVar8];
}
else {
bVar8 = bVar5;
bVar5 = 0;
}
if (bVar7 == 0) {
bVar4 = *param_4;
bVar7 = combo2map[bVar4];
param_4 = param_4 + 1;
bVar4 = combo1map[bVar4];
}
else {
bVar4 = bVar7;
bVar7 = 0;
}
if (bVar8 != bVar4) {
return (ulong)((uint)bVar8 - (uint)bVar4);
}
} while( true );
}
| |
24,826 | findopt | eloqsql/mysys/my_getopt.c | static int findopt(char *optpat, uint length,
const struct my_option **opt_res,
const char **ffname)
{
uint count;
const struct my_option *opt= *opt_res;
DBUG_ENTER("findopt");
for (count= 0; opt->name; opt++)
{
if (!getopt_compare_strings(opt->name, optpat, length)) /* match found */
{
(*opt_res)= opt;
if (!opt->name[length]) /* Exact match */
DBUG_RETURN(1);
if (!my_getopt_prefix_matching)
continue;
if (!count)
{
/* We only need to know one prev */
count= 1;
*ffname= opt->name;
}
else if (strcmp(*ffname, opt->name))
{
/*
The above test is to not count same option twice
(see mysql.cc, option "help")
*/
count++;
}
}
}
if (count == 1)
my_getopt_error_reporter(INFORMATION_LEVEL,
"Using unique option prefix '%.*s' is error-prone "
"and can break in the future. "
"Please use the full name '%s' instead.",
length, optpat, *ffname);
DBUG_RETURN(count);
} | O3 | c | findopt:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, -0x38(%rbp)
movq (%rdx), %r15
movq (%r15), %rax
testq %rax, %rax
je 0x9a8eb
movq %rdx, %r12
movl %esi, %r10d
movq %rdi, %rbx
movl %esi, %r13d
leaq 0x34aa3e(%rip), %rcx # 0x3e5261
movb (%rcx), %r9b
xorl %edi, %edi
movl $0x5f, %r14d
movl %esi, -0x3c(%rbp)
movb %r9b, -0x29(%rbp)
testl %r10d, %r10d
je 0x9a862
xorl %ecx, %ecx
movzbl (%rax,%rcx), %r8d
cmpb $0x2d, %r8b
cmovel %r14d, %r8d
movzbl (%rbx,%rcx), %esi
cmpb $0x2d, %sil
cmovel %r14d, %esi
cmpb %sil, %r8b
jne 0x9a8a9
incq %rcx
cmpq %rcx, %r13
jne 0x9a83c
movq %r15, (%r12)
movq (%r15), %rsi
cmpb $0x0, (%rsi,%r13)
je 0x9a8e4
testb %r9b, %r9b
je 0x9a8a9
testl %edi, %edi
je 0x9a89d
movq -0x38(%rbp), %rax
movq %rdi, -0x48(%rbp)
movq (%rax), %rdi
callq 0x5fa10
movb -0x29(%rbp), %r9b
movq -0x48(%rbp), %rdi
movl -0x3c(%rbp), %r10d
cmpl $0x1, %eax
sbbl $-0x1, %edi
jmp 0x9a8a9
movq -0x38(%rbp), %rax
movq %rsi, (%rax)
movl $0x1, %edi
movq 0x70(%r15), %rax
addq $0x70, %r15
testq %rax, %rax
jne 0x9a835
cmpl $0x1, %edi
jne 0x9a8ed
leaq 0x34a97a(%rip), %r9 # 0x3e5240
movq -0x38(%rbp), %rax
movq (%rax), %r8
leaq 0x78889(%rip), %rsi # 0x11315d
movl $0x2, %edi
movl %r10d, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq *(%r9)
movl $0x1, %edi
jmp 0x9a8ed
xorl %edi, %edi
movl %edi, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| findopt:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov [rbp+var_38], rcx
mov r15, [rdx]
mov rax, [r15]
test rax, rax
jz loc_9A8EB
mov r12, rdx
mov r10d, esi
mov rbx, rdi
mov r13d, esi
lea rcx, my_getopt_prefix_matching
mov r9b, [rcx]
xor edi, edi
mov r14d, 5Fh ; '_'
mov [rbp+var_3C], esi
mov [rbp+var_29], r9b
loc_9A835:
test r10d, r10d
jz short loc_9A862
xor ecx, ecx
loc_9A83C:
movzx r8d, byte ptr [rax+rcx]
cmp r8b, 2Dh ; '-'
cmovz r8d, r14d
movzx esi, byte ptr [rbx+rcx]
cmp sil, 2Dh ; '-'
cmovz esi, r14d
cmp r8b, sil
jnz short loc_9A8A9
inc rcx
cmp r13, rcx
jnz short loc_9A83C
loc_9A862:
mov [r12], r15
mov rsi, [r15]
cmp byte ptr [rsi+r13], 0
jz short loc_9A8E4
test r9b, r9b
jz short loc_9A8A9
test edi, edi
jz short loc_9A89D
mov rax, [rbp+var_38]
mov [rbp+var_48], rdi
mov rdi, [rax]
call _strcmp
mov r9b, [rbp+var_29]
mov rdi, [rbp+var_48]
mov r10d, [rbp+var_3C]
cmp eax, 1
sbb edi, 0FFFFFFFFh
jmp short loc_9A8A9
loc_9A89D:
mov rax, [rbp+var_38]
mov [rax], rsi
mov edi, 1
loc_9A8A9:
mov rax, [r15+70h]
add r15, 70h ; 'p'
test rax, rax
jnz loc_9A835
cmp edi, 1
jnz short loc_9A8ED
lea r9, my_getopt_error_reporter
mov rax, [rbp+var_38]
mov r8, [rax]
lea rsi, aUsingUniqueOpt; "Using unique option prefix '%.*s' is er"...
mov edi, 2
mov edx, r10d
mov rcx, rbx
xor eax, eax
call qword ptr [r9]
loc_9A8E4:
mov edi, 1
jmp short loc_9A8ED
loc_9A8EB:
xor edi, edi
loc_9A8ED:
mov eax, edi
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long findopt(const char *a1, unsigned int a2, long long **a3, const char **a4)
{
long long *v4; // r15
long long v5; // rax
int v7; // r10d
long long v9; // r13
char v10; // r9
unsigned int v11; // edi
long long v12; // rcx
char v13; // r8
char v14; // si
const char *v15; // rsi
int v16; // eax
char v20; // [rsp+27h] [rbp-29h]
v4 = *a3;
v5 = **a3;
if ( v5 )
{
v7 = a2;
v9 = a2;
v10 = my_getopt_prefix_matching;
v11 = 0;
v20 = my_getopt_prefix_matching;
do
{
if ( v7 )
{
v12 = 0LL;
while ( 1 )
{
v13 = *(_BYTE *)(v5 + v12);
if ( v13 == 45 )
v13 = 95;
v14 = a1[v12];
if ( v14 == 45 )
v14 = 95;
if ( v13 != v14 )
break;
if ( v9 == ++v12 )
goto LABEL_11;
}
}
else
{
LABEL_11:
*a3 = v4;
v15 = (const char *)*v4;
if ( !*(_BYTE *)(*v4 + v9) )
return 1;
if ( v10 )
{
if ( v11 )
{
v16 = strcmp(*a4, v15);
v10 = v20;
v7 = a2;
v11 -= (v16 == 0) - 1;
}
else
{
*a4 = v15;
v11 = 1;
}
}
}
v5 = v4[14];
v4 += 14;
}
while ( v5 );
if ( v11 != 1 )
return v11;
my_getopt_error_reporter(
2,
"Using unique option prefix '%.*s' is error-prone and can break in the future. Please use the full name '%s' instead.",
v7,
a1,
*a4);
return 1;
}
else
{
return 0;
}
}
| findopt:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x38],RCX
MOV R15,qword ptr [RDX]
MOV RAX,qword ptr [R15]
TEST RAX,RAX
JZ 0x0019a8eb
MOV R12,RDX
MOV R10D,ESI
MOV RBX,RDI
MOV R13D,ESI
LEA RCX,[0x4e5261]
MOV R9B,byte ptr [RCX]
XOR EDI,EDI
MOV R14D,0x5f
MOV dword ptr [RBP + -0x3c],ESI
MOV byte ptr [RBP + -0x29],R9B
LAB_0019a835:
TEST R10D,R10D
JZ 0x0019a862
XOR ECX,ECX
LAB_0019a83c:
MOVZX R8D,byte ptr [RAX + RCX*0x1]
CMP R8B,0x2d
CMOVZ R8D,R14D
MOVZX ESI,byte ptr [RBX + RCX*0x1]
CMP SIL,0x2d
CMOVZ ESI,R14D
CMP R8B,SIL
JNZ 0x0019a8a9
INC RCX
CMP R13,RCX
JNZ 0x0019a83c
LAB_0019a862:
MOV qword ptr [R12],R15
MOV RSI,qword ptr [R15]
CMP byte ptr [RSI + R13*0x1],0x0
JZ 0x0019a8e4
TEST R9B,R9B
JZ 0x0019a8a9
TEST EDI,EDI
JZ 0x0019a89d
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x48],RDI
MOV RDI,qword ptr [RAX]
CALL 0x0015fa10
MOV R9B,byte ptr [RBP + -0x29]
MOV RDI,qword ptr [RBP + -0x48]
MOV R10D,dword ptr [RBP + -0x3c]
CMP EAX,0x1
SBB EDI,-0x1
JMP 0x0019a8a9
LAB_0019a89d:
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RSI
MOV EDI,0x1
LAB_0019a8a9:
MOV RAX,qword ptr [R15 + 0x70]
ADD R15,0x70
TEST RAX,RAX
JNZ 0x0019a835
CMP EDI,0x1
JNZ 0x0019a8ed
LEA R9,[0x4e5240]
MOV RAX,qword ptr [RBP + -0x38]
MOV R8,qword ptr [RAX]
LEA RSI,[0x21315d]
MOV EDI,0x2
MOV EDX,R10D
MOV RCX,RBX
XOR EAX,EAX
CALL qword ptr [R9]
LAB_0019a8e4:
MOV EDI,0x1
JMP 0x0019a8ed
LAB_0019a8eb:
XOR EDI,EDI
LAB_0019a8ed:
MOV EAX,EDI
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int findopt(long param_1,uint param_2,int8 *param_3,int8 *param_4)
{
char *__s2;
char cVar1;
int iVar2;
long lVar3;
ulong uVar4;
char cVar5;
int iVar6;
char cVar7;
long *plVar8;
cVar1 = my_getopt_prefix_matching;
plVar8 = (long *)*param_3;
lVar3 = *plVar8;
if (lVar3 == 0) {
iVar6 = 0;
}
else {
iVar6 = 0;
do {
if (param_2 != 0) {
uVar4 = 0;
do {
cVar7 = *(char *)(lVar3 + uVar4);
if (*(char *)(lVar3 + uVar4) == '-') {
cVar7 = '_';
}
cVar5 = *(char *)(param_1 + uVar4);
if (cVar5 == '-') {
cVar5 = '_';
}
if (cVar7 != cVar5) goto LAB_0019a8a9;
uVar4 = uVar4 + 1;
} while (param_2 != uVar4);
}
*param_3 = plVar8;
__s2 = (char *)*plVar8;
if (__s2[param_2] == '\0') goto LAB_0019a8e4;
if (cVar1 != '\0') {
if (iVar6 == 0) {
*param_4 = __s2;
iVar6 = 1;
}
else {
iVar2 = strcmp((char *)*param_4,__s2);
iVar6 = (iVar6 + 1) - (uint)(iVar2 == 0);
}
}
LAB_0019a8a9:
lVar3 = plVar8[0xe];
plVar8 = plVar8 + 0xe;
} while (lVar3 != 0);
if (iVar6 == 1) {
(*(code *)my_getopt_error_reporter)
(2,
"Using unique option prefix \'%.*s\' is error-prone and can break in the future. Please use the full name \'%s\' instead."
,param_2,param_1,*param_4);
LAB_0019a8e4:
iVar6 = 1;
}
}
return iVar6;
}
| |
24,827 | b2d | eloqsql/strings/dtoa.c | static double b2d(Bigint *a, int *e)
{
ULong *xa, *xa0, w, y, z;
int k;
U d;
#define d0 word0(&d)
#define d1 word1(&d)
xa0= a->p.x;
xa= xa0 + a->wds;
y= *--xa;
k= hi0bits(y);
*e= 32 - k;
if (k < Ebits)
{
d0= Exp_1 | y >> (Ebits - k);
w= xa > xa0 ? *--xa : 0;
d1= y << ((32-Ebits) + k) | w >> (Ebits - k);
goto ret_d;
}
z= xa > xa0 ? *--xa : 0;
if (k-= Ebits)
{
d0= Exp_1 | y << k | z >> (32 - k);
y= xa > xa0 ? *--xa : 0;
d1= z << k | y >> (32 - k);
}
else
{
d0= Exp_1 | y;
d1= z;
}
ret_d:
#undef d0
#undef d1
return dval(&d);
} | O3 | c | b2d:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %r14
movslq %esi, %rax
leaq (%rdi,%rax,4), %r13
leaq (%rdi,%rax,4), %r12
addq $-0x4, %r12
movl (%r12), %ebx
movl %ebx, %edi
callq 0x615d2
movl $0x20, %ecx
subl %eax, %ecx
movl %ecx, (%r15)
cmpl $0xa, %eax
ja 0x616a0
movl $0xb, %edx
subl %eax, %edx
movl %ebx, %esi
movl %edx, %ecx
shrl %cl, %esi
xorl %edi, %edi
cmpq %r14, %r12
jbe 0x61693
movl -0x8(%r13), %edi
leal 0x15(%rax), %ecx
shll %cl, %ebx
movl %edx, %ecx
shrl %cl, %edi
orl %ebx, %edi
jmp 0x616e7
xorl %edi, %edi
cmpq %r14, %r12
jbe 0x616b2
movl -0x8(%r13), %edi
addq $-0x8, %r13
movq %r13, %r12
movl %eax, %edx
addl $-0xb, %edx
je 0x616e5
movl %edx, %ecx
shll %cl, %ebx
movl $0x2b, %esi
subl %eax, %esi
movl %edi, %eax
movl %esi, %ecx
shrl %cl, %eax
xorl %r8d, %r8d
cmpq %r14, %r12
jbe 0x616d7
movl -0x4(%r12), %r8d
movl %edx, %ecx
shll %cl, %edi
movl %esi, %ecx
shrl %cl, %r8d
orl %eax, %ebx
orl %r8d, %edi
movl %ebx, %esi
orl $0x3ff00000, %esi # imm = 0x3FF00000
shlq $0x20, %rsi
movl %edi, %eax
orq %rsi, %rax
movq %rax, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| b2d:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rdx
mov r14, rdi
movsxd rax, esi
lea r13, [rdi+rax*4]
lea r12, [rdi+rax*4]
add r12, 0FFFFFFFFFFFFFFFCh
mov ebx, [r12]
mov edi, ebx
call hi0bits
mov ecx, 20h ; ' '
sub ecx, eax
mov [r15], ecx
cmp eax, 0Ah
ja short loc_616A0
mov edx, 0Bh
sub edx, eax
mov esi, ebx
mov ecx, edx
shr esi, cl
xor edi, edi
cmp r12, r14
jbe short loc_61693
mov edi, [r13-8]
loc_61693:
lea ecx, [rax+15h]
shl ebx, cl
mov ecx, edx
shr edi, cl
or edi, ebx
jmp short loc_616E7
loc_616A0:
xor edi, edi
cmp r12, r14
jbe short loc_616B2
mov edi, [r13-8]
add r13, 0FFFFFFFFFFFFFFF8h
mov r12, r13
loc_616B2:
mov edx, eax
add edx, 0FFFFFFF5h
jz short loc_616E5
mov ecx, edx
shl ebx, cl
mov esi, 2Bh ; '+'
sub esi, eax
mov eax, edi
mov ecx, esi
shr eax, cl
xor r8d, r8d
cmp r12, r14
jbe short loc_616D7
mov r8d, [r12-4]
loc_616D7:
mov ecx, edx
shl edi, cl
mov ecx, esi
shr r8d, cl
or ebx, eax
or edi, r8d
loc_616E5:
mov esi, ebx
loc_616E7:
or esi, 3FF00000h
shl rsi, 20h
mov eax, edi
or rax, rsi
movq xmm0, rax
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| double b2d(unsigned long long a1, int a2, _DWORD *a3)
{
unsigned long long v5; // r13
unsigned long long v6; // r12
unsigned int v7; // ebx
unsigned int v8; // eax
unsigned int v9; // esi
unsigned int v10; // edi
unsigned int v11; // edi
char v12; // dl
unsigned int v13; // ebx
char v14; // si
unsigned int v15; // eax
unsigned int v16; // r8d
double result; // xmm0_8
v5 = a1 + 4LL * a2;
v6 = v5 - 4;
v7 = *(_DWORD *)(v5 - 4);
v8 = hi0bits(v7);
*a3 = 32 - v8;
if ( v8 > 0xA )
{
v11 = 0;
if ( v6 > a1 )
{
v11 = *(_DWORD *)(v5 - 8);
v6 = v5 - 8;
}
v12 = v8 - 11;
if ( v8 != 11 )
{
v13 = v7 << v12;
v14 = 43 - v8;
v15 = v11 >> (43 - v8);
v16 = 0;
if ( v6 > a1 )
v16 = *(_DWORD *)(v6 - 4);
v7 = v15 | v13;
v11 = (v16 >> v14) | (v11 << v12);
}
v9 = v7;
}
else
{
v9 = v7 >> (11 - v8);
v10 = 0;
if ( v6 > a1 )
v10 = *(_DWORD *)(v5 - 8);
v11 = (v7 << (v8 + 21)) | (v10 >> (11 - v8));
}
*(_QWORD *)&result = ((unsigned long long)(v9 | 0x3FF00000) << 32) | v11;
return result;
}
| b2d:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDX
MOV R14,RDI
MOVSXD RAX,ESI
LEA R13,[RDI + RAX*0x4]
LEA R12,[RDI + RAX*0x4]
ADD R12,-0x4
MOV EBX,dword ptr [R12]
MOV EDI,EBX
CALL 0x001615d2
MOV ECX,0x20
SUB ECX,EAX
MOV dword ptr [R15],ECX
CMP EAX,0xa
JA 0x001616a0
MOV EDX,0xb
SUB EDX,EAX
MOV ESI,EBX
MOV ECX,EDX
SHR ESI,CL
XOR EDI,EDI
CMP R12,R14
JBE 0x00161693
MOV EDI,dword ptr [R13 + -0x8]
LAB_00161693:
LEA ECX,[RAX + 0x15]
SHL EBX,CL
MOV ECX,EDX
SHR EDI,CL
OR EDI,EBX
JMP 0x001616e7
LAB_001616a0:
XOR EDI,EDI
CMP R12,R14
JBE 0x001616b2
MOV EDI,dword ptr [R13 + -0x8]
ADD R13,-0x8
MOV R12,R13
LAB_001616b2:
MOV EDX,EAX
ADD EDX,-0xb
JZ 0x001616e5
MOV ECX,EDX
SHL EBX,CL
MOV ESI,0x2b
SUB ESI,EAX
MOV EAX,EDI
MOV ECX,ESI
SHR EAX,CL
XOR R8D,R8D
CMP R12,R14
JBE 0x001616d7
MOV R8D,dword ptr [R12 + -0x4]
LAB_001616d7:
MOV ECX,EDX
SHL EDI,CL
MOV ECX,ESI
SHR R8D,CL
OR EBX,EAX
OR EDI,R8D
LAB_001616e5:
MOV ESI,EBX
LAB_001616e7:
OR ESI,0x3ff00000
SHL RSI,0x20
MOV EAX,EDI
OR RAX,RSI
MOVQ XMM0,RAX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong b2d(uint *param_1,int param_2,int *param_3)
{
char cVar1;
uint uVar2;
long lVar3;
byte bVar4;
uint uVar5;
uint uVar6;
uint *puVar7;
lVar3 = (long)param_2;
puVar7 = param_1 + lVar3 + -1;
uVar5 = *puVar7;
uVar2 = hi0bits(uVar5);
*param_3 = 0x20 - uVar2;
cVar1 = (char)uVar2;
if (uVar2 < 0xb) {
uVar2 = 0;
if (param_1 < puVar7) {
uVar2 = param_1[lVar3 + -2];
}
uVar6 = uVar2 >> (0xbU - cVar1 & 0x1f) | uVar5 << (cVar1 + 0x15U & 0x1f);
uVar5 = uVar5 >> (0xbU - cVar1 & 0x1f);
}
else {
uVar6 = 0;
if (param_1 < puVar7) {
uVar6 = param_1[lVar3 + -2];
puVar7 = param_1 + lVar3 + -2;
}
if (uVar2 - 0xb != 0) {
bVar4 = (byte)(uVar2 - 0xb);
uVar2 = 0;
if (param_1 < puVar7) {
uVar2 = puVar7[-1];
}
uVar5 = uVar5 << (bVar4 & 0x1f) | uVar6 >> (0x2bU - cVar1 & 0x1f);
uVar6 = uVar6 << (bVar4 & 0x1f) | uVar2 >> (0x2bU - cVar1 & 0x1f);
}
}
return CONCAT44(uVar5,uVar6) | 0x3ff0000000000000;
}
| |
24,828 | JS_GetOwnPropertyNames2 | bluesky950520[P]quickjs/quickjs.c | static JSValue JS_GetOwnPropertyNames2(JSContext *ctx, JSValue obj1,
int flags, int kind)
{
JSValue obj, r, val, key, value;
JSObject *p;
JSPropertyEnum *atoms;
uint32_t len, i, j;
r = JS_UNDEFINED;
val = JS_UNDEFINED;
obj = JS_ToObject(ctx, obj1);
if (JS_IsException(obj))
return JS_EXCEPTION;
p = JS_VALUE_GET_OBJ(obj);
if (JS_GetOwnPropertyNamesInternal(ctx, &atoms, &len, p, flags & ~JS_GPN_ENUM_ONLY))
goto exception;
r = JS_NewArray(ctx);
if (JS_IsException(r))
goto exception;
for(j = i = 0; i < len; i++) {
JSAtom atom = atoms[i].atom;
if (flags & JS_GPN_ENUM_ONLY) {
JSPropertyDescriptor desc;
int res;
/* Check if property is still enumerable */
res = JS_GetOwnPropertyInternal(ctx, &desc, p, atom);
if (res < 0)
goto exception;
if (!res)
continue;
js_free_desc(ctx, &desc);
if (!(desc.flags & JS_PROP_ENUMERABLE))
continue;
}
switch(kind) {
default:
case JS_ITERATOR_KIND_KEY:
val = JS_AtomToValue(ctx, atom);
if (JS_IsException(val))
goto exception;
break;
case JS_ITERATOR_KIND_VALUE:
val = JS_GetProperty(ctx, obj, atom);
if (JS_IsException(val))
goto exception;
break;
case JS_ITERATOR_KIND_KEY_AND_VALUE:
val = JS_NewArray(ctx);
if (JS_IsException(val))
goto exception;
key = JS_AtomToValue(ctx, atom);
if (JS_IsException(key))
goto exception1;
if (JS_CreateDataPropertyUint32(ctx, val, 0, key, JS_PROP_THROW) < 0)
goto exception1;
value = JS_GetProperty(ctx, obj, atom);
if (JS_IsException(value))
goto exception1;
if (JS_CreateDataPropertyUint32(ctx, val, 1, value, JS_PROP_THROW) < 0)
goto exception1;
break;
}
if (JS_CreateDataPropertyUint32(ctx, r, j++, val, 0) < 0)
goto exception;
}
goto done;
exception1:
JS_FreeValue(ctx, val);
exception:
JS_FreeValue(ctx, r);
r = JS_EXCEPTION;
done:
js_free_prop_enum(ctx, atoms, len);
JS_FreeValue(ctx, obj);
return r;
} | O0 | c | JS_GetOwnPropertyNames2:
subq $0x198, %rsp # imm = 0x198
movq %rsi, 0x178(%rsp)
movq %rdx, 0x180(%rsp)
movq %rdi, 0x170(%rsp)
movl %ecx, 0x16c(%rsp)
movl %r8d, 0x168(%rsp)
movl $0x0, 0xe8(%rsp)
movq $0x3, 0xf0(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0x148(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x150(%rsp)
movl $0x0, 0xd8(%rsp)
movq $0x3, 0xe0(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x138(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x140(%rsp)
movq 0x170(%rsp), %rdi
movq 0x178(%rsp), %rsi
movq 0x180(%rsp), %rdx
callq 0x37770
movq %rax, 0xc8(%rsp)
movq %rdx, 0xd0(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x158(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x160(%rsp)
movq 0x158(%rsp), %rdi
movq 0x160(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0x87eaf
movl $0x0, 0x188(%rsp)
movq $0x6, 0x190(%rsp)
jmp 0x883be
movq 0x158(%rsp), %rax
movq %rax, 0x110(%rsp)
movq 0x170(%rsp), %rdi
movq 0x110(%rsp), %rcx
movl 0x16c(%rsp), %r8d
andl $-0x11, %r8d
leaq 0x108(%rsp), %rsi
leaq 0x104(%rsp), %rdx
callq 0x2f5e0
cmpl $0x0, %eax
je 0x87efa
jmp 0x8831d
movq 0x170(%rsp), %rdi
callq 0x2a520
movq %rax, 0xb8(%rsp)
movq %rdx, 0xc0(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x148(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x150(%rsp)
movq 0x148(%rsp), %rdi
movq 0x150(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0x87f56
jmp 0x8831d
movl $0x0, 0x100(%rsp)
movl $0x0, 0xfc(%rsp)
movl 0x100(%rsp), %eax
cmpl 0x104(%rsp), %eax
jae 0x882fe
movq 0x108(%rsp), %rax
movl 0x100(%rsp), %ecx
movl 0x4(%rax,%rcx,8), %eax
movl %eax, 0xb4(%rsp)
movl 0x16c(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x8800b
movq 0x170(%rsp), %rdi
movq 0x110(%rsp), %rdx
movl 0xb4(%rsp), %ecx
leaq 0x78(%rsp), %rsi
callq 0x301c0
movl %eax, 0x74(%rsp)
cmpl $0x0, 0x74(%rsp)
jge 0x87fda
jmp 0x8831d
cmpl $0x0, 0x74(%rsp)
jne 0x87fe6
jmp 0x882e8
movq 0x170(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x60a00
movl 0x78(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x88009
jmp 0x882e8
jmp 0x8800b
movl 0x168(%rsp), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x88038
jmp 0x8801c
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0x88094
jmp 0x88027
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0x88100
jmp 0x88036
jmp 0x88038
movq 0x170(%rsp), %rdi
movl 0xb4(%rsp), %esi
callq 0x28e30
movq %rax, 0x60(%rsp)
movq %rdx, 0x68(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x138(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x140(%rsp)
movq 0x138(%rsp), %rdi
movq 0x140(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0x8808f
jmp 0x8831d
jmp 0x88292
movq 0x170(%rsp), %rdi
movl 0xb4(%rsp), %ecx
movq 0x158(%rsp), %rsi
movq 0x160(%rsp), %rdx
callq 0x29d80
movq %rax, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x138(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x140(%rsp)
movq 0x138(%rsp), %rdi
movq 0x140(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0x880fb
jmp 0x8831d
jmp 0x88292
movq 0x170(%rsp), %rdi
callq 0x2a520
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x138(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x140(%rsp)
movq 0x138(%rsp), %rdi
movq 0x140(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0x88150
jmp 0x8831d
movq 0x170(%rsp), %rdi
movl 0xb4(%rsp), %esi
callq 0x28e30
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x128(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x130(%rsp)
movq 0x128(%rsp), %rdi
movq 0x130(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0x881a7
jmp 0x88300
movq 0x170(%rsp), %rdi
movq 0x138(%rsp), %rsi
movq 0x140(%rsp), %rdx
movq 0x128(%rsp), %r8
movq 0x130(%rsp), %r9
xorl %eax, %eax
movl %eax, %ecx
movl $0x4000, (%rsp) # imm = 0x4000
callq 0x709a0
cmpl $0x0, %eax
jge 0x881e9
jmp 0x88300
movq 0x170(%rsp), %rdi
movl 0xb4(%rsp), %ecx
movq 0x158(%rsp), %rsi
movq 0x160(%rsp), %rdx
callq 0x29d80
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x118(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x120(%rsp)
movq 0x118(%rsp), %rdi
movq 0x120(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0x88250
jmp 0x88300
movq 0x170(%rsp), %rdi
movq 0x138(%rsp), %rsi
movq 0x140(%rsp), %rdx
movq 0x118(%rsp), %r8
movq 0x120(%rsp), %r9
movl $0x1, %ecx
movl $0x4000, (%rsp) # imm = 0x4000
callq 0x709a0
cmpl $0x0, %eax
jge 0x88290
jmp 0x88300
jmp 0x88292
movq 0x170(%rsp), %rdi
movl 0xfc(%rsp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0xfc(%rsp)
movl %eax, %eax
movl %eax, %ecx
movq 0x148(%rsp), %rsi
movq 0x150(%rsp), %rdx
movq 0x138(%rsp), %r8
movq 0x140(%rsp), %r9
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x709a0
cmpl $0x0, %eax
jge 0x882e6
jmp 0x8831d
jmp 0x882e8
movl 0x100(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x100(%rsp)
jmp 0x87f6c
jmp 0x88365
movq 0x170(%rsp), %rdi
movq 0x138(%rsp), %rsi
movq 0x140(%rsp), %rdx
callq 0x23c90
movq 0x170(%rsp), %rdi
movq 0x148(%rsp), %rsi
movq 0x150(%rsp), %rdx
callq 0x23c90
movl $0x0, 0x10(%rsp)
movq $0x6, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x148(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x150(%rsp)
movq 0x170(%rsp), %rdi
movq 0x108(%rsp), %rsi
movl 0x104(%rsp), %edx
callq 0x30a40
movq 0x170(%rsp), %rdi
movq 0x158(%rsp), %rsi
movq 0x160(%rsp), %rdx
callq 0x23c90
movq 0x148(%rsp), %rax
movq %rax, 0x188(%rsp)
movq 0x150(%rsp), %rax
movq %rax, 0x190(%rsp)
movq 0x188(%rsp), %rax
movq 0x190(%rsp), %rdx
addq $0x198, %rsp # imm = 0x198
retq
nopw %cs:(%rax,%rax)
| JS_GetOwnPropertyNames2:
sub rsp, 198h
mov [rsp+198h+var_20], rsi
mov [rsp+198h+var_18], rdx
mov [rsp+198h+var_28], rdi
mov [rsp+198h+var_2C], ecx
mov [rsp+198h+var_30], r8d
mov dword ptr [rsp+198h+var_B0], 0
mov [rsp+198h+var_A8], 3
mov rax, [rsp+198h+var_B0]
mov [rsp+198h+var_50], rax
mov rax, [rsp+198h+var_A8]
mov [rsp+198h+var_48], rax
mov dword ptr [rsp+198h+var_C0], 0
mov [rsp+198h+var_B8], 3
mov rax, [rsp+198h+var_C0]
mov [rsp+198h+var_60], rax
mov rax, [rsp+198h+var_B8]
mov [rsp+198h+var_58], rax
mov rdi, [rsp+198h+var_28]
mov rsi, [rsp+198h+var_20]
mov rdx, [rsp+198h+var_18]
call JS_ToObject
mov [rsp+198h+var_D0], rax
mov [rsp+198h+var_C8], rdx
mov rax, [rsp+198h+var_D0]
mov [rsp+198h+var_40], rax
mov rax, [rsp+198h+var_C8]
mov [rsp+198h+var_38], rax
mov rdi, [rsp+198h+var_40]
mov rsi, [rsp+198h+var_38]
call JS_IsException_1
cmp eax, 0
jz short loc_87EAF
mov dword ptr [rsp+198h+var_10], 0
mov [rsp+198h+var_8], 6
jmp loc_883BE
loc_87EAF:
mov rax, [rsp+198h+var_40]
mov [rsp+198h+var_88], rax
mov rdi, [rsp+198h+var_28]
mov rcx, [rsp+198h+var_88]
mov r8d, [rsp+198h+var_2C]
and r8d, 0FFFFFFEFh
lea rsi, [rsp+198h+var_90]
lea rdx, [rsp+198h+var_94]
call JS_GetOwnPropertyNamesInternal
cmp eax, 0
jz short loc_87EFA
jmp loc_8831D
loc_87EFA:
mov rdi, [rsp+198h+var_28]
call JS_NewArray
mov [rsp+198h+var_E0], rax
mov [rsp+198h+var_D8], rdx
mov rax, [rsp+198h+var_E0]
mov [rsp+198h+var_50], rax
mov rax, [rsp+198h+var_D8]
mov [rsp+198h+var_48], rax
mov rdi, [rsp+198h+var_50]
mov rsi, [rsp+198h+var_48]
call JS_IsException_1
cmp eax, 0
jz short loc_87F56
jmp loc_8831D
loc_87F56:
mov [rsp+198h+var_98], 0
mov [rsp+198h+var_9C], 0
loc_87F6C:
mov eax, [rsp+198h+var_98]
cmp eax, [rsp+198h+var_94]
jnb loc_882FE
mov rax, [rsp+198h+var_90]
mov ecx, [rsp+198h+var_98]
mov eax, [rax+rcx*8+4]
mov [rsp+198h+var_E4], eax
mov eax, [rsp+198h+var_2C]
and eax, 10h
cmp eax, 0
jz short loc_8800B
mov rdi, [rsp+198h+var_28]
mov rdx, [rsp+198h+var_88]
mov ecx, [rsp+198h+var_E4]
lea rsi, [rsp+198h+var_120]
call JS_GetOwnPropertyInternal
mov [rsp+198h+var_124], eax
cmp [rsp+198h+var_124], 0
jge short loc_87FDA
jmp loc_8831D
loc_87FDA:
cmp [rsp+198h+var_124], 0
jnz short loc_87FE6
jmp loc_882E8
loc_87FE6:
mov rdi, [rsp+198h+var_28]
lea rsi, [rsp+198h+var_120]
call js_free_desc
mov eax, [rsp+198h+var_120]
and eax, 4
cmp eax, 0
jnz short loc_88009
jmp loc_882E8
loc_88009:
jmp short $+2
loc_8800B:
mov eax, [rsp+198h+var_30]
mov [rsp+198h+var_18C], eax
test eax, eax
jz short loc_88038
jmp short $+2
loc_8801C:
mov eax, [rsp+198h+var_18C]
sub eax, 1
jz short loc_88094
jmp short $+2
loc_88027:
mov eax, [rsp+198h+var_18C]
sub eax, 2
jz loc_88100
jmp short $+2
loc_88036:
jmp short $+2
loc_88038:
mov rdi, [rsp+198h+var_28]
mov esi, [rsp+198h+var_E4]
call JS_AtomToValue
mov [rsp+198h+var_138], rax
mov [rsp+198h+var_130], rdx
mov rax, [rsp+198h+var_138]
mov [rsp+198h+var_60], rax
mov rax, [rsp+198h+var_130]
mov [rsp+198h+var_58], rax
mov rdi, [rsp+198h+var_60]
mov rsi, [rsp+198h+var_58]
call JS_IsException_1
cmp eax, 0
jz short loc_8808F
jmp loc_8831D
loc_8808F:
jmp loc_88292
loc_88094:
mov rdi, [rsp+198h+var_28]
mov ecx, [rsp+198h+var_E4]
mov rsi, [rsp+198h+var_40]
mov rdx, [rsp+198h+var_38]
call JS_GetProperty
mov [rsp+198h+var_148], rax
mov [rsp+198h+var_140], rdx
mov rax, [rsp+198h+var_148]
mov [rsp+198h+var_60], rax
mov rax, [rsp+198h+var_140]
mov [rsp+198h+var_58], rax
mov rdi, [rsp+198h+var_60]
mov rsi, [rsp+198h+var_58]
call JS_IsException_1
cmp eax, 0
jz short loc_880FB
jmp loc_8831D
loc_880FB:
jmp loc_88292
loc_88100:
mov rdi, [rsp+198h+var_28]
call JS_NewArray
mov [rsp+198h+var_158], rax
mov [rsp+198h+var_150], rdx
mov rax, [rsp+198h+var_158]
mov [rsp+198h+var_60], rax
mov rax, [rsp+198h+var_150]
mov [rsp+198h+var_58], rax
mov rdi, [rsp+198h+var_60]
mov rsi, [rsp+198h+var_58]
call JS_IsException_1
cmp eax, 0
jz short loc_88150
jmp loc_8831D
loc_88150:
mov rdi, [rsp+198h+var_28]
mov esi, [rsp+198h+var_E4]
call JS_AtomToValue
mov [rsp+198h+var_168], rax
mov [rsp+198h+var_160], rdx
mov rax, [rsp+198h+var_168]
mov [rsp+198h+var_70], rax
mov rax, [rsp+198h+var_160]
mov [rsp+198h+var_68], rax
mov rdi, [rsp+198h+var_70]
mov rsi, [rsp+198h+var_68]
call JS_IsException_1
cmp eax, 0
jz short loc_881A7
jmp loc_88300
loc_881A7:
mov rdi, [rsp+198h+var_28]
mov rsi, [rsp+198h+var_60]
mov rdx, [rsp+198h+var_58]
mov r8, [rsp+198h+var_70]
mov r9, [rsp+198h+var_68]
xor eax, eax
mov ecx, eax
mov [rsp+198h+var_198], 4000h
call JS_CreateDataPropertyUint32
cmp eax, 0
jge short loc_881E9
jmp loc_88300
loc_881E9:
mov rdi, [rsp+198h+var_28]
mov ecx, [rsp+198h+var_E4]
mov rsi, [rsp+198h+var_40]
mov rdx, [rsp+198h+var_38]
call JS_GetProperty
mov [rsp+198h+var_178], rax
mov [rsp+198h+var_170], rdx
mov rax, [rsp+198h+var_178]
mov [rsp+198h+var_80], rax
mov rax, [rsp+198h+var_170]
mov [rsp+198h+var_78], rax
mov rdi, [rsp+198h+var_80]
mov rsi, [rsp+198h+var_78]
call JS_IsException_1
cmp eax, 0
jz short loc_88250
jmp loc_88300
loc_88250:
mov rdi, [rsp+198h+var_28]
mov rsi, [rsp+198h+var_60]
mov rdx, [rsp+198h+var_58]
mov r8, [rsp+198h+var_80]
mov r9, [rsp+198h+var_78]
mov ecx, 1
mov [rsp+198h+var_198], 4000h
call JS_CreateDataPropertyUint32
cmp eax, 0
jge short loc_88290
jmp short loc_88300
loc_88290:
jmp short $+2
loc_88292:
mov rdi, [rsp+198h+var_28]
mov eax, [rsp+198h+var_9C]
mov ecx, eax
add ecx, 1
mov [rsp+198h+var_9C], ecx
mov eax, eax
mov ecx, eax
mov rsi, [rsp+198h+var_50]
mov rdx, [rsp+198h+var_48]
mov r8, [rsp+198h+var_60]
mov r9, [rsp+198h+var_58]
xor eax, eax
mov [rsp+198h+var_198], 0
call JS_CreateDataPropertyUint32
cmp eax, 0
jge short loc_882E6
jmp short loc_8831D
loc_882E6:
jmp short $+2
loc_882E8:
mov eax, [rsp+198h+var_98]
add eax, 1
mov [rsp+198h+var_98], eax
jmp loc_87F6C
loc_882FE:
jmp short loc_88365
loc_88300:
mov rdi, [rsp+198h+var_28]
mov rsi, [rsp+198h+var_60]
mov rdx, [rsp+198h+var_58]
call JS_FreeValue
loc_8831D:
mov rdi, [rsp+198h+var_28]
mov rsi, [rsp+198h+var_50]
mov rdx, [rsp+198h+var_48]
call JS_FreeValue
mov dword ptr [rsp+198h+var_188], 0
mov [rsp+198h+var_180], 6
mov rax, [rsp+198h+var_188]
mov [rsp+198h+var_50], rax
mov rax, [rsp+198h+var_180]
mov [rsp+198h+var_48], rax
loc_88365:
mov rdi, [rsp+198h+var_28]
mov rsi, [rsp+198h+var_90]
mov edx, [rsp+198h+var_94]
call js_free_prop_enum
mov rdi, [rsp+198h+var_28]
mov rsi, [rsp+198h+var_40]
mov rdx, [rsp+198h+var_38]
call JS_FreeValue
mov rax, [rsp+198h+var_50]
mov [rsp+198h+var_10], rax
mov rax, [rsp+198h+var_48]
mov [rsp+198h+var_8], rax
loc_883BE:
mov rax, [rsp+198h+var_10]
mov rdx, [rsp+198h+var_8]
add rsp, 198h
retn
| long long JS_GetOwnPropertyNames2(
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)
{
long long v14; // rdx
long long v15; // rdx
long long v16; // rdx
double v17; // xmm4_8
double v18; // xmm5_8
long long v19; // rdx
long long v20; // rdx
long long v21; // rdx
double v22; // xmm4_8
double v23; // xmm5_8
long long v24; // rdx
double v25; // xmm4_8
double v26; // xmm5_8
unsigned int v27; // eax
long long v29; // [rsp+10h] [rbp-188h]
int OwnPropertyInternal; // [rsp+74h] [rbp-124h]
long long v31[7]; // [rsp+78h] [rbp-120h] BYREF
unsigned int v32; // [rsp+B4h] [rbp-E4h]
long long v33; // [rsp+B8h] [rbp-E0h]
long long v34; // [rsp+C0h] [rbp-D8h]
_DWORD *v35; // [rsp+C8h] [rbp-D0h]
long long v36; // [rsp+D0h] [rbp-C8h]
_DWORD *v37; // [rsp+D8h] [rbp-C0h]
long long v38; // [rsp+E0h] [rbp-B8h]
long long v39; // [rsp+E8h] [rbp-B0h]
long long v40; // [rsp+F0h] [rbp-A8h]
unsigned int v41; // [rsp+FCh] [rbp-9Ch]
unsigned int v42; // [rsp+100h] [rbp-98h]
unsigned int v43; // [rsp+104h] [rbp-94h] BYREF
long long v44; // [rsp+108h] [rbp-90h] BYREF
_DWORD *v45; // [rsp+110h] [rbp-88h]
_DWORD *v46; // [rsp+118h] [rbp-80h]
long long v47; // [rsp+120h] [rbp-78h]
_DWORD *v48; // [rsp+128h] [rbp-70h]
long long v49; // [rsp+130h] [rbp-68h]
_DWORD *Property; // [rsp+138h] [rbp-60h]
long long v51; // [rsp+140h] [rbp-58h]
long long v52; // [rsp+148h] [rbp-50h]
long long v53; // [rsp+150h] [rbp-48h]
_DWORD *v54; // [rsp+158h] [rbp-40h]
long long v55; // [rsp+160h] [rbp-38h]
int v56; // [rsp+168h] [rbp-30h]
int v57; // [rsp+16Ch] [rbp-2Ch]
long long v58; // [rsp+170h] [rbp-28h]
_DWORD *v59; // [rsp+178h] [rbp-20h]
long long v60; // [rsp+180h] [rbp-18h]
long long v61; // [rsp+188h] [rbp-10h]
long long v62; // [rsp+190h] [rbp-8h]
v59 = a2;
v60 = a3;
v58 = a1;
v57 = a4;
v56 = a5;
LODWORD(v39) = 0;
v40 = 3LL;
v52 = v39;
v53 = 3LL;
LODWORD(v37) = 0;
v38 = 3LL;
Property = v37;
v51 = 3LL;
v35 = JS_ToObject(a1, a2, a3, a7, a8, a9, a10, a11, a12, a13, a14, a4, a5, a6);
v36 = v14;
v54 = v35;
v55 = v14;
if ( JS_IsException_1((long long)v35, v14) )
{
LODWORD(v61) = 0;
v62 = 6LL;
return v61;
}
v45 = v54;
if ( !(unsigned int)JS_GetOwnPropertyNamesInternal(v58, &v44, &v43, (long long)v54, v57 & 0xFFFFFFEF) )
{
v33 = JS_NewArray(v58);
v34 = v15;
v52 = v33;
v53 = v15;
if ( !JS_IsException_1(v33, v15) )
{
v42 = 0;
v41 = 0;
while ( 1 )
{
if ( v42 >= v43 )
goto LABEL_28;
v32 = *(_DWORD *)(v44 + 8LL * v42 + 4);
if ( (v57 & 0x10) == 0 )
break;
OwnPropertyInternal = JS_GetOwnPropertyInternal(v58, (long long)v31, (long long)v45, v32);
if ( OwnPropertyInternal < 0 )
goto LABEL_27;
if ( OwnPropertyInternal )
{
js_free_desc(v58, v31);
if ( (v31[0] & 4) != 0 )
break;
}
LABEL_24:
++v42;
}
if ( v56 )
{
if ( v56 == 1 )
{
Property = (_DWORD *)JS_GetProperty(v58, (int)v54, v55, v32);
v51 = v19;
if ( JS_IsException_1((long long)Property, v19) )
goto LABEL_27;
LABEL_23:
v27 = v41++;
if ( (int)JS_CreateDataPropertyUint32(
v58,
v52,
v53,
v27,
Property,
v51,
a7,
a8,
a9,
a10,
v17,
v18,
a13,
a14,
0) < 0 )
goto LABEL_27;
goto LABEL_24;
}
if ( v56 == 2 )
{
Property = (_DWORD *)JS_NewArray(v58);
v51 = v20;
if ( JS_IsException_1((long long)Property, v20) )
goto LABEL_27;
v48 = (_DWORD *)JS_AtomToValue(v58, v32);
v49 = v21;
if ( JS_IsException_1((long long)v48, v21)
|| (int)JS_CreateDataPropertyUint32(
v58,
(long long)Property,
v51,
0LL,
v48,
v49,
a7,
a8,
a9,
a10,
v22,
v23,
a13,
a14,
0x4000) < 0
|| (v46 = (_DWORD *)JS_GetProperty(v58, (int)v54, v55, v32), v47 = v24, JS_IsException_1((long long)v46, v24))
|| (int)JS_CreateDataPropertyUint32(
v58,
(long long)Property,
v51,
1LL,
v46,
v47,
a7,
a8,
a9,
a10,
v25,
v26,
a13,
a14,
0x4000) < 0 )
{
JS_FreeValue(v58, (long long)Property, v51);
goto LABEL_27;
}
goto LABEL_23;
}
}
Property = (_DWORD *)JS_AtomToValue(v58, v32);
v51 = v16;
if ( JS_IsException_1((long long)Property, v16) )
goto LABEL_27;
goto LABEL_23;
}
}
LABEL_27:
JS_FreeValue(v58, v52, v53);
LODWORD(v29) = 0;
v52 = v29;
v53 = 6LL;
LABEL_28:
js_free_prop_enum(v58, v44, v43);
JS_FreeValue(v58, (long long)v54, v55);
v61 = v52;
v62 = v53;
return v61;
}
| JS_GetOwnPropertyNames2:
SUB RSP,0x198
MOV qword ptr [RSP + 0x178],RSI
MOV qword ptr [RSP + 0x180],RDX
MOV qword ptr [RSP + 0x170],RDI
MOV dword ptr [RSP + 0x16c],ECX
MOV dword ptr [RSP + 0x168],R8D
MOV dword ptr [RSP + 0xe8],0x0
MOV qword ptr [RSP + 0xf0],0x3
MOV RAX,qword ptr [RSP + 0xe8]
MOV qword ptr [RSP + 0x148],RAX
MOV RAX,qword ptr [RSP + 0xf0]
MOV qword ptr [RSP + 0x150],RAX
MOV dword ptr [RSP + 0xd8],0x0
MOV qword ptr [RSP + 0xe0],0x3
MOV RAX,qword ptr [RSP + 0xd8]
MOV qword ptr [RSP + 0x138],RAX
MOV RAX,qword ptr [RSP + 0xe0]
MOV qword ptr [RSP + 0x140],RAX
MOV RDI,qword ptr [RSP + 0x170]
MOV RSI,qword ptr [RSP + 0x178]
MOV RDX,qword ptr [RSP + 0x180]
CALL 0x00137770
MOV qword ptr [RSP + 0xc8],RAX
MOV qword ptr [RSP + 0xd0],RDX
MOV RAX,qword ptr [RSP + 0xc8]
MOV qword ptr [RSP + 0x158],RAX
MOV RAX,qword ptr [RSP + 0xd0]
MOV qword ptr [RSP + 0x160],RAX
MOV RDI,qword ptr [RSP + 0x158]
MOV RSI,qword ptr [RSP + 0x160]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x00187eaf
MOV dword ptr [RSP + 0x188],0x0
MOV qword ptr [RSP + 0x190],0x6
JMP 0x001883be
LAB_00187eaf:
MOV RAX,qword ptr [RSP + 0x158]
MOV qword ptr [RSP + 0x110],RAX
MOV RDI,qword ptr [RSP + 0x170]
MOV RCX,qword ptr [RSP + 0x110]
MOV R8D,dword ptr [RSP + 0x16c]
AND R8D,0xffffffef
LEA RSI,[RSP + 0x108]
LEA RDX,[RSP + 0x104]
CALL 0x0012f5e0
CMP EAX,0x0
JZ 0x00187efa
JMP 0x0018831d
LAB_00187efa:
MOV RDI,qword ptr [RSP + 0x170]
CALL 0x0012a520
MOV qword ptr [RSP + 0xb8],RAX
MOV qword ptr [RSP + 0xc0],RDX
MOV RAX,qword ptr [RSP + 0xb8]
MOV qword ptr [RSP + 0x148],RAX
MOV RAX,qword ptr [RSP + 0xc0]
MOV qword ptr [RSP + 0x150],RAX
MOV RDI,qword ptr [RSP + 0x148]
MOV RSI,qword ptr [RSP + 0x150]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x00187f56
JMP 0x0018831d
LAB_00187f56:
MOV dword ptr [RSP + 0x100],0x0
MOV dword ptr [RSP + 0xfc],0x0
LAB_00187f6c:
MOV EAX,dword ptr [RSP + 0x100]
CMP EAX,dword ptr [RSP + 0x104]
JNC 0x001882fe
MOV RAX,qword ptr [RSP + 0x108]
MOV ECX,dword ptr [RSP + 0x100]
MOV EAX,dword ptr [RAX + RCX*0x8 + 0x4]
MOV dword ptr [RSP + 0xb4],EAX
MOV EAX,dword ptr [RSP + 0x16c]
AND EAX,0x10
CMP EAX,0x0
JZ 0x0018800b
MOV RDI,qword ptr [RSP + 0x170]
MOV RDX,qword ptr [RSP + 0x110]
MOV ECX,dword ptr [RSP + 0xb4]
LEA RSI,[RSP + 0x78]
CALL 0x001301c0
MOV dword ptr [RSP + 0x74],EAX
CMP dword ptr [RSP + 0x74],0x0
JGE 0x00187fda
JMP 0x0018831d
LAB_00187fda:
CMP dword ptr [RSP + 0x74],0x0
JNZ 0x00187fe6
JMP 0x001882e8
LAB_00187fe6:
MOV RDI,qword ptr [RSP + 0x170]
LEA RSI,[RSP + 0x78]
CALL 0x00160a00
MOV EAX,dword ptr [RSP + 0x78]
AND EAX,0x4
CMP EAX,0x0
JNZ 0x00188009
JMP 0x001882e8
LAB_00188009:
JMP 0x0018800b
LAB_0018800b:
MOV EAX,dword ptr [RSP + 0x168]
MOV dword ptr [RSP + 0xc],EAX
TEST EAX,EAX
JZ 0x00188038
JMP 0x0018801c
LAB_0018801c:
MOV EAX,dword ptr [RSP + 0xc]
SUB EAX,0x1
JZ 0x00188094
JMP 0x00188027
LAB_00188027:
MOV EAX,dword ptr [RSP + 0xc]
SUB EAX,0x2
JZ 0x00188100
JMP 0x00188036
LAB_00188036:
JMP 0x00188038
LAB_00188038:
MOV RDI,qword ptr [RSP + 0x170]
MOV ESI,dword ptr [RSP + 0xb4]
CALL 0x00128e30
MOV qword ptr [RSP + 0x60],RAX
MOV qword ptr [RSP + 0x68],RDX
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x138],RAX
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0x140],RAX
MOV RDI,qword ptr [RSP + 0x138]
MOV RSI,qword ptr [RSP + 0x140]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x0018808f
JMP 0x0018831d
LAB_0018808f:
JMP 0x00188292
LAB_00188094:
MOV RDI,qword ptr [RSP + 0x170]
MOV ECX,dword ptr [RSP + 0xb4]
MOV RSI,qword ptr [RSP + 0x158]
MOV RDX,qword ptr [RSP + 0x160]
CALL 0x00129d80
MOV qword ptr [RSP + 0x50],RAX
MOV qword ptr [RSP + 0x58],RDX
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x138],RAX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x140],RAX
MOV RDI,qword ptr [RSP + 0x138]
MOV RSI,qword ptr [RSP + 0x140]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x001880fb
JMP 0x0018831d
LAB_001880fb:
JMP 0x00188292
LAB_00188100:
MOV RDI,qword ptr [RSP + 0x170]
CALL 0x0012a520
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],RDX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x138],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x140],RAX
MOV RDI,qword ptr [RSP + 0x138]
MOV RSI,qword ptr [RSP + 0x140]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x00188150
JMP 0x0018831d
LAB_00188150:
MOV RDI,qword ptr [RSP + 0x170]
MOV ESI,dword ptr [RSP + 0xb4]
CALL 0x00128e30
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP + 0x38],RDX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x128],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x130],RAX
MOV RDI,qword ptr [RSP + 0x128]
MOV RSI,qword ptr [RSP + 0x130]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x001881a7
JMP 0x00188300
LAB_001881a7:
MOV RDI,qword ptr [RSP + 0x170]
MOV RSI,qword ptr [RSP + 0x138]
MOV RDX,qword ptr [RSP + 0x140]
MOV R8,qword ptr [RSP + 0x128]
MOV R9,qword ptr [RSP + 0x130]
XOR EAX,EAX
MOV ECX,EAX
MOV dword ptr [RSP],0x4000
CALL 0x001709a0
CMP EAX,0x0
JGE 0x001881e9
JMP 0x00188300
LAB_001881e9:
MOV RDI,qword ptr [RSP + 0x170]
MOV ECX,dword ptr [RSP + 0xb4]
MOV RSI,qword ptr [RSP + 0x158]
MOV RDX,qword ptr [RSP + 0x160]
CALL 0x00129d80
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x28],RDX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x118],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x120],RAX
MOV RDI,qword ptr [RSP + 0x118]
MOV RSI,qword ptr [RSP + 0x120]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x00188250
JMP 0x00188300
LAB_00188250:
MOV RDI,qword ptr [RSP + 0x170]
MOV RSI,qword ptr [RSP + 0x138]
MOV RDX,qword ptr [RSP + 0x140]
MOV R8,qword ptr [RSP + 0x118]
MOV R9,qword ptr [RSP + 0x120]
MOV ECX,0x1
MOV dword ptr [RSP],0x4000
CALL 0x001709a0
CMP EAX,0x0
JGE 0x00188290
JMP 0x00188300
LAB_00188290:
JMP 0x00188292
LAB_00188292:
MOV RDI,qword ptr [RSP + 0x170]
MOV EAX,dword ptr [RSP + 0xfc]
MOV ECX,EAX
ADD ECX,0x1
MOV dword ptr [RSP + 0xfc],ECX
MOV EAX,EAX
MOV ECX,EAX
MOV RSI,qword ptr [RSP + 0x148]
MOV RDX,qword ptr [RSP + 0x150]
MOV R8,qword ptr [RSP + 0x138]
MOV R9,qword ptr [RSP + 0x140]
XOR EAX,EAX
MOV dword ptr [RSP],0x0
CALL 0x001709a0
CMP EAX,0x0
JGE 0x001882e6
JMP 0x0018831d
LAB_001882e6:
JMP 0x001882e8
LAB_001882e8:
MOV EAX,dword ptr [RSP + 0x100]
ADD EAX,0x1
MOV dword ptr [RSP + 0x100],EAX
JMP 0x00187f6c
LAB_001882fe:
JMP 0x00188365
LAB_00188300:
MOV RDI,qword ptr [RSP + 0x170]
MOV RSI,qword ptr [RSP + 0x138]
MOV RDX,qword ptr [RSP + 0x140]
CALL 0x00123c90
LAB_0018831d:
MOV RDI,qword ptr [RSP + 0x170]
MOV RSI,qword ptr [RSP + 0x148]
MOV RDX,qword ptr [RSP + 0x150]
CALL 0x00123c90
MOV dword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x6
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x148],RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x150],RAX
LAB_00188365:
MOV RDI,qword ptr [RSP + 0x170]
MOV RSI,qword ptr [RSP + 0x108]
MOV EDX,dword ptr [RSP + 0x104]
CALL 0x00130a40
MOV RDI,qword ptr [RSP + 0x170]
MOV RSI,qword ptr [RSP + 0x158]
MOV RDX,qword ptr [RSP + 0x160]
CALL 0x00123c90
MOV RAX,qword ptr [RSP + 0x148]
MOV qword ptr [RSP + 0x188],RAX
MOV RAX,qword ptr [RSP + 0x150]
MOV qword ptr [RSP + 0x190],RAX
LAB_001883be:
MOV RAX,qword ptr [RSP + 0x188]
MOV RDX,qword ptr [RSP + 0x190]
ADD RSP,0x198
RET
|
int1 [16]
JS_GetOwnPropertyNames2
(int8 param_1,int8 param_2,int8 param_3,uint param_4,int param_5)
{
int iVar1;
int1 auVar2 [16];
uint uStack_184;
uint local_120 [15];
int4 local_e4;
int1 local_e0 [16];
int1 local_d0 [16];
int4 local_c0;
uint uStack_bc;
int8 local_b8;
int4 local_b0;
uint uStack_ac;
int8 local_a8;
int local_9c;
uint local_98;
uint local_94;
long local_90;
int8 local_88;
int1 local_80 [16];
int1 local_70 [16];
int1 local_60 [16];
int1 local_50 [16];
int1 local_40 [16];
int local_30;
uint local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
int4 local_10;
int4 uStack_c;
int8 local_8;
local_b0 = 0;
local_a8 = 3;
local_50._0_8_ = (ulong)uStack_ac << 0x20;
local_50._8_8_ = 3;
local_c0 = 0;
local_b8 = 3;
local_60._0_8_ = (ulong)uStack_bc << 0x20;
local_60._8_8_ = 3;
local_30 = param_5;
local_2c = param_4;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
local_d0 = JS_ToObject(param_1,param_2,param_3);
local_40 = local_d0;
iVar1 = JS_IsException(local_d0._0_8_,local_d0._8_8_);
if (iVar1 != 0) {
local_10 = 0;
local_8 = 6;
goto LAB_001883be;
}
local_88 = local_40._0_8_;
iVar1 = JS_GetOwnPropertyNamesInternal
(local_28,&local_90,&local_94,local_40._0_8_,local_2c & 0xffffffef);
if (iVar1 == 0) {
local_e0 = JS_NewArray(local_28);
local_50 = local_e0;
iVar1 = JS_IsException(local_e0._0_8_,local_e0._8_8_);
if (iVar1 != 0) goto LAB_0018831d;
local_9c = 0;
for (local_98 = 0; local_98 < local_94; local_98 = local_98 + 1) {
local_e4 = *(int4 *)(local_90 + 4 + (ulong)local_98 * 8);
if ((local_2c & 0x10) == 0) {
LAB_0018800b:
if (local_30 == 0) {
LAB_00188038:
auVar2 = JS_AtomToValue(local_28,local_e4);
local_60 = auVar2;
iVar1 = JS_IsException(auVar2._0_8_,auVar2._8_8_);
joined_r0x00188088:
if (iVar1 != 0) goto LAB_0018831d;
}
else {
if (local_30 == 1) {
auVar2 = JS_GetProperty(local_28,local_40._0_8_,local_40._8_8_,local_e4);
local_60 = auVar2;
iVar1 = JS_IsException(auVar2._0_8_,auVar2._8_8_);
goto joined_r0x00188088;
}
if (local_30 != 2) goto LAB_00188038;
auVar2 = JS_NewArray(local_28);
local_60 = auVar2;
iVar1 = JS_IsException(auVar2._0_8_,auVar2._8_8_);
if (iVar1 != 0) goto LAB_0018831d;
auVar2 = JS_AtomToValue(local_28,local_e4);
local_70 = auVar2;
iVar1 = JS_IsException(auVar2._0_8_,auVar2._8_8_);
if (iVar1 != 0) {
LAB_00188300:
JS_FreeValue(local_28,local_60._0_8_,local_60._8_8_);
goto LAB_0018831d;
}
iVar1 = JS_CreateDataPropertyUint32
(local_28,local_60._0_8_,local_60._8_8_,0,local_70._0_8_,local_70._8_8_,
0x4000);
if (iVar1 < 0) goto LAB_00188300;
auVar2 = JS_GetProperty(local_28,local_40._0_8_,local_40._8_8_,local_e4);
local_80 = auVar2;
iVar1 = JS_IsException(auVar2._0_8_,auVar2._8_8_);
if (iVar1 != 0) goto LAB_00188300;
iVar1 = JS_CreateDataPropertyUint32
(local_28,local_60._0_8_,local_60._8_8_,1,local_80._0_8_,local_80._8_8_,
0x4000);
if (iVar1 < 0) goto LAB_00188300;
}
iVar1 = local_9c;
local_9c = local_9c + 1;
iVar1 = JS_CreateDataPropertyUint32
(local_28,local_50._0_8_,local_50._8_8_,iVar1,local_60._0_8_,
local_60._8_8_,0);
if (iVar1 < 0) goto LAB_0018831d;
}
else {
iVar1 = JS_GetOwnPropertyInternal(local_28,local_120,local_88,local_e4);
if (iVar1 < 0) goto LAB_0018831d;
if (iVar1 != 0) {
js_free_desc(local_28,local_120);
if ((local_120[0] & 4) != 0) goto LAB_0018800b;
}
}
}
}
else {
LAB_0018831d:
JS_FreeValue(local_28,local_50._0_8_,local_50._8_8_);
local_50._8_8_ = 6;
local_50._0_8_ = (ulong)uStack_184 << 0x20;
}
js_free_prop_enum(local_28,local_90,local_94);
JS_FreeValue(local_28,local_40._0_8_,local_40._8_8_);
local_10 = local_50._0_4_;
uStack_c = local_50._4_4_;
local_8 = local_50._8_8_;
LAB_001883be:
auVar2._4_4_ = uStack_c;
auVar2._0_4_ = local_10;
auVar2._8_8_ = local_8;
return auVar2;
}
| |
24,829 | JS_GetOwnPropertyNames2 | bluesky950520[P]quickjs/quickjs.c | static JSValue JS_GetOwnPropertyNames2(JSContext *ctx, JSValue obj1,
int flags, int kind)
{
JSValue obj, r, val, key, value;
JSObject *p;
JSPropertyEnum *atoms;
uint32_t len, i, j;
r = JS_UNDEFINED;
val = JS_UNDEFINED;
obj = JS_ToObject(ctx, obj1);
if (JS_IsException(obj))
return JS_EXCEPTION;
p = JS_VALUE_GET_OBJ(obj);
if (JS_GetOwnPropertyNamesInternal(ctx, &atoms, &len, p, flags & ~JS_GPN_ENUM_ONLY))
goto exception;
r = JS_NewArray(ctx);
if (JS_IsException(r))
goto exception;
for(j = i = 0; i < len; i++) {
JSAtom atom = atoms[i].atom;
if (flags & JS_GPN_ENUM_ONLY) {
JSPropertyDescriptor desc;
int res;
/* Check if property is still enumerable */
res = JS_GetOwnPropertyInternal(ctx, &desc, p, atom);
if (res < 0)
goto exception;
if (!res)
continue;
js_free_desc(ctx, &desc);
if (!(desc.flags & JS_PROP_ENUMERABLE))
continue;
}
switch(kind) {
default:
case JS_ITERATOR_KIND_KEY:
val = JS_AtomToValue(ctx, atom);
if (JS_IsException(val))
goto exception;
break;
case JS_ITERATOR_KIND_VALUE:
val = JS_GetProperty(ctx, obj, atom);
if (JS_IsException(val))
goto exception;
break;
case JS_ITERATOR_KIND_KEY_AND_VALUE:
val = JS_NewArray(ctx);
if (JS_IsException(val))
goto exception;
key = JS_AtomToValue(ctx, atom);
if (JS_IsException(key))
goto exception1;
if (JS_CreateDataPropertyUint32(ctx, val, 0, key, JS_PROP_THROW) < 0)
goto exception1;
value = JS_GetProperty(ctx, obj, atom);
if (JS_IsException(value))
goto exception1;
if (JS_CreateDataPropertyUint32(ctx, val, 1, value, JS_PROP_THROW) < 0)
goto exception1;
break;
}
if (JS_CreateDataPropertyUint32(ctx, r, j++, val, 0) < 0)
goto exception;
}
goto done;
exception1:
JS_FreeValue(ctx, val);
exception:
JS_FreeValue(ctx, r);
r = JS_EXCEPTION;
done:
js_free_prop_enum(ctx, atoms, len);
JS_FreeValue(ctx, obj);
return r;
} | O1 | c | JS_GetOwnPropertyNames2:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %r8d, %ebp
movl %ecx, %r13d
movq %rdi, %rbx
callq 0x26ddd
movq %rdx, %r14
movq %rax, 0x40(%rsp)
cmpl $0x6, %r14d
jne 0x4d81b
movl $0x6, %r15d
xorl %eax, %eax
xorl %r12d, %r12d
jmp 0x4d893
movq 0x40(%rsp), %r15
movl %r13d, %r8d
andl $-0x11, %r8d
leaq 0x60(%rsp), %rsi
leaq 0x3c(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rcx
callq 0x235bd
testl %eax, %eax
je 0x4d8ab
movl $0x3, %r15d
xorl %ebp, %ebp
xorl %r12d, %r12d
shlq $0x20, %r12
movl %ebp, %esi
orq %r12, %rsi
movq 0x18(%rbx), %rdi
movq %r15, %rdx
callq 0x1d8c6
movl $0x6, %r15d
xorl %ebp, %ebp
xorl %r12d, %r12d
movq 0x60(%rsp), %rsi
movl 0x3c(%rsp), %edx
movq %rbx, %rdi
callq 0x23e79
movq 0x40(%rsp), %rsi
movq 0x18(%rbx), %rdi
movq %r14, %rdx
callq 0x1d8c6
shlq $0x20, %r12
movl %ebp, %eax
orq %r12, %rax
movq %r15, %rdx
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, 0x68(%rsp)
movl %ebp, 0x4c(%rsp)
movq 0x38(%rbx), %rsi
incl (%rsi)
movq %rbx, %rdi
movl $0x2, %edx
callq 0xf516
movq %rax, %rbp
movq %rdx, %r15
movq %rax, %r12
shrq $0x20, %r12
cmpl $0x6, %r15d
je 0x4d84b
movl 0x3c(%rsp), %eax
movq %rax, 0x70(%rsp)
testq %rax, %rax
je 0x4d86b
movq 0x60(%rsp), %rax
movq %rax, 0x78(%rsp)
movl $0x3, %eax
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x50(%rsp)
xorl %edx, %edx
xorl %esi, %esi
movq $0x0, 0x58(%rsp)
movq 0x78(%rsp), %rax
movl 0x4(%rax,%rdx,8), %ecx
testb $0x10, %r13b
movq %rdx, 0x28(%rsp)
je 0x4d9a2
movq %rsi, 0x20(%rsp)
movq %rbx, %rdi
leaq 0x80(%rsp), %rsi
movq 0x68(%rsp), %rdx
movl %ecx, 0x1c(%rsp)
callq 0x23bd9
testl %eax, %eax
js 0x4d97e
je 0x4d985
movq %rbx, %rdi
leaq 0x80(%rsp), %rsi
callq 0x3d8c3
movl 0x80(%rsp), %ecx
andl $0x4, %ecx
movl %ecx, %eax
shrl $0x2, %eax
xorl %edx, %edx
testl %ecx, %ecx
sete %dl
leal (%rdx,%rdx,4), %edi
jmp 0x4d98c
movl $0x2, %edi
jmp 0x4d98a
movl $0x5, %edi
xorl %eax, %eax
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %ecx
testb %al, %al
je 0x4dbb6
movl 0x4c(%rsp), %eax
cmpl $0x1, %eax
je 0x4d9be
cmpl $0x2, %eax
je 0x4d9ff
movq %rbx, %rdi
movl %ecx, %esi
xorl %edx, %edx
callq 0x2075a
jmp 0x4d9e4
movl $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
movq %rbx, %rdi
movq 0x50(%rsp), %rsi
movq %r14, %rdx
movq %rsi, %r8
movq %r14, %r9
callq 0x22fa3
movq %rax, %rsi
movl $0x2, %edi
cmpl $0x6, %edx
jne 0x4db31
movq %rdx, 0x30(%rsp)
jmp 0x4dbb1
movl %ecx, 0x1c(%rsp)
movq 0x38(%rbx), %rsi
incl (%rsi)
movq %rbx, %rdi
movl $0x2, %edx
callq 0xf516
movq %rax, %rsi
movq %rdx, 0x30(%rsp)
cmpl $0x6, %edx
jne 0x4da32
movq 0x28(%rsp), %rdx
movl $0x2, %edi
jmp 0x4dbb6
movq %rsi, 0x20(%rsp)
movq %rbx, %rdi
movl 0x1c(%rsp), %esi
xorl %edx, %edx
callq 0x2075a
movl $0x7, %edi
cmpl $0x6, %edx
jne 0x4da5e
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rsi
jmp 0x4dbb6
movq %rax, 0x80(%rsp)
movq %rdx, 0x88(%rsp)
movups 0x80(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movq 0x20(%rsp), %rsi
movq 0x30(%rsp), %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movl $0x4007, %r9d # imm = 0x4007
callq 0x26b2d
testl %eax, %eax
js 0x4daca
movl $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
movq %rbx, %rdi
movq 0x50(%rsp), %rsi
movq %r14, %rdx
movl 0x1c(%rsp), %ecx
movq %rsi, %r8
movq %r14, %r9
callq 0x22fa3
cmpl $0x6, %edx
jne 0x4dade
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rsi
movl $0x7, %edi
jmp 0x4dbb6
movq %rax, 0x80(%rsp)
movq %rdx, 0x88(%rsp)
movups 0x80(%rsp), %xmm0
movups %xmm0, (%rsp)
movl $0x1, %ecx
movq %rbx, %rdi
movq 0x20(%rsp), %rsi
movq 0x30(%rsp), %rdx
xorl %r8d, %r8d
movl $0x4007, %r9d # imm = 0x4007
callq 0x26b2d
movq 0x20(%rsp), %rsi
movq 0x30(%rsp), %rdx
testl %eax, %eax
movl $0x7, %edi
js 0x4dbb1
movq %rsi, 0x20(%rsp)
movq 0x58(%rsp), %rcx
leal 0x1(%rcx), %eax
movl %eax, 0x1c(%rsp)
movl %ecx, %eax
movq %rsi, 0x80(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
testl %ecx, %ecx
movq %xmm0, %rcx
cmovnsq %rax, %rcx
movq %rdx, 0x30(%rsp)
movq %rdx, 0x88(%rsp)
movl $0x7, %r8d
movl $0x0, %eax
cmovnsq %rax, %r8
movups 0x80(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movl $0x7, %r9d
callq 0x26b2d
movq 0x20(%rsp), %rsi
movl %eax, %edi
shrl $0x1e, %edi
andl $-0x2, %edi
movl 0x1c(%rsp), %eax
movq %rax, 0x58(%rsp)
movq 0x28(%rsp), %rdx
cmpl $0x7, %edi
ja 0x4dbe0
movl %edi, %eax
leaq 0x4f194(%rip), %rcx # 0x9cd58
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
incq %rdx
cmpq %rdx, 0x70(%rsp)
jne 0x4d91b
jmp 0x4d86b
xorl %eax, %eax
xorl %r12d, %r12d
jmp 0x4d893
movq 0x18(%rbx), %rdi
movq 0x30(%rsp), %rdx
callq 0x1d8c6
jmp 0x4d84b
| JS_GetOwnPropertyNames2:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0B8h
mov ebp, r8d
mov r13d, ecx
mov rbx, rdi
call JS_ToObject
mov r14, rdx
mov [rsp+0E8h+var_A8], rax
cmp r14d, 6
jnz short loc_4D81B
mov r15d, 6
xor eax, eax
xor r12d, r12d
jmp short loc_4D893
loc_4D81B:
mov r15, [rsp+0E8h+var_A8]
mov r8d, r13d
and r8d, 0FFFFFFEFh
lea rsi, [rsp+0E8h+var_88]
lea rdx, [rsp+0E8h+var_AC]
mov rdi, rbx
mov rcx, r15
call JS_GetOwnPropertyNamesInternal
test eax, eax
jz short loc_4D8AB
mov r15d, 3
xor ebp, ebp
xor r12d, r12d
loc_4D84B:
shl r12, 20h; jumptable 000000000004DBCB case 2
mov esi, ebp
or rsi, r12
mov rdi, [rbx+18h]
mov rdx, r15
call JS_FreeValueRT
mov r15d, 6
xor ebp, ebp
xor r12d, r12d
loc_4D86B:
mov rsi, [rsp+0E8h+var_88]
mov edx, [rsp+0E8h+var_AC]
mov rdi, rbx
call js_free_prop_enum
mov rsi, [rsp+0E8h+var_A8]
mov rdi, [rbx+18h]
mov rdx, r14
call JS_FreeValueRT
shl r12, 20h
mov eax, ebp
loc_4D893:
or rax, r12
mov rdx, r15
add rsp, 0B8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4D8AB:
mov [rsp+0E8h+var_80], r15
mov [rsp+0E8h+var_9C], ebp
mov rsi, [rbx+38h]
inc dword ptr [rsi]
mov rdi, rbx
mov edx, 2
call JS_NewObjectFromShape
mov rbp, rax
mov r15, rdx
mov r12, rax
shr r12, 20h
cmp r15d, 6
jz loc_4D84B; jumptable 000000000004DBCB case 2
mov eax, [rsp+0E8h+var_AC]
mov [rsp+0E8h+var_78], rax
test rax, rax
jz loc_4D86B
mov rax, [rsp+0E8h+var_88]
mov [rsp+0E8h+var_70], rax
mov eax, 3
mov [rsp+0E8h+var_B8], rax
mov rax, [rsp+0E8h+var_A8]
mov [rsp+0E8h+var_98], rax
xor edx, edx
xor esi, esi
mov [rsp+0E8h+var_90], 0
loc_4D91B:
mov rax, [rsp+0E8h+var_70]
mov ecx, [rax+rdx*8+4]
test r13b, 10h
mov [rsp+0E8h+var_C0], rdx
jz short loc_4D9A2
mov [rsp+0E8h+var_C8], rsi
mov rdi, rbx
lea rsi, [rsp+0E8h+var_68]
mov rdx, [rsp+0E8h+var_80]
mov [rsp+0E8h+var_CC], ecx
call JS_GetOwnPropertyInternal
test eax, eax
js short loc_4D97E
jz short loc_4D985
mov rdi, rbx
lea rsi, [rsp+0E8h+var_68]
call js_free_desc
mov ecx, dword ptr [rsp+0E8h+var_68]
and ecx, 4
mov eax, ecx
shr eax, 2
xor edx, edx
test ecx, ecx
setz dl
lea edi, [rdx+rdx*4]
jmp short loc_4D98C
loc_4D97E:
mov edi, 2
jmp short loc_4D98A
loc_4D985:
mov edi, 5
loc_4D98A:
xor eax, eax
loc_4D98C:
mov rdx, [rsp+0E8h+var_C0]
mov rsi, [rsp+0E8h+var_C8]
mov ecx, [rsp+0E8h+var_CC]
test al, al
jz loc_4DBB6
loc_4D9A2:
mov eax, [rsp+0E8h+var_9C]
cmp eax, 1
jz short loc_4D9BE
cmp eax, 2
jz short loc_4D9FF
mov rdi, rbx
mov esi, ecx
xor edx, edx
call __JS_AtomToValue
jmp short loc_4D9E4
loc_4D9BE:
mov dword ptr [rsp+0E8h+var_E8+8], 0
mov qword ptr [rsp+0E8h+var_E8], 0
mov rdi, rbx
mov rsi, [rsp+0E8h+var_98]
mov rdx, r14
mov r8, rsi
mov r9, r14
call JS_GetPropertyInternal2
loc_4D9E4:
mov rsi, rax
mov edi, 2
cmp edx, 6
jnz loc_4DB31
mov [rsp+0E8h+var_B8], rdx
jmp loc_4DBB1
loc_4D9FF:
mov [rsp+0E8h+var_CC], ecx
mov rsi, [rbx+38h]
inc dword ptr [rsi]
mov rdi, rbx
mov edx, 2
call JS_NewObjectFromShape
mov rsi, rax
mov [rsp+0E8h+var_B8], rdx
cmp edx, 6
jnz short loc_4DA32
mov rdx, [rsp+0E8h+var_C0]
mov edi, 2
jmp loc_4DBB6
loc_4DA32:
mov [rsp+0E8h+var_C8], rsi
mov rdi, rbx
mov esi, [rsp+0E8h+var_CC]
xor edx, edx
call __JS_AtomToValue
mov edi, 7
cmp edx, 6
jnz short loc_4DA5E
mov rdx, [rsp+0E8h+var_C0]
mov rsi, [rsp+0E8h+var_C8]
jmp loc_4DBB6
loc_4DA5E:
mov qword ptr [rsp+0E8h+var_68], rax
mov qword ptr [rsp+0E8h+var_68+8], rdx
movups xmm0, [rsp+0E8h+var_68]
movups [rsp+0E8h+var_E8], xmm0
mov rdi, rbx
mov rsi, [rsp+0E8h+var_C8]
mov rdx, [rsp+0E8h+var_B8]
xor ecx, ecx
xor r8d, r8d
mov r9d, 4007h
call JS_DefinePropertyValueValue
test eax, eax
js short loc_4DACA
mov dword ptr [rsp+0E8h+var_E8+8], 0
mov qword ptr [rsp+0E8h+var_E8], 0
mov rdi, rbx
mov rsi, [rsp+0E8h+var_98]
mov rdx, r14
mov ecx, [rsp+0E8h+var_CC]
mov r8, rsi
mov r9, r14
call JS_GetPropertyInternal2
cmp edx, 6
jnz short loc_4DADE
loc_4DACA:
mov rdx, [rsp+0E8h+var_C0]
mov rsi, [rsp+0E8h+var_C8]
mov edi, 7
jmp loc_4DBB6
loc_4DADE:
mov qword ptr [rsp+0E8h+var_68], rax
mov qword ptr [rsp+0E8h+var_68+8], rdx
movups xmm0, [rsp+0E8h+var_68]
movups [rsp+0E8h+var_E8], xmm0
mov ecx, 1
mov rdi, rbx
mov rsi, [rsp+0E8h+var_C8]
mov rdx, [rsp+0E8h+var_B8]
xor r8d, r8d
mov r9d, 4007h
call JS_DefinePropertyValueValue
mov rsi, [rsp+0E8h+var_C8]
mov rdx, [rsp+0E8h+var_B8]
test eax, eax
mov edi, 7
js loc_4DBB1
loc_4DB31:
mov [rsp+0E8h+var_C8], rsi
mov rcx, [rsp+0E8h+var_90]
lea eax, [rcx+1]
mov [rsp+0E8h+var_CC], eax
mov eax, ecx
mov qword ptr [rsp+0E8h+var_68], rsi
xorps xmm0, xmm0
cvtsi2sd xmm0, rax
test ecx, ecx
movq rcx, xmm0
cmovns rcx, rax
mov [rsp+0E8h+var_B8], rdx
mov qword ptr [rsp+0E8h+var_68+8], rdx
mov r8d, 7
mov eax, 0
cmovns r8, rax
movups xmm0, [rsp+0E8h+var_68]
movups [rsp+0E8h+var_E8], xmm0
mov rdi, rbx
mov rsi, rbp
mov rdx, r15
mov r9d, 7
call JS_DefinePropertyValueValue
mov rsi, [rsp+0E8h+var_C8]
mov edi, eax
shr edi, 1Eh
and edi, 0FFFFFFFEh
mov eax, [rsp+0E8h+var_CC]
mov [rsp+0E8h+var_90], rax
loc_4DBB1:
mov rdx, [rsp+0E8h+var_C0]
loc_4DBB6:
cmp edi, 7; switch 8 cases
ja short def_4DBCB; jumptable 000000000004DBCB default case, cases 1,3,4,6
mov eax, edi
lea rcx, jpt_4DBCB
movsxd rax, ds:(jpt_4DBCB - 9CD58h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_4DBCD:
inc rdx; jumptable 000000000004DBCB cases 0,5
cmp [rsp+0E8h+var_78], rdx
jnz loc_4D91B
jmp loc_4D86B
def_4DBCB:
xor eax, eax; jumptable 000000000004DBCB default case, cases 1,3,4,6
xor r12d, r12d
jmp loc_4D893
loc_4DBEA:
mov rdi, [rbx+18h]; jumptable 000000000004DBCB case 7
mov rdx, [rsp+0E8h+var_B8]
call JS_FreeValueRT
jmp loc_4D84B; jumptable 000000000004DBCB case 2
| unsigned long long JS_GetOwnPropertyNames2(
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)
{
int v14; // ebp
int v15; // r13d
_DWORD *v17; // rax
long long v18; // rdx
long long v19; // r14
long long v20; // rax
unsigned long long v21; // r12
_DWORD *v22; // r15
long long v23; // r15
unsigned long long v24; // rbp
unsigned long long v25; // r12
_DWORD *v27; // rsi
long long v28; // rdx
long long v29; // rdx
_DWORD *v30; // rsi
unsigned int v31; // ecx
int OwnPropertyInternal; // eax
int v33; // eax
unsigned int v34; // edi
long long v35; // rdx
unsigned long long PropertyInternal2; // rax
long long v37; // rdx
double v38; // xmm4_8
double v39; // xmm5_8
_DWORD *v40; // rsi
long long v41; // rax
long long v42; // rdx
__int128 v43; // rax
double v44; // xmm4_8
double v45; // xmm5_8
__int128 v46; // rax
double v47; // xmm4_8
double v48; // xmm5_8
int v49; // eax
double v50; // rcx
long long v51; // r8
unsigned int v52; // [rsp+1Ch] [rbp-CCh]
unsigned int v53; // [rsp+1Ch] [rbp-CCh]
unsigned int v54; // [rsp+1Ch] [rbp-CCh]
unsigned long long v55; // [rsp+20h] [rbp-C8h]
long long v56; // [rsp+28h] [rbp-C0h]
long long v57; // [rsp+30h] [rbp-B8h]
unsigned int v58; // [rsp+3Ch] [rbp-ACh] BYREF
_DWORD *v59; // [rsp+40h] [rbp-A8h]
int v60; // [rsp+4Ch] [rbp-9Ch]
_DWORD *v61; // [rsp+50h] [rbp-98h]
long long v62; // [rsp+58h] [rbp-90h]
long long v63; // [rsp+60h] [rbp-88h] BYREF
_DWORD *v64; // [rsp+68h] [rbp-80h]
long long v65; // [rsp+70h] [rbp-78h]
long long v66; // [rsp+78h] [rbp-70h]
double v67[13]; // [rsp+80h] [rbp-68h] BYREF
v14 = a5;
v15 = a4;
v17 = JS_ToObject(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
v19 = v18;
v59 = v17;
if ( (_DWORD)v18 == 6 )
{
v20 = 0LL;
v21 = 0LL;
return v21 | v20;
}
v22 = v59;
if ( (unsigned int)JS_GetOwnPropertyNamesInternal(a1, &v63, &v58, (long long)v59, v15 & 0xFFFFFFEF) )
{
v23 = 3LL;
LODWORD(v24) = 0;
v25 = 0LL;
LABEL_5:
JS_FreeValueRT(*(_QWORD *)(a1 + 24), (_DWORD *)((v25 << 32) | (unsigned int)v24), v23);
LODWORD(v24) = 0;
v25 = 0LL;
LABEL_6:
js_free_prop_enum(a1, v63, v58);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v59, v19);
v21 = v25 << 32;
v20 = (unsigned int)v24;
return v21 | v20;
}
v64 = v22;
v60 = v14;
v27 = *(_DWORD **)(a1 + 56);
++*v27;
v24 = JS_NewObjectFromShape(a1, v27, 2u);
v23 = v28;
v25 = HIDWORD(v24);
if ( (_DWORD)v28 == 6 )
goto LABEL_5;
v65 = v58;
if ( !v58 )
goto LABEL_6;
v66 = v63;
v57 = 3LL;
v61 = v59;
v29 = 0LL;
v30 = 0LL;
v62 = 0LL;
while ( 2 )
{
v31 = *(_DWORD *)(v66 + 8 * v29 + 4);
v56 = v29;
if ( (v15 & 0x10) == 0 )
goto LABEL_19;
v52 = *(_DWORD *)(v66 + 8 * v29 + 4);
OwnPropertyInternal = JS_GetOwnPropertyInternal(a1, (long long)v67, (long long)v64, v31);
if ( OwnPropertyInternal < 0 )
{
v34 = 2;
}
else
{
if ( OwnPropertyInternal )
{
js_free_desc(a1, (long long)v67);
v33 = (unsigned __int8)(LOBYTE(v67[0]) & 4) >> 2;
v34 = 5 * ((LOBYTE(v67[0]) & 4) == 0);
goto LABEL_18;
}
v34 = 5;
}
LOBYTE(v33) = 0;
LABEL_18:
v35 = v56;
v31 = v52;
if ( !(_BYTE)v33 )
goto LABEL_39;
LABEL_19:
if ( v60 == 1 )
{
PropertyInternal2 = JS_GetPropertyInternal2(a1, (long long)v61, v19, v31, (long long)v61, v19, 0LL, 0);
LABEL_23:
v30 = (_DWORD *)PropertyInternal2;
v34 = 2;
if ( (_DWORD)v37 == 6 )
{
v57 = v37;
goto LABEL_38;
}
LABEL_33:
v54 = v62 + 1;
*(_QWORD *)&v67[0] = v30;
v50 = (double)(int)v62;
if ( (int)v62 >= 0 )
*(_QWORD *)&v50 = (unsigned int)v62;
v57 = v37;
*(_QWORD *)&v67[1] = v37;
v51 = 7LL;
if ( (int)v62 >= 0 )
v51 = 0LL;
v34 = ((unsigned int)JS_DefinePropertyValueValue(
a1,
v24,
v23,
*(_DWORD **)&v50,
v51,
7,
v67[0],
a8,
a9,
a10,
v38,
v39,
a13,
a14,
*(_DWORD **)&v67[0],
*(long long *)&v67[1]) >> 30) & 0xFFFFFFFE;
v62 = v54;
goto LABEL_38;
}
if ( v60 != 2 )
{
PropertyInternal2 = _JS_AtomToValue(a1, v31, 0);
goto LABEL_23;
}
v53 = v31;
v40 = *(_DWORD **)(a1 + 56);
++*v40;
v41 = JS_NewObjectFromShape(a1, v40, 2u);
v30 = (_DWORD *)v41;
v57 = v42;
if ( (_DWORD)v42 == 6 )
{
v35 = v56;
v34 = 2;
goto LABEL_39;
}
v55 = v41;
*(_QWORD *)&v43 = _JS_AtomToValue(a1, v53, 0);
v34 = 7;
if ( DWORD2(v43) == 6 )
{
v35 = v56;
v30 = (_DWORD *)v55;
goto LABEL_39;
}
*(_OWORD *)v67 = v43;
if ( (int)JS_DefinePropertyValueValue(
a1,
v55,
v57,
0LL,
0LL,
16391,
*(double *)&v43,
a8,
a9,
a10,
v44,
v45,
a13,
a14,
(_DWORD *)v43,
*((long long *)&v43 + 1)) < 0
|| (*(_QWORD *)&v46 = JS_GetPropertyInternal2(a1, (long long)v61, v19, v53, (long long)v61, v19, 0LL, 0),
DWORD2(v46) == 6) )
{
v35 = v56;
v30 = (_DWORD *)v55;
v34 = 7;
goto LABEL_39;
}
*(_OWORD *)v67 = v46;
v49 = JS_DefinePropertyValueValue(
a1,
v55,
v57,
(int *)((char *)&dword_0 + 1),
0LL,
16391,
*(double *)&v46,
a8,
a9,
a10,
v47,
v48,
a13,
a14,
(_DWORD *)v46,
*((long long *)&v46 + 1));
v30 = (_DWORD *)v55;
v37 = v57;
v34 = 7;
if ( v49 >= 0 )
goto LABEL_33;
LABEL_38:
v35 = v56;
LABEL_39:
switch ( v34 )
{
case 0u:
case 5u:
v29 = v35 + 1;
if ( v65 == v29 )
goto LABEL_6;
continue;
case 2u:
goto LABEL_5;
case 7u:
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v30, v57);
goto LABEL_5;
default:
v20 = 0LL;
v21 = 0LL;
break;
}
return v21 | v20;
}
}
| |||
24,830 | MySQLConnection::Close() | SylCore-WoTLK/src/server/database/Database/MySQLConnection.cpp | void MySQLConnection::Close()
{
// Stop the worker thread before the statements are cleared
m_worker.reset();
m_stmts.clear();
if (m_Mysql)
{
mysql_close(m_Mysql);
m_Mysql = nullptr;
}
} | O3 | cpp | MySQLConnection::Close():
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x38, %rdi
xorl %esi, %esi
callq 0x73aee
movq 0x8(%rbx), %r15
movq 0x10(%rbx), %r12
cmpq %r15, %r12
je 0x6cfe9
movq %r15, %r14
movq %r14, %rdi
callq 0x73992
addq $0x8, %r14
cmpq %r12, %r14
jne 0x6cfd4
movq %r15, 0x10(%rbx)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x6cfff
callq 0x1c7b0
movq $0x0, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| _ZN15MySQLConnection5CloseEv:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rdi
add rdi, 38h ; '8'
xor esi, esi
call _ZNSt15__uniq_ptr_implI14DatabaseWorkerSt14default_deleteIS0_EE5resetEPS0_; std::__uniq_ptr_impl<DatabaseWorker,std::default_delete<DatabaseWorker>>::reset(DatabaseWorker*)
mov r15, [rbx+8]
mov r12, [rbx+10h]
cmp r12, r15
jz short loc_6CFE9
mov r14, r15
loc_6CFD4:
mov rdi, r14
call _ZNSt10unique_ptrI22MySQLPreparedStatementSt14default_deleteIS0_EED2Ev; std::unique_ptr<MySQLPreparedStatement>::~unique_ptr()
add r14, 8
cmp r14, r12
jnz short loc_6CFD4
mov [rbx+10h], r15
loc_6CFE9:
mov rdi, [rbx+28h]
test rdi, rdi
jz short loc_6CFFF
call _mysql_close
mov qword ptr [rbx+28h], 0
loc_6CFFF:
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| long long MySQLConnection::Close(MySQLConnection *this)
{
long long result; // rax
long long v3; // r15
long long v4; // r12
long long v5; // r14
long long v6; // rdi
result = std::__uniq_ptr_impl<DatabaseWorker,std::default_delete<DatabaseWorker>>::reset((char *)this + 56, 0LL);
v3 = *((_QWORD *)this + 1);
v4 = *((_QWORD *)this + 2);
if ( v4 != v3 )
{
v5 = *((_QWORD *)this + 1);
do
{
result = std::unique_ptr<MySQLPreparedStatement>::~unique_ptr(v5);
v5 += 8LL;
}
while ( v5 != v4 );
*((_QWORD *)this + 2) = v3;
}
v6 = *((_QWORD *)this + 5);
if ( v6 )
{
result = mysql_close(v6);
*((_QWORD *)this + 5) = 0LL;
}
return result;
}
| Close:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
ADD RDI,0x38
XOR ESI,ESI
CALL 0x00173aee
MOV R15,qword ptr [RBX + 0x8]
MOV R12,qword ptr [RBX + 0x10]
CMP R12,R15
JZ 0x0016cfe9
MOV R14,R15
LAB_0016cfd4:
MOV RDI,R14
CALL 0x00173992
ADD R14,0x8
CMP R14,R12
JNZ 0x0016cfd4
MOV qword ptr [RBX + 0x10],R15
LAB_0016cfe9:
MOV RDI,qword ptr [RBX + 0x28]
TEST RDI,RDI
JZ 0x0016cfff
CALL 0x0011c7b0
MOV qword ptr [RBX + 0x28],0x0
LAB_0016cfff:
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* MySQLConnection::Close() */
void __thiscall MySQLConnection::Close(MySQLConnection *this)
{
unique_ptr<MySQLPreparedStatement,std::default_delete<MySQLPreparedStatement>> *puVar1;
unique_ptr<MySQLPreparedStatement,std::default_delete<MySQLPreparedStatement>> *puVar2;
unique_ptr<MySQLPreparedStatement,std::default_delete<MySQLPreparedStatement>> *this_00;
std::__uniq_ptr_impl<DatabaseWorker,std::default_delete<DatabaseWorker>>::reset
((__uniq_ptr_impl<DatabaseWorker,std::default_delete<DatabaseWorker>> *)(this + 0x38),
(DatabaseWorker *)0x0);
puVar1 = *(unique_ptr<MySQLPreparedStatement,std::default_delete<MySQLPreparedStatement>> **)
(this + 8);
puVar2 = *(unique_ptr<MySQLPreparedStatement,std::default_delete<MySQLPreparedStatement>> **)
(this + 0x10);
this_00 = puVar1;
if (puVar2 != puVar1) {
do {
std::unique_ptr<MySQLPreparedStatement,std::default_delete<MySQLPreparedStatement>>::
~unique_ptr(this_00);
this_00 = this_00 + 8;
} while (this_00 != puVar2);
*(unique_ptr<MySQLPreparedStatement,std::default_delete<MySQLPreparedStatement>> **)
(this + 0x10) = puVar1;
}
if (*(long *)(this + 0x28) != 0) {
mysql_close();
*(int8 *)(this + 0x28) = 0;
}
return;
}
| |
24,831 | translog_write_variable_record_1group_header | eloqsql/storage/maria/ma_loghandler.c | static void
translog_write_variable_record_1group_header(struct st_translog_parts *parts,
enum translog_record_type type,
SHORT_TRANSACTION_ID short_trid,
uint16 header_length,
uchar *chunk0_header)
{
LEX_CUSTRING *part;
DBUG_ASSERT(parts->current != 0); /* first part is left for header */
part= parts->parts + (--parts->current);
parts->total_record_length+= (translog_size_t) (part->length= header_length);
part->str= chunk0_header;
/* puts chunk type */
*chunk0_header= (uchar) (type | TRANSLOG_CHUNK_LSN);
int2store(chunk0_header + 1, short_trid);
/* puts record length */
translog_write_variable_record_1group_code_len(chunk0_header + 3,
parts->record_length,
header_length);
/* puts 0 as chunk length which indicate 1 group record */
int2store(chunk0_header + header_length - 2, 0);
} | O0 | c | translog_write_variable_record_1group_header:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %cx, %ax
movw %dx, %cx
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movw %cx, -0xe(%rbp)
movw %ax, -0x10(%rbp)
movq %r8, -0x18(%rbp)
jmp 0x37613
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdx
movl 0x8(%rdx), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rdx)
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movzwl -0x10(%rbp), %eax
movq -0x20(%rbp), %rcx
movq %rax, 0x8(%rcx)
movl %eax, %ecx
movq -0x8(%rbp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %eax
orl $0x0, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movw -0xe(%rbp), %cx
movq -0x28(%rbp), %rax
movw %cx, (%rax)
movq -0x18(%rbp), %rdi
addq $0x3, %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
movzwl -0x10(%rbp), %edx
callq 0x37a10
movq -0x18(%rbp), %rax
movzwl -0x10(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
addq $-0x2, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movw $0x0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| translog_write_variable_record_1group_header:
push rbp
mov rbp, rsp
sub rsp, 30h
mov ax, cx
mov cx, dx
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_E], cx
mov [rbp+var_10], ax
mov [rbp+var_18], r8
jmp short $+2
loc_37613:
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov rdx, [rbp+var_8]
mov ecx, [rdx+8]
add ecx, 0FFFFFFFFh
mov [rdx+8], ecx
mov ecx, ecx
shl rcx, 4
add rax, rcx
mov [rbp+var_20], rax
movzx eax, [rbp+var_10]
mov rcx, [rbp+var_20]
mov [rcx+8], rax
mov ecx, eax
mov rax, [rbp+var_8]
add ecx, [rax+4]
mov [rax+4], ecx
mov rcx, [rbp+var_18]
mov rax, [rbp+var_20]
mov [rax], rcx
mov eax, [rbp+var_C]
or eax, 0
mov cl, al
mov rax, [rbp+var_18]
mov [rax], cl
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_28], rax
mov cx, [rbp+var_E]
mov rax, [rbp+var_28]
mov [rax], cx
mov rdi, [rbp+var_18]
add rdi, 3
mov rax, [rbp+var_8]
mov esi, [rax]
movzx edx, [rbp+var_10]
call translog_write_variable_record_1group_code_len
mov rax, [rbp+var_18]
movzx ecx, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
add rax, 0FFFFFFFFFFFFFFFEh
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
mov word ptr [rax], 0
add rsp, 30h
pop rbp
retn
| _WORD * translog_write_variable_record_1group_header(
unsigned int *a1,
char a2,
__int16 a3,
unsigned __int16 a4,
long long a5)
{
long long v5; // rax
unsigned int v6; // ecx
_WORD *result; // rax
_QWORD *v8; // [rsp+10h] [rbp-20h]
v5 = *((_QWORD *)a1 + 2);
v6 = a1[2] - 1;
a1[2] = v6;
v8 = (_QWORD *)(16LL * v6 + v5);
v8[1] = a4;
a1[1] += a4;
*v8 = a5;
*(_BYTE *)a5 = a2;
*(_WORD *)(a5 + 1) = a3;
translog_write_variable_record_1group_code_len(a5 + 3, *a1, a4);
result = (_WORD *)(a4 + a5 - 2);
*result = 0;
return result;
}
| translog_write_variable_record_1group_header:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV AX,CX
MOV CX,DX
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV word ptr [RBP + -0xe],CX
MOV word ptr [RBP + -0x10],AX
MOV qword ptr [RBP + -0x18],R8
JMP 0x00137613
LAB_00137613:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RDX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RDX + 0x8]
ADD ECX,-0x1
MOV dword ptr [RDX + 0x8],ECX
MOV ECX,ECX
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOVZX EAX,word ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x20]
MOV qword ptr [RCX + 0x8],RAX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD ECX,dword ptr [RAX + 0x4]
MOV dword ptr [RAX + 0x4],ECX
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
MOV EAX,dword ptr [RBP + -0xc]
OR EAX,0x0
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
MOV CX,word ptr [RBP + -0xe]
MOV RAX,qword ptr [RBP + -0x28]
MOV word ptr [RAX],CX
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x3
MOV RAX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RAX]
MOVZX EDX,word ptr [RBP + -0x10]
CALL 0x00137a10
MOV RAX,qword ptr [RBP + -0x18]
MOVZX ECX,word ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
ADD RAX,-0x2
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV word ptr [RAX],0x0
ADD RSP,0x30
POP RBP
RET
|
void translog_write_variable_record_1group_header
(int4 *param_1,int1 param_2,int2 param_3,ushort param_4,
int1 *param_5)
{
int iVar1;
int8 *puVar2;
iVar1 = param_1[2];
param_1[2] = iVar1 - 1U;
puVar2 = (int8 *)(*(long *)(param_1 + 4) + (ulong)(iVar1 - 1U) * 0x10);
puVar2[1] = (ulong)param_4;
param_1[1] = (uint)param_4 + param_1[1];
*puVar2 = param_5;
*param_5 = param_2;
*(int2 *)(param_5 + 1) = param_3;
translog_write_variable_record_1group_code_len(param_5 + 3,*param_1,param_4);
*(int2 *)(param_5 + (long)(int)(uint)param_4 + -2) = 0;
return;
}
| |
24,832 | safe_hash_search | eloqsql/mysys/my_safehash.c | uchar *safe_hash_search(SAFE_HASH *hash, const uchar *key, uint length,
uchar *def)
{
uchar *result;
DBUG_ENTER("safe_hash_search");
mysql_rwlock_rdlock(&hash->mutex);
result= my_hash_search(&hash->hash, key, length);
mysql_rwlock_unlock(&hash->mutex);
if (!result)
result= def;
else
result= ((SAFE_HASH_ENTRY*) result)->data;
DBUG_PRINT("exit",("data: %p", result));
DBUG_RETURN(result);
} | O0 | c | safe_hash_search:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x55e68(%rip), %rsi # 0x15478a
movl $0xa7, %edx
callq 0xfe990
movq -0x8(%rbp), %rdi
addq $0x98, %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0xde0a0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0xfea00
cmpq $0x0, -0x28(%rbp)
jne 0xfe963
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0xfe96f
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xfe971
jmp 0xfe973
jmp 0xfe975
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| safe_hash_search:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
mov rdi, [rbp+var_8]
lea rsi, aWorkspaceLlm4b_40; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0A7h
call inline_mysql_rwlock_rdlock_4
mov rdi, [rbp+var_8]
add rdi, 98h
mov rsi, [rbp+var_10]
mov eax, [rbp+var_14]
mov edx, eax
call my_hash_search
mov [rbp+var_28], rax
mov rdi, [rbp+var_8]
call inline_mysql_rwlock_unlock_8
cmp [rbp+var_28], 0
jnz short loc_FE963
mov rax, [rbp+var_20]
mov [rbp+var_28], rax
jmp short loc_FE96F
loc_FE963:
mov rax, [rbp+var_28]
mov rax, [rax+10h]
mov [rbp+var_28], rax
loc_FE96F:
jmp short $+2
loc_FE971:
jmp short $+2
loc_FE973:
jmp short $+2
loc_FE975:
mov rax, [rbp+var_28]
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
add rsp, 30h
pop rbp
retn
| long long safe_hash_search(long long a1, long long a2, unsigned int a3, long long a4)
{
long long v5; // [rsp+8h] [rbp-28h]
inline_mysql_rwlock_rdlock_4(a1, "/workspace/llm4binary/github2025/eloqsql/mysys/my_safehash.c", 167LL);
v5 = my_hash_search(a1 + 152, a2, a3);
inline_mysql_rwlock_unlock_8(a1);
if ( v5 )
return *(_QWORD *)(v5 + 16);
else
return a4;
}
| safe_hash_search:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x25478a]
MOV EDX,0xa7
CALL 0x001fe990
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x98
MOV RSI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x14]
MOV EDX,EAX
CALL 0x001de0a0
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001fea00
CMP qword ptr [RBP + -0x28],0x0
JNZ 0x001fe963
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001fe96f
LAB_001fe963:
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x28],RAX
LAB_001fe96f:
JMP 0x001fe971
LAB_001fe971:
JMP 0x001fe973
LAB_001fe973:
JMP 0x001fe975
LAB_001fe975:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x30
POP RBP
RET
|
int8 safe_hash_search(long param_1,int8 param_2,int4 param_3,int8 param_4)
{
long lVar1;
int8 local_30;
inline_mysql_rwlock_rdlock
(param_1,"/workspace/llm4binary/github2025/eloqsql/mysys/my_safehash.c",0xa7);
lVar1 = my_hash_search(param_1 + 0x98,param_2,param_3);
inline_mysql_rwlock_unlock(param_1);
local_30 = param_4;
if (lVar1 != 0) {
local_30 = *(int8 *)(lVar1 + 0x10);
}
return local_30;
}
| |
24,833 | my_mutex_end | eloqsql/mysys/thr_mutex.c | void my_mutex_end()
{
#ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
pthread_mutexattr_destroy(&my_fast_mutexattr);
#endif
#ifdef PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP
pthread_mutexattr_destroy(&my_errorcheck_mutexattr);
#endif
} | O3 | c | my_mutex_end:
pushq %rbp
movq %rsp, %rbp
leaq 0xb642c5(%rip), %rdi # 0xc08570
callq 0x291d0
leaq 0xb642bd(%rip), %rdi # 0xc08574
popq %rbp
jmp 0x291d0
nopl (%rax)
| my_mutex_end:
push rbp
mov rbp, rsp
lea rdi, my_fast_mutexattr
call _pthread_mutexattr_destroy
lea rdi, my_errorcheck_mutexattr
pop rbp
jmp _pthread_mutexattr_destroy
| long long my_mutex_end()
{
pthread_mutexattr_destroy(&my_fast_mutexattr);
return pthread_mutexattr_destroy(&my_errorcheck_mutexattr);
}
| my_mutex_end:
PUSH RBP
MOV RBP,RSP
LEA RDI,[0xd08570]
CALL 0x001291d0
LEA RDI,[0xd08574]
POP RBP
JMP 0x001291d0
|
void my_mutex_end(void)
{
pthread_mutexattr_destroy((pthread_mutexattr_t *)&my_fast_mutexattr);
pthread_mutexattr_destroy((pthread_mutexattr_t *)&my_errorcheck_mutexattr);
return;
}
| |
24,834 | js_regexp_string_iterator_next | bluesky950520[P]quickjs/quickjs.c | static JSValue js_regexp_string_iterator_next(JSContext *ctx,
JSValue this_val,
int argc, JSValue *argv,
BOOL *pdone, int magic)
{
JSRegExpStringIteratorData *it;
JSValue R, S;
JSValue matchStr = JS_UNDEFINED, match = JS_UNDEFINED;
JSString *sp;
it = JS_GetOpaque2(ctx, this_val, JS_CLASS_REGEXP_STRING_ITERATOR);
if (!it)
goto exception;
if (it->done) {
*pdone = TRUE;
return JS_UNDEFINED;
}
R = it->iterating_regexp;
S = it->iterated_string;
match = JS_RegExpExec(ctx, R, S);
if (JS_IsException(match))
goto exception;
if (JS_IsNull(match)) {
it->done = TRUE;
*pdone = TRUE;
return JS_UNDEFINED;
} else if (it->global) {
matchStr = JS_ToStringFree(ctx, JS_GetPropertyInt64(ctx, match, 0));
if (JS_IsException(matchStr))
goto exception;
if (JS_IsEmptyString(matchStr)) {
int64_t thisIndex, nextIndex;
if (JS_ToLengthFree(ctx, &thisIndex,
JS_GetProperty(ctx, R, JS_ATOM_lastIndex)) < 0)
goto exception;
sp = JS_VALUE_GET_STRING(S);
nextIndex = string_advance_index(sp, thisIndex, it->unicode);
if (JS_SetProperty(ctx, R, JS_ATOM_lastIndex, js_int64(nextIndex)) < 0)
goto exception;
}
JS_FreeValue(ctx, matchStr);
} else {
it->done = TRUE;
}
*pdone = FALSE;
return match;
exception:
JS_FreeValue(ctx, match);
JS_FreeValue(ctx, matchStr);
*pdone = FALSE;
return JS_EXCEPTION;
} | O2 | c | js_regexp_string_iterator_next:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %rdi, %r15
pushq $0x2e
popq %rcx
callq 0x24db7
pushq $0x3
popq %r13
testq %rax, %rax
je 0x458b0
movq %rax, %r12
cmpl $0x0, 0x28(%rax)
je 0x458f0
movl $0x1, (%rbx)
pushq $0x3
jmp 0x458d5
xorl %esi, %esi
movq %r13, %r14
xorl %ebp, %ebp
movq %r15, %rdi
movq %r14, %rdx
callq 0x1bbce
movq %r15, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x1bbce
andl $0x0, (%rbx)
pushq $0x6
popq %r14
xorl %eax, %eax
xorl %ecx, %ecx
orq %rcx, %rax
movq %r14, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r12), %rbp
movq 0x8(%r12), %rdx
movq 0x10(%r12), %rcx
movq 0x18(%r12), %r8
movq %r15, %rdi
movq %rbp, %rsi
movq %rdx, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
callq 0x44eeb
movq %rax, %rsi
movq %rdx, %r14
cmpl $0x6, %r14d
je 0x458b5
cmpl $0x2, %r14d
jne 0x45939
pushq $0x1
popq %rax
movl %eax, 0x28(%r12)
movl %eax, (%rbx)
jmp 0x458ac
cmpl $0x0, 0x20(%r12)
je 0x45995
movq %rbp, 0x8(%rsp)
movq %r15, %rdi
movq %rsi, (%rsp)
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x21d28
movq %r15, %rdi
movq %rax, %rsi
callq 0x31bf9
movq %rax, %rbp
movq %rdx, %r13
cmpl $0x6, %r13d
je 0x45a23
cmpl $-0x7, %r13d
jne 0x45981
testl $0x7fffffff, 0x4(%rbp) # imm = 0x7FFFFFFF
je 0x459b8
movq %r15, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x1bbce
movq (%rsp), %rsi
jmp 0x4599e
movl $0x1, 0x28(%r12)
andl $0x0, (%rbx)
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %rsi, %rcx
andq %rax, %rcx
movl %esi, %eax
jmp 0x458db
pushq $0x56
popq %rcx
movq %r15, %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x1ebf3
movq %rdx, %rcx
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
movq %rax, %rdx
callq 0x416a8
testl %eax, %eax
js 0x45a23
movq 0x20(%rsp), %rsi
movl 0x24(%r12), %edx
movq 0x18(%rsp), %rdi
callq 0x45101
movq %rax, %rdi
callq 0x245bb
movq %rdx, %r9
pushq $0x56
popq %rcx
movq %r15, %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %r8
callq 0x21ff6
testl %eax, %eax
jns 0x45981
movq (%rsp), %rsi
jmp 0x458b7
| js_regexp_string_iterator_next:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, r9
mov r15, rdi
push 2Eh ; '.'
pop rcx
call JS_GetOpaque2
push 3
pop r13
test rax, rax
jz short loc_458B0
mov r12, rax
cmp dword ptr [rax+28h], 0
jz short loc_458F0
mov dword ptr [rbx], 1
loc_458AC:
push 3
jmp short loc_458D5
loc_458B0:
xor esi, esi
mov r14, r13
loc_458B5:
xor ebp, ebp
loc_458B7:
mov rdi, r15
mov rdx, r14
call JS_FreeValue
mov rdi, r15
mov rsi, rbp
mov rdx, r13
call JS_FreeValue
and dword ptr [rbx], 0
push 6
loc_458D5:
pop r14
xor eax, eax
xor ecx, ecx
loc_458DB:
or rax, rcx
mov rdx, r14
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_458F0:
mov rbp, [r12]
mov rdx, [r12+8]
mov rcx, [r12+10h]
mov r8, [r12+18h]
mov rdi, r15
mov rsi, rbp
mov [rsp+58h+var_48], rdx
mov [rsp+58h+var_40], rcx
call JS_RegExpExec
mov rsi, rax
mov r14, rdx
cmp r14d, 6
jz short loc_458B5
cmp r14d, 2
jnz short loc_45939
push 1
pop rax
mov [r12+28h], eax
mov [rbx], eax
jmp loc_458AC
loc_45939:
cmp dword ptr [r12+20h], 0
jz short loc_45995
mov [rsp+58h+var_50], rbp
mov rdi, r15
mov [rsp+58h+var_58], rsi
mov rdx, r14
xor ecx, ecx
call JS_GetPropertyInt64
mov rdi, r15
mov rsi, rax
call JS_ToStringFree
mov rbp, rax
mov r13, rdx
cmp r13d, 6
jz loc_45A23
cmp r13d, 0FFFFFFF9h
jnz short loc_45981
test dword ptr [rbp+4], 7FFFFFFFh
jz short loc_459B8
loc_45981:
mov rdi, r15
mov rsi, rbp
mov rdx, r13
call JS_FreeValue
mov rsi, [rsp+58h+var_58]
jmp short loc_4599E
loc_45995:
mov dword ptr [r12+28h], 1
loc_4599E:
and dword ptr [rbx], 0
mov rax, 0FFFFFFFF00000000h
mov rcx, rsi
and rcx, rax
mov eax, esi
jmp loc_458DB
loc_459B8:
push 56h ; 'V'
pop rcx
mov rdi, r15
mov rsi, [rsp+58h+var_50]
mov rdx, [rsp+58h+var_48]
call JS_GetProperty
mov rcx, rdx
lea rsi, [rsp+58h+var_38]
mov rdi, r15
mov rdx, rax
call JS_ToLengthFree
test eax, eax
js short loc_45A23
mov rsi, [rsp+58h+var_38]
mov edx, [r12+24h]
mov rdi, [rsp+58h+var_40]
call string_advance_index
mov rdi, rax
call js_int64
mov r9, rdx
push 56h ; 'V'
pop rcx
mov rdi, r15
mov rsi, [rsp+58h+var_50]
mov rdx, [rsp+58h+var_48]
mov r8, rax
call JS_SetProperty
test eax, eax
jns loc_45981
loc_45A23:
mov rsi, [rsp+58h+var_58]
jmp loc_458B7
| unsigned long long js_regexp_string_iterator_next(
long long a1,
long long a2,
int a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11,
long long a12,
long long a13,
_DWORD *a14)
{
long long Opaque2; // rax
double v16; // xmm4_8
double v17; // xmm5_8
long long v18; // r13
_DWORD *v19; // r12
long long v20; // rsi
long long v21; // r14
long long v22; // rbp
long long v23; // rax
unsigned long long v24; // rcx
long long v26; // rbp
long long v27; // rax
long long v28; // rdx
unsigned long long PropertyInt64; // rax
long long v30; // rdx
long long v31; // rax
long long v32; // rdx
_DWORD *Property; // rax
long long v34; // rdx
long long v35; // rax
int v36; // eax
int v37; // edx
long long v38; // [rsp+0h] [rbp-58h]
int v39; // [rsp+8h] [rbp-50h]
long long v40; // [rsp+10h] [rbp-48h]
long long v41; // [rsp+18h] [rbp-40h]
unsigned long long v42[7]; // [rsp+20h] [rbp-38h] BYREF
Opaque2 = JS_GetOpaque2(a1, a2, a3, 0x2Eu);
v18 = 3LL;
if ( !Opaque2 )
{
v20 = 0LL;
v21 = 3LL;
goto LABEL_5;
}
v19 = (_DWORD *)Opaque2;
if ( !*(_DWORD *)(Opaque2 + 40) )
{
v26 = *(_QWORD *)Opaque2;
v40 = *(_QWORD *)(Opaque2 + 8);
v41 = *(_QWORD *)(Opaque2 + 16);
v27 = JS_RegExpExec(a1, *(_QWORD *)Opaque2, v40, v41, *(_QWORD *)(Opaque2 + 24), a4, a5, a6, a7, v16, v17, a10, a11);
v20 = v27;
v21 = v28;
if ( (_DWORD)v28 != 6 )
{
if ( (_DWORD)v28 == 2 )
{
v19[10] = 1;
*a14 = 1;
goto LABEL_7;
}
if ( v19[8] )
{
v39 = v26;
v38 = v27;
PropertyInt64 = JS_GetPropertyInt64(a1, v27, v28, 0LL);
v31 = JS_ToStringFree(a1, PropertyInt64, v30);
v22 = v31;
v18 = v32;
if ( (_DWORD)v32 == 6
|| (_DWORD)v32 == -7
&& (*(_DWORD *)(v31 + 4) & 0x7FFFFFFF) == 0
&& ((Property = (_DWORD *)JS_GetProperty(a1, v39, v40, 86), (int)JS_ToLengthFree(a1, v42, Property, v34) < 0)
|| (v35 = string_advance_index(v41, v42[0], v19[9]),
v36 = js_int64(v35),
(int)JS_SetProperty(a1, v39, v40, 86, v36, v37) < 0)) )
{
v20 = v38;
goto LABEL_6;
}
JS_FreeValue(a1, v22, v18);
v20 = v38;
}
else
{
v19[10] = 1;
}
*a14 = 0;
v24 = v20 & 0xFFFFFFFF00000000LL;
v23 = (unsigned int)v20;
return v24 | v23;
}
LABEL_5:
v22 = 0LL;
LABEL_6:
JS_FreeValue(a1, v20, v21);
JS_FreeValue(a1, v22, v18);
*a14 = 0;
goto LABEL_7;
}
*a14 = 1;
LABEL_7:
v23 = 0LL;
v24 = 0LL;
return v24 | v23;
}
| js_regexp_string_iterator_next:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,R9
MOV R15,RDI
PUSH 0x2e
POP RCX
CALL 0x00124db7
PUSH 0x3
POP R13
TEST RAX,RAX
JZ 0x001458b0
MOV R12,RAX
CMP dword ptr [RAX + 0x28],0x0
JZ 0x001458f0
MOV dword ptr [RBX],0x1
LAB_001458ac:
PUSH 0x3
JMP 0x001458d5
LAB_001458b0:
XOR ESI,ESI
MOV R14,R13
LAB_001458b5:
XOR EBP,EBP
LAB_001458b7:
MOV RDI,R15
MOV RDX,R14
CALL 0x0011bbce
MOV RDI,R15
MOV RSI,RBP
MOV RDX,R13
CALL 0x0011bbce
AND dword ptr [RBX],0x0
PUSH 0x6
LAB_001458d5:
POP R14
XOR EAX,EAX
XOR ECX,ECX
LAB_001458db:
OR RAX,RCX
MOV RDX,R14
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001458f0:
MOV RBP,qword ptr [R12]
MOV RDX,qword ptr [R12 + 0x8]
MOV RCX,qword ptr [R12 + 0x10]
MOV R8,qword ptr [R12 + 0x18]
MOV RDI,R15
MOV RSI,RBP
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RSP + 0x18],RCX
CALL 0x00144eeb
MOV RSI,RAX
MOV R14,RDX
CMP R14D,0x6
JZ 0x001458b5
CMP R14D,0x2
JNZ 0x00145939
PUSH 0x1
POP RAX
MOV dword ptr [R12 + 0x28],EAX
MOV dword ptr [RBX],EAX
JMP 0x001458ac
LAB_00145939:
CMP dword ptr [R12 + 0x20],0x0
JZ 0x00145995
MOV qword ptr [RSP + 0x8],RBP
MOV RDI,R15
MOV qword ptr [RSP],RSI
MOV RDX,R14
XOR ECX,ECX
CALL 0x00121d28
MOV RDI,R15
MOV RSI,RAX
CALL 0x00131bf9
MOV RBP,RAX
MOV R13,RDX
CMP R13D,0x6
JZ 0x00145a23
CMP R13D,-0x7
JNZ 0x00145981
TEST dword ptr [RBP + 0x4],0x7fffffff
JZ 0x001459b8
LAB_00145981:
MOV RDI,R15
MOV RSI,RBP
MOV RDX,R13
CALL 0x0011bbce
MOV RSI,qword ptr [RSP]
JMP 0x0014599e
LAB_00145995:
MOV dword ptr [R12 + 0x28],0x1
LAB_0014599e:
AND dword ptr [RBX],0x0
MOV RAX,-0x100000000
MOV RCX,RSI
AND RCX,RAX
MOV EAX,ESI
JMP 0x001458db
LAB_001459b8:
PUSH 0x56
POP RCX
MOV RDI,R15
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
CALL 0x0011ebf3
MOV RCX,RDX
LEA RSI,[RSP + 0x20]
MOV RDI,R15
MOV RDX,RAX
CALL 0x001416a8
TEST EAX,EAX
JS 0x00145a23
MOV RSI,qword ptr [RSP + 0x20]
MOV EDX,dword ptr [R12 + 0x24]
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x00145101
MOV RDI,RAX
CALL 0x001245bb
MOV R9,RDX
PUSH 0x56
POP RCX
MOV RDI,R15
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
MOV R8,RAX
CALL 0x00121ff6
TEST EAX,EAX
JNS 0x00145981
LAB_00145a23:
MOV RSI,qword ptr [RSP]
JMP 0x001458b7
|
int1 [16] js_regexp_string_iterator_next(int8 param_1)
{
int8 uVar1;
int8 uVar2;
int iVar3;
int8 *puVar4;
ulong uVar5;
int8 uVar6;
int8 uVar7;
ulong uVar8;
int4 *in_R9;
int1 auVar9 [16];
int1 auVar10 [16];
int1 auVar11 [16];
int8 uStack_60;
int8 local_38;
puVar4 = (int8 *)JS_GetOpaque2();
if (puVar4 == (int8 *)0x0) {
auVar9 = ZEXT816(3) << 0x40;
LAB_001458b5:
auVar10 = ZEXT816(3) << 0x40;
LAB_001458b7:
JS_FreeValue(param_1,auVar9._0_8_,auVar9._8_8_);
JS_FreeValue(param_1,auVar10._0_8_,auVar10._8_8_);
*in_R9 = 0;
uStack_60 = 6;
}
else {
if (*(int *)(puVar4 + 5) == 0) {
uVar1 = *puVar4;
uVar2 = puVar4[1];
uVar7 = puVar4[2];
auVar9 = JS_RegExpExec(param_1,uVar1,uVar2,uVar7,puVar4[3]);
uStack_60 = auVar9._8_8_;
uVar5 = auVar9._0_8_;
if (auVar9._8_4_ == 6) goto LAB_001458b5;
if (auVar9._8_4_ == 2) {
*(int4 *)(puVar4 + 5) = 1;
*in_R9 = 1;
goto LAB_001458ac;
}
if (*(int *)(puVar4 + 4) == 0) {
*(int4 *)(puVar4 + 5) = 1;
LAB_0014599e:
*in_R9 = 0;
uVar8 = uVar5 & 0xffffffff00000000;
uVar5 = uVar5 & 0xffffffff;
goto LAB_001458db;
}
uVar6 = JS_GetPropertyInt64(param_1,uVar5,uStack_60,0);
auVar10 = JS_ToStringFree(param_1,uVar6);
if (auVar10._8_4_ != 6) {
if ((auVar10._8_4_ != -7) || ((*(uint *)(auVar10._0_8_ + 4) & 0x7fffffff) != 0)) {
LAB_00145981:
JS_FreeValue(param_1,auVar10._0_8_,auVar10._8_8_);
goto LAB_0014599e;
}
auVar11 = JS_GetProperty(param_1,uVar1,uVar2,0x56);
iVar3 = JS_ToLengthFree(param_1,&local_38,auVar11._0_8_,auVar11._8_8_);
if (-1 < iVar3) {
uVar7 = string_advance_index(uVar7,local_38,*(int4 *)((long)puVar4 + 0x24));
auVar11 = js_int64(uVar7);
iVar3 = JS_SetProperty(param_1,uVar1,uVar2,0x56,auVar11._0_8_,auVar11._8_8_);
if (-1 < iVar3) goto LAB_00145981;
}
}
goto LAB_001458b7;
}
*in_R9 = 1;
LAB_001458ac:
uStack_60 = 3;
}
uVar5 = 0;
uVar8 = 0;
LAB_001458db:
auVar9._0_8_ = uVar5 | uVar8;
auVar9._8_8_ = uStack_60;
return auVar9;
}
| |
24,835 | dirname_length | eloqsql/mysys/mf_dirname.c | size_t dirname_length(const char *name)
{
register char *pos, *gpos;
#ifdef BASKSLASH_MBTAIL
CHARSET_INFO *fs= fs_character_set();
#endif
#ifdef FN_DEVCHAR
if ((pos=(char*)strrchr(name,FN_DEVCHAR)) == 0)
#endif
pos=(char*) name-1;
gpos= pos++;
for ( ; *pos ; pos++) /* Find last FN_LIBCHAR */
{
#ifdef BASKSLASH_MBTAIL
uint l;
if (my_ci_use_mb(fs) && (l= my_ismbchar(fs, pos, pos + 3)))
{
pos+= l - 1;
continue;
}
#endif
if (*pos == FN_LIBCHAR || *pos == '/')
gpos=pos;
}
return (size_t) (gpos+1-(char*) name);
} | O3 | c | dirname_length:
pushq %rbp
movq %rsp, %rbp
leaq -0x1(%rdi), %rax
movq %rdi, %rcx
movzbl (%rcx), %edx
cmpl $0x2f, %edx
je 0x94c7d
testl %edx, %edx
jne 0x94c80
jmp 0x94c85
movq %rcx, %rax
incq %rcx
jmp 0x94c6f
subq %rdi, %rax
incq %rax
popq %rbp
retq
| dirname_length:
push rbp
mov rbp, rsp
lea rax, [rdi-1]
mov rcx, rdi
loc_94C6F:
movzx edx, byte ptr [rcx]
cmp edx, 2Fh ; '/'
jz short loc_94C7D
test edx, edx
jnz short loc_94C80
jmp short loc_94C85
loc_94C7D:
mov rax, rcx
loc_94C80:
inc rcx
jmp short loc_94C6F
loc_94C85:
sub rax, rdi
inc rax
pop rbp
retn
| long long dirname_length(_BYTE *a1)
{
_BYTE *v1; // rax
_BYTE *i; // rcx
v1 = a1 - 1;
for ( i = a1; *i == 47; ++i )
{
v1 = i;
LABEL_6:
;
}
if ( *i )
goto LABEL_6;
return v1 - a1 + 1;
}
| dirname_length:
PUSH RBP
MOV RBP,RSP
LEA RAX,[RDI + -0x1]
MOV RCX,RDI
LAB_00194c6f:
MOVZX EDX,byte ptr [RCX]
CMP EDX,0x2f
JZ 0x00194c7d
TEST EDX,EDX
JNZ 0x00194c80
JMP 0x00194c85
LAB_00194c7d:
MOV RAX,RCX
LAB_00194c80:
INC RCX
JMP 0x00194c6f
LAB_00194c85:
SUB RAX,RDI
INC RAX
POP RBP
RET
|
char * dirname_length(char *param_1)
{
char *pcVar1;
char *pcVar2;
char *pcVar3;
pcVar1 = param_1 + -1;
for (pcVar3 = param_1; (pcVar2 = pcVar3, *pcVar3 == '/' || (pcVar2 = pcVar1, *pcVar3 != '\0'));
pcVar3 = pcVar3 + 1) {
pcVar1 = pcVar2;
}
return pcVar1 + (1 - (long)param_1);
}
| |
24,836 | testing::internal::PrintBytesInObjectTo(unsigned char const*, unsigned long, std::ostream*) | AlayaLite/build_O3/_deps/googletest-src/googletest/src/gtest-printers.cc | void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count,
ostream* os) {
PrintBytesInObjectToImpl(obj_bytes, count, os);
} | O3 | cpp | testing::internal::PrintBytesInObjectTo(unsigned char const*, unsigned long, std::ostream*):
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x11630
leaq 0x2f24e(%rip), %rsi # 0x88119
movl $0xe, %edx
movq %rax, %rdi
callq 0x11b90
cmpq $0x83, %r14
ja 0x58ee8
movq %r15, %rdi
xorl %esi, %esi
jmp 0x58f1c
movl $0x40, %edx
movq %r15, %rdi
xorl %esi, %esi
movq %rbx, %rcx
callq 0x71c66
leaq 0x2f227(%rip), %rsi # 0x88128
movl $0x5, %edx
movq %rbx, %rdi
callq 0x11b90
leaq -0x3f(%r14), %rsi
andq $-0x2, %rsi
subq %rsi, %r14
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x71c66
leaq 0x2e885(%rip), %rsi # 0x877b3
movl $0x1, %edx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x11b90
| _ZN7testing8internal20PrintBytesInObjectToEPKhmPSo:
push r15
push r14
push rbx
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov rdi, rdx
call __ZNSo9_M_insertImEERSoT_; std::ostream::_M_insert<ulong>(ulong)
lea rsi, aByteObject; "-byte object <"
mov edx, 0Eh
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)
cmp r14, 83h
ja short loc_58EE8
mov rdi, r15
xor esi, esi
jmp short loc_58F1C
loc_58EE8:
mov edx, 40h ; '@'; unsigned __int64
mov rdi, r15; this
xor esi, esi; unsigned __int8 *
mov rcx, rbx; unsigned __int64
call _ZN7testing12_GLOBAL__N_126PrintByteSegmentInObjectToEPKhmmPSo; testing::`anonymous namespace'::PrintByteSegmentInObjectTo(uchar const*,ulong,ulong,std::ostream *)
lea rsi, asc_88128; " ... "
mov edx, 5
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, [r14-3Fh]
and rsi, 0FFFFFFFFFFFFFFFEh; unsigned __int8 *
sub r14, rsi
mov rdi, r15; this
loc_58F1C:
mov rdx, r14; unsigned __int64
mov rcx, rbx; unsigned __int64
call _ZN7testing12_GLOBAL__N_126PrintByteSegmentInObjectToEPKhmmPSo; testing::`anonymous namespace'::PrintByteSegmentInObjectTo(uchar const*,ulong,ulong,std::ostream *)
lea rsi, aType+9; ">"
mov edx, 1
mov rdi, rbx
pop rbx
pop r14
pop r15
jmp __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
| long long testing::internal::PrintBytesInObjectTo(
testing::internal *this,
const unsigned __int8 *a2,
unsigned long long a3,
std::ostream *a4)
{
const unsigned __int8 *v5; // r14
long long v6; // rax
std::ostream *v7; // r8
unsigned long long v8; // rsi
v5 = a2;
v6 = std::ostream::_M_insert<unsigned long>(a3, a2);
std::__ostream_insert<char,std::char_traits<char>>(v6, "-byte object <", 14LL);
if ( (unsigned long long)a2 > 0x83 )
{
testing::`anonymous namespace'::PrintByteSegmentInObjectTo(this, 0LL, 0x40uLL, a3, v7);
std::__ostream_insert<char,std::char_traits<char>>(a3, " ... ", 5LL);
v8 = (unsigned long long)(a2 - 63) & 0xFFFFFFFFFFFFFFFELL;
v5 -= v8;
}
else
{
v8 = 0LL;
}
testing::`anonymous namespace'::PrintByteSegmentInObjectTo(
this,
(const unsigned __int8 *)v8,
(unsigned long long)v5,
a3,
v7);
return std::__ostream_insert<char,std::char_traits<char>>(a3, ">", 1LL);
}
| PrintBytesInObjectTo:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV RDI,RDX
CALL 0x00111630
LEA RSI,[0x188119]
MOV EDX,0xe
MOV RDI,RAX
CALL 0x00111b90
CMP R14,0x83
JA 0x00158ee8
MOV RDI,R15
XOR ESI,ESI
JMP 0x00158f1c
LAB_00158ee8:
MOV EDX,0x40
MOV RDI,R15
XOR ESI,ESI
MOV RCX,RBX
CALL 0x00171c66
LEA RSI,[0x188128]
MOV EDX,0x5
MOV RDI,RBX
CALL 0x00111b90
LEA RSI,[R14 + -0x3f]
AND RSI,-0x2
SUB R14,RSI
MOV RDI,R15
LAB_00158f1c:
MOV RDX,R14
MOV RCX,RBX
CALL 0x00171c66
LEA RSI,[0x1877b3]
MOV EDX,0x1
MOV RDI,RBX
POP RBX
POP R14
POP R15
JMP 0x00111b90
|
/* testing::internal::PrintBytesInObjectTo(unsigned char const*, unsigned long, std::ostream*) */
void testing::internal::PrintBytesInObjectTo(uchar *param_1,ulong param_2,ostream *param_3)
{
ostream *poVar1;
ulong uVar2;
poVar1 = std::ostream::_M_insert<unsigned_long>((ulong)param_3);
std::__ostream_insert<char,std::char_traits<char>>(poVar1,"-byte object <",0xe);
if (param_2 < 0x84) {
uVar2 = 0;
}
else {
testing::(anonymous_namespace)::PrintByteSegmentInObjectTo(param_1,0,0x40,param_3);
std::__ostream_insert<char,std::char_traits<char>>(param_3," ... ",5);
uVar2 = param_2 - 0x3f & 0xfffffffffffffffe;
param_2 = param_2 - uVar2;
}
testing::(anonymous_namespace)::PrintByteSegmentInObjectTo(param_1,uVar2,param_2,param_3);
std::__ostream_insert<char,std::char_traits<char>>(param_3,">",1);
return;
}
| |
24,837 | facebook::yoga::test::EventTest_layout_events_counts_cache_hits_single_node_layout_Test::EventTest_layout_events_counts_cache_hits_single_node_layout_Test() | yoga-mod/tests/EventsTest.cpp | TEST_F(EventTest, layout_events_counts_cache_hits_single_node_layout) {
auto root = YGNodeNew();
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
ASSERT_EQ(events[4].node, root);
ASSERT_EQ(events[4].type, Event::LayoutPassStart);
ASSERT_EQ(events[6].node, root);
ASSERT_EQ(events[6].type, Event::LayoutPassEnd);
LayoutData layoutData =
events[6].eventTestData<Event::LayoutPassEnd>().layoutData;
ASSERT_EQ(layoutData.layouts, 0);
ASSERT_EQ(layoutData.measures, 0);
ASSERT_EQ(layoutData.cachedLayouts, 1);
ASSERT_EQ(layoutData.cachedMeasures, 0);
} | O0 | cpp | facebook::yoga::test::EventTest_layout_events_counts_cache_hits_single_node_layout_Test::EventTest_layout_events_counts_cache_hits_single_node_layout_Test():
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x930e0
movq -0x10(%rbp), %rax
leaq 0x7c703c(%rip), %rcx # 0x85b310
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| _ZN8facebook4yoga4test65EventTest_layout_events_counts_cache_hits_single_node_layout_TestC2Ev:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]; this
mov [rbp+var_10], rdi
call _ZN8facebook4yoga4test9EventTestC2Ev; facebook::yoga::test::EventTest::EventTest(void)
mov rax, [rbp+var_10]
lea rcx, _ZTVN8facebook4yoga4test65EventTest_layout_events_counts_cache_hits_single_node_layout_TestE; `vtable for'facebook::yoga::test::EventTest_layout_events_counts_cache_hits_single_node_layout_Test
add rcx, 10h
mov [rax], rcx
add rsp, 10h
pop rbp
retn
| facebook::yoga::test::EventTest_layout_events_counts_cache_hits_single_node_layout_Test * facebook::yoga::test::EventTest_layout_events_counts_cache_hits_single_node_layout_Test::EventTest_layout_events_counts_cache_hits_single_node_layout_Test(
facebook::yoga::test::EventTest_layout_events_counts_cache_hits_single_node_layout_Test *this)
{
facebook::yoga::test::EventTest_layout_events_counts_cache_hits_single_node_layout_Test *result; // rax
facebook::yoga::test::EventTest::EventTest(this);
result = this;
*(_QWORD *)this = (char *)&`vtable for'facebook::yoga::test::EventTest_layout_events_counts_cache_hits_single_node_layout_Test
+ 16;
return result;
}
| EventTest_layout_events_counts_cache_hits_single_node_layout_Test:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RDI
CALL 0x001930e0
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0x95b310]
ADD RCX,0x10
MOV qword ptr [RAX],RCX
ADD RSP,0x10
POP RBP
RET
|
/* facebook::yoga::test::EventTest_layout_events_counts_cache_hits_single_node_layout_Test::EventTest_layout_events_counts_cache_hits_single_node_layout_Test()
*/
void __thiscall
facebook::yoga::test::EventTest_layout_events_counts_cache_hits_single_node_layout_Test::
EventTest_layout_events_counts_cache_hits_single_node_layout_Test
(EventTest_layout_events_counts_cache_hits_single_node_layout_Test *this)
{
EventTest::EventTest((EventTest *)this);
*(int ***)this =
&PTR__EventTest_layout_events_counts_cache_hits_single_node_layout_Test_0095b320;
return;
}
| |
24,838 | OpenSubdiv::v3_6_0::Bfr::(anonymous namespace)::FacetStrip::connectNonUniformFacets(OpenSubdiv::v3_6_0::Bfr::(anonymous namespace)::FacetArray) const | NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/tessellation.cpp | int
FacetStrip::connectNonUniformFacets(FacetArray facets) const {
//
// General case:
//
// oPrev -- iFirst . ... i0+/-i ... . iLast --*
// | / . . \ |
// | / | | \ |
// oFirst -------- o0 ... o0+i ... oN-1 ------ oLast
//
// The sequence of edges -- both inner and outer -- is parameterized
// over the integer range [0 .. M*N] where M and N are the resolution
// (number of edges) of the inner and outer rings respectively.
//
// Note that the current implementation expects the faces at the
// ends to be "split", i.e. a diagonal edge created between the
// first/last points of the inner and outer rings at both ends.
// It is possible that this will later be relaxed (allowing an
// unsplit quad at the corner to be generated), as is currently
// the case with uniform strips. In the meantime, the caller is
// expected to explicitly request split corners to make it clear
// where they need to adapt later.
//
assert(splitFirstFace && splitLastFace);
int M = innerEdges + (quadTopology ? 2 : 3);
int N = outerEdges;
int dtOuter = M;
int dtInner = N;
int dtMin = std::min(dtInner, dtOuter);
int dtMax = std::max(dtInner, dtOuter);
// Use larger slope when M ~= N to accomodate tri insertion:
int dtSlopeMax = ((dtMax / 2) < dtMin) ? (dtMin - 1) : (dtMax / 2);
int tOuterLast = dtOuter * N;
int tOuterMiddle = tOuterLast / 2;
int tInnerOffset = 0;
int tInnerLast = dtInner * (M - 1);
// If tris, adjust parametric range for the inner edges:
if (!quadTopology) {
tInnerOffset = dtInner / 2;
tInnerLast += tInnerOffset - dtInner;
}
int dInner = innerReversed ? -1 : 1;
//
// Two points are successively identified on each of the inner and
// outer sequence of edges, from which facets will be generated:
//
// inner0 inner1
// * ----- * . . .
// /
// /
// * ----------- * . . .
// outer0 outer1
//
// Identify the parameterization and coordinate indices for the
// points starting the sequence:
//
int tOuter0 = 0;
int cOuter0 = outerFirst;
int tOuter1 = dtOuter;
int cOuter1 = (N == 1) ? outerLast : (outerFirst + 1);
int tInner0 = tInnerOffset + dtInner;
int cInner0 = innerFirst;
int tInner1 = tInner0 + (innerEdges ? dtInner : 0);
int cInner1 = (innerEdges == 1) ? innerLast : (innerFirst + dInner);
//
// Walk forward through the strip, identifying each successive quad
// and choosing the most "vertical" edge to use to triangulate it:
//
bool keepQuads = quadTopology && !quadTriangulate;
int nFacetsExpected = 0;
if (keepQuads) {
nFacetsExpected = std::max(innerEdges, outerEdges);
// Include a symmetric center triangle if any side is odd:
if ((nFacetsExpected & 1) == 0) {
nFacetsExpected += (innerEdges & 1) || (outerEdges & 1);
}
} else {
nFacetsExpected = innerEdges + outerEdges;
}
// These help maintain symmetry where possible:
int nFacetsLeading = nFacetsExpected / 2;
int nFacetsMiddle = nFacetsExpected & 1;
int middleFacet = nFacetsMiddle ? nFacetsLeading : -1;
bool middleQuad = keepQuads && (outerEdges & 1) && (innerEdges & 1);
//
// Assign all expected facets sequentially -- advancing references
// to the inner and outer edges according to what is used for each:
//
for (int facetIndex = 0; facetIndex < nFacetsExpected; ++facetIndex) {
bool generateTriOuter = false;
bool generateTriInner = false;
bool generateQuad = false;
//
// Detect simple cases first: the symmetric center face or
// triangles in the absence of an inner or outer edge:
//
if (facetIndex == middleFacet) {
if (middleQuad) {
generateQuad = true;
} else if (outerEdges & 1) {
generateTriOuter = true;
} else {
generateTriInner = true;
}
} else if (tInner1 == tInner0) {
generateTriOuter = true;
} else if (tOuter1 == tOuter0) {
generateTriInner = true;
} else {
//
// For the general case, assign a quad if specified and
// possible. Otherwise continue with a triangle. Both
// situations avoid poor aspect and preserve symmetry:
//
if (keepQuads) {
// If face is after the midpoint, use the same kind of
// face as its mirrored counterpart. Otherwise, reject a
// quad trying to cross the midpoint. Finally, test the
// slope of the "vertical" edge of the potential quad:
if (facetIndex >= nFacetsLeading) {
int mirroredFacetIndex = nFacetsLeading - 1 -
(facetIndex - nFacetsLeading - nFacetsMiddle);
generateQuad = (facets[mirroredFacetIndex][3] >= 0);
} else if ((tInner1 > tOuterMiddle) ||
(tOuter1 > tOuterMiddle)) {
generateQuad = false;
} else {
int dtSlope1 = std::abs(tOuter1 - tInner1);
generateQuad = (dtSlope1 <= dtSlopeMax);
}
}
if (!generateQuad) {
// Can't detect symmetric triangles as inner or outer as
// easily as quads, but the test is relatively simple --
// choose the diagonal spanning the shortest interval
// (when equal, choose relative to midpoint for symmetry):
int dtDiagToOuter1 = tOuter1 - tInner0;
int dtDiagToInner1 = tInner1 - tOuter0;
bool useOuterEdge = (dtDiagToOuter1 == dtDiagToInner1)
? (tOuter1 > tOuterMiddle)
: (dtDiagToOuter1 < dtDiagToInner1);
if (useOuterEdge) {
generateTriOuter = true;
} else {
generateTriInner = true;
}
}
}
// Assign the face as determined above:
if (generateTriOuter) {
facets[facetIndex].Set(cOuter0, cOuter1, cInner0);
} else if (generateTriInner) {
facets[facetIndex].Set(cInner1, cInner0, cOuter0);
} else {
facets[facetIndex].Set(cOuter0, cOuter1, cInner1, cInner0);
}
// Advance to the next point of the next outer edge:
bool advanceOuter = generateTriOuter || generateQuad;
if (advanceOuter) {
tOuter0 = tOuter1;
cOuter0 = cOuter1;
tOuter1 += dtOuter;
cOuter1 = cOuter1 + 1;
if (tOuter1 >= tOuterLast) {
tOuter1 = tOuterLast;
cOuter1 = outerLast;
}
}
// Advance to the next point of the next inner edge:
bool advanceInner = generateTriInner || generateQuad;
if (advanceInner) {
tInner0 = tInner1;
cInner0 = cInner1;
tInner1 += dtInner;
cInner1 = cInner1 + dInner;
if (tInner1 >= tInnerLast) {
tInner1 = tInnerLast;
cInner1 = innerLast;
}
}
}
return nFacetsExpected;
} | O1 | cpp | OpenSubdiv::v3_6_0::Bfr::(anonymous namespace)::FacetStrip::connectNonUniformFacets(OpenSubdiv::v3_6_0::Bfr::(anonymous namespace)::FacetArray) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, 0x10(%rsp)
movb (%rdi), %r9b
movl %r9d, %eax
notb %al
testb $0x30, %al
jne 0xa0fe5
movl 0x4(%rdi), %r10d
movl 0x8(%rdi), %r11d
movl %r9d, %eax
andb $0x1, %al
movzbl %al, %eax
movl %eax, %ecx
xorl $0x3, %ecx
leal (%r11,%rcx), %r8d
cmpl %r10d, %r8d
movl %r10d, %edx
cmovll %r8d, %edx
movq %r8, %rsi
movq %r8, 0x38(%rsp)
cmovll %r10d, %esi
movl %esi, %r8d
shrl $0x1f, %r8d
addl %esi, %r8d
sarl %r8d
leal -0x1(%rdx), %esi
cmpl %edx, %r8d
cmovgel %r8d, %esi
movl %esi, 0x20(%rsp)
addl %r11d, %ecx
decl %ecx
imull %r10d, %ecx
xorl %edx, %edx
testb %al, %al
jne 0xa0cb8
movl %r10d, %eax
shrl $0x1f, %eax
addl %r10d, %eax
sarl %eax
movl %eax, %edx
subl %r10d, %eax
addl %eax, %ecx
movl %ecx, 0x28(%rsp)
movl %r9d, %eax
shrb $0x2, %al
movzbl %al, %eax
andl $0x1, %eax
negl %eax
movl 0xc(%rdi), %esi
cmpl $0x1, %r10d
jne 0xa0cd9
movl 0x10(%rdi), %r12d
jmp 0xa0cdd
leal 0x1(%rsi), %r12d
orl $0x1, %eax
movl 0x18(%rdi), %ebp
testl %r11d, %r11d
movl %r10d, %r15d
cmovel %r11d, %r15d
cmpl $0x1, %r11d
jne 0xa0cf9
movl 0x1c(%rdi), %r13d
jmp 0xa0cfd
leal (%rax,%rbp), %r13d
andb $0x3, %r9b
cmpb $0x1, %r9b
movq %rax, 0x50(%rsp)
je 0xa0d12
leal (%r10,%r11), %ebx
jmp 0xa0d37
xorl %eax, %eax
cmpl %r10d, %r11d
setge %al
movl 0x4(%rdi,%rax,4), %ebx
testb $0x1, %bl
jne 0xa0d37
movl %r10d, %eax
andl $0x1, %eax
testb $0x1, %r11b
movl $0x1, %ecx
cmovel %eax, %ecx
orl %ecx, %ebx
cmpb $0x1, %r9b
setne %al
testb $0x1, %r10b
sete %cl
orb %al, %cl
movb %r9b, 0x7(%rsp)
je 0xa0d59
movq $0x0, 0x30(%rsp)
jmp 0xa0d62
andb $0x1, %r11b
movq %r11, 0x30(%rsp)
testl %ebx, %ebx
jle 0xa0fd4
movq 0x38(%rsp), %r14
movl %r14d, %eax
imull %r10d, %eax
movl %eax, %ecx
shrl $0x1f, %ecx
movl %ebx, %r8d
shrl $0x1f, %r8d
movl %eax, 0x24(%rsp)
addl %eax, %ecx
movq %r10, 0x58(%rsp)
addl %r10d, %edx
addl %ebx, %r8d
sarl %ecx
movl %ecx, 0x1c(%rsp)
movl %edx, 0xc(%rsp)
addl %edx, %r15d
sarl %r8d
movl %ebx, %eax
andl $0x1, %eax
movq %r8, 0x48(%rsp)
movq %rax, 0x60(%rsp)
leal (%rax,%r8,2), %r8d
decl %r8d
movq 0x10(%rsp), %rax
movq (%rax), %r11
movl $0x0, 0x8(%rsp)
xorl %edx, %edx
movq %rdi, 0x40(%rsp)
movl %ebx, 0x2c(%rsp)
cmpl $0x0, 0x60(%rsp)
sete %al
cmpl %edx, 0x48(%rsp)
setne %cl
orb %al, %cl
jne 0xa0df7
cmpb $0x0, 0x30(%rsp)
je 0xa0e05
movb $0x1, %cl
xorl %ebx, %ebx
xorl %r9d, %r9d
jmp 0xa0e23
cmpl 0xc(%rsp), %r15d
jne 0xa0e11
movb $0x1, %bl
xorl %r9d, %r9d
jmp 0xa0e21
movl 0x4(%rdi), %ebx
andl $0x1, %ebx
sete %r9b
jmp 0xa0e21
cmpl 0x8(%rsp), %r14d
jne 0xa0f46
movb $0x1, %r9b
xorl %ebx, %ebx
xorl %ecx, %ecx
movslq %edx, %rax
testb %bl, %bl
je 0xa0e5e
movq %rsi, %rdi
movq 0x10(%rsp), %rsi
movslq 0xc(%rsi), %r10
imulq %rax, %r10
leaq (%r11,%r10,4), %rax
movslq 0x8(%rsi), %r10
movq %rdi, %rsi
movq 0x40(%rsp), %rdi
movl $0xffffffff, -0x4(%rax,%r10,4) # imm = 0xFFFFFFFF
movl %esi, (%rax)
movl %r12d, 0x4(%rax)
movl %ebp, 0x8(%rax)
jmp 0xa0eb7
testb %r9b, %r9b
je 0xa0e97
movq %rsi, %rdi
movq 0x10(%rsp), %rsi
movslq 0xc(%rsi), %r10
imulq %rax, %r10
leaq (%r11,%r10,4), %rax
movslq 0x8(%rsi), %r10
movq %rdi, %rsi
movq 0x40(%rsp), %rdi
movl $0xffffffff, -0x4(%rax,%r10,4) # imm = 0xFFFFFFFF
movl %r13d, (%rax)
movl %ebp, 0x4(%rax)
movl %esi, 0x8(%rax)
jmp 0xa0eb7
movq 0x10(%rsp), %r10
movslq 0xc(%r10), %r10
imulq %rax, %r10
movl %esi, (%r11,%r10,4)
movl %r12d, 0x4(%r11,%r10,4)
movl %r13d, 0x8(%r11,%r10,4)
movl %ebp, 0xc(%r11,%r10,4)
orb %cl, %bl
cmpb $0x1, %bl
jne 0xa0ed6
movq 0x38(%rsp), %rax
leal (%r14,%rax), %ebx
movl 0x24(%rsp), %esi
cmpl %esi, %ebx
jl 0xa0ede
movl 0x10(%rdi), %eax
movl %esi, %ebx
jmp 0xa0ee3
movl %r12d, %eax
movl %r14d, %ebx
jmp 0xa0eeb
leal 0x1(%r12), %eax
movl %r12d, %esi
movl %r14d, 0x8(%rsp)
orb %cl, %r9b
cmpb $0x1, %r9b
jne 0xa0f2a
movq %rsi, %r10
movq 0x58(%rsp), %rcx
addl %r15d, %ecx
movl 0x28(%rsp), %r9d
cmpl %r9d, %ecx
jl 0xa0f11
movl 0x1c(%rdi), %esi
movl %r9d, %ecx
jmp 0xa0f19
movq 0x50(%rsp), %rsi
addl %r13d, %esi
movl %r15d, 0xc(%rsp)
movl %r13d, %ebp
movl %ecx, %r15d
movl %esi, %r13d
movq %r10, %rsi
incl %edx
decl %r8d
movl %ebx, %r14d
movl %eax, %r12d
movl 0x2c(%rsp), %ebx
cmpl %edx, %ebx
jne 0xa0dd4
jmp 0xa0fd4
cmpb $0x1, 0x7(%rsp)
je 0xa0f51
xorl %ecx, %ecx
jmp 0xa0f99
cmpl 0x48(%rsp), %edx
jge 0xa0f7d
xorl %ecx, %ecx
movl 0x1c(%rsp), %eax
cmpl %eax, %r15d
jg 0xa0f99
cmpl %eax, %r14d
jg 0xa0f99
movl %r14d, %eax
subl %r15d, %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
cmpl 0x20(%rsp), %ecx
setle %cl
jmp 0xa0f99
movq 0x10(%rsp), %rcx
movq (%rcx), %rax
movslq 0xc(%rcx), %rcx
movslq %r8d, %r9
imulq %rcx, %r9
cmpl $0x0, 0xc(%rax,%r9,4)
setns %cl
testb %cl, %cl
jne 0xa0df0
movl %r14d, %eax
subl 0xc(%rsp), %eax
movl %r15d, %r9d
subl 0x8(%rsp), %r9d
xorl %ebx, %ebx
cmpl 0x1c(%rsp), %r14d
setg %bl
xorl %r10d, %r10d
cmpl %r9d, %eax
setl %r10b
cmovnel %r10d, %ebx
movl %ebx, %r9d
xorb $0x1, %r9b
jmp 0xa0e23
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x213de(%rip), %rdi # 0xc23ca
leaq 0x20c9d(%rip), %rsi # 0xc1c90
leaq 0x213f0(%rip), %rcx # 0xc23ea
movl $0x1be, %edx # imm = 0x1BE
callq 0x39560
| _ZNK10OpenSubdiv6v3_6_03Bfr12_GLOBAL__N_110FacetStrip23connectNonUniformFacetsENS2_10FacetArrayE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov [rsp+98h+var_88], rsi
mov r9b, [rdi]
mov eax, r9d
not al
test al, 30h
jnz loc_A0FE5
mov r10d, [rdi+4]
mov r11d, [rdi+8]
mov eax, r9d
and al, 1
movzx eax, al
mov ecx, eax
xor ecx, 3
lea r8d, [r11+rcx]
cmp r8d, r10d
mov edx, r10d
cmovl edx, r8d
mov rsi, r8
mov [rsp+98h+var_60], r8
cmovl esi, r10d
mov r8d, esi
shr r8d, 1Fh
add r8d, esi
sar r8d, 1
lea esi, [rdx-1]
cmp r8d, edx
cmovge esi, r8d
mov [rsp+98h+var_78], esi
add ecx, r11d
dec ecx
imul ecx, r10d
xor edx, edx
test al, al
jnz short loc_A0CB8
mov eax, r10d
shr eax, 1Fh
add eax, r10d
sar eax, 1
mov edx, eax
sub eax, r10d
add ecx, eax
loc_A0CB8:
mov [rsp+98h+var_70], ecx
mov eax, r9d
shr al, 2
movzx eax, al
and eax, 1
neg eax
mov esi, [rdi+0Ch]
cmp r10d, 1
jnz short loc_A0CD9
mov r12d, [rdi+10h]
jmp short loc_A0CDD
loc_A0CD9:
lea r12d, [rsi+1]
loc_A0CDD:
or eax, 1
mov ebp, [rdi+18h]
test r11d, r11d
mov r15d, r10d
cmovz r15d, r11d
cmp r11d, 1
jnz short loc_A0CF9
mov r13d, [rdi+1Ch]
jmp short loc_A0CFD
loc_A0CF9:
lea r13d, [rax+rbp]
loc_A0CFD:
and r9b, 3
cmp r9b, 1
mov [rsp+98h+var_48], rax
jz short loc_A0D12
lea ebx, [r10+r11]
jmp short loc_A0D37
loc_A0D12:
xor eax, eax
cmp r11d, r10d
setnl al
mov ebx, [rdi+rax*4+4]
test bl, 1
jnz short loc_A0D37
mov eax, r10d
and eax, 1
test r11b, 1
mov ecx, 1
cmovz ecx, eax
or ebx, ecx
loc_A0D37:
cmp r9b, 1
setnz al
test r10b, 1
setz cl
or cl, al
mov [rsp+98h+var_91], r9b
jz short loc_A0D59
mov [rsp+98h+var_68], 0
jmp short loc_A0D62
loc_A0D59:
and r11b, 1
mov [rsp+98h+var_68], r11
loc_A0D62:
test ebx, ebx
jle loc_A0FD4
mov r14, [rsp+98h+var_60]
mov eax, r14d
imul eax, r10d
mov ecx, eax
shr ecx, 1Fh
mov r8d, ebx
shr r8d, 1Fh
mov [rsp+98h+var_74], eax
add ecx, eax
mov [rsp+98h+var_40], r10
add edx, r10d
add r8d, ebx
sar ecx, 1
mov [rsp+98h+var_7C], ecx
mov [rsp+98h+var_8C], edx
add r15d, edx
sar r8d, 1
mov eax, ebx
and eax, 1
mov [rsp+98h+var_50], r8
mov [rsp+98h+var_38], rax
lea r8d, [rax+r8*2]
dec r8d
mov rax, [rsp+98h+var_88]
mov r11, [rax]
mov [rsp+98h+var_90], 0
xor edx, edx
mov [rsp+98h+var_58], rdi
mov [rsp+98h+var_6C], ebx
loc_A0DD4:
cmp dword ptr [rsp+98h+var_38], 0
setz al
cmp dword ptr [rsp+98h+var_50], edx
setnz cl
or cl, al
jnz short loc_A0DF7
cmp byte ptr [rsp+98h+var_68], 0
jz short loc_A0E05
mov cl, 1
loc_A0DF0:
xor ebx, ebx
xor r9d, r9d
jmp short loc_A0E23
loc_A0DF7:
cmp r15d, [rsp+98h+var_8C]
jnz short loc_A0E11
mov bl, 1
xor r9d, r9d
jmp short loc_A0E21
loc_A0E05:
mov ebx, [rdi+4]
and ebx, 1
setz r9b
jmp short loc_A0E21
loc_A0E11:
cmp r14d, [rsp+98h+var_90]
jnz loc_A0F46
mov r9b, 1
xor ebx, ebx
loc_A0E21:
xor ecx, ecx
loc_A0E23:
movsxd rax, edx
test bl, bl
jz short loc_A0E5E
mov rdi, rsi
mov rsi, [rsp+98h+var_88]
movsxd r10, dword ptr [rsi+0Ch]
imul r10, rax
lea rax, [r11+r10*4]
movsxd r10, dword ptr [rsi+8]
mov rsi, rdi
mov rdi, [rsp+98h+var_58]
mov dword ptr [rax+r10*4-4], 0FFFFFFFFh
mov [rax], esi
mov [rax+4], r12d
mov [rax+8], ebp
jmp short loc_A0EB7
loc_A0E5E:
test r9b, r9b
jz short loc_A0E97
mov rdi, rsi
mov rsi, [rsp+98h+var_88]
movsxd r10, dword ptr [rsi+0Ch]
imul r10, rax
lea rax, [r11+r10*4]
movsxd r10, dword ptr [rsi+8]
mov rsi, rdi
mov rdi, [rsp+98h+var_58]
mov dword ptr [rax+r10*4-4], 0FFFFFFFFh
mov [rax], r13d
mov [rax+4], ebp
mov [rax+8], esi
jmp short loc_A0EB7
loc_A0E97:
mov r10, [rsp+98h+var_88]
movsxd r10, dword ptr [r10+0Ch]
imul r10, rax
mov [r11+r10*4], esi
mov [r11+r10*4+4], r12d
mov [r11+r10*4+8], r13d
mov [r11+r10*4+0Ch], ebp
loc_A0EB7:
or bl, cl
cmp bl, 1
jnz short loc_A0ED6
mov rax, [rsp+98h+var_60]
lea ebx, [r14+rax]
mov esi, [rsp+98h+var_74]
cmp ebx, esi
jl short loc_A0EDE
mov eax, [rdi+10h]
mov ebx, esi
jmp short loc_A0EE3
loc_A0ED6:
mov eax, r12d
mov ebx, r14d
jmp short loc_A0EEB
loc_A0EDE:
lea eax, [r12+1]
loc_A0EE3:
mov esi, r12d
mov [rsp+98h+var_90], r14d
loc_A0EEB:
or r9b, cl
cmp r9b, 1
jnz short loc_A0F2A
mov r10, rsi
mov rcx, [rsp+98h+var_40]
add ecx, r15d
mov r9d, [rsp+98h+var_70]
cmp ecx, r9d
jl short loc_A0F11
mov esi, [rdi+1Ch]
mov ecx, r9d
jmp short loc_A0F19
loc_A0F11:
mov rsi, [rsp+98h+var_48]
add esi, r13d
loc_A0F19:
mov [rsp+98h+var_8C], r15d
mov ebp, r13d
mov r15d, ecx
mov r13d, esi
mov rsi, r10
loc_A0F2A:
inc edx
dec r8d
mov r14d, ebx
mov r12d, eax
mov ebx, [rsp+98h+var_6C]
cmp ebx, edx
jnz loc_A0DD4
jmp loc_A0FD4
loc_A0F46:
cmp [rsp+98h+var_91], 1
jz short loc_A0F51
xor ecx, ecx
jmp short loc_A0F99
loc_A0F51:
cmp edx, dword ptr [rsp+98h+var_50]
jge short loc_A0F7D
xor ecx, ecx
mov eax, [rsp+98h+var_7C]
cmp r15d, eax
jg short loc_A0F99
cmp r14d, eax
jg short loc_A0F99
mov eax, r14d
sub eax, r15d
mov ecx, eax
neg ecx
cmovs ecx, eax
cmp ecx, [rsp+98h+var_78]
setle cl
jmp short loc_A0F99
loc_A0F7D:
mov rcx, [rsp+98h+var_88]
mov rax, [rcx]
movsxd rcx, dword ptr [rcx+0Ch]
movsxd r9, r8d
imul r9, rcx
cmp dword ptr [rax+r9*4+0Ch], 0
setns cl
loc_A0F99:
test cl, cl
jnz loc_A0DF0
mov eax, r14d
sub eax, [rsp+98h+var_8C]
mov r9d, r15d
sub r9d, [rsp+98h+var_90]
xor ebx, ebx
cmp r14d, [rsp+98h+var_7C]
setnle bl
xor r10d, r10d
cmp eax, r9d
setl r10b
cmovnz ebx, r10d
mov r9d, ebx
xor r9b, 1
jmp loc_A0E23
loc_A0FD4:
mov eax, ebx
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_A0FE5:
lea rdi, aSplitfirstface; "splitFirstFace && splitLastFace"
lea rsi, aWorkspaceLlm4b_47; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aIntOpensubdivV_36; "int OpenSubdiv::v3_6_0::Bfr::(anonymous"...
mov edx, 1BEh
call ___assert_fail
| long long OpenSubdiv::v3_6_0::Bfr::`anonymous namespace'::FacetStrip::connectNonUniformFacets(
char *a1,
long long *a2)
{
char v2; // r9
int v3; // r10d
int v4; // r11d
int v5; // ecx
int v6; // edx
int v7; // esi
int v8; // r8d
int v9; // esi
int v10; // ecx
int v11; // edx
long long v12; // rsi
unsigned int v13; // r12d
int v14; // eax
int v15; // ebp
int v16; // r15d
int v17; // r13d
char v18; // r9
int v19; // ebx
int v20; // ecx
int v21; // r14d
int v22; // r15d
int v23; // r8d
long long v24; // r11
int v25; // edx
bool v26; // cl
int v27; // ebx
char v28; // r9
_DWORD *v29; // rax
_DWORD *v30; // rax
long long v31; // r10
int v32; // ebx
unsigned int v33; // eax
long long v34; // r10
int v35; // ecx
int v36; // esi
int v37; // ecx
char v39; // [rsp+7h] [rbp-91h]
int v40; // [rsp+8h] [rbp-90h]
int v41; // [rsp+Ch] [rbp-8Ch]
int v43; // [rsp+1Ch] [rbp-7Ch]
int v44; // [rsp+20h] [rbp-78h]
int v45; // [rsp+24h] [rbp-74h]
int v46; // [rsp+28h] [rbp-70h]
int i; // [rsp+2Ch] [rbp-6Ch]
char v48; // [rsp+30h] [rbp-68h]
int v49; // [rsp+38h] [rbp-60h]
char *v50; // [rsp+40h] [rbp-58h]
int v51; // [rsp+48h] [rbp-50h]
int v52; // [rsp+50h] [rbp-48h]
int v53; // [rsp+58h] [rbp-40h]
int v54; // [rsp+60h] [rbp-38h]
v2 = *a1;
if ( (~*a1 & 0x30) != 0 )
__assert_fail(
"splitFirstFace && splitLastFace",
"/workspace/llm4binary/github/2025_star3/NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/tessellation.cpp",
446LL,
"int OpenSubdiv::v3_6_0::Bfr::(anonymous namespace)::FacetStrip::connectNonUniformFacets(FacetArray) const");
v3 = *((_DWORD *)a1 + 1);
v4 = *((_DWORD *)a1 + 2);
v5 = v2 & 1 ^ 3;
v6 = v3;
if ( v4 + v5 < v3 )
v6 = v4 + v5;
v7 = v4 + v5;
v49 = v4 + v5;
if ( v4 + v5 < v3 )
v7 = *((_DWORD *)a1 + 1);
v8 = v7 / 2;
v9 = v6 - 1;
if ( v8 >= v6 )
v9 = v8;
v44 = v9;
v10 = v3 * (v4 + v5 - 1);
v11 = 0;
if ( (v2 & 1) == 0 )
{
v11 = v3 / 2;
v10 += v3 / 2 - v3;
}
v46 = v10;
v12 = *((unsigned int *)a1 + 3);
if ( v3 == 1 )
v13 = *((_DWORD *)a1 + 4);
else
v13 = v12 + 1;
v14 = (v2 & 4) != 0 ? -1 : 1;
v15 = *((_DWORD *)a1 + 6);
v16 = *((_DWORD *)a1 + 1);
if ( !v4 )
v16 = 0;
if ( v4 == 1 )
v17 = *((_DWORD *)a1 + 7);
else
v17 = v14 + v15;
v18 = v2 & 3;
v52 = v14;
if ( v18 == 1 )
{
v19 = *(_DWORD *)&a1[4 * (v4 >= v3) + 4];
if ( (v19 & 1) == 0 )
{
v20 = 1;
if ( (v4 & 1) == 0 )
v20 = v3 & 1;
v19 |= v20;
}
}
else
{
v19 = v3 + v4;
}
v39 = v18;
if ( v18 != 1 || (v3 & 1) == 0 )
v48 = 0;
else
v48 = v4 & 1;
if ( v19 > 0 )
{
v21 = v49;
v45 = v3 * v49;
v53 = *((_DWORD *)a1 + 1);
v43 = v3 * v49 / 2;
v41 = v3 + v11;
v22 = v3 + v11 + v16;
v51 = v19 / 2;
v54 = v19 & 1;
v23 = v54 + 2 * (v19 / 2) - 1;
v24 = *a2;
v40 = 0;
v25 = 0;
v50 = a1;
for ( i = v19; i != v25; v19 = i )
{
if ( v54 == 0 || v51 != v25 )
{
if ( v22 == v41 )
{
LOBYTE(v27) = 1;
v28 = 0;
LABEL_38:
v26 = 0;
goto LABEL_39;
}
if ( v21 == v40 )
{
v28 = 1;
LOBYTE(v27) = 0;
goto LABEL_38;
}
if ( v39 == 1 )
{
if ( v25 >= v51 )
{
v26 = *(_DWORD *)(*a2 + 4 * *((int *)a2 + 3) * (long long)v23 + 12) >= 0;
}
else
{
v26 = 0;
if ( v22 <= v43 && v21 <= v43 )
{
v37 = v22 - v21;
if ( v22 - v21 < 0 )
v37 = v21 - v22;
v26 = v37 <= v44;
}
}
}
else
{
v26 = 0;
}
if ( !v26 )
{
LOBYTE(v27) = v21 > v43;
if ( v21 - v41 != v22 - v40 )
LOBYTE(v27) = v21 - v41 < v22 - v40;
v28 = v27 ^ 1;
goto LABEL_39;
}
}
else
{
if ( !v48 )
{
v27 = *((_DWORD *)a1 + 1) & 1;
v28 = v27 == 0;
goto LABEL_38;
}
v26 = 1;
}
LOBYTE(v27) = 0;
v28 = 0;
LABEL_39:
if ( (_BYTE)v27 )
{
v29 = (_DWORD *)(v24 + 4 * v25 * (long long)*((int *)a2 + 3));
a1 = v50;
v29[*((int *)a2 + 2) - 1] = -1;
*v29 = v12;
v29[1] = v13;
v29[2] = v15;
}
else if ( v28 )
{
v30 = (_DWORD *)(v24 + 4 * v25 * (long long)*((int *)a2 + 3));
a1 = v50;
v30[*((int *)a2 + 2) - 1] = -1;
*v30 = v17;
v30[1] = v15;
v30[2] = v12;
}
else
{
v31 = v25 * (long long)*((int *)a2 + 3);
*(_DWORD *)(v24 + 4 * v31) = v12;
*(_DWORD *)(v24 + 4 * v31 + 4) = v13;
*(_DWORD *)(v24 + 4 * v31 + 8) = v17;
*(_DWORD *)(v24 + 4 * v31 + 12) = v15;
}
if ( (v26 | (unsigned __int8)v27) == 1 )
{
v32 = v21 + v49;
if ( v21 + v49 < v45 )
{
v33 = v13 + 1;
}
else
{
v33 = *((_DWORD *)a1 + 4);
v32 = v45;
}
v12 = v13;
v40 = v21;
}
else
{
v33 = v13;
v32 = v21;
}
if ( (v26 | (unsigned __int8)v28) == 1 )
{
v34 = v12;
v35 = v22 + v53;
if ( v22 + v53 < v46 )
{
v36 = v17 + v52;
}
else
{
v36 = *((_DWORD *)a1 + 7);
v35 = v46;
}
v41 = v22;
v15 = v17;
v22 = v35;
v17 = v36;
v12 = v34;
}
++v25;
--v23;
v21 = v32;
v13 = v33;
}
}
return (unsigned int)v19;
}
| connectNonUniformFacets:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RSP + 0x10],RSI
MOV R9B,byte ptr [RDI]
MOV EAX,R9D
NOT AL
TEST AL,0x30
JNZ 0x001a0fe5
MOV R10D,dword ptr [RDI + 0x4]
MOV R11D,dword ptr [RDI + 0x8]
MOV EAX,R9D
AND AL,0x1
MOVZX EAX,AL
MOV ECX,EAX
XOR ECX,0x3
LEA R8D,[R11 + RCX*0x1]
CMP R8D,R10D
MOV EDX,R10D
CMOVL EDX,R8D
MOV RSI,R8
MOV qword ptr [RSP + 0x38],R8
CMOVL ESI,R10D
MOV R8D,ESI
SHR R8D,0x1f
ADD R8D,ESI
SAR R8D,0x1
LEA ESI,[RDX + -0x1]
CMP R8D,EDX
CMOVGE ESI,R8D
MOV dword ptr [RSP + 0x20],ESI
ADD ECX,R11D
DEC ECX
IMUL ECX,R10D
XOR EDX,EDX
TEST AL,AL
JNZ 0x001a0cb8
MOV EAX,R10D
SHR EAX,0x1f
ADD EAX,R10D
SAR EAX,0x1
MOV EDX,EAX
SUB EAX,R10D
ADD ECX,EAX
LAB_001a0cb8:
MOV dword ptr [RSP + 0x28],ECX
MOV EAX,R9D
SHR AL,0x2
MOVZX EAX,AL
AND EAX,0x1
NEG EAX
MOV ESI,dword ptr [RDI + 0xc]
CMP R10D,0x1
JNZ 0x001a0cd9
MOV R12D,dword ptr [RDI + 0x10]
JMP 0x001a0cdd
LAB_001a0cd9:
LEA R12D,[RSI + 0x1]
LAB_001a0cdd:
OR EAX,0x1
MOV EBP,dword ptr [RDI + 0x18]
TEST R11D,R11D
MOV R15D,R10D
CMOVZ R15D,R11D
CMP R11D,0x1
JNZ 0x001a0cf9
MOV R13D,dword ptr [RDI + 0x1c]
JMP 0x001a0cfd
LAB_001a0cf9:
LEA R13D,[RAX + RBP*0x1]
LAB_001a0cfd:
AND R9B,0x3
CMP R9B,0x1
MOV qword ptr [RSP + 0x50],RAX
JZ 0x001a0d12
LEA EBX,[R10 + R11*0x1]
JMP 0x001a0d37
LAB_001a0d12:
XOR EAX,EAX
CMP R11D,R10D
SETGE AL
MOV EBX,dword ptr [RDI + RAX*0x4 + 0x4]
TEST BL,0x1
JNZ 0x001a0d37
MOV EAX,R10D
AND EAX,0x1
TEST R11B,0x1
MOV ECX,0x1
CMOVZ ECX,EAX
OR EBX,ECX
LAB_001a0d37:
CMP R9B,0x1
SETNZ AL
TEST R10B,0x1
SETZ CL
OR CL,AL
MOV byte ptr [RSP + 0x7],R9B
JZ 0x001a0d59
MOV qword ptr [RSP + 0x30],0x0
JMP 0x001a0d62
LAB_001a0d59:
AND R11B,0x1
MOV qword ptr [RSP + 0x30],R11
LAB_001a0d62:
TEST EBX,EBX
JLE 0x001a0fd4
MOV R14,qword ptr [RSP + 0x38]
MOV EAX,R14D
IMUL EAX,R10D
MOV ECX,EAX
SHR ECX,0x1f
MOV R8D,EBX
SHR R8D,0x1f
MOV dword ptr [RSP + 0x24],EAX
ADD ECX,EAX
MOV qword ptr [RSP + 0x58],R10
ADD EDX,R10D
ADD R8D,EBX
SAR ECX,0x1
MOV dword ptr [RSP + 0x1c],ECX
MOV dword ptr [RSP + 0xc],EDX
ADD R15D,EDX
SAR R8D,0x1
MOV EAX,EBX
AND EAX,0x1
MOV qword ptr [RSP + 0x48],R8
MOV qword ptr [RSP + 0x60],RAX
LEA R8D,[RAX + R8*0x2]
DEC R8D
MOV RAX,qword ptr [RSP + 0x10]
MOV R11,qword ptr [RAX]
MOV dword ptr [RSP + 0x8],0x0
XOR EDX,EDX
MOV qword ptr [RSP + 0x40],RDI
MOV dword ptr [RSP + 0x2c],EBX
LAB_001a0dd4:
CMP dword ptr [RSP + 0x60],0x0
SETZ AL
CMP dword ptr [RSP + 0x48],EDX
SETNZ CL
OR CL,AL
JNZ 0x001a0df7
CMP byte ptr [RSP + 0x30],0x0
JZ 0x001a0e05
MOV CL,0x1
LAB_001a0df0:
XOR EBX,EBX
XOR R9D,R9D
JMP 0x001a0e23
LAB_001a0df7:
CMP R15D,dword ptr [RSP + 0xc]
JNZ 0x001a0e11
MOV BL,0x1
XOR R9D,R9D
JMP 0x001a0e21
LAB_001a0e05:
MOV EBX,dword ptr [RDI + 0x4]
AND EBX,0x1
SETZ R9B
JMP 0x001a0e21
LAB_001a0e11:
CMP R14D,dword ptr [RSP + 0x8]
JNZ 0x001a0f46
MOV R9B,0x1
XOR EBX,EBX
LAB_001a0e21:
XOR ECX,ECX
LAB_001a0e23:
MOVSXD RAX,EDX
TEST BL,BL
JZ 0x001a0e5e
MOV RDI,RSI
MOV RSI,qword ptr [RSP + 0x10]
MOVSXD R10,dword ptr [RSI + 0xc]
IMUL R10,RAX
LEA RAX,[R11 + R10*0x4]
MOVSXD R10,dword ptr [RSI + 0x8]
MOV RSI,RDI
MOV RDI,qword ptr [RSP + 0x40]
MOV dword ptr [RAX + R10*0x4 + -0x4],0xffffffff
MOV dword ptr [RAX],ESI
MOV dword ptr [RAX + 0x4],R12D
MOV dword ptr [RAX + 0x8],EBP
JMP 0x001a0eb7
LAB_001a0e5e:
TEST R9B,R9B
JZ 0x001a0e97
MOV RDI,RSI
MOV RSI,qword ptr [RSP + 0x10]
MOVSXD R10,dword ptr [RSI + 0xc]
IMUL R10,RAX
LEA RAX,[R11 + R10*0x4]
MOVSXD R10,dword ptr [RSI + 0x8]
MOV RSI,RDI
MOV RDI,qword ptr [RSP + 0x40]
MOV dword ptr [RAX + R10*0x4 + -0x4],0xffffffff
MOV dword ptr [RAX],R13D
MOV dword ptr [RAX + 0x4],EBP
MOV dword ptr [RAX + 0x8],ESI
JMP 0x001a0eb7
LAB_001a0e97:
MOV R10,qword ptr [RSP + 0x10]
MOVSXD R10,dword ptr [R10 + 0xc]
IMUL R10,RAX
MOV dword ptr [R11 + R10*0x4],ESI
MOV dword ptr [R11 + R10*0x4 + 0x4],R12D
MOV dword ptr [R11 + R10*0x4 + 0x8],R13D
MOV dword ptr [R11 + R10*0x4 + 0xc],EBP
LAB_001a0eb7:
OR BL,CL
CMP BL,0x1
JNZ 0x001a0ed6
MOV RAX,qword ptr [RSP + 0x38]
LEA EBX,[R14 + RAX*0x1]
MOV ESI,dword ptr [RSP + 0x24]
CMP EBX,ESI
JL 0x001a0ede
MOV EAX,dword ptr [RDI + 0x10]
MOV EBX,ESI
JMP 0x001a0ee3
LAB_001a0ed6:
MOV EAX,R12D
MOV EBX,R14D
JMP 0x001a0eeb
LAB_001a0ede:
LEA EAX,[R12 + 0x1]
LAB_001a0ee3:
MOV ESI,R12D
MOV dword ptr [RSP + 0x8],R14D
LAB_001a0eeb:
OR R9B,CL
CMP R9B,0x1
JNZ 0x001a0f2a
MOV R10,RSI
MOV RCX,qword ptr [RSP + 0x58]
ADD ECX,R15D
MOV R9D,dword ptr [RSP + 0x28]
CMP ECX,R9D
JL 0x001a0f11
MOV ESI,dword ptr [RDI + 0x1c]
MOV ECX,R9D
JMP 0x001a0f19
LAB_001a0f11:
MOV RSI,qword ptr [RSP + 0x50]
ADD ESI,R13D
LAB_001a0f19:
MOV dword ptr [RSP + 0xc],R15D
MOV EBP,R13D
MOV R15D,ECX
MOV R13D,ESI
MOV RSI,R10
LAB_001a0f2a:
INC EDX
DEC R8D
MOV R14D,EBX
MOV R12D,EAX
MOV EBX,dword ptr [RSP + 0x2c]
CMP EBX,EDX
JNZ 0x001a0dd4
JMP 0x001a0fd4
LAB_001a0f46:
CMP byte ptr [RSP + 0x7],0x1
JZ 0x001a0f51
XOR ECX,ECX
JMP 0x001a0f99
LAB_001a0f51:
CMP EDX,dword ptr [RSP + 0x48]
JGE 0x001a0f7d
XOR ECX,ECX
MOV EAX,dword ptr [RSP + 0x1c]
CMP R15D,EAX
JG 0x001a0f99
CMP R14D,EAX
JG 0x001a0f99
MOV EAX,R14D
SUB EAX,R15D
MOV ECX,EAX
NEG ECX
CMOVS ECX,EAX
CMP ECX,dword ptr [RSP + 0x20]
SETLE CL
JMP 0x001a0f99
LAB_001a0f7d:
MOV RCX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RCX]
MOVSXD RCX,dword ptr [RCX + 0xc]
MOVSXD R9,R8D
IMUL R9,RCX
CMP dword ptr [RAX + R9*0x4 + 0xc],0x0
SETNS CL
LAB_001a0f99:
TEST CL,CL
JNZ 0x001a0df0
MOV EAX,R14D
SUB EAX,dword ptr [RSP + 0xc]
MOV R9D,R15D
SUB R9D,dword ptr [RSP + 0x8]
XOR EBX,EBX
CMP R14D,dword ptr [RSP + 0x1c]
SETG BL
XOR R10D,R10D
CMP EAX,R9D
SETL R10B
CMOVNZ EBX,R10D
MOV R9D,EBX
XOR R9B,0x1
JMP 0x001a0e23
LAB_001a0fd4:
MOV EAX,EBX
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001a0fe5:
LEA RDI,[0x1c23ca]
LEA RSI,[0x1c1c90]
LEA RCX,[0x1c23ea]
MOV EDX,0x1be
CALL 0x00139560
|
/* OpenSubdiv::v3_6_0::Bfr::(anonymous
namespace)::FacetStrip::connectNonUniformFacets(OpenSubdiv::v3_6_0::Bfr::(anonymous
namespace)::FacetArray) const */
uint __thiscall
OpenSubdiv::v3_6_0::Bfr::(anonymous_namespace)::FacetStrip::connectNonUniformFacets
(FacetStrip *this,long *param_2)
{
int *piVar1;
FacetStrip FVar2;
uint uVar3;
long lVar4;
uint uVar5;
uint uVar6;
int iVar7;
long lVar8;
uint uVar9;
int iVar10;
int iVar11;
int iVar12;
uint uVar13;
bool bVar14;
uint uVar15;
int iVar16;
int iVar17;
int iVar18;
uint uVar19;
uint uVar20;
int iVar21;
byte bVar22;
byte bVar23;
int iVar24;
int iVar25;
uint uVar26;
int iVar27;
bool bVar28;
bool bVar29;
uint local_90;
int local_8c;
FVar2 = *this;
if ((~(byte)FVar2 & 0x30) != 0) {
/* WARNING: Subroutine does not return */
__assert_fail("splitFirstFace && splitLastFace",
"/workspace/llm4binary/github/2025_star3/NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/tessellation.cpp"
,0x1be,
"int OpenSubdiv::v3_6_0::Bfr::(anonymous namespace)::FacetStrip::connectNonUniformFacets(FacetArray) const"
);
}
uVar3 = *(uint *)(this + 4);
uVar26 = *(uint *)(this + 8);
uVar9 = (byte)FVar2 & 1 ^ 3;
uVar19 = uVar26 + uVar9;
uVar5 = uVar19;
uVar13 = uVar3;
if ((int)uVar19 < (int)uVar3) {
uVar5 = uVar3;
uVar13 = uVar19;
}
iVar17 = uVar13 - 1;
if ((int)uVar13 <= (int)uVar5 / 2) {
iVar17 = (int)uVar5 / 2;
}
iVar10 = (uVar9 + uVar26 + -1) * uVar3;
local_8c = 0;
if (((byte)FVar2 & 1) == 0) {
local_8c = (int)uVar3 / 2;
iVar10 = iVar10 + (local_8c - uVar3);
}
iVar18 = *(int *)(this + 0xc);
if (uVar3 == 1) {
iVar24 = *(int *)(this + 0x10);
}
else {
iVar24 = iVar18 + 1;
}
uVar5 = -((byte)FVar2 >> 2 & 1) | 1;
iVar16 = *(int *)(this + 0x18);
uVar13 = uVar3;
if (uVar26 == 0) {
uVar13 = 0;
}
if (uVar26 == 1) {
iVar25 = *(int *)(this + 0x1c);
}
else {
iVar25 = uVar5 + iVar16;
}
bVar22 = (byte)FVar2 & 3;
if (bVar22 == 1) {
uVar9 = *(uint *)(this + (ulong)((int)uVar3 <= (int)uVar26) * 4 + 4);
if ((uVar9 & 1) == 0) {
uVar6 = 1;
if ((uVar26 & 1) == 0) {
uVar6 = uVar3 & 1;
}
uVar9 = uVar9 | uVar6;
}
}
else {
uVar9 = uVar3 + uVar26;
}
if ((uVar3 & 1) == 0 || bVar22 != 1) {
bVar23 = 0;
}
else {
bVar23 = (byte)uVar26 & 1;
}
if (0 < (int)uVar9) {
uVar6 = uVar19 * uVar3;
local_8c = local_8c + uVar3;
iVar11 = (int)uVar6 / 2;
iVar27 = uVar13 + local_8c;
uVar20 = (int)uVar9 / 2;
iVar21 = (uVar9 & 1) + uVar20 * 2;
lVar4 = *param_2;
local_90 = 0;
uVar13 = 0;
uVar26 = uVar19;
do {
iVar21 = iVar21 + -1;
if (uVar20 == uVar13 && (uVar9 & 1) != 0) {
if (bVar23 == 0) {
bVar14 = SUB41(*(uint *)(this + 4) & 1,0);
bVar28 = (*(uint *)(this + 4) & 1) == 0;
goto LAB_001a0e21;
}
bVar29 = true;
LAB_001a0df0:
bVar14 = false;
bVar28 = false;
}
else {
if (iVar27 == local_8c) {
bVar14 = true;
bVar28 = false;
}
else {
if (uVar26 != local_90) {
if (bVar22 == 1) {
if ((int)uVar13 < (int)uVar20) {
bVar29 = false;
if ((iVar27 <= iVar11) && ((int)uVar26 <= iVar11)) {
iVar7 = uVar26 - iVar27;
iVar12 = -iVar7;
if (0 < iVar7) {
iVar12 = iVar7;
}
bVar29 = iVar12 <= iVar17;
}
}
else {
bVar29 = -1 < *(int *)(*param_2 + 0xc +
(long)iVar21 * (long)*(int *)((long)param_2 + 0xc) * 4);
}
}
else {
bVar29 = false;
}
if (bVar29 != false) goto LAB_001a0df0;
bVar14 = iVar11 < (int)uVar26;
if (uVar26 - local_8c != iVar27 - local_90) {
bVar14 = (int)(uVar26 - local_8c) < (int)(iVar27 - local_90);
}
bVar28 = (bool)(bVar14 ^ 1);
goto LAB_001a0e23;
}
bVar28 = true;
bVar14 = false;
}
LAB_001a0e21:
bVar29 = false;
}
LAB_001a0e23:
lVar8 = (long)(int)uVar13;
if (bVar14 == false) {
if (bVar28 == false) {
lVar8 = *(int *)((long)param_2 + 0xc) * lVar8;
*(int *)(lVar4 + lVar8 * 4) = iVar18;
*(int *)(lVar4 + 4 + lVar8 * 4) = iVar24;
*(int *)(lVar4 + 8 + lVar8 * 4) = iVar25;
*(int *)(lVar4 + 0xc + lVar8 * 4) = iVar16;
}
else {
piVar1 = (int *)(lVar4 + *(int *)((long)param_2 + 0xc) * lVar8 * 4);
piVar1[(long)(int)param_2[1] + -1] = -1;
*piVar1 = iVar25;
piVar1[1] = iVar16;
piVar1[2] = iVar18;
}
}
else {
piVar1 = (int *)(lVar4 + *(int *)((long)param_2 + 0xc) * lVar8 * 4);
piVar1[(long)(int)param_2[1] + -1] = -1;
*piVar1 = iVar18;
piVar1[1] = iVar24;
piVar1[2] = iVar16;
}
uVar15 = uVar26;
if ((bVar14 | bVar29) == 1) {
uVar15 = uVar26 + uVar19;
iVar18 = iVar24;
local_90 = uVar26;
if ((int)uVar15 < (int)uVar6) {
iVar24 = iVar24 + 1;
}
else {
uVar15 = uVar6;
iVar24 = *(int *)(this + 0x10);
}
}
if ((bVar28 | bVar29) == 1) {
iVar16 = iVar25;
local_8c = iVar27;
if ((int)(uVar3 + iVar27) < iVar10) {
iVar25 = uVar5 + iVar25;
iVar27 = uVar3 + iVar27;
}
else {
iVar25 = *(int *)(this + 0x1c);
iVar27 = iVar10;
}
}
uVar13 = uVar13 + 1;
uVar26 = uVar15;
} while (uVar9 != uVar13);
}
return uVar9;
}
| |
24,839 | cxxopts::exceptions::specification::specification(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | shubhamoy[P]dir2txt/include/cxxopts.hpp | explicit specification(const std::string& message)
: exception(message)
{
} | O3 | cpp | cxxopts::exceptions::specification::specification(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x9ed8
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
movq (%r14), %rcx
cmpq %r15, %rcx
je 0x1d856
movq %rcx, 0x8(%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rbx)
jmp 0x1d85d
movups (%r15), %xmm0
movups %xmm0, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rbx)
leaq 0x2fad3(%rip), %rax # 0x4d340
movq %rax, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
| _ZN7cxxopts10exceptions13specificationC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push rbx
sub rsp, 20h
mov rbx, rdi
lea r15, [rsp+38h+var_28]
mov [r15-10h], r15
mov rax, [rsi]
mov rdx, [rsi+8]
add rdx, rax
mov r14, rsp
mov rdi, r14
mov rsi, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea rax, [rbx+18h]
mov [rbx+8], rax
mov rcx, [r14]
cmp rcx, r15
jz short loc_1D856
mov [rbx+8], rcx
mov rax, [rsp+38h+var_28]
mov [rbx+18h], rax
jmp short loc_1D85D
loc_1D856:
movups xmm0, xmmword ptr [r15]
movups xmmword ptr [rax], xmm0
loc_1D85D:
mov rax, [rsp+38h+var_30]
mov [rbx+10h], rax
lea rax, off_4D340
mov [rbx], rax
add rsp, 20h
pop rbx
pop r14
pop r15
retn
| void ( ** cxxopts::exceptions::specification::specification(
long long a1,
long long a2))(cxxopts::exceptions::exception *__hidden this)
{
void ( **result)(cxxopts::exceptions::exception *__hidden); // rax
_QWORD v3[2]; // [rsp+0h] [rbp-38h] BYREF
_OWORD v4[2]; // [rsp+10h] [rbp-28h] BYREF
v3[0] = v4;
std::string::_M_construct<char *>(v3, *(_BYTE **)a2, *(_QWORD *)a2 + *(_QWORD *)(a2 + 8));
*(_QWORD *)(a1 + 8) = a1 + 24;
if ( (_OWORD *)v3[0] == v4 )
{
*(_OWORD *)(a1 + 24) = v4[0];
}
else
{
*(_QWORD *)(a1 + 8) = v3[0];
*(_QWORD *)(a1 + 24) = *(_QWORD *)&v4[0];
}
*(_QWORD *)(a1 + 16) = v3[1];
result = off_4D340;
*(_QWORD *)a1 = off_4D340;
return result;
}
| specification:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x20
MOV RBX,RDI
LEA R15,[RSP + 0x10]
MOV qword ptr [R15 + -0x10],R15
MOV RAX,qword ptr [RSI]
MOV RDX,qword ptr [RSI + 0x8]
ADD RDX,RAX
MOV R14,RSP
MOV RDI,R14
MOV RSI,RAX
CALL 0x00109ed8
LEA RAX,[RBX + 0x18]
MOV qword ptr [RBX + 0x8],RAX
MOV RCX,qword ptr [R14]
CMP RCX,R15
JZ 0x0011d856
MOV qword ptr [RBX + 0x8],RCX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RBX + 0x18],RAX
JMP 0x0011d85d
LAB_0011d856:
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RAX],XMM0
LAB_0011d85d:
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RBX + 0x10],RAX
LEA RAX,[0x14d340]
MOV qword ptr [RBX],RAX
ADD RSP,0x20
POP RBX
POP R14
POP R15
RET
|
/* cxxopts::exceptions::specification::specification(std::__cxx11::string const&) */
void __thiscall
cxxopts::exceptions::specification::specification(specification *this,string *param_1)
{
int8 *local_38;
int8 local_30;
int8 local_28;
int8 uStack_20;
local_38 = &local_28;
std::__cxx11::string::_M_construct<char*>
(&local_38,*(long *)param_1,*(long *)(param_1 + 8) + *(long *)param_1);
*(specification **)(this + 8) = this + 0x18;
if (local_38 == &local_28) {
*(int8 *)(this + 0x18) = local_28;
*(int8 *)(this + 0x20) = uStack_20;
}
else {
*(int8 **)(this + 8) = local_38;
*(int8 *)(this + 0x18) = local_28;
}
*(int8 *)(this + 0x10) = local_30;
*(int ***)this = &PTR__exception_0014d340;
return;
}
| |
24,840 | mult | eloqsql/libmariadb/libmariadb/ma_dtoa.c | static Bigint *mult(Bigint *a, Bigint *b, Stack_alloc *alloc)
{
Bigint *c;
int k, wa, wb, wc;
ULong *x, *xa, *xae, *xb, *xbe, *xc, *xc0;
ULong y;
ULLong carry, z;
if (a->wds < b->wds)
{
c= a;
a= b;
b= c;
}
k= a->k;
wa= a->wds;
wb= b->wds;
wc= wa + wb;
if (wc > a->maxwds)
k++;
c= Balloc(k, alloc);
for (x= c->p.x, xa= x + wc; x < xa; x++)
*x= 0;
xa= a->p.x;
xae= xa + wa;
xb= b->p.x;
xbe= xb + wb;
xc0= c->p.x;
for (; xb < xbe; xc0++)
{
if ((y= *xb++))
{
x= xa;
xc= xc0;
carry= 0;
do
{
z= *x++ * (ULLong)y + *xc + carry;
carry= z >> 32;
*xc++= (ULong) (z & FFFFFFFF);
}
while (x < xae);
*xc= (ULong) carry;
}
}
for (xc0= c->p.x, xc= xc0 + wc; wc > 0 && !*--xc; --wc) ;
c->wds= wc;
return c;
} | O3 | c | mult:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl 0x14(%rdi), %eax
cmpl 0x14(%rsi), %eax
movq %rsi, %r12
cmovlq %rdi, %r12
cmovlq %rsi, %r14
movslq 0x14(%r14), %rax
movslq 0x14(%r12), %r13
movq %rax, -0x30(%rbp)
leaq (%rax,%r13), %r15
xorl %edi, %edi
cmpl 0xc(%r14), %r15d
setg %dil
addl 0x8(%r14), %edi
movq %rdx, %rsi
callq 0x6b257
movq %rax, %rbx
movq (%rax), %rdi
testl %r15d, %r15d
jle 0x6af7a
leaq (%rdi,%r15,4), %rax
leaq 0x4(%rdi), %rcx
cmpq %rcx, %rax
cmovaq %rax, %rcx
movq %rdi, %rdx
notq %rdx
addq %rcx, %rdx
andq $-0x4, %rdx
addq $0x4, %rdx
xorl %esi, %esi
callq 0x3a3a0
movq (%rbx), %rdi
testl %r13d, %r13d
jle 0x6afe2
movq (%r14), %rax
movq -0x30(%rbp), %rcx
leaq (%rax,%rcx,4), %rcx
movq (%r12), %rdx
leaq (%rdx,%r13,4), %rsi
movl (%rdx), %r8d
testq %r8, %r8
je 0x6afd2
xorl %r9d, %r9d
xorl %r10d, %r10d
leaq (%rax,%r9), %r11
addq $0x4, %r11
movl -0x4(%r11), %r14d
imulq %r8, %r14
movl (%rdi,%r9), %r12d
addq %r10, %r12
addq %r14, %r12
movq %r12, %r10
shrq $0x20, %r10
movl %r12d, (%rdi,%r9)
addq $0x4, %r9
cmpq %rcx, %r11
jb 0x6afa0
movl %r10d, (%rdi,%r9)
addq $0x4, %rdx
addq $0x4, %rdi
cmpq %rsi, %rdx
jb 0x6af92
movq (%rbx), %rdi
testl %r15d, %r15d
jle 0x6b008
leaq (%rdi,%r15,4), %rax
addq $-0x4, %rax
cmpl $0x0, (%rax)
jne 0x6b008
leal -0x1(%r15), %ecx
addq $-0x4, %rax
cmpl $0x1, %r15d
movl %ecx, %r15d
jg 0x6afef
xorl %r15d, %r15d
movl %r15d, 0x14(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| mult:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rdi
mov eax, [rdi+14h]
cmp eax, [rsi+14h]
mov r12, rsi
cmovl r12, rdi
cmovl r14, rsi
movsxd rax, dword ptr [r14+14h]
movsxd r13, dword ptr [r12+14h]
mov [rbp+var_30], rax
lea r15, [rax+r13]
xor edi, edi
cmp r15d, [r14+0Ch]
setnle dil
add edi, [r14+8]
mov rsi, rdx
call Balloc
mov rbx, rax
mov rdi, [rax]
test r15d, r15d
jle short loc_6AF7A
lea rax, [rdi+r15*4]
lea rcx, [rdi+4]
cmp rax, rcx
cmova rcx, rax
mov rdx, rdi
not rdx
add rdx, rcx
and rdx, 0FFFFFFFFFFFFFFFCh
add rdx, 4
xor esi, esi
call _memset
mov rdi, [rbx]
loc_6AF7A:
test r13d, r13d
jle short loc_6AFE2
mov rax, [r14]
mov rcx, [rbp+var_30]
lea rcx, [rax+rcx*4]
mov rdx, [r12]
lea rsi, [rdx+r13*4]
loc_6AF92:
mov r8d, [rdx]
test r8, r8
jz short loc_6AFD2
xor r9d, r9d
xor r10d, r10d
loc_6AFA0:
lea r11, [rax+r9]
add r11, 4
mov r14d, [r11-4]
imul r14, r8
mov r12d, [rdi+r9]
add r12, r10
add r12, r14
mov r10, r12
shr r10, 20h
mov [rdi+r9], r12d
add r9, 4
cmp r11, rcx
jb short loc_6AFA0
mov [rdi+r9], r10d
loc_6AFD2:
add rdx, 4
add rdi, 4
cmp rdx, rsi
jb short loc_6AF92
mov rdi, [rbx]
loc_6AFE2:
test r15d, r15d
jle short loc_6B008
lea rax, [rdi+r15*4]
add rax, 0FFFFFFFFFFFFFFFCh
loc_6AFEF:
cmp dword ptr [rax], 0
jnz short loc_6B008
lea ecx, [r15-1]
add rax, 0FFFFFFFFFFFFFFFCh
cmp r15d, 1
mov r15d, ecx
jg short loc_6AFEF
xor r15d, r15d
loc_6B008:
mov [rbx+14h], r15d
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long mult(long long *a1, long long *a2, long long a3, long long a4)
{
long long *v4; // r14
long long *v5; // r12
long long v6; // r13
long long v7; // r15
long long v8; // rbx
long long v9; // rdi
long long v10; // rcx
long long v11; // rax
unsigned long long v12; // rcx
_DWORD *v13; // rdx
unsigned long long v14; // rsi
long long v15; // r8
long long v16; // r9
unsigned long long v17; // r10
unsigned long long v18; // r11
unsigned long long v19; // r12
_DWORD *v20; // rax
bool v21; // cc
long long v23; // [rsp+0h] [rbp-30h]
v4 = a1;
v5 = a2;
if ( *((_DWORD *)a1 + 5) < *((_DWORD *)a2 + 5) )
{
v5 = a1;
v4 = a2;
}
v6 = *((int *)v5 + 5);
v23 = *((int *)v4 + 5);
v7 = v23 + v6;
v8 = Balloc(*((_DWORD *)v4 + 2) + (unsigned int)((int)v23 + (int)v6 > *((_DWORD *)v4 + 3)), a3, a3, a4);
v9 = *(_QWORD *)v8;
if ( (int)v23 + (int)v6 > 0 )
{
v10 = v9 + 4;
if ( v9 + 4 * v7 > (unsigned long long)(v9 + 4) )
v10 = v9 + 4 * v7;
memset(v9, 0LL, ((v10 + ~v9) & 0xFFFFFFFFFFFFFFFCLL) + 4);
v9 = *(_QWORD *)v8;
}
if ( (int)v6 > 0 )
{
v11 = *v4;
v12 = *v4 + 4 * v23;
v13 = (_DWORD *)*v5;
v14 = *v5 + 4 * v6;
do
{
v15 = (unsigned int)*v13;
if ( *v13 )
{
v16 = 0LL;
v17 = 0LL;
do
{
v18 = v11 + v16 + 4;
v19 = v15 * *(unsigned int *)(v11 + v16) + v17 + *(unsigned int *)(v9 + v16);
v17 = HIDWORD(v19);
*(_DWORD *)(v9 + v16) = v19;
v16 += 4LL;
}
while ( v18 < v12 );
*(_DWORD *)(v9 + v16) = HIDWORD(v19);
}
++v13;
v9 += 4LL;
}
while ( (unsigned long long)v13 < v14 );
v9 = *(_QWORD *)v8;
}
if ( (int)v7 > 0 )
{
v20 = (_DWORD *)(v9 + 4 * v7 - 4);
while ( !*v20 )
{
--v20;
v21 = (int)v7 <= 1;
LODWORD(v7) = v7 - 1;
if ( v21 )
{
LODWORD(v7) = 0;
break;
}
}
}
*(_DWORD *)(v8 + 20) = v7;
return v8;
}
| mult:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDI
MOV EAX,dword ptr [RDI + 0x14]
CMP EAX,dword ptr [RSI + 0x14]
MOV R12,RSI
CMOVL R12,RDI
CMOVL R14,RSI
MOVSXD RAX,dword ptr [R14 + 0x14]
MOVSXD R13,dword ptr [R12 + 0x14]
MOV qword ptr [RBP + -0x30],RAX
LEA R15,[RAX + R13*0x1]
XOR EDI,EDI
CMP R15D,dword ptr [R14 + 0xc]
SETG DIL
ADD EDI,dword ptr [R14 + 0x8]
MOV RSI,RDX
CALL 0x0016b257
MOV RBX,RAX
MOV RDI,qword ptr [RAX]
TEST R15D,R15D
JLE 0x0016af7a
LEA RAX,[RDI + R15*0x4]
LEA RCX,[RDI + 0x4]
CMP RAX,RCX
CMOVA RCX,RAX
MOV RDX,RDI
NOT RDX
ADD RDX,RCX
AND RDX,-0x4
ADD RDX,0x4
XOR ESI,ESI
CALL 0x0013a3a0
MOV RDI,qword ptr [RBX]
LAB_0016af7a:
TEST R13D,R13D
JLE 0x0016afe2
MOV RAX,qword ptr [R14]
MOV RCX,qword ptr [RBP + -0x30]
LEA RCX,[RAX + RCX*0x4]
MOV RDX,qword ptr [R12]
LEA RSI,[RDX + R13*0x4]
LAB_0016af92:
MOV R8D,dword ptr [RDX]
TEST R8,R8
JZ 0x0016afd2
XOR R9D,R9D
XOR R10D,R10D
LAB_0016afa0:
LEA R11,[RAX + R9*0x1]
ADD R11,0x4
MOV R14D,dword ptr [R11 + -0x4]
IMUL R14,R8
MOV R12D,dword ptr [RDI + R9*0x1]
ADD R12,R10
ADD R12,R14
MOV R10,R12
SHR R10,0x20
MOV dword ptr [RDI + R9*0x1],R12D
ADD R9,0x4
CMP R11,RCX
JC 0x0016afa0
MOV dword ptr [RDI + R9*0x1],R10D
LAB_0016afd2:
ADD RDX,0x4
ADD RDI,0x4
CMP RDX,RSI
JC 0x0016af92
MOV RDI,qword ptr [RBX]
LAB_0016afe2:
TEST R15D,R15D
JLE 0x0016b008
LEA RAX,[RDI + R15*0x4]
ADD RAX,-0x4
LAB_0016afef:
CMP dword ptr [RAX],0x0
JNZ 0x0016b008
LEA ECX,[R15 + -0x1]
ADD RAX,-0x4
CMP R15D,0x1
MOV R15D,ECX
JG 0x0016afef
XOR R15D,R15D
LAB_0016b008:
MOV dword ptr [RBX + 0x14],R15D
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 * mult(long *param_1,long *param_2)
{
void *pvVar1;
uint *puVar2;
uint *puVar3;
int iVar4;
int iVar5;
uint uVar6;
long lVar7;
int8 *puVar8;
int *piVar9;
void *pvVar10;
uint *puVar11;
void *__s;
long lVar12;
ulong uVar13;
ulong uVar14;
long *plVar15;
int iVar16;
ulong uVar17;
plVar15 = param_1;
if (*(int *)((long)param_1 + 0x14) < *(int *)((long)param_2 + 0x14)) {
plVar15 = param_2;
param_2 = param_1;
}
iVar4 = *(int *)((long)plVar15 + 0x14);
iVar5 = *(int *)((long)param_2 + 0x14);
uVar17 = (long)iVar4 + (long)iVar5;
iVar16 = (int)uVar17;
puVar8 = (int8 *)Balloc((uint)(*(int *)((long)plVar15 + 0xc) < iVar16) + (int)plVar15[1]);
__s = (void *)*puVar8;
if (0 < iVar16) {
pvVar1 = (void *)((long)__s + uVar17 * 4);
pvVar10 = (void *)((long)__s + 4U);
if ((void *)((long)__s + 4U) < pvVar1) {
pvVar10 = pvVar1;
}
memset(__s,0,(~(ulong)__s + (long)pvVar10 & 0xfffffffffffffffc) + 4);
__s = (void *)*puVar8;
}
if (0 < iVar5) {
lVar7 = *plVar15;
puVar11 = (uint *)*param_2;
puVar2 = puVar11 + iVar5;
do {
uVar6 = *puVar11;
if ((ulong)uVar6 != 0) {
lVar12 = 0;
uVar13 = 0;
do {
puVar3 = (uint *)(lVar7 + lVar12);
uVar14 = *(uint *)((long)__s + lVar12) + uVar13 + (ulong)*puVar3 * (ulong)uVar6;
uVar13 = uVar14 >> 0x20;
*(int *)((long)__s + lVar12) = (int)uVar14;
lVar12 = lVar12 + 4;
} while (puVar3 + 1 < (uint *)(lVar7 + (long)iVar4 * 4));
*(int *)((long)__s + lVar12) = (int)(uVar14 >> 0x20);
}
puVar11 = puVar11 + 1;
__s = (void *)((long)__s + 4);
} while (puVar11 < puVar2);
__s = (void *)*puVar8;
}
if (0 < iVar16) {
piVar9 = (int *)((long)__s + uVar17 * 4);
do {
piVar9 = piVar9 + -1;
if (*piVar9 != 0) goto LAB_0016b008;
iVar4 = (int)uVar17;
uVar17 = (ulong)(iVar4 - 1);
} while (1 < iVar4);
uVar17 = 0;
}
LAB_0016b008:
*(int *)((long)puVar8 + 0x14) = (int)uVar17;
return puVar8;
}
| |
24,841 | ggml_vec_silu_backward_f32 | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | inline static void ggml_vec_silu_backward_f32(const int n, float * dx, const float * x, const float * dy) {
for (int i = 0; i < n; ++i) {
// we did not use x[i] to compute forward silu but its f16 equivalent
// take derivative at f16 of x[i]:
ggml_fp16_t fp16 = GGML_FP32_TO_FP16(x[i]);
float usedx = GGML_FP16_TO_FP32(fp16);
dx[i] = ggml_silu_backward_f32(usedx, dy[i]);
}
} | O0 | c | ggml_vec_silu_backward_f32:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x44(%rsp), %eax
jge 0x14fbf6
movq 0x30(%rsp), %rax
movslq 0x24(%rsp), %rcx
vmovss (%rax,%rcx,4), %xmm0
vmovaps %xmm0, 0x10(%rsp)
vmovaps 0x10(%rsp), %xmm0
vcvtps2ph $0x0, %xmm0, %xmm0
vmovd %xmm0, %eax
movw %ax, 0x20(%rsp)
movw 0x20(%rsp), %ax
movw %ax, 0x22(%rsp)
movzwl 0x22(%rsp), %edi
callq 0x11a5e0
vmovss %xmm0, 0xc(%rsp)
vmovss 0xc(%rsp), %xmm0
movq 0x28(%rsp), %rax
movslq 0x24(%rsp), %rcx
vmovss (%rax,%rcx,4), %xmm1
callq 0x14fc00
movq 0x38(%rsp), %rax
movslq 0x24(%rsp), %rcx
vmovss %xmm0, (%rax,%rcx,4)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x14fb6f
addq $0x48, %rsp
retq
nopl (%rax,%rax)
| ggml_vec_silu_backward_f32:
sub rsp, 48h
mov [rsp+48h+var_4], edi
mov [rsp+48h+var_10], rsi
mov [rsp+48h+var_18], rdx
mov [rsp+48h+var_20], rcx
mov [rsp+48h+var_24], 0
loc_14FB6F:
mov eax, [rsp+48h+var_24]
cmp eax, [rsp+48h+var_4]
jge short loc_14FBF6
mov rax, [rsp+48h+var_18]
movsxd rcx, [rsp+48h+var_24]
vmovss xmm0, dword ptr [rax+rcx*4]
vmovaps [rsp+48h+var_38], xmm0
vmovaps xmm0, [rsp+48h+var_38]
vcvtps2ph xmm0, xmm0, 0
vmovd eax, xmm0
mov [rsp+48h+var_28], ax
mov ax, [rsp+48h+var_28]
mov [rsp+48h+var_26], ax
movzx edi, [rsp+48h+var_26]
call ggml_lookup_fp16_to_fp32
vmovss [rsp+48h+var_3C], xmm0
vmovss xmm0, [rsp+48h+var_3C]
mov rax, [rsp+48h+var_20]
movsxd rcx, [rsp+48h+var_24]
vmovss xmm1, dword ptr [rax+rcx*4]
call ggml_silu_backward_f32
mov rax, [rsp+48h+var_10]
movsxd rcx, [rsp+48h+var_24]
vmovss dword ptr [rax+rcx*4], xmm0
mov eax, [rsp+48h+var_24]
add eax, 1
mov [rsp+48h+var_24], eax
jmp loc_14FB6F
loc_14FBF6:
add rsp, 48h
retn
| long long ggml_vec_silu_backward_f32(int a1, long long a2, long long a3, long long a4)
{
long long result; // rax
unsigned int i; // [rsp+24h] [rbp-24h]
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= a1 )
break;
_RAX = a3;
_RCX = (int)i;
__asm
{
vmovss xmm0, dword ptr [rax+rcx*4]
vmovaps [rsp+48h+var_38], xmm0
vmovaps xmm0, [rsp+48h+var_38]
vcvtps2ph xmm0, xmm0, 0
vmovd eax, xmm0
}
_XMM0 = ggml_lookup_fp16_to_fp32(_RAX);
__asm
{
vmovss [rsp+48h+var_3C], xmm0
vmovss xmm0, [rsp+48h+var_3C]
}
_RAX = a4;
_RCX = (int)i;
__asm { vmovss xmm1, dword ptr [rax+rcx*4] }
*(double *)&_XMM0 = ggml_silu_backward_f32(*(double *)&_XMM0, *(double *)&_XMM1);
_RAX = a2;
_RCX = (int)i;
__asm { vmovss dword ptr [rax+rcx*4], xmm0 }
}
return result;
}
| copy<__gnu_cxx::__normal_iterator<unsigned_int_const*,std::vector<unsigned_int,std::allocator<unsigned_int>>>,unsigned_int*>:
SUB RSP,0x38
MOV qword ptr [RSP + 0x30],RDI
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x20],RDX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x0014fc30
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP]
CALL 0x0014fc30
MOV qword ptr [RSP + 0x8],RAX
MOV RDX,qword ptr [RSP + 0x20]
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x0014fbb0
ADD RSP,0x38
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* unsigned int* std::copy<__gnu_cxx::__normal_iterator<unsigned int const*, std::vector<unsigned
int, std::allocator<unsigned int> > >, unsigned int*>(__gnu_cxx::__normal_iterator<unsigned int
const*, std::vector<unsigned int, std::allocator<unsigned int> > >,
__gnu_cxx::__normal_iterator<unsigned int const*, std::vector<unsigned int,
std::allocator<unsigned int> > >, unsigned int*) */
uint * std::
copy<__gnu_cxx::__normal_iterator<unsigned_int_const*,std::vector<unsigned_int,std::allocator<unsigned_int>>>,unsigned_int*>
(int8 param_1,int8 param_2,int8 param_3)
{
int8 uVar1;
int8 uVar2;
uint *puVar3;
uVar1 = __miter_base<__gnu_cxx::__normal_iterator<unsigned_int_const*,std::vector<unsigned_int,std::allocator<unsigned_int>>>>
(param_1);
uVar2 = __miter_base<__gnu_cxx::__normal_iterator<unsigned_int_const*,std::vector<unsigned_int,std::allocator<unsigned_int>>>>
(param_2);
puVar3 = __copy_move_a<false,__gnu_cxx::__normal_iterator<unsigned_int_const*,std::vector<unsigned_int,std::allocator<unsigned_int>>>,unsigned_int*>
(uVar1,uVar2,param_3);
return puVar3;
}
| |
24,842 | initialize_bucket(st_lf_hash*, LF_SLIST**, unsigned int, LF_PINS*) | eloqsql/mysys/lf_hash.cc | static int initialize_bucket(LF_HASH *hash, LF_SLIST **node,
uint bucket, LF_PINS *pins)
{
uint parent= my_clear_highest_bit(bucket);
LF_SLIST *dummy= (LF_SLIST *)my_malloc(key_memory_lf_slist,
sizeof(LF_SLIST), MYF(MY_WME));
LF_SLIST **tmp= 0, *cur;
LF_SLIST **el= (LF_SLIST **)lf_dynarray_lvalue(&hash->array, parent);
if (unlikely(!el || !dummy))
return -1;
if (*el == NULL && bucket &&
unlikely(initialize_bucket(hash, el, parent, pins)))
{
my_free(dummy);
return -1;
}
dummy->hashnr= my_reverse_bits(bucket) | 0; /* dummy node */
dummy->key= dummy_key;
dummy->keylen= 0;
if ((cur= l_insert(el, hash->charset, dummy, pins, LF_HASH_UNIQUE)))
{
my_free(dummy);
dummy= cur;
}
my_atomic_casptr((void **)node, (void **)(char*) &tmp, dummy);
/*
note that if the CAS above failed (after l_insert() succeeded),
it would mean that some other thread has executed l_insert() for
the same dummy node, its l_insert() failed, it picked up our
dummy node (in "dummy= cur") and executed the same CAS as above.
Which means that even if CAS above failed we don't need to retry,
and we should not free(dummy) - there's no memory leak here
*/
return 0;
} | O3 | cpp | initialize_bucket(st_lf_hash*, LF_SLIST**, unsigned int, LF_PINS*):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, -0x40(%rbp)
movl %edx, %r12d
movq %rsi, -0x30(%rbp)
movq %rdi, %rbx
movl %edx, %eax
shrl %eax
movl %edx, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %r15d
shrl $0x10, %r15d
orl %eax, %r15d
andl %edx, %r15d
leaq 0xbdade9(%rip), %rax # 0xc0a6e4
movl (%rax), %edi
pushq $0x20
popq %rsi
pushq $0x10
popq %rdx
callq 0xa1359
movq %rax, %r13
movq %rbx, -0x38(%rbp)
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2f59a
pushq $-0x1
popq %r14
testq %rax, %rax
je 0x2f9da
testq %r13, %r13
je 0x2f9da
movq %rax, %rbx
testl %r12d, %r12d
je 0x2f942
cmpq $0x0, (%rbx)
je 0x2f9ec
movl $0xff, %eax
movl %r12d, %ecx
andl %eax, %ecx
leaq 0xb33dd(%rip), %rdx # 0xe2d30
movzbl (%rdx,%rcx), %ecx
shll $0x18, %ecx
movl %r12d, %esi
shrl $0x8, %esi
andl %eax, %esi
movzbl (%rdx,%rsi), %esi
shll $0x10, %esi
orl %ecx, %esi
movl %r12d, %ecx
shrl $0x10, %ecx
andl %eax, %ecx
movzbl (%rdx,%rcx), %eax
shll $0x8, %eax
orl %esi, %eax
shrl $0x18, %r12d
movzbl (%rdx,%r12), %ecx
orl %eax, %ecx
movl %ecx, 0x18(%r13)
leaq 0xb11cd(%rip), %rax # 0xe0b5f
movq %rax, 0x8(%r13)
andq $0x0, 0x10(%r13)
movq -0x38(%rbp), %rax
movq 0xa8(%rax), %rsi
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %r13, %rdx
movq -0x40(%rbp), %rcx
callq 0xa7405
testq %rax, %rax
je 0x2f9cc
movq %rax, %rbx
movq %r13, %rdi
callq 0xa1586
movq %rbx, %r13
movq -0x30(%rbp), %rcx
xorl %r14d, %r14d
xorl %eax, %eax
lock
cmpxchgq %r13, (%rcx)
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
movl %r15d, %edx
movq -0x40(%rbp), %rcx
callq 0x2f8a8
testl %eax, %eax
je 0x2f942
movq %r13, %rdi
callq 0xa1586
jmp 0x2f9da
| _ZL17initialize_bucketP10st_lf_hashPP8LF_SLISTjP7LF_PINS:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov [rbp+var_40], rcx
mov r12d, edx
mov [rbp+var_30], rsi
mov rbx, rdi
mov eax, edx
shr eax, 1
mov ecx, edx
shr ecx, 2
or ecx, eax
mov eax, ecx
shr eax, 2
or eax, ecx
mov ecx, eax
shr ecx, 4
or ecx, eax
mov eax, ecx
shr eax, 8
or eax, ecx
mov r15d, eax
shr r15d, 10h
or r15d, eax
and r15d, edx
lea rax, key_memory_lf_slist
mov edi, [rax]
push 20h ; ' '
pop rsi
push 10h
pop rdx
call my_malloc
mov r13, rax
mov [rbp+var_38], rbx
mov rdi, rbx
mov esi, r15d
call lf_dynarray_lvalue
push 0FFFFFFFFFFFFFFFFh
pop r14
test rax, rax
jz loc_2F9DA
test r13, r13
jz loc_2F9DA
mov rbx, rax
test r12d, r12d
jz short loc_2F942
cmp qword ptr [rbx], 0
jz loc_2F9EC
loc_2F942:
mov eax, 0FFh
mov ecx, r12d
and ecx, eax
lea rdx, _my_bits_reverse_table
movzx ecx, byte ptr [rdx+rcx]
shl ecx, 18h
mov esi, r12d
shr esi, 8
and esi, eax
movzx esi, byte ptr [rdx+rsi]
shl esi, 10h
or esi, ecx
mov ecx, r12d
shr ecx, 10h
and ecx, eax
movzx eax, byte ptr [rdx+rcx]
shl eax, 8
or eax, esi
shr r12d, 18h
movzx ecx, byte ptr [rdx+r12]
or ecx, eax
mov [r13+18h], ecx
lea rax, asc_E0B5B+4; ""
mov [r13+8], rax
and qword ptr [r13+10h], 0
mov rax, [rbp+var_38]
mov rsi, [rax+0A8h]
push 1
pop r8
mov rdi, rbx
mov rdx, r13
mov rcx, [rbp+var_40]
call _ZL8l_insertPP8LF_SLISTPK15charset_info_stS0_P7LF_PINSj; l_insert(LF_SLIST **,charset_info_st const*,LF_SLIST *,LF_PINS *,uint)
test rax, rax
jz short loc_2F9CC
mov rbx, rax
mov rdi, r13
call my_free
mov r13, rbx
loc_2F9CC:
mov rcx, [rbp+var_30]
xor r14d, r14d
xor eax, eax
lock cmpxchg [rcx], r13
loc_2F9DA:
mov eax, r14d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_2F9EC:
mov rdi, [rbp+var_38]
mov rsi, rbx
mov edx, r15d
mov rcx, [rbp+var_40]
call _ZL17initialize_bucketP10st_lf_hashPP8LF_SLISTjP7LF_PINS; initialize_bucket(st_lf_hash *,LF_SLIST **,uint,LF_PINS *)
test eax, eax
jz loc_2F942
mov rdi, r13
call my_free
jmp short loc_2F9DA
| long long initialize_bucket(long long a1, volatile signed long long *a2, unsigned int a3, long long a4)
{
unsigned int v5; // ecx
unsigned int v6; // r15d
signed long long v7; // r13
_QWORD *v8; // rax
unsigned int v9; // r14d
_QWORD *v10; // rbx
long long v11; // rax
signed long long v12; // rbx
v5 = (a3 >> 1) | (a3 >> 2) | (((a3 >> 1) | (a3 >> 2)) >> 2) | (((a3 >> 1) | (a3 >> 2) | (((a3 >> 1) | (a3 >> 2)) >> 2)) >> 4);
v6 = a3 & (v5 | (v5 >> 8) | ((v5 | (v5 >> 8)) >> 16));
v7 = my_malloc(key_memory_lf_slist, 32LL, 16LL);
v8 = (_QWORD *)lf_dynarray_lvalue(a1, v6);
v9 = -1;
if ( v8 && v7 )
{
v10 = v8;
if ( a3 && !*v8 && (unsigned int)initialize_bucket(a1, v8, v6, a4) )
{
my_free(v7);
}
else
{
*(_DWORD *)(v7 + 24) = (my_bits_reverse_table[(unsigned __int8)a3] << 24) | (my_bits_reverse_table[BYTE1(a3)] << 16) | (my_bits_reverse_table[BYTE2(a3)] << 8) | my_bits_reverse_table[HIBYTE(a3)];
*(_QWORD *)(v7 + 8) = "";
*(_QWORD *)(v7 + 16) = 0LL;
v11 = l_insert(v10, *(_QWORD *)(a1 + 168), v7, a4, 1LL);
if ( v11 )
{
v12 = v11;
my_free(v7);
v7 = v12;
}
v9 = 0;
_InterlockedCompareExchange64(a2, v7, 0LL);
}
}
return v9;
}
| initialize_bucket:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RBP + -0x40],RCX
MOV R12D,EDX
MOV qword ptr [RBP + -0x30],RSI
MOV RBX,RDI
MOV EAX,EDX
SHR EAX,0x1
MOV ECX,EDX
SHR ECX,0x2
OR ECX,EAX
MOV EAX,ECX
SHR EAX,0x2
OR EAX,ECX
MOV ECX,EAX
SHR ECX,0x4
OR ECX,EAX
MOV EAX,ECX
SHR EAX,0x8
OR EAX,ECX
MOV R15D,EAX
SHR R15D,0x10
OR R15D,EAX
AND R15D,EDX
LEA RAX,[0xd0a6e4]
MOV EDI,dword ptr [RAX]
PUSH 0x20
POP RSI
PUSH 0x10
POP RDX
CALL 0x001a1359
MOV R13,RAX
MOV qword ptr [RBP + -0x38],RBX
MOV RDI,RBX
MOV ESI,R15D
CALL 0x0012f59a
PUSH -0x1
POP R14
TEST RAX,RAX
JZ 0x0012f9da
TEST R13,R13
JZ 0x0012f9da
MOV RBX,RAX
TEST R12D,R12D
JZ 0x0012f942
CMP qword ptr [RBX],0x0
JZ 0x0012f9ec
LAB_0012f942:
MOV EAX,0xff
MOV ECX,R12D
AND ECX,EAX
LEA RDX,[0x1e2d30]
MOVZX ECX,byte ptr [RDX + RCX*0x1]
SHL ECX,0x18
MOV ESI,R12D
SHR ESI,0x8
AND ESI,EAX
MOVZX ESI,byte ptr [RDX + RSI*0x1]
SHL ESI,0x10
OR ESI,ECX
MOV ECX,R12D
SHR ECX,0x10
AND ECX,EAX
MOVZX EAX,byte ptr [RDX + RCX*0x1]
SHL EAX,0x8
OR EAX,ESI
SHR R12D,0x18
MOVZX ECX,byte ptr [RDX + R12*0x1]
OR ECX,EAX
MOV dword ptr [R13 + 0x18],ECX
LEA RAX,[0x1e0b5f]
MOV qword ptr [R13 + 0x8],RAX
AND qword ptr [R13 + 0x10],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RAX + 0xa8]
PUSH 0x1
POP R8
MOV RDI,RBX
MOV RDX,R13
MOV RCX,qword ptr [RBP + -0x40]
CALL 0x001a7405
TEST RAX,RAX
JZ 0x0012f9cc
MOV RBX,RAX
MOV RDI,R13
CALL 0x001a1586
MOV R13,RBX
LAB_0012f9cc:
MOV RCX,qword ptr [RBP + -0x30]
XOR R14D,R14D
XOR EAX,EAX
CMPXCHG.LOCK qword ptr [RCX],R13
LAB_0012f9da:
MOV EAX,R14D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0012f9ec:
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,RBX
MOV EDX,R15D
MOV RCX,qword ptr [RBP + -0x40]
CALL 0x0012f8a8
TEST EAX,EAX
JZ 0x0012f942
MOV RDI,R13
CALL 0x001a1586
JMP 0x0012f9da
|
/* initialize_bucket(st_lf_hash*, LF_SLIST**, unsigned int, LF_PINS*) */
int4 initialize_bucket(st_lf_hash *param_1,LF_SLIST **param_2,uint param_3,LF_PINS *param_4)
{
int iVar1;
LF_SLIST *pLVar2;
LF_SLIST **ppLVar3;
LF_SLIST *pLVar4;
uint uVar5;
int4 uVar6;
uVar5 = param_3 >> 2 | param_3 >> 1;
uVar5 = uVar5 >> 2 | uVar5;
uVar5 = uVar5 >> 4 | uVar5;
uVar5 = uVar5 >> 8 | uVar5;
uVar5 = (uVar5 >> 0x10 | uVar5) & param_3;
pLVar2 = (LF_SLIST *)my_malloc(key_memory_lf_slist,0x20,0x10);
ppLVar3 = (LF_SLIST **)lf_dynarray_lvalue(param_1,uVar5);
uVar6 = 0xffffffff;
if ((ppLVar3 != (LF_SLIST **)0x0) && (pLVar2 != (LF_SLIST *)0x0)) {
if ((param_3 == 0) ||
((*ppLVar3 != (LF_SLIST *)0x0 ||
(iVar1 = initialize_bucket(param_1,ppLVar3,uVar5,param_4), iVar1 == 0)))) {
*(uint *)(pLVar2 + 0x18) =
(uint)(byte)_my_bits_reverse_table[param_3 >> 0x18] |
(uint)(byte)_my_bits_reverse_table[param_3 >> 0x10 & 0xff] << 8 |
(uint)(byte)_my_bits_reverse_table[param_3 >> 8 & 0xff] << 0x10 |
(uint)(byte)_my_bits_reverse_table[param_3 & 0xff] << 0x18;
*(int **)(pLVar2 + 8) = &DAT_001e0b5f;
*(int8 *)(pLVar2 + 0x10) = 0;
pLVar4 = (LF_SLIST *)l_insert(ppLVar3,*(charset_info_st **)(param_1 + 0xa8),pLVar2,param_4,1);
if (pLVar4 != (LF_SLIST *)0x0) {
my_free(pLVar2);
pLVar2 = pLVar4;
}
uVar6 = 0;
LOCK();
if (*param_2 == (LF_SLIST *)0x0) {
*param_2 = pLVar2;
}
UNLOCK();
}
else {
my_free(pLVar2);
}
}
return uVar6;
}
| |
24,843 | ma_calc_length_for_store_length | eloqsql/storage/maria/ma_blockrec.c | uint ma_calc_length_for_store_length(ulong nr)
{
if (nr < 251)
return 1;
if (nr < 65536)
{
if (nr <= 255)
return 2;
return 3;
}
if (nr < 16777216)
return 4;
return 5;
} | O3 | c | ma_calc_length_for_store_length:
pushq %rbp
movq %rsp, %rbp
movl $0x1, %eax
cmpq $0xfb, %rdi
jb 0x5fcb6
cmpq $0xffff, %rdi # imm = 0xFFFF
ja 0x5fca7
cmpq $0x100, %rdi # imm = 0x100
movl $0x3, %eax
jmp 0x5fcb3
cmpq $0x1000000, %rdi # imm = 0x1000000
movl $0x5, %eax
sbbl $0x0, %eax
popq %rbp
retq
| ma_calc_length_for_store_length:
push rbp
mov rbp, rsp
mov eax, 1
cmp rdi, 0FBh
jb short loc_5FCB6
cmp rdi, 0FFFFh
ja short loc_5FCA7
cmp rdi, 100h
mov eax, 3
jmp short loc_5FCB3
loc_5FCA7:
cmp rdi, 1000000h
mov eax, 5
loc_5FCB3:
sbb eax, 0
loc_5FCB6:
pop rbp
retn
| long long ma_calc_length_for_store_length(unsigned long long a1)
{
long long result; // rax
bool v2; // cf
int v3; // eax
result = 1LL;
if ( a1 >= 0xFB )
{
if ( a1 > 0xFFFF )
{
v2 = a1 < 0x1000000;
v3 = 5;
}
else
{
v2 = a1 < 0x100;
v3 = 3;
}
return v3 - (unsigned int)v2;
}
return result;
}
| ma_calc_length_for_store_length:
PUSH RBP
MOV RBP,RSP
MOV EAX,0x1
CMP RDI,0xfb
JC 0x0015fcb6
CMP RDI,0xffff
JA 0x0015fca7
CMP RDI,0x100
MOV EAX,0x3
JMP 0x0015fcb3
LAB_0015fca7:
CMP RDI,0x1000000
MOV EAX,0x5
LAB_0015fcb3:
SBB EAX,0x0
LAB_0015fcb6:
POP RBP
RET
|
int ma_calc_length_for_store_length(ulong param_1)
{
int iVar1;
bool bVar2;
iVar1 = 1;
if (0xfa < param_1) {
if (param_1 < 0x10000) {
bVar2 = param_1 < 0x100;
iVar1 = 3;
}
else {
bVar2 = param_1 < 0x1000000;
iVar1 = 5;
}
iVar1 = iVar1 - (uint)bVar2;
}
return iVar1;
}
| |
24,844 | mi_read_static_record | eloqsql/storage/myisam/mi_statrec.c | int _mi_read_static_record(register MI_INFO *info, register my_off_t pos,
register uchar *record)
{
int error;
if (pos != HA_OFFSET_ERROR)
{
if (info->opt_flag & WRITE_CACHE_USED &&
info->rec_cache.pos_in_file <= pos &&
flush_io_cache(&info->rec_cache))
return(-1);
info->rec_cache.seek_not_done=1; /* We have done a seek */
error=info->s->file_read(info, record, info->s->base.reclength,
pos,MYF(MY_NABP)) != 0;
fast_mi_writeinfo(info);
if (! error)
{
if (!*record)
{
my_errno=HA_ERR_RECORD_DELETED;
return(1); /* Record is deleted */
}
info->update|= HA_STATE_AKTIV; /* Record is read */
return(0);
}
return(-1); /* Error on read */
}
fast_mi_writeinfo(info); /* No such record */
return(-1);
} | O0 | c | mi_read_static_record:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $-0x1, -0x18(%rbp)
je 0xc84d8
movq -0x10(%rbp), %rax
movl 0x1c8(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0xc8428
movq -0x10(%rbp), %rax
movq 0x220(%rax), %rax
cmpq -0x18(%rbp), %rax
ja 0xc8428
movq -0x10(%rbp), %rdi
addq $0x220, %rdi # imm = 0x220
movl $0x1, %esi
callq 0xe4d00
cmpl $0x0, %eax
je 0xc8428
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc84fa
movq -0x10(%rbp), %rax
movl $0x1, 0x300(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x2e0(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq 0x140(%rcx), %rdx
movq -0x18(%rbp), %rcx
movl $0x4, %r8d
callq *%rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x368(%rax)
jne 0xc8490
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xb52b0
cmpl $0x0, -0x24(%rbp)
jne 0xc84cf
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xc84b3
callq 0xfa320
movl $0x86, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xc84fa
movq -0x10(%rbp), %rax
movl 0x1d0(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x1d0(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xc84fa
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc84fa
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x368(%rax)
jne 0xc84f3
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xb52b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _mi_read_static_record:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
cmp [rbp+var_18], 0FFFFFFFFFFFFFFFFh
jz loc_C84D8
mov rax, [rbp+var_10]
mov eax, [rax+1C8h]
and eax, 10h
cmp eax, 0
jz short loc_C8428
mov rax, [rbp+var_10]
mov rax, [rax+220h]
cmp rax, [rbp+var_18]
ja short loc_C8428
mov rdi, [rbp+var_10]
add rdi, 220h
mov esi, 1
call my_b_flush_io_cache
cmp eax, 0
jz short loc_C8428
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_C84FA
loc_C8428:
mov rax, [rbp+var_10]
mov dword ptr [rax+300h], 1
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+2E0h]
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
mov rcx, [rbp+var_10]
mov rcx, [rcx]
mov rdx, [rcx+140h]
mov rcx, [rbp+var_18]
mov r8d, 4
call rax
cmp rax, 0
setnz al
and al, 1
movzx eax, al
mov [rbp+var_24], eax
mov rax, [rbp+var_10]
mov rax, [rax]
cmp dword ptr [rax+368h], 0
jnz short loc_C8490
mov rdi, [rbp+var_10]
xor esi, esi
call _mi_writeinfo
loc_C8490:
cmp [rbp+var_24], 0
jnz short loc_C84CF
mov rax, [rbp+var_20]
cmp byte ptr [rax], 0
jnz short loc_C84B3
call _my_thread_var
mov dword ptr [rax], 86h
mov [rbp+var_4], 1
jmp short loc_C84FA
loc_C84B3:
mov rax, [rbp+var_10]
mov ecx, [rax+1D0h]
or ecx, 2
mov [rax+1D0h], ecx
mov [rbp+var_4], 0
jmp short loc_C84FA
loc_C84CF:
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_C84FA
loc_C84D8:
mov rax, [rbp+var_10]
mov rax, [rax]
cmp dword ptr [rax+368h], 0
jnz short loc_C84F3
mov rdi, [rbp+var_10]
xor esi, esi
call _mi_writeinfo
loc_C84F3:
mov [rbp+var_4], 0FFFFFFFFh
loc_C84FA:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long mi_read_static_record(long long a1, unsigned long long a2, char *a3)
{
const char *v3; // rsi
BOOL v5; // [rsp+Ch] [rbp-24h]
if ( a2 == -1LL )
{
if ( !*(_DWORD *)(*(_QWORD *)a1 + 872LL) )
mi_writeinfo((_QWORD *)a1, 0LL);
return (unsigned int)-1;
}
else if ( (*(_DWORD *)(a1 + 456) & 0x10) != 0
&& *(_QWORD *)(a1 + 544) <= a2
&& (unsigned int)my_b_flush_io_cache(a1 + 544, 1LL) )
{
return (unsigned int)-1;
}
else
{
*(_DWORD *)(a1 + 768) = 1;
v3 = a3;
v5 = (*(long long ( **)(long long, char *, _QWORD, unsigned long long, long long))(*(_QWORD *)a1 + 736LL))(
a1,
a3,
*(_QWORD *)(*(_QWORD *)a1 + 320LL),
a2,
4LL) != 0;
if ( !*(_DWORD *)(*(_QWORD *)a1 + 872LL) )
{
v3 = 0LL;
mi_writeinfo((_QWORD *)a1, 0LL);
}
if ( v5 )
{
return (unsigned int)-1;
}
else if ( *a3 )
{
*(_DWORD *)(a1 + 464) |= 2u;
return 0;
}
else
{
*(_DWORD *)my_thread_var(a1, v3) = 134;
return 1;
}
}
}
| _mi_read_static_record:
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
CMP qword ptr [RBP + -0x18],-0x1
JZ 0x001c84d8
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x1c8]
AND EAX,0x10
CMP EAX,0x0
JZ 0x001c8428
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x220]
CMP RAX,qword ptr [RBP + -0x18]
JA 0x001c8428
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x220
MOV ESI,0x1
CALL 0x001e4d00
CMP EAX,0x0
JZ 0x001c8428
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001c84fa
LAB_001c8428:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x300],0x1
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x2e0]
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX]
MOV RDX,qword ptr [RCX + 0x140]
MOV RCX,qword ptr [RBP + -0x18]
MOV R8D,0x4
CALL RAX
CMP RAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RBP + -0x24],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
CMP dword ptr [RAX + 0x368],0x0
JNZ 0x001c8490
MOV RDI,qword ptr [RBP + -0x10]
XOR ESI,ESI
CALL 0x001b52b0
LAB_001c8490:
CMP dword ptr [RBP + -0x24],0x0
JNZ 0x001c84cf
MOV RAX,qword ptr [RBP + -0x20]
CMP byte ptr [RAX],0x0
JNZ 0x001c84b3
CALL 0x001fa320
MOV dword ptr [RAX],0x86
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001c84fa
LAB_001c84b3:
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x1d0]
OR ECX,0x2
MOV dword ptr [RAX + 0x1d0],ECX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001c84fa
LAB_001c84cf:
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001c84fa
LAB_001c84d8:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
CMP dword ptr [RAX + 0x368],0x0
JNZ 0x001c84f3
MOV RDI,qword ptr [RBP + -0x10]
XOR ESI,ESI
CALL 0x001b52b0
LAB_001c84f3:
MOV dword ptr [RBP + -0x4],0xffffffff
LAB_001c84fa:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 _mi_read_static_record(long *param_1,ulong param_2,char *param_3)
{
int iVar1;
long lVar2;
int4 *puVar3;
int4 local_c;
if (param_2 == 0xffffffffffffffff) {
if (*(int *)(*param_1 + 0x368) == 0) {
_mi_writeinfo(param_1,0);
}
local_c = 0xffffffff;
}
else {
if ((((*(uint *)(param_1 + 0x39) & 0x10) != 0) && ((ulong)param_1[0x44] <= param_2)) &&
(iVar1 = my_b_flush_io_cache(param_1 + 0x44,1), iVar1 != 0)) {
return 0xffffffff;
}
*(int4 *)(param_1 + 0x60) = 1;
lVar2 = (**(code **)(*param_1 + 0x2e0))
(param_1,param_3,*(int8 *)(*param_1 + 0x140),param_2,4);
if (*(int *)(*param_1 + 0x368) == 0) {
_mi_writeinfo(param_1,0);
}
if (lVar2 == 0) {
if (*param_3 == '\0') {
puVar3 = (int4 *)_my_thread_var();
*puVar3 = 0x86;
local_c = 1;
}
else {
*(uint *)(param_1 + 0x3a) = *(uint *)(param_1 + 0x3a) | 2;
local_c = 0;
}
}
else {
local_c = 0xffffffff;
}
}
return local_c;
}
| |
24,845 | bool 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>::contains<char const (&) [12], 0>(char const (&) [12]) const | monkey531[P]llama/common/./json.hpp | constexpr bool is_object() const noexcept
{
return m_data.m_type == value_t::object;
} | O3 | cpp | bool 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>::contains<char const (&) [12], 0>(char const (&) [12]) const:
cmpb $0x1, (%rdi)
jne 0x95617
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%r12), %rbx
cmpq 0x8(%r12), %rbx
je 0x9561a
movq %rsi, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x181a0
testl %eax, %eax
je 0x9560a
addq $0x30, %rbx
cmpq 0x8(%r12), %rbx
jne 0x955f0
movq %rbx, %rax
movq 0x8(%r14), %rcx
movq 0x8(%rcx), %rbx
jmp 0x9561d
xorl %eax, %eax
retq
movq %rbx, %rax
cmpq %rbx, %rax
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA12_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_:
cmp byte ptr [rdi], 1
jnz short loc_95617
push r15
push r14
push r12
push rbx
push rax
mov r14, rdi
mov r12, [rdi+8]
mov rbx, [r12]
cmp rbx, [r12+8]
jz short loc_9561A
mov r15, rsi
loc_955F0:
mov rdi, rbx
mov rsi, r15
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_9560A
add rbx, 30h ; '0'
cmp rbx, [r12+8]
jnz short loc_955F0
loc_9560A:
mov rax, rbx
mov rcx, [r14+8]
mov rbx, [rcx+8]
jmp short loc_9561D
loc_95617:
xor eax, eax
retn
loc_9561A:
mov rax, rbx
loc_9561D:
cmp rax, rbx
setnz al
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| bool ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA12_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_(
long long a1,
long long a2)
{
long long *v2; // r12
long long v3; // rbx
long long v4; // rax
if ( *(_BYTE *)a1 != 1 )
return 0;
v2 = *(long long **)(a1 + 8);
v3 = *v2;
if ( *v2 == v2[1] )
{
v4 = *v2;
}
else
{
do
{
if ( !(unsigned int)std::string::compare(v3, a2) )
break;
v3 += 48LL;
}
while ( v3 != v2[1] );
v4 = v3;
v3 = *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL);
}
return v4 != v3;
}
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA12_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_:
CMP byte ptr [RDI],0x1
JNZ 0x00195617
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDI
MOV R12,qword ptr [RDI + 0x8]
MOV RBX,qword ptr [R12]
CMP RBX,qword ptr [R12 + 0x8]
JZ 0x0019561a
MOV R15,RSI
LAB_001955f0:
MOV RDI,RBX
MOV RSI,R15
CALL 0x001181a0
TEST EAX,EAX
JZ 0x0019560a
ADD RBX,0x30
CMP RBX,qword ptr [R12 + 0x8]
JNZ 0x001955f0
LAB_0019560a:
MOV RAX,RBX
MOV RCX,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [RCX + 0x8]
JMP 0x0019561d
LAB_00195617:
XOR EAX,EAX
RET
LAB_0019561a:
MOV RAX,RBX
LAB_0019561d:
CMP RAX,RBX
SETNZ AL
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int8
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA12_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
(char *param_1)
{
long *plVar1;
int iVar2;
char *pcVar3;
char *pcVar4;
if (*param_1 != '\x01') {
return 0;
}
plVar1 = *(long **)(param_1 + 8);
pcVar3 = (char *)*plVar1;
pcVar4 = pcVar3;
if (pcVar3 != (char *)plVar1[1]) {
do {
iVar2 = std::__cxx11::string::compare(pcVar3);
if (iVar2 == 0) break;
pcVar3 = pcVar3 + 0x30;
} while (pcVar3 != (char *)plVar1[1]);
pcVar4 = *(char **)(*(long *)(param_1 + 8) + 8);
}
return CONCAT71((int7)((ulong)pcVar3 >> 8),pcVar3 != pcVar4);
}
| |
24,846 | minja::Parser::parseLogicalAnd() | monkey531[P]llama/common/minja.hpp | std::shared_ptr<Expression> parseLogicalAnd() {
auto left = parseLogicalNot();
if (!left) throw std::runtime_error("Expected left side of 'logical and' expression");
static std::regex and_tok(R"(and\b)");
auto location = get_location();
while (!consumeToken(and_tok).empty()) {
auto right = parseLogicalNot();
if (!right) throw std::runtime_error("Expected right side of 'and' expression");
left = std::make_shared<BinaryOpExpr>(location, std::move(left), std::move(right), BinaryOpExpr::Op::And);
}
return left;
} | O0 | cpp | minja::Parser::parseLogicalAnd():
subq $0xb8, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xa8(%rsp), %rsi
movq %rsi, 0x20(%rsp)
movb $0x0, 0xa7(%rsp)
callq 0x125360
movq 0x28(%rsp), %rdi
callq 0x101d30
testb $0x1, %al
jne 0x125038
movl $0x10, %edi
callq 0x52670
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
leaq 0xbbacd(%rip), %rsi # 0x1e0aa5
callq 0x52460
jmp 0x124fdf
movq 0x10(%rsp), %rdi
movq 0x141fb5(%rip), %rsi # 0x266fa0
movq 0x141f6e(%rip), %rdx # 0x266f60
callq 0x52a60
jmp 0x125274
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
callq 0x52e60
jmp 0x12525d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x12525d
leaq 0x143181(%rip), %rax # 0x2681c0
cmpb $0x0, (%rax)
jne 0x125095
leaq 0x143175(%rip), %rdi # 0x2681c0
callq 0x525e0
cmpl $0x0, %eax
je 0x125095
leaq 0x143144(%rip), %rdi # 0x2681a0
leaq 0xbba71(%rip), %rsi # 0x1e0ad4
movl $0x10, %edx
callq 0x100f90
jmp 0x12506f
leaq -0x24036(%rip), %rdi # 0x101040
leaq 0x143123(%rip), %rsi # 0x2681a0
leaq 0x142984(%rip), %rdx # 0x267a08
callq 0x52e40
leaq 0x143130(%rip), %rdi # 0x2681c0
callq 0x52970
movq 0x20(%rsp), %rsi
leaq 0x78(%rsp), %rdi
callq 0x1010c0
jmp 0x1250a6
jmp 0x1250a8
movq 0x20(%rsp), %rsi
leaq 0x1430ec(%rip), %rdx # 0x2681a0
leaq 0x58(%rsp), %rdi
movl $0x1, %ecx
callq 0x101b50
jmp 0x1250c5
leaq 0x58(%rsp), %rdi
callq 0x524d0
xorb $-0x1, %al
movb %al, 0xf(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x53408
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x1250ec
jmp 0x12521c
movq 0x20(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x125360
jmp 0x1250fd
leaq 0x48(%rsp), %rdi
callq 0x101d30
testb $0x1, %al
jne 0x1251c0
movl $0x10, %edi
callq 0x52670
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
leaq 0xbb9b0(%rip), %rsi # 0x1e0ada
callq 0x52460
jmp 0x125131
movq (%rsp), %rdi
movq 0x141e64(%rip), %rsi # 0x266fa0
movq 0x141e1d(%rip), %rdx # 0x266f60
callq 0x52a60
jmp 0x125274
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x143058(%rip), %rdi # 0x2681c0
callq 0x52700
jmp 0x12525d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x12523a
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
callq 0x52e60
jmp 0x125210
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x125210
movq 0x28(%rsp), %rdx
movl $0xe, 0x34(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x78(%rsp), %rsi
leaq 0x48(%rsp), %rcx
leaq 0x34(%rsp), %r8
callq 0x125280
jmp 0x1251e8
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x125320
leaq 0x38(%rsp), %rdi
callq 0x125350
leaq 0x48(%rsp), %rdi
callq 0x101b40
jmp 0x1250a8
leaq 0x48(%rsp), %rdi
callq 0x101b40
jmp 0x12523a
movb $0x1, 0xa7(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x104780
testb $0x1, 0xa7(%rsp)
jne 0x125250
jmp 0x125246
leaq 0x78(%rsp), %rdi
callq 0x104780
jmp 0x12525d
movq 0x28(%rsp), %rdi
callq 0x101b40
movq 0x18(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x101b40
movq 0x98(%rsp), %rdi
callq 0x52ae0
nopw %cs:(%rax,%rax)
nop
| _ZN5minja6Parser15parseLogicalAndEv:
sub rsp, 0B8h
mov [rsp+0B8h+var_90], rdi
mov rax, rdi
mov [rsp+0B8h+var_A0], rax
mov [rsp+0B8h+var_8], rdi
mov [rsp+0B8h+var_10], rsi
mov rsi, [rsp+0B8h+var_10]
mov [rsp+0B8h+var_98], rsi
mov [rsp+0B8h+var_11], 0
call _ZN5minja6Parser15parseLogicalNotEv; minja::Parser::parseLogicalNot(void)
mov rdi, [rsp+0B8h+var_90]
call _ZNKSt12__shared_ptrIN5minja10ExpressionELN9__gnu_cxx12_Lock_policyE2EEcvbEv; std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator bool(void)
test al, 1
jnz short loc_125038
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+0B8h+var_A8], rax
lea rsi, aExpectedLeftSi_0; "Expected left side of 'logical and' exp"...
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_124FDF:
mov rdi, [rsp+0B8h+var_A8]; void *
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp loc_125274
mov rdi, [rsp+arg_8]; void *
mov rcx, rax
mov eax, edx
mov [rsp+arg_90], rcx
mov [rsp+arg_8C], eax
call ___cxa_free_exception
jmp loc_12525D
mov rcx, rax
mov eax, edx
mov [rsp+arg_90], rcx
mov [rsp+arg_8C], eax
jmp loc_12525D
loc_125038:
lea rax, _ZGVZN5minja6Parser15parseLogicalAndEvE7and_tokB5cxx11; `guard variable for'minja::Parser::parseLogicalAnd(void)::and_tok
cmp byte ptr [rax], 0
jnz short loc_125095
lea rdi, _ZGVZN5minja6Parser15parseLogicalAndEvE7and_tokB5cxx11; __guard *
call ___cxa_guard_acquire
cmp eax, 0
jz short loc_125095
lea rdi, _ZZN5minja6Parser15parseLogicalAndEvE7and_tokB5cxx11; minja::Parser::parseLogicalAnd(void)::and_tok
lea rsi, aAndB; "and\\b"
mov edx, 10h
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
jmp short $+2
loc_12506F:
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZN5minja6Parser15parseLogicalAndEvE7and_tokB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN5minja6Parser15parseLogicalAndEvE7and_tokB5cxx11; __guard *
call ___cxa_guard_release
loc_125095:
mov rsi, [rsp+0B8h+var_98]
lea rdi, [rsp+0B8h+var_40]; this
call _ZNK5minja6Parser12get_locationEv; minja::Parser::get_location(void)
jmp short $+2
loc_1250A6:
jmp short $+2
loc_1250A8:
mov rsi, [rsp+0B8h+var_98]
lea rdx, _ZZN5minja6Parser15parseLogicalAndEvE7and_tokB5cxx11; minja::Parser::parseLogicalAnd(void)::and_tok
lea rdi, [rsp+0B8h+var_60]
mov ecx, 1
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
jmp short $+2
loc_1250C5:
lea rdi, [rsp+0B8h+var_60]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
xor al, 0FFh
mov [rsp+0B8h+var_A9], al
lea rdi, [rsp+0B8h+var_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov al, [rsp+0B8h+var_A9]
test al, 1
jnz short loc_1250EC
jmp loc_12521C
loc_1250EC:
mov rsi, [rsp+0B8h+var_98]
lea rdi, [rsp+0B8h+var_70]; this
call _ZN5minja6Parser15parseLogicalNotEv; minja::Parser::parseLogicalNot(void)
jmp short $+2
loc_1250FD:
lea rdi, [rsp+0B8h+var_70]
call _ZNKSt12__shared_ptrIN5minja10ExpressionELN9__gnu_cxx12_Lock_policyE2EEcvbEv; std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator bool(void)
test al, 1
jnz loc_1251C0
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+0B8h+var_B8], rax
lea rsi, aExpectedRightS_0; "Expected right side of 'and' expression"
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_125131:
mov rdi, [rsp+0B8h+var_B8]; void *
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp loc_125274
mov rcx, rax
mov eax, edx
mov [rsp+arg_90], rcx
mov [rsp+arg_8C], eax
lea rdi, _ZGVZN5minja6Parser15parseLogicalAndEvE7and_tokB5cxx11; __guard *
call ___cxa_guard_abort
jmp loc_12525D
mov rcx, rax
mov eax, edx
mov [rsp+arg_90], rcx
mov [rsp+arg_8C], eax
jmp loc_12523A
mov rdi, [rsp+0]; void *
mov rcx, rax
mov eax, edx
mov [rsp+arg_90], rcx
mov [rsp+arg_8C], eax
call ___cxa_free_exception
jmp short loc_125210
mov rcx, rax
mov eax, edx
mov [rsp+arg_90], rcx
mov [rsp+arg_8C], eax
jmp short loc_125210
loc_1251C0:
mov rdx, [rsp+0B8h+var_90]
mov [rsp+0B8h+var_84], 0Eh
lea rdi, [rsp+0B8h+var_80]
lea rsi, [rsp+0B8h+var_40]
lea rcx, [rsp+0B8h+var_70]
lea r8, [rsp+0B8h+var_84]
call _ZSt11make_sharedIN5minja12BinaryOpExprEJRNS0_8LocationESt10shared_ptrINS0_10ExpressionEES6_NS1_2OpEEES4_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 &&)
jmp short $+2
loc_1251E8:
mov rdi, [rsp+0B8h+var_90]
lea rsi, [rsp+0B8h+var_80]
call _ZNSt10shared_ptrIN5minja10ExpressionEEaSINS0_12BinaryOpExprEEENSt9enable_ifIXsr13is_assignableIRSt12__shared_ptrIS1_LN9__gnu_cxx12_Lock_policyE2EES_IT_EEE5valueERS2_E4typeEOSC_
lea rdi, [rsp+0B8h+var_80]
call _ZNSt10shared_ptrIN5minja12BinaryOpExprEED2Ev; std::shared_ptr<minja::BinaryOpExpr>::~shared_ptr()
lea rdi, [rsp+0B8h+var_70]
call _ZNSt10shared_ptrIN5minja10ExpressionEED2Ev; std::shared_ptr<minja::Expression>::~shared_ptr()
jmp loc_1250A8
loc_125210:
lea rdi, [rsp+arg_40]
call _ZNSt10shared_ptrIN5minja10ExpressionEED2Ev; std::shared_ptr<minja::Expression>::~shared_ptr()
jmp short loc_12523A
loc_12521C:
mov [rsp+0B8h+var_11], 1
lea rdi, [rsp+0B8h+var_40]; this
call _ZN5minja8LocationD2Ev; minja::Location::~Location()
test [rsp+0B8h+var_11], 1
jnz short loc_125250
jmp short loc_125246
loc_12523A:
lea rdi, [rsp+arg_70]; this
call _ZN5minja8LocationD2Ev; minja::Location::~Location()
jmp short loc_12525D
loc_125246:
mov rdi, [rsp+0B8h+var_90]
call _ZNSt10shared_ptrIN5minja10ExpressionEED2Ev; std::shared_ptr<minja::Expression>::~shared_ptr()
loc_125250:
mov rax, [rsp+0B8h+var_A0]
add rsp, 0B8h
retn
loc_12525D:
mov rdi, [rsp+arg_20]
call _ZNSt10shared_ptrIN5minja10ExpressionEED2Ev; std::shared_ptr<minja::Expression>::~shared_ptr()
mov rdi, [rsp+arg_90]
call __Unwind_Resume
loc_125274:
nop word ptr [rax+rax+00000000h]
xchg ax, ax
| minja::Parser * minja::Parser::parseLogicalAnd(minja::Parser *this, long long a2)
{
int v2; // r9d
int v4; // [rsp+0h] [rbp-B8h]
std::runtime_error *v5; // [rsp+0h] [rbp-B8h]
int v6; // [rsp+8h] [rbp-B0h]
char v7; // [rsp+Fh] [rbp-A9h]
int v8; // [rsp+10h] [rbp-A8h]
std::runtime_error *exception; // [rsp+10h] [rbp-A8h]
minja::Parser *v10; // [rsp+18h] [rbp-A0h]
long long v11; // [rsp+20h] [rbp-98h]
int v12; // [rsp+34h] [rbp-84h] BYREF
_BYTE v13[16]; // [rsp+38h] [rbp-80h] BYREF
_QWORD v14[2]; // [rsp+48h] [rbp-70h] BYREF
_BYTE v15[32]; // [rsp+58h] [rbp-60h] BYREF
_BYTE v16[47]; // [rsp+78h] [rbp-40h] BYREF
char v17; // [rsp+A7h] [rbp-11h]
long long v18; // [rsp+A8h] [rbp-10h]
minja::Parser *v19; // [rsp+B0h] [rbp-8h]
v10 = this;
v19 = this;
v18 = a2;
v11 = a2;
v17 = 0;
minja::Parser::parseLogicalNot(this);
if ( !std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator bool(this) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expected left side of 'logical and' 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::parseLogicalAnd(void)::and_tok[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseLogicalAnd(void)::and_tok[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseLogicalAnd(void)::and_tok[abi:cxx11],
(long long)"and\\b",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseLogicalAnd(void)::and_tok[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseLogicalAnd(void)::and_tok[abi:cxx11]);
}
minja::Parser::get_location((minja::Parser *)v16, a2);
while ( 1 )
{
minja::Parser::consumeToken(
(long long)v15,
v11,
(long long)&minja::Parser::parseLogicalAnd(void)::and_tok[abi:cxx11],
1u);
v7 = ~(unsigned __int8)std::string::empty(v15);
std::string::~string(v15);
if ( (v7 & 1) == 0 )
break;
minja::Parser::parseLogicalNot((minja::Parser *)v14);
if ( !std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator bool(v14) )
{
v5 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v5, "Expected right side of 'and' expression");
__cxa_throw(
v5,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v12 = 14;
std::make_shared<minja::BinaryOpExpr,minja::Location &,std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>,minja::BinaryOpExpr::Op>(
(unsigned int)v13,
(unsigned int)v16,
(_DWORD)this,
(unsigned int)v14,
(unsigned int)&v12,
v2,
v4,
v6,
v8,
(long long)v10,
v11);
std::shared_ptr<minja::Expression>::operator=<minja::BinaryOpExpr>(this, v13);
std::shared_ptr<minja::BinaryOpExpr>::~shared_ptr(v13);
std::shared_ptr<minja::Expression>::~shared_ptr((long long)v14);
}
v17 = 1;
minja::Location::~Location((minja::Location *)v16);
if ( (v17 & 1) == 0 )
std::shared_ptr<minja::Expression>::~shared_ptr((long long)this);
return v10;
}
| |||
24,847 | minja::Parser::parseLogicalAnd() | monkey531[P]llama/common/minja.hpp | std::shared_ptr<Expression> parseLogicalAnd() {
auto left = parseLogicalNot();
if (!left) throw std::runtime_error("Expected left side of 'logical and' expression");
static std::regex and_tok(R"(and\b)");
auto location = get_location();
while (!consumeToken(and_tok).empty()) {
auto right = parseLogicalNot();
if (!right) throw std::runtime_error("Expected right side of 'and' expression");
left = std::make_shared<BinaryOpExpr>(location, std::move(left), std::move(right), BinaryOpExpr::Op::And);
}
return left;
} | O3 | cpp | minja::Parser::parseLogicalAnd():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x6b73e
cmpq $0x0, (%rbx)
je 0x6b645
leaq 0x7dae6(%rip), %rax # 0xe8fc0
movb (%rax), %al
testb %al, %al
je 0x6b677
movq (%r14), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%r14), %rax
movq %rax, 0x28(%rsp)
testq %rax, %rax
je 0x6b50f
movq 0x7ca8f(%rip), %rcx # 0xe7f90
cmpb $0x0, (%rcx)
je 0x6b50b
incl 0x8(%rax)
jmp 0x6b50f
lock
incl 0x8(%rax)
movq 0x20(%r14), %rax
subq 0x10(%r14), %rax
leaq 0x20(%rsp), %rcx
movq %rax, 0x10(%rcx)
movq %rsp, %r13
leaq 0x7b86e(%rip), %r12 # 0xe6d98
addq $0x10, %r12
movq %r13, %rdi
movq %r14, %rsi
leaq 0x7da65(%rip), %rdx # 0xe8fa0
movl $0x1, %ecx
callq 0x5f158
movq (%rsp), %rdi
movq 0x8(%rsp), %r15
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x6b565
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x197b0
testq %r15, %r15
je 0x6b5f0
movq %r13, %rdi
movq %r14, %rsi
callq 0x6b73e
cmpq $0x0, (%rsp)
je 0x6b611
movl $0x58, %edi
callq 0x197a0
movq %rax, %rbp
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%rbp)
movq %r12, (%rbp)
movq %rbp, %r15
addq $0x10, %r15
movq %r15, %rdi
leaq 0x20(%rsp), %rsi
movq %rbx, %rdx
movq %r13, %rcx
movl $0xe, %r8d
callq 0x77632
movq %r15, (%rbx)
movq 0x8(%rbx), %rdi
movq %rbp, 0x8(%rbx)
testq %rdi, %rdi
je 0x6b5d8
callq 0x33e7e
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6b52e
callq 0x33e7e
jmp 0x6b52e
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x6b5ff
callq 0x33e7e
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x193b0
movq %rax, %r15
leaq 0x49cbc(%rip), %rsi # 0xb52e1
movq %rax, %rdi
callq 0x192c0
movq 0x7c9bc(%rip), %rsi # 0xe7ff0
movq 0x7c92d(%rip), %rdx # 0xe7f68
movq %r15, %rdi
callq 0x19da0
jmp 0x6b677
movl $0x10, %edi
callq 0x193b0
movq %rax, %r15
leaq 0x49c53(%rip), %rsi # 0xb52ac
movq %rax, %rdi
callq 0x192c0
movq 0x7c988(%rip), %rsi # 0xe7ff0
movq 0x7c8f9(%rip), %rdx # 0xe7f68
movq %r15, %rdi
callq 0x19da0
leaq 0x7d942(%rip), %rdi # 0xe8fc0
callq 0x19e70
testl %eax, %eax
je 0x6b4e4
leaq 0x7d90e(%rip), %rdi # 0xe8fa0
leaq 0x49c42(%rip), %rsi # 0xb52db
movl $0x10, %edx
callq 0x5ecc2
leaq -0xc980(%rip), %rdi # 0x5ed2a
leaq 0x7d8ef(%rip), %rsi # 0xe8fa0
leaq 0x7d150(%rip), %rdx # 0xe8808
callq 0x19680
leaq 0x7d8fc(%rip), %rdi # 0xe8fc0
callq 0x194c0
jmp 0x6b4e4
movq %rax, %r14
leaq 0x7d8e8(%rip), %rdi # 0xe8fc0
callq 0x194b0
jmp 0x6b728
movq %rax, %r14
jmp 0x6b728
movq %rax, %r14
movq %r15, %rdi
callq 0x19570
jmp 0x6b728
jmp 0x6b702
movq %rax, %r14
movq %r15, %rdi
callq 0x19570
jmp 0x6b705
jmp 0x6b716
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6b719
callq 0x33e7e
jmp 0x6b719
movq %rax, %r14
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x6b728
callq 0x33e7e
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x6b736
callq 0x33e7e
movq %r14, %rdi
callq 0x19e10
| _ZN5minja6Parser15parseLogicalAndEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r14, rsi
mov rbx, rdi
call _ZN5minja6Parser15parseLogicalNotEv; minja::Parser::parseLogicalNot(void)
cmp qword ptr [rbx], 0
jz loc_6B645
lea rax, _ZGVZN5minja6Parser15parseLogicalAndEvE7and_tokB5cxx11; `guard variable for'minja::Parser::parseLogicalAnd(void)::and_tok
mov al, [rax]
test al, al
jz loc_6B677
loc_6B4E4:
mov rax, [r14]
mov [rsp+68h+var_48], rax
mov rax, [r14+8]
mov [rsp+68h+var_40], rax
test rax, rax
jz short loc_6B50F
mov rcx, cs:__libc_single_threaded_ptr
cmp byte ptr [rcx], 0
jz short loc_6B50B
inc dword ptr [rax+8]
jmp short loc_6B50F
loc_6B50B:
lock inc dword ptr [rax+8]
loc_6B50F:
mov rax, [r14+20h]
sub rax, [r14+10h]
lea rcx, [rsp+68h+var_48]
mov [rcx+10h], rax
mov r13, rsp
lea r12, _ZTVSt23_Sp_counted_ptr_inplaceIN5minja12BinaryOpExprESaIS1_ELN9__gnu_cxx12_Lock_policyE2EE; `vtable for'std::_Sp_counted_ptr_inplace<minja::BinaryOpExpr,std::allocator<minja::BinaryOpExpr>,(__gnu_cxx::_Lock_policy)2>
add r12, 10h
loc_6B52E:
mov rdi, r13
mov rsi, r14
lea rdx, _ZZN5minja6Parser15parseLogicalAndEvE7and_tokB5cxx11; minja::Parser::parseLogicalAnd(void)::and_tok
mov ecx, 1
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
mov rdi, [rsp+68h+var_68]; void *
mov r15, [rsp+68h+var_60]
lea rax, [rsp+68h+var_58]
cmp rdi, rax
jz short loc_6B565
mov rsi, [rsp+68h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_6B565:
test r15, r15
jz loc_6B5F0
mov rdi, r13; this
mov rsi, r14
call _ZN5minja6Parser15parseLogicalNotEv; minja::Parser::parseLogicalNot(void)
cmp [rsp+68h+var_68], 0
jz loc_6B611
mov edi, 58h ; 'X'; unsigned __int64
call __Znwm; operator new(ulong)
mov rbp, rax
mov rax, 100000001h
mov [rbp+8], rax
mov [rbp+0], r12
mov r15, rbp
add r15, 10h
mov rdi, r15
lea rsi, [rsp+68h+var_48]
mov rdx, rbx
mov rcx, r13
mov r8d, 0Eh
call _ZN5minja12BinaryOpExprC2ERKNS_8LocationEOSt10shared_ptrINS_10ExpressionEES7_NS0_2OpE; minja::BinaryOpExpr::BinaryOpExpr(minja::Location const&,std::shared_ptr<minja::Expression> &&,std::shared_ptr<minja::Expression> &,minja::BinaryOpExpr::Op)
mov [rbx], r15
mov rdi, [rbx+8]
mov [rbx+8], rbp
test rdi, rdi
jz short loc_6B5D8
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_6B5D8:
mov rdi, [rsp+68h+var_60]
test rdi, rdi
jz loc_6B52E
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
jmp loc_6B52E
loc_6B5F0:
mov rdi, [rsp+68h+var_40]
test rdi, rdi
jz short loc_6B5FF
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_6B5FF:
mov rax, rbx
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_6B611:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aExpectedRightS_0; "Expected right side of 'and' expression"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
jmp short loc_6B677
loc_6B645:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aExpectedLeftSi_0; "Expected left side of 'logical and' exp"...
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
loc_6B677:
lea rdi, _ZGVZN5minja6Parser15parseLogicalAndEvE7and_tokB5cxx11; __guard *
call ___cxa_guard_acquire
test eax, eax
jz loc_6B4E4
lea rdi, _ZZN5minja6Parser15parseLogicalAndEvE7and_tokB5cxx11; minja::Parser::parseLogicalAnd(void)::and_tok
lea rsi, aAndB; "and\\b"
mov edx, 10h
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZN5minja6Parser15parseLogicalAndEvE7and_tokB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN5minja6Parser15parseLogicalAndEvE7and_tokB5cxx11; __guard *
call ___cxa_guard_release
jmp loc_6B4E4
mov r14, rax
lea rdi, _ZGVZN5minja6Parser15parseLogicalAndEvE7and_tokB5cxx11; __guard *
call ___cxa_guard_abort
jmp short loc_6B728
mov r14, rax
jmp short loc_6B728
mov r14, rax
mov rdi, r15; void *
call ___cxa_free_exception
jmp short loc_6B728
jmp short loc_6B702
mov r14, rax
mov rdi, r15; void *
call ___cxa_free_exception
jmp short loc_6B705
jmp short loc_6B716
loc_6B702:
mov r14, rax
loc_6B705:
mov rdi, [rsp+arg_0]
test rdi, rdi
jz short loc_6B719
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
jmp short loc_6B719
loc_6B716:
mov r14, rax
loc_6B719:
mov rdi, [rsp+arg_20]
test rdi, rdi
jz short loc_6B728
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_6B728:
mov rdi, [rbx+8]
test rdi, rdi
jz short loc_6B736
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_6B736:
mov rdi, r14
call __Unwind_Resume
| minja::Parser * minja::Parser::parseLogicalAnd(volatile signed __int32 **this, long long *a2)
{
volatile signed __int32 *v3; // rax
volatile signed __int32 *v4; // r15
volatile signed __int32 *v5; // rbp
volatile signed __int32 *v6; // rdi
std::runtime_error *v8; // r15
std::runtime_error *exception; // r15
void *v10; // [rsp+0h] [rbp-68h] BYREF
volatile signed __int32 *v11; // [rsp+8h] [rbp-60h]
long long v12; // [rsp+10h] [rbp-58h] BYREF
long long v13; // [rsp+20h] [rbp-48h] BYREF
volatile signed __int32 *v14; // [rsp+28h] [rbp-40h]
long long v15; // [rsp+30h] [rbp-38h]
minja::Parser::parseLogicalNot((minja::Parser *)this);
if ( !*this )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expected left side of 'logical and' 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::parseLogicalAnd(void)::and_tok[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseLogicalAnd(void)::and_tok[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseLogicalAnd(void)::and_tok[abi:cxx11],
"and\\b",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseLogicalAnd(void)::and_tok[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseLogicalAnd(void)::and_tok[abi:cxx11]);
}
v13 = *a2;
v3 = (volatile signed __int32 *)a2[1];
v14 = v3;
if ( v3 )
{
if ( _libc_single_threaded )
++*((_DWORD *)v3 + 2);
else
_InterlockedIncrement(v3 + 2);
}
v15 = a2[4] - a2[2];
while ( 1 )
{
minja::Parser::consumeToken(
(long long)&v10,
(long long)a2,
(long long)&minja::Parser::parseLogicalAnd(void)::and_tok[abi:cxx11],
1u);
v4 = v11;
if ( v10 != &v12 )
operator delete(v10, v12 + 1);
if ( !v4 )
break;
minja::Parser::parseLogicalNot((minja::Parser *)&v10);
if ( !v10 )
{
v8 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v8, "Expected right side of 'and' expression");
__cxa_throw(
v8,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v5 = (volatile signed __int32 *)operator new(0x58uLL);
*((_QWORD *)v5 + 1) = 0x100000001LL;
*(_QWORD *)v5 = &`vtable for'std::_Sp_counted_ptr_inplace<minja::BinaryOpExpr,std::allocator<minja::BinaryOpExpr>,(__gnu_cxx::_Lock_policy)2>
+ 2;
minja::BinaryOpExpr::BinaryOpExpr(v5 + 4, &v13, this, &v10, 14LL);
*this = v5 + 4;
v6 = this[1];
this[1] = v5;
if ( v6 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v6);
if ( v11 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v11);
}
if ( v14 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v14);
return (minja::Parser *)this;
}
| parseLogicalAnd:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R14,RSI
MOV RBX,RDI
CALL 0x0016b73e
CMP qword ptr [RBX],0x0
JZ 0x0016b645
LEA RAX,[0x1e8fc0]
MOV AL,byte ptr [RAX]
TEST AL,AL
JZ 0x0016b677
LAB_0016b4e4:
MOV RAX,qword ptr [R14]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [R14 + 0x8]
MOV qword ptr [RSP + 0x28],RAX
TEST RAX,RAX
JZ 0x0016b50f
MOV RCX,qword ptr [0x001e7f90]
CMP byte ptr [RCX],0x0
JZ 0x0016b50b
INC dword ptr [RAX + 0x8]
JMP 0x0016b50f
LAB_0016b50b:
INC.LOCK dword ptr [RAX + 0x8]
LAB_0016b50f:
MOV RAX,qword ptr [R14 + 0x20]
SUB RAX,qword ptr [R14 + 0x10]
LEA RCX,[RSP + 0x20]
MOV qword ptr [RCX + 0x10],RAX
MOV R13,RSP
LEA R12,[0x1e6d98]
ADD R12,0x10
LAB_0016b52e:
MOV RDI,R13
MOV RSI,R14
LEA RDX,[0x1e8fa0]
MOV ECX,0x1
CALL 0x0015f158
MOV RDI,qword ptr [RSP]
MOV R15,qword ptr [RSP + 0x8]
LEA RAX,[RSP + 0x10]
CMP RDI,RAX
JZ 0x0016b565
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x001197b0
LAB_0016b565:
TEST R15,R15
JZ 0x0016b5f0
LAB_0016b56e:
MOV RDI,R13
MOV RSI,R14
CALL 0x0016b73e
CMP qword ptr [RSP],0x0
JZ 0x0016b611
LAB_0016b584:
MOV EDI,0x58
CALL 0x001197a0
LAB_0016b58e:
MOV RBP,RAX
MOV RAX,0x100000001
MOV qword ptr [RBP + 0x8],RAX
MOV qword ptr [RBP],R12
MOV R15,RBP
ADD R15,0x10
MOV RDI,R15
LEA RSI,[RSP + 0x20]
MOV RDX,RBX
MOV RCX,R13
MOV R8D,0xe
CALL 0x00177632
MOV qword ptr [RBX],R15
MOV RDI,qword ptr [RBX + 0x8]
MOV qword ptr [RBX + 0x8],RBP
TEST RDI,RDI
JZ 0x0016b5d8
CALL 0x00133e7e
LAB_0016b5d8:
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x0016b52e
CALL 0x00133e7e
JMP 0x0016b52e
LAB_0016b5f0:
MOV RDI,qword ptr [RSP + 0x28]
TEST RDI,RDI
JZ 0x0016b5ff
CALL 0x00133e7e
LAB_0016b5ff:
MOV RAX,RBX
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0016b611:
MOV EDI,0x10
CALL 0x001193b0
MOV R15,RAX
LAB_0016b61e:
LEA RSI,[0x1b52e1]
MOV RDI,RAX
CALL 0x001192c0
LAB_0016b62d:
MOV RSI,qword ptr [0x001e7ff0]
MOV RDX,qword ptr [0x001e7f68]
MOV RDI,R15
CALL 0x00119da0
LAB_0016b645:
MOV EDI,0x10
CALL 0x001193b0
MOV R15,RAX
LAB_0016b652:
LEA RSI,[0x1b52ac]
MOV RDI,RAX
CALL 0x001192c0
LAB_0016b661:
MOV RSI,qword ptr [0x001e7ff0]
MOV RDX,qword ptr [0x001e7f68]
MOV RDI,R15
CALL 0x00119da0
LAB_0016b677:
LEA RDI,[0x1e8fc0]
CALL 0x00119e70
TEST EAX,EAX
JZ 0x0016b4e4
LAB_0016b68b:
LEA RDI,[0x1e8fa0]
LEA RSI,[0x1b52db]
MOV EDX,0x10
CALL 0x0015ecc2
LAB_0016b6a3:
LEA RDI,[0x15ed2a]
LEA RSI,[0x1e8fa0]
LEA RDX,[0x1e8808]
CALL 0x00119680
LEA RDI,[0x1e8fc0]
CALL 0x001194c0
JMP 0x0016b4e4
|
/* minja::Parser::parseLogicalAnd() */
void minja::Parser::parseLogicalAnd(void)
{
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Var1;
int iVar2;
int8 *puVar3;
runtime_error *prVar4;
int8 *in_RSI;
long *in_RDI;
long *local_68;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_60;
long local_58 [2];
int8 local_48;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_40;
long local_38;
parseLogicalNot();
if (*in_RDI == 0) {
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0016b652 to 0016b660 has its CatchHandler @ 0016b6e4 */
std::runtime_error::runtime_error(prVar4,"Expected left side of \'logical and\' expression");
/* try { // try from 0016b661 to 0016b676 has its CatchHandler @ 0016b6df */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_001e7ff0,PTR__runtime_error_001e7f68);
}
if (parseLogicalAnd()::and_tok_abi_cxx11_ == '\0') {
iVar2 = __cxa_guard_acquire(&parseLogicalAnd()::and_tok_abi_cxx11_);
if (iVar2 != 0) {
/* try { // try from 0016b68b to 0016b6a2 has its CatchHandler @ 0016b6ce */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
((basic_regex<char,std::__cxx11::regex_traits<char>> *)
parseLogicalAnd()::and_tok_abi_cxx11_,"and\\b",0x10);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
parseLogicalAnd()::and_tok_abi_cxx11_,&__dso_handle);
__cxa_guard_release(&parseLogicalAnd()::and_tok_abi_cxx11_);
}
}
local_48 = *in_RSI;
local_40 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)in_RSI[1];
if (local_40 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
if (*PTR___libc_single_threaded_001e7f90 == '\0') {
LOCK();
*(int *)(local_40 + 8) = *(int *)(local_40 + 8) + 1;
UNLOCK();
}
else {
*(int *)(local_40 + 8) = *(int *)(local_40 + 8) + 1;
}
}
local_38 = in_RSI[4] - in_RSI[2];
while( true ) {
/* try { // try from 0016b52e to 0016b544 has its CatchHandler @ 0016b716 */
consumeToken(&local_68);
p_Var1 = local_60;
if (local_68 != local_58) {
operator_delete(local_68,local_58[0] + 1);
}
if (p_Var1 == (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) break;
/* try { // try from 0016b56e to 0016b578 has its CatchHandler @ 0016b700 */
parseLogicalNot();
if (local_68 == (long *)0x0) {
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0016b61e to 0016b62c has its CatchHandler @ 0016b6f3 */
std::runtime_error::runtime_error(prVar4,"Expected right side of \'and\' expression");
/* try { // try from 0016b62d to 0016b642 has its CatchHandler @ 0016b6f1 */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_001e7ff0,PTR__runtime_error_001e7f68);
}
/* try { // try from 0016b584 to 0016b58d has its CatchHandler @ 0016b702 */
puVar3 = (int8 *)operator_new(0x58);
puVar3[1] = 0x100000001;
*puVar3 = &PTR___Sp_counted_ptr_inplace_001e6da8;
BinaryOpExpr::BinaryOpExpr((BinaryOpExpr *)(puVar3 + 2),&local_48);
*in_RDI = (long)(puVar3 + 2);
p_Var1 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)in_RDI[1];
in_RDI[1] = (long)puVar3;
if (p_Var1 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(p_Var1);
}
if (local_60 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_60);
}
}
if (local_40 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_40);
}
return;
}
| |
24,848 | google::protobuf::DescriptorProto::SharedDtor() | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.pb.cc | inline void DescriptorProto::SharedDtor() {
GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
_impl_.field_.~RepeatedPtrField();
_impl_.nested_type_.~RepeatedPtrField();
_impl_.enum_type_.~RepeatedPtrField();
_impl_.extension_range_.~RepeatedPtrField();
_impl_.extension_.~RepeatedPtrField();
_impl_.oneof_decl_.~RepeatedPtrField();
_impl_.reserved_range_.~RepeatedPtrField();
_impl_.reserved_name_.~RepeatedPtrField();
_impl_.name_.Destroy();
if (this != internal_default_instance()) delete _impl_.options_;
} | O3 | cpp | google::protobuf::DescriptorProto::SharedDtor():
pushq %rbx
movq %rdi, %rbx
addq $0x18, %rdi
callq 0x58e70
leaq 0x30(%rbx), %rdi
callq 0x58eca
leaq 0x48(%rbx), %rdi
callq 0x58eac
leaq 0x60(%rbx), %rdi
callq 0x59158
leaq 0x78(%rbx), %rdi
callq 0x58e70
leaq 0x90(%rbx), %rdi
callq 0x5913a
leaq 0xa8(%rbx), %rdi
callq 0x5911c
leaq 0xc0(%rbx), %rdi
callq 0xa5bb0
leaq 0xd8(%rbx), %rdi
callq 0x933e4
leaq 0xa929a(%rip), %rax # 0x102478
cmpq %rax, %rbx
je 0x59200
movq 0xe0(%rbx), %rbx
testq %rbx, %rbx
je 0x591f7
movq %rbx, %rdi
callq 0x52034
movq %rbx, %rdi
popq %rbx
jmp 0xf330
popq %rbx
retq
| _ZN6google8protobuf15DescriptorProto10SharedDtorEv:
push rbx
mov rbx, rdi
add rdi, 18h
call _ZN6google8protobuf16RepeatedPtrFieldINS0_20FieldDescriptorProtoEED2Ev; google::protobuf::RepeatedPtrField<google::protobuf::FieldDescriptorProto>::~RepeatedPtrField()
lea rdi, [rbx+30h]
call _ZN6google8protobuf16RepeatedPtrFieldINS0_15DescriptorProtoEED2Ev; google::protobuf::RepeatedPtrField<google::protobuf::DescriptorProto>::~RepeatedPtrField()
lea rdi, [rbx+48h]
call _ZN6google8protobuf16RepeatedPtrFieldINS0_19EnumDescriptorProtoEED2Ev; google::protobuf::RepeatedPtrField<google::protobuf::EnumDescriptorProto>::~RepeatedPtrField()
lea rdi, [rbx+60h]
call _ZN6google8protobuf16RepeatedPtrFieldINS0_30DescriptorProto_ExtensionRangeEED2Ev; google::protobuf::RepeatedPtrField<google::protobuf::DescriptorProto_ExtensionRange>::~RepeatedPtrField()
lea rdi, [rbx+78h]
call _ZN6google8protobuf16RepeatedPtrFieldINS0_20FieldDescriptorProtoEED2Ev; google::protobuf::RepeatedPtrField<google::protobuf::FieldDescriptorProto>::~RepeatedPtrField()
lea rdi, [rbx+90h]
call _ZN6google8protobuf16RepeatedPtrFieldINS0_20OneofDescriptorProtoEED2Ev; google::protobuf::RepeatedPtrField<google::protobuf::OneofDescriptorProto>::~RepeatedPtrField()
lea rdi, [rbx+0A8h]
call _ZN6google8protobuf16RepeatedPtrFieldINS0_29DescriptorProto_ReservedRangeEED2Ev; google::protobuf::RepeatedPtrField<google::protobuf::DescriptorProto_ReservedRange>::~RepeatedPtrField()
lea rdi, [rbx+0C0h]
call _ZN6google8protobuf16RepeatedPtrFieldINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEED2Ev; google::protobuf::RepeatedPtrField<std::string>::~RepeatedPtrField()
lea rdi, [rbx+0D8h]; this
call _ZN6google8protobuf8internal14ArenaStringPtr7DestroyEv; google::protobuf::internal::ArenaStringPtr::Destroy(void)
lea rax, _ZN6google8protobuf34_DescriptorProto_default_instance_E; google::protobuf::_DescriptorProto_default_instance_
cmp rbx, rax
jz short loc_59200
mov rbx, [rbx+0E0h]
test rbx, rbx
jz short loc_591F7
mov rdi, rbx; this
call _ZN6google8protobuf14MessageOptionsD2Ev; google::protobuf::MessageOptions::~MessageOptions()
loc_591F7:
mov rdi, rbx; void *
pop rbx
jmp __ZdlPv; operator delete(void *)
loc_59200:
pop rbx
retn
| void google::protobuf::DescriptorProto::SharedDtor(
void ( ***this)(google::protobuf::DescriptorProto *__hidden this))
{
google::protobuf::MessageOptions *v1; // rbx
google::protobuf::RepeatedPtrField<google::protobuf::FieldDescriptorProto>::~RepeatedPtrField((google::protobuf::internal::RepeatedPtrFieldBase *)(this + 3));
google::protobuf::RepeatedPtrField<google::protobuf::DescriptorProto>::~RepeatedPtrField((google::protobuf::internal::RepeatedPtrFieldBase *)(this + 6));
google::protobuf::RepeatedPtrField<google::protobuf::EnumDescriptorProto>::~RepeatedPtrField((google::protobuf::internal::RepeatedPtrFieldBase *)(this + 9));
google::protobuf::RepeatedPtrField<google::protobuf::DescriptorProto_ExtensionRange>::~RepeatedPtrField((google::protobuf::internal::RepeatedPtrFieldBase *)(this + 12));
google::protobuf::RepeatedPtrField<google::protobuf::FieldDescriptorProto>::~RepeatedPtrField((google::protobuf::internal::RepeatedPtrFieldBase *)(this + 15));
google::protobuf::RepeatedPtrField<google::protobuf::OneofDescriptorProto>::~RepeatedPtrField((google::protobuf::internal::RepeatedPtrFieldBase *)(this + 18));
google::protobuf::RepeatedPtrField<google::protobuf::DescriptorProto_ReservedRange>::~RepeatedPtrField((google::protobuf::internal::RepeatedPtrFieldBase *)(this + 21));
google::protobuf::RepeatedPtrField<std::string>::~RepeatedPtrField(this + 24);
google::protobuf::internal::ArenaStringPtr::Destroy((google::protobuf::internal::ArenaStringPtr *)(this + 27));
if ( this != &google::protobuf::_DescriptorProto_default_instance_ )
{
v1 = (google::protobuf::MessageOptions *)this[28];
if ( v1 )
google::protobuf::MessageOptions::~MessageOptions(v1);
operator delete(v1);
}
}
| SharedDtor:
PUSH RBX
MOV RBX,RDI
ADD RDI,0x18
CALL 0x00158e70
LEA RDI,[RBX + 0x30]
CALL 0x00158eca
LEA RDI,[RBX + 0x48]
CALL 0x00158eac
LEA RDI,[RBX + 0x60]
CALL 0x00159158
LEA RDI,[RBX + 0x78]
CALL 0x00158e70
LEA RDI,[RBX + 0x90]
CALL 0x0015913a
LEA RDI,[RBX + 0xa8]
CALL 0x0015911c
LEA RDI,[RBX + 0xc0]
CALL 0x001a5bb0
LEA RDI,[RBX + 0xd8]
CALL 0x001933e4
LEA RAX,[0x202478]
CMP RBX,RAX
JZ 0x00159200
MOV RBX,qword ptr [RBX + 0xe0]
TEST RBX,RBX
JZ 0x001591f7
MOV RDI,RBX
CALL 0x00152034
LAB_001591f7:
MOV RDI,RBX
POP RBX
JMP 0x0010f330
LAB_00159200:
POP RBX
RET
|
/* google::protobuf::DescriptorProto::SharedDtor() */
void __thiscall google::protobuf::DescriptorProto::SharedDtor(DescriptorProto *this)
{
MessageOptions *this_00;
RepeatedPtrField<google::protobuf::FieldDescriptorProto>::~RepeatedPtrField
((RepeatedPtrField<google::protobuf::FieldDescriptorProto> *)(this + 0x18));
RepeatedPtrField<google::protobuf::DescriptorProto>::~RepeatedPtrField
((RepeatedPtrField<google::protobuf::DescriptorProto> *)(this + 0x30));
RepeatedPtrField<google::protobuf::EnumDescriptorProto>::~RepeatedPtrField
((RepeatedPtrField<google::protobuf::EnumDescriptorProto> *)(this + 0x48));
RepeatedPtrField<google::protobuf::DescriptorProto_ExtensionRange>::~RepeatedPtrField
((RepeatedPtrField<google::protobuf::DescriptorProto_ExtensionRange> *)(this + 0x60));
RepeatedPtrField<google::protobuf::FieldDescriptorProto>::~RepeatedPtrField
((RepeatedPtrField<google::protobuf::FieldDescriptorProto> *)(this + 0x78));
RepeatedPtrField<google::protobuf::OneofDescriptorProto>::~RepeatedPtrField
((RepeatedPtrField<google::protobuf::OneofDescriptorProto> *)(this + 0x90));
RepeatedPtrField<google::protobuf::DescriptorProto_ReservedRange>::~RepeatedPtrField
((RepeatedPtrField<google::protobuf::DescriptorProto_ReservedRange> *)(this + 0xa8));
RepeatedPtrField<std::__cxx11::string>::~RepeatedPtrField
((RepeatedPtrField<std::__cxx11::string> *)(this + 0xc0));
internal::ArenaStringPtr::Destroy((ArenaStringPtr *)(this + 0xd8));
if (this != (DescriptorProto *)_DescriptorProto_default_instance_) {
this_00 = *(MessageOptions **)(this + 0xe0);
if (this_00 != (MessageOptions *)0x0) {
MessageOptions::~MessageOptions(this_00);
}
operator_delete(this_00);
return;
}
return;
}
| |
24,849 | JOIN_TAB_SCAN_MRR::next() | eloqsql/sql/sql_join_cache.cc | int JOIN_TAB_SCAN_MRR::next()
{
char **ptr= (char **) cache->get_curr_association_ptr();
DBUG_ASSERT(sizeof(range_id_t) == sizeof(*ptr));
int rc= join_tab->table->file->multi_range_read_next((range_id_t*)ptr) ? -1 : 0;
if (!rc)
{
join_tab->tracker->r_rows++;
join_tab->tracker->r_rows_after_where++;
/*
If a record in in an incremental cache contains no fields then the
association for the last record in cache will be equal to cache->end_pos
*/
/*
psergey: this makes no sense where HA_MRR_NO_ASSOC is used.
DBUG_ASSERT(cache->buff <= (uchar *) (*ptr) &&
(uchar *) (*ptr) <= cache->end_pos);
*/
}
return rc;
} | O0 | cpp | JOIN_TAB_SCAN_MRR::next():
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x18(%rax), %rdi
movq (%rdi), %rax
callq *0x80(%rax)
movq %rax, -0x10(%rbp)
jmp 0xaa2037
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x1d0(%rax)
movl %eax, %edx
xorl %eax, %eax
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0xaa209d
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq 0xa0(%rcx), %rcx
movq 0x8(%rcx), %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movq 0x10(%rax), %rax
movq 0xa0(%rax), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZN17JOIN_TAB_SCAN_MRR4nextEv:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
mov rdi, [rax+18h]
mov rax, [rdi]
call qword ptr [rax+80h]
mov [rbp+var_10], rax
jmp short $+2
loc_AA2037:
mov rax, [rbp+var_20]
mov rax, [rax+10h]
mov rax, [rax]
mov rdi, [rax+8]
mov rsi, [rbp+var_10]
mov rax, [rdi]
call qword ptr [rax+1D0h]
mov edx, eax
xor eax, eax
mov ecx, 0FFFFFFFFh
cmp edx, 0
cmovnz eax, ecx
mov [rbp+var_14], eax
cmp [rbp+var_14], 0
jnz short loc_AA209D
mov rax, [rbp+var_20]
mov rcx, [rax+10h]
mov rcx, [rcx+0A0h]
mov rdx, [rcx+8]
add rdx, 1
mov [rcx+8], rdx
mov rax, [rax+10h]
mov rax, [rax+0A0h]
mov rcx, [rax+10h]
add rcx, 1
mov [rax+10h], rcx
loc_AA209D:
mov eax, [rbp+var_14]
add rsp, 20h
pop rbp
retn
| long long JOIN_TAB_SCAN_MRR::next(JOIN_TAB_SCAN_MRR *this)
{
long long v1; // rdi
int v2; // edx
long long result; // rax
long long v5; // [rsp+10h] [rbp-10h]
v5 = (*(long long ( **)(_QWORD))(**((_QWORD **)this + 3) + 128LL))(*((_QWORD *)this + 3));
v1 = *(_QWORD *)(**((_QWORD **)this + 2) + 8LL);
v2 = (*(long long ( **)(long long, long long))(*(_QWORD *)v1 + 464LL))(v1, v5);
LODWORD(result) = 0;
if ( v2 )
LODWORD(result) = -1;
if ( !(_DWORD)result )
{
++*(_QWORD *)(*(_QWORD *)(*((_QWORD *)this + 2) + 160LL) + 8LL);
++*(_QWORD *)(*(_QWORD *)(*((_QWORD *)this + 2) + 160LL) + 16LL);
}
return (unsigned int)result;
}
| get_schema_triggers_record:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV AL,CL
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
AND AL,0x1
MOV byte ptr [RBP + -0x21],AL
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
TEST byte ptr [RBP + -0x21],0x1
JZ 0x00aa20a4
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x008ec7d0
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x00aa208d
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x60],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x008ddd20
MOV RDI,RAX
CALL 0x008ec100
MOV dword ptr [RBP + -0x54],EAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x008ddd20
MOV RDI,RAX
CALL 0x008ec130
MOV RDI,qword ptr [RBP + -0x60]
MOV EDX,dword ptr [RBP + -0x54]
MOV RCX,RAX
MOV ESI,0x1
CALL 0x009ab370
LAB_00aa208d:
MOV RDI,qword ptr [RBP + -0x10]
XOR ESI,ESI
CALL 0x00911a50
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00aa21a5
LAB_00aa20a4:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x198],0x0
JNZ 0x00aa219a
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x100]
CMP qword ptr [RAX + 0xe0],0x0
JZ 0x00aa219a
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x100]
MOV RAX,qword ptr [RAX + 0xe0]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV ESI,0x8000000
XOR ECX,ECX
MOV R9D,0x1
MOV R8D,R9D
CALL 0x009f5500
TEST AL,0x1
JNZ 0x00aa2108
JMP 0x00aa210d
LAB_00aa2108:
JMP 0x00aa219c
LAB_00aa210d:
MOV dword ptr [RBP + -0x44],0x0
LAB_00aa2114:
CMP dword ptr [RBP + -0x44],0x3
JGE 0x00aa2198
MOV dword ptr [RBP + -0x48],0x0
LAB_00aa2121:
CMP dword ptr [RBP + -0x48],0x2
JGE 0x00aa2188
MOV RDI,qword ptr [RBP + -0x40]
MOV ESI,dword ptr [RBP + -0x44]
MOV EDX,dword ptr [RBP + -0x48]
CALL 0x009bd260
MOV qword ptr [RBP + -0x50],RAX
LAB_00aa213a:
CMP qword ptr [RBP + -0x50],0x0
JZ 0x00aa217b
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x30]
MOV R8,qword ptr [RBP + -0x38]
CALL 0x00aa5b00
TEST AL,0x1
JNZ 0x00aa2160
JMP 0x00aa216b
LAB_00aa2160:
JMP 0x00aa2162
LAB_00aa2162:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00aa21a5
LAB_00aa216b:
JMP 0x00aa216d
LAB_00aa216d:
MOV RAX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00aa213a
LAB_00aa217b:
JMP 0x00aa217d
LAB_00aa217d:
MOV EAX,dword ptr [RBP + -0x48]
ADD EAX,0x1
MOV dword ptr [RBP + -0x48],EAX
JMP 0x00aa2121
LAB_00aa2188:
JMP 0x00aa218a
LAB_00aa218a:
MOV EAX,dword ptr [RBP + -0x44]
ADD EAX,0x1
MOV dword ptr [RBP + -0x44],EAX
JMP 0x00aa2114
LAB_00aa2198:
JMP 0x00aa219a
LAB_00aa219a:
JMP 0x00aa219c
LAB_00aa219c:
JMP 0x00aa219e
LAB_00aa219e:
MOV dword ptr [RBP + -0x4],0x0
LAB_00aa21a5:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x60
POP RBP
RET
|
/* get_schema_triggers_record(THD*, TABLE_LIST*, TABLE*, bool, st_mysql_const_lex_string const*,
st_mysql_const_lex_string const*) */
int4
get_schema_triggers_record
(THD *param_1,TABLE_LIST *param_2,TABLE *param_3,bool param_4,
st_mysql_const_lex_string *param_5,st_mysql_const_lex_string *param_6)
{
Table_triggers_list *pTVar1;
byte bVar2;
int4 uVar3;
Diagnostics_area *pDVar4;
int8 uVar5;
ulong uVar6;
Trigger *local_58;
int local_50;
int local_4c;
if (param_4) {
bVar2 = THD::is_error(param_1);
if ((bVar2 & 1) != 0) {
pDVar4 = (Diagnostics_area *)THD::get_stmt_da(param_1);
uVar3 = Diagnostics_area::sql_errno(pDVar4);
pDVar4 = (Diagnostics_area *)THD::get_stmt_da(param_1);
uVar5 = Diagnostics_area::message(pDVar4);
push_warning(param_1,1,uVar3,uVar5);
}
THD::clear_error(param_1,false);
}
else if ((*(long *)(param_2 + 0x198) == 0) && (*(long *)(*(long *)(param_2 + 0x100) + 0xe0) != 0))
{
pTVar1 = *(Table_triggers_list **)(*(long *)(param_2 + 0x100) + 0xe0);
uVar6 = check_table_access(param_1,0x8000000,param_2,0,1);
if ((uVar6 & 1) == 0) {
for (local_4c = 0; local_4c < 3; local_4c = local_4c + 1) {
for (local_50 = 0; local_50 < 2; local_50 = local_50 + 1) {
for (local_58 = (Trigger *)Table_triggers_list::get_trigger(pTVar1,local_4c,local_50);
local_58 != (Trigger *)0x0; local_58 = *(Trigger **)(local_58 + 0x10)) {
uVar6 = store_trigger(param_1,local_58,param_3,param_5,param_6);
if ((uVar6 & 1) != 0) {
return 1;
}
}
}
}
}
}
return 0;
}
| |
24,850 | expand_tilde | eloqsql/mysys/mf_pack.c | static char * expand_tilde(char **path)
{
if (path[0][0] == FN_LIBCHAR)
return home_dir; /* ~/ expanded to home */
#ifdef HAVE_GETPWNAM
{
char *str,save;
struct passwd *user_entry;
if (!(str=strchr(*path,FN_LIBCHAR)))
str=strend(*path);
save= *str; *str= '\0';
user_entry=getpwnam(*path);
*str=save;
endpwent();
if (user_entry)
{
*path=str;
return user_entry->pw_dir;
}
}
#endif
return (char *) 0;
} | O0 | c | expand_tilde:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x641ee
leaq 0x321a76(%rip), %rax # 0x385c58
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6426f
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x2f, %esi
callq 0x24100
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x64219
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x78440
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x24210
movq %rax, -0x28(%rbp)
movb -0x19(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
callq 0x242f0
cmpq $0x0, -0x28(%rbp)
je 0x64267
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6426f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| expand_tilde:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov rax, [rax]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jnz short loc_641EE
lea rax, home_dir
mov rax, [rax]
mov [rbp+var_8], rax
jmp loc_6426F
loc_641EE:
mov rax, [rbp+var_10]
mov rdi, [rax]
mov esi, 2Fh ; '/'
call _strchr
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_64219
mov rax, [rbp+var_10]
mov rdi, [rax]
call strend
mov [rbp+var_18], rax
loc_64219:
mov rax, [rbp+var_18]
mov al, [rax]
mov [rbp+var_19], al
mov rax, [rbp+var_18]
mov byte ptr [rax], 0
mov rax, [rbp+var_10]
mov rdi, [rax]
call _getpwnam
mov [rbp+var_28], rax
mov cl, [rbp+var_19]
mov rax, [rbp+var_18]
mov [rax], cl
call _endpwent
cmp [rbp+var_28], 0
jz short loc_64267
mov rcx, [rbp+var_18]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rax, [rbp+var_28]
mov rax, [rax+20h]
mov [rbp+var_8], rax
jmp short loc_6426F
loc_64267:
mov [rbp+var_8], 0
loc_6426F:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| long long expand_tilde(char **a1)
{
long long v2; // [rsp+8h] [rbp-28h]
char v3; // [rsp+17h] [rbp-19h]
char *v4; // [rsp+18h] [rbp-18h]
if ( **a1 == 47 )
return home_dir;
v4 = (char *)strchr(*a1, 47LL);
if ( !v4 )
v4 = (char *)strend(*a1);
v3 = *v4;
*v4 = 0;
v2 = getpwnam(*a1);
*v4 = v3;
endpwent();
if ( !v2 )
return 0LL;
*a1 = v4;
return *(_QWORD *)(v2 + 32);
}
| expand_tilde:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JNZ 0x001641ee
LEA RAX,[0x485c58]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0016426f
LAB_001641ee:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV ESI,0x2f
CALL 0x00124100
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x00164219
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
CALL 0x00178440
MOV qword ptr [RBP + -0x18],RAX
LAB_00164219:
MOV RAX,qword ptr [RBP + -0x18]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x19],AL
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
CALL 0x00124210
MOV qword ptr [RBP + -0x28],RAX
MOV CL,byte ptr [RBP + -0x19]
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],CL
CALL 0x001242f0
CMP qword ptr [RBP + -0x28],0x0
JZ 0x00164267
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0016426f
LAB_00164267:
MOV qword ptr [RBP + -0x8],0x0
LAB_0016426f:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
char * expand_tilde(int8 *param_1)
{
char cVar1;
passwd *ppVar2;
char *local_20;
char *local_10;
if (*(char *)*param_1 == '/') {
local_10 = home_dir;
}
else {
local_20 = strchr((char *)*param_1,0x2f);
if (local_20 == (char *)0x0) {
local_20 = (char *)strend(*param_1);
}
cVar1 = *local_20;
*local_20 = '\0';
ppVar2 = getpwnam((char *)*param_1);
*local_20 = cVar1;
endpwent();
if (ppVar2 == (passwd *)0x0) {
local_10 = (char *)0x0;
}
else {
*param_1 = local_20;
local_10 = ppVar2->pw_dir;
}
}
return local_10;
}
| |
24,851 | js_parse_string | bluesky950520[P]quickjs/quickjs.c | static __exception int js_parse_string(JSParseState *s, int sep,
BOOL do_throw, const uint8_t *p,
JSToken *token, const uint8_t **pp)
{
const uint8_t *p_next;
int ret;
uint32_t c;
StringBuffer b_s, *b = &b_s;
/* string */
if (string_buffer_init(s->ctx, b, 32))
goto fail;
for(;;) {
if (p >= s->buf_end)
goto invalid_char;
c = *p;
if (c < 0x20) {
if (sep == '`') {
if (c == '\r') {
if (p[1] == '\n')
p++;
c = '\n';
}
/* do not update s->line_num */
} else if (c == '\n' || c == '\r')
goto invalid_char;
}
p++;
if (c == sep)
break;
if (c == '$' && *p == '{' && sep == '`') {
/* template start or middle part */
p++;
break;
}
if (c == '\\') {
c = *p;
switch(c) {
case '\0':
if (p >= s->buf_end) {
if (sep != '`')
goto invalid_char;
if (do_throw)
js_parse_error(s, "Unexpected end of input");
goto fail;
}
p++;
break;
case '\'':
case '\"':
case '\\':
p++;
break;
case '\r': /* accept DOS and MAC newline sequences */
if (p[1] == '\n') {
p++;
}
/* fall thru */
case '\n':
/* ignore escaped newline sequence */
p++;
if (sep != '`') {
s->line_num++;
s->eol = &p[-1];
s->mark = p;
}
continue;
default:
if (c == '0' && !(p[1] >= '0' && p[1] <= '9')) {
/* accept isolated \0 */
p++;
c = '\0';
} else
if ((c >= '0' && c <= '9')
&& (s->cur_func->is_strict_mode || sep == '`')) {
if (do_throw) {
js_parse_error(s, "%s are not allowed in %s",
(c >= '8') ? "\\8 and \\9" : "Octal escape sequences",
(sep == '`') ? "template strings" : "strict mode");
}
goto fail;
} else if (c >= 0x80) {
c = utf8_decode(p, &p_next);
if (p_next == p + 1) {
goto invalid_utf8;
}
p = p_next;
/* LS or PS are skipped */
if (c == CP_LS || c == CP_PS)
continue;
} else {
ret = lre_parse_escape(&p, TRUE);
if (ret == -1) {
if (do_throw) {
js_parse_error(s, "Invalid %s escape sequence",
c == 'u' ? "Unicode" : "hexadecimal");
}
goto fail;
} else if (ret < 0) {
/* ignore the '\' (could output a warning) */
p++;
} else {
c = ret;
}
}
break;
}
} else if (c >= 0x80) {
c = utf8_decode(p - 1, &p_next);
if (p_next == p)
goto invalid_utf8;
p = p_next;
}
if (string_buffer_putc(b, c))
goto fail;
}
token->val = TOK_STRING;
token->u.str.sep = c;
token->u.str.str = string_buffer_end(b);
*pp = p;
return 0;
invalid_utf8:
if (do_throw)
js_parse_error(s, "invalid UTF-8 sequence");
goto fail;
invalid_char:
if (do_throw)
js_parse_error(s, "unexpected end of string");
fail:
string_buffer_free(b);
return -1;
} | O0 | c | js_parse_string:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movl %esi, 0x74(%rsp)
movl %edx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq %r8, 0x60(%rsp)
movq %r9, 0x58(%rsp)
leaq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x78(%rsp), %rax
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
movl $0x20, %edx
callq 0x50640
cmpl $0x0, %eax
je 0x9eafe
jmp 0x9ef86
jmp 0x9eb00
movq 0x68(%rsp), %rax
movq 0x78(%rsp), %rcx
cmpq 0x78(%rcx), %rax
jb 0x9eb15
jmp 0x9ef6a
movq 0x68(%rsp), %rax
movzbl (%rax), %eax
movl %eax, 0x48(%rsp)
cmpl $0x20, 0x48(%rsp)
jae 0x9eb73
cmpl $0x60, 0x74(%rsp)
jne 0x9eb5c
cmpl $0xd, 0x48(%rsp)
jne 0x9eb5a
movq 0x68(%rsp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xa, %eax
jne 0x9eb52
movq 0x68(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x68(%rsp)
movl $0xa, 0x48(%rsp)
jmp 0x9eb71
cmpl $0xa, 0x48(%rsp)
je 0x9eb6a
cmpl $0xd, 0x48(%rsp)
jne 0x9eb6f
jmp 0x9ef6a
jmp 0x9eb71
jmp 0x9eb73
movq 0x68(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x68(%rsp)
movl 0x48(%rsp), %eax
cmpl 0x74(%rsp), %eax
jne 0x9eb90
jmp 0x9eee7
cmpl $0x24, 0x48(%rsp)
jne 0x9ebbe
movq 0x68(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x7b, %eax
jne 0x9ebbe
cmpl $0x60, 0x74(%rsp)
jne 0x9ebbe
movq 0x68(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x68(%rsp)
jmp 0x9eee7
cmpl $0x5c, 0x48(%rsp)
jne 0x9ee8c
movq 0x68(%rsp), %rax
movzbl (%rax), %eax
movl %eax, 0x48(%rsp)
movl 0x48(%rsp), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x9ec25
jmp 0x9ebe3
movl 0xc(%rsp), %eax
subl $0xa, %eax
je 0x9eca4
jmp 0x9ebf2
movl 0xc(%rsp), %eax
subl $0xd, %eax
je 0x9ec86
jmp 0x9ec01
movl 0xc(%rsp), %eax
subl $0x22, %eax
je 0x9ec73
jmp 0x9ec0c
movl 0xc(%rsp), %eax
subl $0x27, %eax
je 0x9ec73
jmp 0x9ec17
movl 0xc(%rsp), %eax
subl $0x5c, %eax
je 0x9ec73
jmp 0x9ecf2
movq 0x68(%rsp), %rax
movq 0x78(%rsp), %rcx
cmpq 0x78(%rcx), %rax
jb 0x9ec60
cmpl $0x60, 0x74(%rsp)
je 0x9ec41
jmp 0x9ef6a
cmpl $0x0, 0x70(%rsp)
je 0x9ec5b
movq 0x78(%rsp), %rdi
leaq 0x70c60(%rip), %rsi # 0x10f8b4
movb $0x0, %al
callq 0x48690
jmp 0x9ef86
movq 0x68(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x68(%rsp)
jmp 0x9ee8a
movq 0x68(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x68(%rsp)
jmp 0x9ee8a
movq 0x68(%rsp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xa, %eax
jne 0x9eca2
movq 0x68(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x68(%rsp)
jmp 0x9eca4
movq 0x68(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x68(%rsp)
cmpl $0x60, 0x74(%rsp)
je 0x9eced
movq 0x78(%rsp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq 0x68(%rsp), %rcx
addq $-0x1, %rcx
movq 0x78(%rsp), %rax
movq %rcx, 0x80(%rax)
movq 0x68(%rsp), %rcx
movq 0x78(%rsp), %rax
movq %rcx, 0x88(%rax)
jmp 0x9eb00
cmpl $0x30, 0x48(%rsp)
jne 0x9ed30
movq 0x68(%rsp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x30, %eax
jl 0x9ed15
movq 0x68(%rsp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x39, %eax
jle 0x9ed30
movq 0x68(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x68(%rsp)
movl $0x0, 0x48(%rsp)
jmp 0x9ee88
cmpl $0x30, 0x48(%rsp)
jb 0x9edb5
cmpl $0x39, 0x48(%rsp)
ja 0x9edb5
movq 0x78(%rsp), %rax
movq 0x90(%rax), %rax
movw 0x84(%rax), %ax
shrw $0xf, %ax
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x9ed64
cmpl $0x60, 0x74(%rsp)
jne 0x9edb5
cmpl $0x0, 0x70(%rsp)
je 0x9edb0
movq 0x78(%rsp), %rdi
movl 0x48(%rsp), %ecx
leaq 0x70b74(%rip), %rdx # 0x10f8ef
leaq 0x70b63(%rip), %rax # 0x10f8e5
cmpl $0x38, %ecx
cmovaeq %rax, %rdx
movl 0x74(%rsp), %esi
leaq 0x70a86(%rip), %rcx # 0x10f81a
leaq 0x70b6b(%rip), %rax # 0x10f906
cmpl $0x60, %esi
cmoveq %rax, %rcx
leaq 0x70b23(%rip), %rsi # 0x10f8cc
movb $0x0, %al
callq 0x48690
jmp 0x9ef86
cmpl $0x80, 0x48(%rsp)
jb 0x9ee0f
movq 0x68(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x1eb50
movl %eax, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq 0x68(%rsp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jne 0x9edea
jmp 0x9ef4e
movq 0x50(%rsp), %rax
movq %rax, 0x68(%rsp)
cmpl $0x2028, 0x48(%rsp) # imm = 0x2028
je 0x9ee08
cmpl $0x2029, 0x48(%rsp) # imm = 0x2029
jne 0x9ee0d
jmp 0x9eb00
jmp 0x9ee84
leaq 0x68(%rsp), %rdi
movl $0x1, %esi
callq 0xfce90
movl %eax, 0x4c(%rsp)
cmpl $-0x1, 0x4c(%rsp)
jne 0x9ee61
cmpl $0x0, 0x70(%rsp)
je 0x9ee5c
movq 0x78(%rsp), %rdi
movl 0x48(%rsp), %ecx
leaq 0x70afa(%rip), %rdx # 0x10f93a
leaq 0x70aeb(%rip), %rax # 0x10f932
cmpl $0x75, %ecx
cmoveq %rax, %rdx
leaq 0x70ac2(%rip), %rsi # 0x10f917
movb $0x0, %al
callq 0x48690
jmp 0x9ef86
cmpl $0x0, 0x4c(%rsp)
jge 0x9ee78
movq 0x68(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x68(%rsp)
jmp 0x9ee80
movl 0x4c(%rsp), %eax
movl %eax, 0x48(%rsp)
jmp 0x9ee82
jmp 0x9ee84
jmp 0x9ee86
jmp 0x9ee88
jmp 0x9ee8a
jmp 0x9eeca
cmpl $0x80, 0x48(%rsp)
jb 0x9eec8
movq 0x68(%rsp), %rdi
addq $-0x1, %rdi
leaq 0x50(%rsp), %rsi
callq 0x1eb50
movl %eax, 0x48(%rsp)
movq 0x50(%rsp), %rax
cmpq 0x68(%rsp), %rax
jne 0x9eebe
jmp 0x9ef4e
movq 0x50(%rsp), %rax
movq %rax, 0x68(%rsp)
jmp 0x9eeca
movq 0x20(%rsp), %rdi
movl 0x48(%rsp), %esi
callq 0x4da80
cmpl $0x0, %eax
je 0x9eee2
jmp 0x9ef86
jmp 0x9eb00
movq 0x60(%rsp), %rax
movl $0xffffff81, (%rax) # imm = 0xFFFFFF81
movl 0x48(%rsp), %ecx
movq 0x60(%rsp), %rax
movl %ecx, 0x28(%rax)
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0x4db00
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x20(%rax)
movq 0x68(%rsp), %rcx
movq 0x58(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x84(%rsp)
jmp 0x9ef9b
cmpl $0x0, 0x70(%rsp)
je 0x9ef68
movq 0x78(%rsp), %rdi
leaq 0x70923(%rip), %rsi # 0x10f884
movb $0x0, %al
callq 0x48690
jmp 0x9ef86
cmpl $0x0, 0x70(%rsp)
je 0x9ef84
movq 0x78(%rsp), %rdi
leaq 0x7091e(%rip), %rsi # 0x10f89b
movb $0x0, %al
callq 0x48690
jmp 0x9ef86
movq 0x20(%rsp), %rdi
callq 0x524b0
movl $0xffffffff, 0x84(%rsp) # imm = 0xFFFFFFFF
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nopw (%rax,%rax)
| js_parse_string:
sub rsp, 88h
mov [rsp+88h+var_10], rdi
mov [rsp+88h+var_14], esi
mov [rsp+88h+var_18], edx
mov [rsp+88h+var_20], rcx
mov [rsp+88h+var_28], r8
mov [rsp+88h+var_30], r9
lea rax, [rsp+88h+var_60]
mov [rsp+88h+var_68], rax
mov rax, [rsp+88h+var_10]
mov rdi, [rax]
mov rsi, [rsp+88h+var_68]
mov edx, 20h ; ' '
call string_buffer_init
cmp eax, 0
jz short loc_9EAFE
jmp loc_9EF86
loc_9EAFE:
jmp short $+2
loc_9EB00:
mov rax, [rsp+88h+var_20]
mov rcx, [rsp+88h+var_10]
cmp rax, [rcx+78h]
jb short loc_9EB15
jmp loc_9EF6A
loc_9EB15:
mov rax, [rsp+88h+var_20]
movzx eax, byte ptr [rax]
mov [rsp+88h+var_40], eax
cmp [rsp+88h+var_40], 20h ; ' '
jnb short loc_9EB73
cmp [rsp+88h+var_14], 60h ; '`'
jnz short loc_9EB5C
cmp [rsp+88h+var_40], 0Dh
jnz short loc_9EB5A
mov rax, [rsp+88h+var_20]
movzx eax, byte ptr [rax+1]
cmp eax, 0Ah
jnz short loc_9EB52
mov rax, [rsp+88h+var_20]
add rax, 1
mov [rsp+88h+var_20], rax
loc_9EB52:
mov [rsp+88h+var_40], 0Ah
loc_9EB5A:
jmp short loc_9EB71
loc_9EB5C:
cmp [rsp+88h+var_40], 0Ah
jz short loc_9EB6A
cmp [rsp+88h+var_40], 0Dh
jnz short loc_9EB6F
loc_9EB6A:
jmp loc_9EF6A
loc_9EB6F:
jmp short $+2
loc_9EB71:
jmp short $+2
loc_9EB73:
mov rax, [rsp+88h+var_20]
add rax, 1
mov [rsp+88h+var_20], rax
mov eax, [rsp+88h+var_40]
cmp eax, [rsp+88h+var_14]
jnz short loc_9EB90
jmp loc_9EEE7
loc_9EB90:
cmp [rsp+88h+var_40], 24h ; '$'
jnz short loc_9EBBE
mov rax, [rsp+88h+var_20]
movzx eax, byte ptr [rax]
cmp eax, 7Bh ; '{'
jnz short loc_9EBBE
cmp [rsp+88h+var_14], 60h ; '`'
jnz short loc_9EBBE
mov rax, [rsp+88h+var_20]
add rax, 1
mov [rsp+88h+var_20], rax
jmp loc_9EEE7
loc_9EBBE:
cmp [rsp+88h+var_40], 5Ch ; '\'
jnz loc_9EE8C
mov rax, [rsp+88h+var_20]
movzx eax, byte ptr [rax]
mov [rsp+88h+var_40], eax
mov eax, [rsp+88h+var_40]
mov [rsp+88h+var_7C], eax
test eax, eax
jz short loc_9EC25
jmp short $+2
loc_9EBE3:
mov eax, [rsp+88h+var_7C]
sub eax, 0Ah
jz loc_9ECA4
jmp short $+2
loc_9EBF2:
mov eax, [rsp+88h+var_7C]
sub eax, 0Dh
jz loc_9EC86
jmp short $+2
loc_9EC01:
mov eax, [rsp+88h+var_7C]
sub eax, 22h ; '"'
jz short loc_9EC73
jmp short $+2
loc_9EC0C:
mov eax, [rsp+88h+var_7C]
sub eax, 27h ; '''
jz short loc_9EC73
jmp short $+2
loc_9EC17:
mov eax, [rsp+88h+var_7C]
sub eax, 5Ch ; '\'
jz short loc_9EC73
jmp loc_9ECF2
loc_9EC25:
mov rax, [rsp+88h+var_20]
mov rcx, [rsp+88h+var_10]
cmp rax, [rcx+78h]
jb short loc_9EC60
cmp [rsp+88h+var_14], 60h ; '`'
jz short loc_9EC41
jmp loc_9EF6A
loc_9EC41:
cmp [rsp+88h+var_18], 0
jz short loc_9EC5B
mov rdi, [rsp+88h+var_10]
lea rsi, aUnexpectedEndO_2; "Unexpected end of input"
mov al, 0
call js_parse_error
loc_9EC5B:
jmp loc_9EF86
loc_9EC60:
mov rax, [rsp+88h+var_20]
add rax, 1
mov [rsp+88h+var_20], rax
jmp loc_9EE8A
loc_9EC73:
mov rax, [rsp+88h+var_20]
add rax, 1
mov [rsp+88h+var_20], rax
jmp loc_9EE8A
loc_9EC86:
mov rax, [rsp+88h+var_20]
movzx eax, byte ptr [rax+1]
cmp eax, 0Ah
jnz short loc_9ECA2
mov rax, [rsp+88h+var_20]
add rax, 1
mov [rsp+88h+var_20], rax
loc_9ECA2:
jmp short $+2
loc_9ECA4:
mov rax, [rsp+88h+var_20]
add rax, 1
mov [rsp+88h+var_20], rax
cmp [rsp+88h+var_14], 60h ; '`'
jz short loc_9ECED
mov rax, [rsp+88h+var_10]
mov ecx, [rax+10h]
add ecx, 1
mov [rax+10h], ecx
mov rcx, [rsp+88h+var_20]
add rcx, 0FFFFFFFFFFFFFFFFh
mov rax, [rsp+88h+var_10]
mov [rax+80h], rcx
mov rcx, [rsp+88h+var_20]
mov rax, [rsp+88h+var_10]
mov [rax+88h], rcx
loc_9ECED:
jmp loc_9EB00
loc_9ECF2:
cmp [rsp+88h+var_40], 30h ; '0'
jnz short loc_9ED30
mov rax, [rsp+88h+var_20]
movzx eax, byte ptr [rax+1]
cmp eax, 30h ; '0'
jl short loc_9ED15
mov rax, [rsp+88h+var_20]
movzx eax, byte ptr [rax+1]
cmp eax, 39h ; '9'
jle short loc_9ED30
loc_9ED15:
mov rax, [rsp+88h+var_20]
add rax, 1
mov [rsp+88h+var_20], rax
mov [rsp+88h+var_40], 0
jmp loc_9EE88
loc_9ED30:
cmp [rsp+88h+var_40], 30h ; '0'
jb short loc_9EDB5
cmp [rsp+88h+var_40], 39h ; '9'
ja short loc_9EDB5
mov rax, [rsp+88h+var_10]
mov rax, [rax+90h]
mov ax, [rax+84h]
shr ax, 0Fh
movzx eax, al
cmp eax, 0
jnz short loc_9ED64
cmp [rsp+88h+var_14], 60h ; '`'
jnz short loc_9EDB5
loc_9ED64:
cmp [rsp+88h+var_18], 0
jz short loc_9EDB0
mov rdi, [rsp+88h+var_10]
mov ecx, [rsp+88h+var_40]
lea rdx, aOctalEscapeSeq; "Octal escape sequences"
lea rax, a8And9; "\\8 and \\9"
cmp ecx, 38h ; '8'
cmovnb rdx, rax
mov esi, [rsp+88h+var_14]
lea rcx, aOctalLiteralsA+22h; "strict mode"
lea rax, aTemplateString; "template strings"
cmp esi, 60h ; '`'
cmovz rcx, rax
lea rsi, aSAreNotAllowed; "%s are not allowed in %s"
mov al, 0
call js_parse_error
loc_9EDB0:
jmp loc_9EF86
loc_9EDB5:
cmp [rsp+88h+var_40], 80h
jb short loc_9EE0F
mov rdi, [rsp+88h+var_20]
lea rsi, [rsp+88h+var_38]
call utf8_decode
mov [rsp+88h+var_40], eax
mov rax, [rsp+88h+var_38]
mov rcx, [rsp+88h+var_20]
add rcx, 1
cmp rax, rcx
jnz short loc_9EDEA
jmp loc_9EF4E
loc_9EDEA:
mov rax, [rsp+88h+var_38]
mov [rsp+88h+var_20], rax
cmp [rsp+88h+var_40], 2028h
jz short loc_9EE08
cmp [rsp+88h+var_40], 2029h
jnz short loc_9EE0D
loc_9EE08:
jmp loc_9EB00
loc_9EE0D:
jmp short loc_9EE84
loc_9EE0F:
lea rdi, [rsp+88h+var_20]
mov esi, 1
call lre_parse_escape
mov [rsp+88h+var_3C], eax
cmp [rsp+88h+var_3C], 0FFFFFFFFh
jnz short loc_9EE61
cmp [rsp+88h+var_18], 0
jz short loc_9EE5C
mov rdi, [rsp+88h+var_10]
mov ecx, [rsp+88h+var_40]
lea rdx, aHexadecimal; "hexadecimal"
lea rax, aUnicode; "Unicode"
cmp ecx, 75h ; 'u'
cmovz rdx, rax
lea rsi, aInvalidSEscape; "Invalid %s escape sequence"
mov al, 0
call js_parse_error
loc_9EE5C:
jmp loc_9EF86
loc_9EE61:
cmp [rsp+88h+var_3C], 0
jge short loc_9EE78
mov rax, [rsp+88h+var_20]
add rax, 1
mov [rsp+88h+var_20], rax
jmp short loc_9EE80
loc_9EE78:
mov eax, [rsp+88h+var_3C]
mov [rsp+88h+var_40], eax
loc_9EE80:
jmp short $+2
loc_9EE82:
jmp short $+2
loc_9EE84:
jmp short $+2
loc_9EE86:
jmp short $+2
loc_9EE88:
jmp short $+2
loc_9EE8A:
jmp short loc_9EECA
loc_9EE8C:
cmp [rsp+88h+var_40], 80h
jb short loc_9EEC8
mov rdi, [rsp+88h+var_20]
add rdi, 0FFFFFFFFFFFFFFFFh
lea rsi, [rsp+88h+var_38]
call utf8_decode
mov [rsp+88h+var_40], eax
mov rax, [rsp+88h+var_38]
cmp rax, [rsp+88h+var_20]
jnz short loc_9EEBE
jmp loc_9EF4E
loc_9EEBE:
mov rax, [rsp+88h+var_38]
mov [rsp+88h+var_20], rax
loc_9EEC8:
jmp short $+2
loc_9EECA:
mov rdi, [rsp+88h+var_68]
mov esi, [rsp+88h+var_40]
call string_buffer_putc
cmp eax, 0
jz short loc_9EEE2
jmp loc_9EF86
loc_9EEE2:
jmp loc_9EB00
loc_9EEE7:
mov rax, [rsp+88h+var_28]
mov dword ptr [rax], 0FFFFFF81h
mov ecx, [rsp+88h+var_40]
mov rax, [rsp+88h+var_28]
mov [rax+28h], ecx
mov rax, [rsp+88h+var_28]
mov [rsp+88h+var_88], rax
mov rdi, [rsp+88h+var_68]
call string_buffer_end
mov rcx, rax
mov rax, [rsp+88h+var_88]
mov [rsp+88h+var_78], rcx
mov [rsp+88h+var_70], rdx
mov rcx, [rsp+88h+var_78]
mov [rax+18h], rcx
mov rcx, [rsp+88h+var_70]
mov [rax+20h], rcx
mov rcx, [rsp+88h+var_20]
mov rax, [rsp+88h+var_30]
mov [rax], rcx
mov [rsp+88h+var_4], 0
jmp short loc_9EF9B
loc_9EF4E:
cmp [rsp+88h+var_18], 0
jz short loc_9EF68
mov rdi, [rsp+88h+var_10]
lea rsi, aInvalidUtf8Seq; "invalid UTF-8 sequence"
mov al, 0
call js_parse_error
loc_9EF68:
jmp short loc_9EF86
loc_9EF6A:
cmp [rsp+88h+var_18], 0
jz short loc_9EF84
mov rdi, [rsp+88h+var_10]
lea rsi, aUnexpectedEndO_1; "unexpected end of string"
mov al, 0
call js_parse_error
loc_9EF84:
jmp short $+2
loc_9EF86:
mov rdi, [rsp+88h+var_68]
call string_buffer_free
mov [rsp+88h+var_4], 0FFFFFFFFh
loc_9EF9B:
mov eax, [rsp+88h+var_4]
add rsp, 88h
retn
| long long js_parse_string(
_QWORD *a1,
int a2,
int a3,
unsigned __int8 *a4,
_DWORD *a5,
_QWORD *a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14)
{
long long v14; // rdx
long long v15; // r8
long long v16; // r9
__m128 v17; // xmm4
__m128 v18; // xmm5
_QWORD *v19; // rcx
const char *v20; // rdx
char *v21; // rcx
unsigned __int8 *v22; // rcx
long long v23; // r8
long long v24; // r9
__m128 v25; // xmm4
__m128 v26; // xmm5
const char *v27; // rdx
long long v28; // rdx
char v30; // [rsp+0h] [rbp-88h]
_DWORD *v31; // [rsp+0h] [rbp-88h]
long long v32[4]; // [rsp+28h] [rbp-60h] BYREF
unsigned int v33; // [rsp+48h] [rbp-40h]
int v34; // [rsp+4Ch] [rbp-3Ch]
unsigned __int8 *v35; // [rsp+50h] [rbp-38h] BYREF
_QWORD *v36; // [rsp+58h] [rbp-30h]
_DWORD *v37; // [rsp+60h] [rbp-28h]
unsigned __int8 *v38; // [rsp+68h] [rbp-20h] BYREF
int v39; // [rsp+70h] [rbp-18h]
int v40; // [rsp+74h] [rbp-14h]
_QWORD *v41; // [rsp+78h] [rbp-10h]
v41 = a1;
v40 = a2;
v39 = a3;
v38 = a4;
v37 = a5;
v36 = a6;
if ( !(unsigned int)string_buffer_init(*a1, (long long)v32, 0x20u) )
{
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
v19 = v41;
if ( (unsigned long long)v38 >= v41[15] )
{
LABEL_77:
if ( v39 )
js_parse_error(
v41,
(long long)"unexpected end of string",
v14,
(long long)v19,
v15,
v16,
a7,
a8,
a9,
a10,
v17,
v18,
a13,
a14,
v30);
goto LABEL_79;
}
v33 = *v38;
if ( v33 < 0x20 )
{
if ( v40 == 96 )
{
if ( v33 == 13 )
{
if ( v38[1] == 10 )
++v38;
v33 = 10;
}
}
else if ( v33 == 10 || v33 == 13 )
{
goto LABEL_77;
}
}
++v38;
if ( v33 == v40 )
goto LABEL_73;
if ( v33 == 36 && *v38 == 123 && v40 == 96 )
{
++v38;
LABEL_73:
*v37 = -127;
v37[10] = v33;
v31 = v37;
*((_QWORD *)v31 + 3) = string_buffer_end((long long)v32);
*((_QWORD *)v31 + 4) = v28;
*v36 = v38;
return 0;
}
if ( v33 != 92 )
{
if ( v33 >= 0x80 )
{
v33 = utf8_decode(v38 - 1, &v35);
if ( v35 == v38 )
{
LABEL_74:
if ( v39 )
js_parse_error(
v41,
(long long)"invalid UTF-8 sequence",
v14,
(long long)v22,
v15,
v16,
a7,
a8,
a9,
a10,
v17,
v18,
a13,
a14,
v30);
goto LABEL_79;
}
v38 = v35;
}
goto LABEL_71;
}
v33 = *v38;
if ( v33 )
break;
v19 = v41;
if ( (unsigned long long)v38 >= v41[15] )
{
if ( v40 == 96 )
{
if ( v39 )
js_parse_error(
v41,
(long long)"Unexpected end of input",
v14,
(long long)v41,
v15,
v16,
a7,
a8,
a9,
a10,
v17,
v18,
a13,
a14,
v30);
goto LABEL_79;
}
goto LABEL_77;
}
++v38;
LABEL_71:
if ( (unsigned int)string_buffer_putc((long long)v32, v33) )
goto LABEL_79;
}
if ( v33 != 10 )
break;
LABEL_35:
++v38;
if ( v40 != 96 )
{
++*((_DWORD *)v41 + 4);
v41[16] = v38 - 1;
v41[17] = v38;
}
}
if ( v33 == 13 )
{
if ( v38[1] == 10 )
++v38;
goto LABEL_35;
}
if ( v33 == 34 || v33 == 39 || v33 == 92 )
{
++v38;
goto LABEL_71;
}
if ( v33 == 48 && (v38[1] < 0x30u || v38[1] > 0x39u) )
{
++v38;
v33 = 0;
goto LABEL_71;
}
if ( v33 >= 0x30 && v33 <= 0x39 && (*(__int16 *)(v41[18] + 132LL) < 0 || v40 == 96) )
{
if ( v39 )
{
v20 = "Octal escape sequences";
if ( v33 >= 0x38 )
v20 = "\\8 and \\9";
v21 = "strict mode";
if ( v40 == 96 )
v21 = "template strings";
js_parse_error(
v41,
(long long)"%s are not allowed in %s",
(long long)v20,
(long long)v21,
v15,
v16,
a7,
a8,
a9,
a10,
v17,
v18,
a13,
a14,
v30);
}
break;
}
if ( v33 < 0x80 )
{
v34 = lre_parse_escape(&v38, 1LL);
if ( v34 == -1 )
{
if ( v39 )
{
v27 = "hexadecimal";
if ( v33 == 117 )
v27 = "Unicode";
js_parse_error(
v41,
(long long)"Invalid %s escape sequence",
(long long)v27,
v33,
v23,
v24,
a7,
a8,
a9,
a10,
v25,
v26,
a13,
a14,
v30);
}
break;
}
if ( v34 >= 0 )
v33 = v34;
else
++v38;
goto LABEL_71;
}
v33 = utf8_decode(v38, &v35);
v22 = v38 + 1;
if ( v35 == v38 + 1 )
goto LABEL_74;
v38 = v35;
if ( v33 != 8232 && v33 != 8233 )
goto LABEL_71;
}
}
LABEL_79:
string_buffer_free(v32);
return (unsigned int)-1;
}
| js_parse_string:
SUB RSP,0x88
MOV qword ptr [RSP + 0x78],RDI
MOV dword ptr [RSP + 0x74],ESI
MOV dword ptr [RSP + 0x70],EDX
MOV qword ptr [RSP + 0x68],RCX
MOV qword ptr [RSP + 0x60],R8
MOV qword ptr [RSP + 0x58],R9
LEA RAX,[RSP + 0x28]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x78]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RSP + 0x20]
MOV EDX,0x20
CALL 0x00150640
CMP EAX,0x0
JZ 0x0019eafe
JMP 0x0019ef86
LAB_0019eafe:
JMP 0x0019eb00
LAB_0019eb00:
MOV RAX,qword ptr [RSP + 0x68]
MOV RCX,qword ptr [RSP + 0x78]
CMP RAX,qword ptr [RCX + 0x78]
JC 0x0019eb15
JMP 0x0019ef6a
LAB_0019eb15:
MOV RAX,qword ptr [RSP + 0x68]
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RSP + 0x48],EAX
CMP dword ptr [RSP + 0x48],0x20
JNC 0x0019eb73
CMP dword ptr [RSP + 0x74],0x60
JNZ 0x0019eb5c
CMP dword ptr [RSP + 0x48],0xd
JNZ 0x0019eb5a
MOV RAX,qword ptr [RSP + 0x68]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0xa
JNZ 0x0019eb52
MOV RAX,qword ptr [RSP + 0x68]
ADD RAX,0x1
MOV qword ptr [RSP + 0x68],RAX
LAB_0019eb52:
MOV dword ptr [RSP + 0x48],0xa
LAB_0019eb5a:
JMP 0x0019eb71
LAB_0019eb5c:
CMP dword ptr [RSP + 0x48],0xa
JZ 0x0019eb6a
CMP dword ptr [RSP + 0x48],0xd
JNZ 0x0019eb6f
LAB_0019eb6a:
JMP 0x0019ef6a
LAB_0019eb6f:
JMP 0x0019eb71
LAB_0019eb71:
JMP 0x0019eb73
LAB_0019eb73:
MOV RAX,qword ptr [RSP + 0x68]
ADD RAX,0x1
MOV qword ptr [RSP + 0x68],RAX
MOV EAX,dword ptr [RSP + 0x48]
CMP EAX,dword ptr [RSP + 0x74]
JNZ 0x0019eb90
JMP 0x0019eee7
LAB_0019eb90:
CMP dword ptr [RSP + 0x48],0x24
JNZ 0x0019ebbe
MOV RAX,qword ptr [RSP + 0x68]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x7b
JNZ 0x0019ebbe
CMP dword ptr [RSP + 0x74],0x60
JNZ 0x0019ebbe
MOV RAX,qword ptr [RSP + 0x68]
ADD RAX,0x1
MOV qword ptr [RSP + 0x68],RAX
JMP 0x0019eee7
LAB_0019ebbe:
CMP dword ptr [RSP + 0x48],0x5c
JNZ 0x0019ee8c
MOV RAX,qword ptr [RSP + 0x68]
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RSP + 0x48],EAX
MOV EAX,dword ptr [RSP + 0x48]
MOV dword ptr [RSP + 0xc],EAX
TEST EAX,EAX
JZ 0x0019ec25
JMP 0x0019ebe3
LAB_0019ebe3:
MOV EAX,dword ptr [RSP + 0xc]
SUB EAX,0xa
JZ 0x0019eca4
JMP 0x0019ebf2
LAB_0019ebf2:
MOV EAX,dword ptr [RSP + 0xc]
SUB EAX,0xd
JZ 0x0019ec86
JMP 0x0019ec01
LAB_0019ec01:
MOV EAX,dword ptr [RSP + 0xc]
SUB EAX,0x22
JZ 0x0019ec73
JMP 0x0019ec0c
LAB_0019ec0c:
MOV EAX,dword ptr [RSP + 0xc]
SUB EAX,0x27
JZ 0x0019ec73
JMP 0x0019ec17
LAB_0019ec17:
MOV EAX,dword ptr [RSP + 0xc]
SUB EAX,0x5c
JZ 0x0019ec73
JMP 0x0019ecf2
LAB_0019ec25:
MOV RAX,qword ptr [RSP + 0x68]
MOV RCX,qword ptr [RSP + 0x78]
CMP RAX,qword ptr [RCX + 0x78]
JC 0x0019ec60
CMP dword ptr [RSP + 0x74],0x60
JZ 0x0019ec41
JMP 0x0019ef6a
LAB_0019ec41:
CMP dword ptr [RSP + 0x70],0x0
JZ 0x0019ec5b
MOV RDI,qword ptr [RSP + 0x78]
LEA RSI,[0x20f8b4]
MOV AL,0x0
CALL 0x00148690
LAB_0019ec5b:
JMP 0x0019ef86
LAB_0019ec60:
MOV RAX,qword ptr [RSP + 0x68]
ADD RAX,0x1
MOV qword ptr [RSP + 0x68],RAX
JMP 0x0019ee8a
LAB_0019ec73:
MOV RAX,qword ptr [RSP + 0x68]
ADD RAX,0x1
MOV qword ptr [RSP + 0x68],RAX
JMP 0x0019ee8a
LAB_0019ec86:
MOV RAX,qword ptr [RSP + 0x68]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0xa
JNZ 0x0019eca2
MOV RAX,qword ptr [RSP + 0x68]
ADD RAX,0x1
MOV qword ptr [RSP + 0x68],RAX
LAB_0019eca2:
JMP 0x0019eca4
LAB_0019eca4:
MOV RAX,qword ptr [RSP + 0x68]
ADD RAX,0x1
MOV qword ptr [RSP + 0x68],RAX
CMP dword ptr [RSP + 0x74],0x60
JZ 0x0019eced
MOV RAX,qword ptr [RSP + 0x78]
MOV ECX,dword ptr [RAX + 0x10]
ADD ECX,0x1
MOV dword ptr [RAX + 0x10],ECX
MOV RCX,qword ptr [RSP + 0x68]
ADD RCX,-0x1
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RAX + 0x80],RCX
MOV RCX,qword ptr [RSP + 0x68]
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RAX + 0x88],RCX
LAB_0019eced:
JMP 0x0019eb00
LAB_0019ecf2:
CMP dword ptr [RSP + 0x48],0x30
JNZ 0x0019ed30
MOV RAX,qword ptr [RSP + 0x68]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x30
JL 0x0019ed15
MOV RAX,qword ptr [RSP + 0x68]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x39
JLE 0x0019ed30
LAB_0019ed15:
MOV RAX,qword ptr [RSP + 0x68]
ADD RAX,0x1
MOV qword ptr [RSP + 0x68],RAX
MOV dword ptr [RSP + 0x48],0x0
JMP 0x0019ee88
LAB_0019ed30:
CMP dword ptr [RSP + 0x48],0x30
JC 0x0019edb5
CMP dword ptr [RSP + 0x48],0x39
JA 0x0019edb5
MOV RAX,qword ptr [RSP + 0x78]
MOV RAX,qword ptr [RAX + 0x90]
MOV AX,word ptr [RAX + 0x84]
SHR AX,0xf
MOVZX EAX,AL
CMP EAX,0x0
JNZ 0x0019ed64
CMP dword ptr [RSP + 0x74],0x60
JNZ 0x0019edb5
LAB_0019ed64:
CMP dword ptr [RSP + 0x70],0x0
JZ 0x0019edb0
MOV RDI,qword ptr [RSP + 0x78]
MOV ECX,dword ptr [RSP + 0x48]
LEA RDX,[0x20f8ef]
LEA RAX,[0x20f8e5]
CMP ECX,0x38
CMOVNC RDX,RAX
MOV ESI,dword ptr [RSP + 0x74]
LEA RCX,[0x20f81a]
LEA RAX,[0x20f906]
CMP ESI,0x60
CMOVZ RCX,RAX
LEA RSI,[0x20f8cc]
MOV AL,0x0
CALL 0x00148690
LAB_0019edb0:
JMP 0x0019ef86
LAB_0019edb5:
CMP dword ptr [RSP + 0x48],0x80
JC 0x0019ee0f
MOV RDI,qword ptr [RSP + 0x68]
LEA RSI,[RSP + 0x50]
CALL 0x0011eb50
MOV dword ptr [RSP + 0x48],EAX
MOV RAX,qword ptr [RSP + 0x50]
MOV RCX,qword ptr [RSP + 0x68]
ADD RCX,0x1
CMP RAX,RCX
JNZ 0x0019edea
JMP 0x0019ef4e
LAB_0019edea:
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x68],RAX
CMP dword ptr [RSP + 0x48],0x2028
JZ 0x0019ee08
CMP dword ptr [RSP + 0x48],0x2029
JNZ 0x0019ee0d
LAB_0019ee08:
JMP 0x0019eb00
LAB_0019ee0d:
JMP 0x0019ee84
LAB_0019ee0f:
LEA RDI,[RSP + 0x68]
MOV ESI,0x1
CALL 0x001fce90
MOV dword ptr [RSP + 0x4c],EAX
CMP dword ptr [RSP + 0x4c],-0x1
JNZ 0x0019ee61
CMP dword ptr [RSP + 0x70],0x0
JZ 0x0019ee5c
MOV RDI,qword ptr [RSP + 0x78]
MOV ECX,dword ptr [RSP + 0x48]
LEA RDX,[0x20f93a]
LEA RAX,[0x20f932]
CMP ECX,0x75
CMOVZ RDX,RAX
LEA RSI,[0x20f917]
MOV AL,0x0
CALL 0x00148690
LAB_0019ee5c:
JMP 0x0019ef86
LAB_0019ee61:
CMP dword ptr [RSP + 0x4c],0x0
JGE 0x0019ee78
MOV RAX,qword ptr [RSP + 0x68]
ADD RAX,0x1
MOV qword ptr [RSP + 0x68],RAX
JMP 0x0019ee80
LAB_0019ee78:
MOV EAX,dword ptr [RSP + 0x4c]
MOV dword ptr [RSP + 0x48],EAX
LAB_0019ee80:
JMP 0x0019ee82
LAB_0019ee82:
JMP 0x0019ee84
LAB_0019ee84:
JMP 0x0019ee86
LAB_0019ee86:
JMP 0x0019ee88
LAB_0019ee88:
JMP 0x0019ee8a
LAB_0019ee8a:
JMP 0x0019eeca
LAB_0019ee8c:
CMP dword ptr [RSP + 0x48],0x80
JC 0x0019eec8
MOV RDI,qword ptr [RSP + 0x68]
ADD RDI,-0x1
LEA RSI,[RSP + 0x50]
CALL 0x0011eb50
MOV dword ptr [RSP + 0x48],EAX
MOV RAX,qword ptr [RSP + 0x50]
CMP RAX,qword ptr [RSP + 0x68]
JNZ 0x0019eebe
JMP 0x0019ef4e
LAB_0019eebe:
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x68],RAX
LAB_0019eec8:
JMP 0x0019eeca
LAB_0019eeca:
MOV RDI,qword ptr [RSP + 0x20]
MOV ESI,dword ptr [RSP + 0x48]
CALL 0x0014da80
CMP EAX,0x0
JZ 0x0019eee2
JMP 0x0019ef86
LAB_0019eee2:
JMP 0x0019eb00
LAB_0019eee7:
MOV RAX,qword ptr [RSP + 0x60]
MOV dword ptr [RAX],0xffffff81
MOV ECX,dword ptr [RSP + 0x48]
MOV RAX,qword ptr [RSP + 0x60]
MOV dword ptr [RAX + 0x28],ECX
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x0014db00
MOV RCX,RAX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x10],RCX
MOV qword ptr [RSP + 0x18],RDX
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + 0x18],RCX
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + 0x20],RCX
MOV RCX,qword ptr [RSP + 0x68]
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RAX],RCX
MOV dword ptr [RSP + 0x84],0x0
JMP 0x0019ef9b
LAB_0019ef4e:
CMP dword ptr [RSP + 0x70],0x0
JZ 0x0019ef68
MOV RDI,qword ptr [RSP + 0x78]
LEA RSI,[0x20f884]
MOV AL,0x0
CALL 0x00148690
LAB_0019ef68:
JMP 0x0019ef86
LAB_0019ef6a:
CMP dword ptr [RSP + 0x70],0x0
JZ 0x0019ef84
MOV RDI,qword ptr [RSP + 0x78]
LEA RSI,[0x20f89b]
MOV AL,0x0
CALL 0x00148690
LAB_0019ef84:
JMP 0x0019ef86
LAB_0019ef86:
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x001524b0
MOV dword ptr [RSP + 0x84],0xffffffff
LAB_0019ef9b:
MOV EAX,dword ptr [RSP + 0x84]
ADD RSP,0x88
RET
|
int4
js_parse_string(int8 *param_1,uint param_2,int param_3,byte *param_4,int4 *param_5,
int8 *param_6)
{
int4 *puVar1;
uint uVar2;
int iVar3;
byte *pbVar4;
byte *pbVar5;
char *pcVar6;
char *pcVar7;
int1 auVar8 [16];
int1 local_60 [32];
uint local_40;
uint local_3c;
byte *local_38;
int8 *local_30;
int4 *local_28;
byte *local_20;
int local_18;
uint local_14;
int8 *local_10;
local_30 = param_6;
local_28 = param_5;
local_20 = param_4;
local_18 = param_3;
local_14 = param_2;
local_10 = param_1;
iVar3 = string_buffer_init(*param_1,local_60,0x20);
joined_r0x0019eaf7:
pbVar5 = local_20;
if (iVar3 != 0) {
LAB_0019ef86:
string_buffer_free(local_60);
return 0xffffffff;
}
LAB_0019eb00:
do {
local_20 = pbVar5;
puVar1 = local_28;
if ((byte *)local_10[0xf] <= local_20) {
LAB_0019ef6a:
if (local_18 != 0) {
js_parse_error(local_10,"unexpected end of string");
}
goto LAB_0019ef86;
}
local_40 = (uint)*local_20;
if (local_40 < 0x20) {
if (local_14 == 0x60) {
if (local_40 == 0xd) {
if (local_20[1] == 10) {
local_20 = local_20 + 1;
}
local_40 = 10;
}
}
else if ((local_40 == 10) || (local_40 == 0xd)) goto LAB_0019ef6a;
}
pbVar5 = local_20;
pbVar4 = local_20 + 1;
if (local_40 == local_14) {
LAB_0019eee7:
local_20 = pbVar4;
*local_28 = 0xffffff81;
local_28[10] = local_40;
auVar8 = string_buffer_end(local_60);
*(int1 (*) [16])(puVar1 + 6) = auVar8;
*local_30 = local_20;
return 0;
}
if (((local_40 == 0x24) && (*pbVar4 == 0x7b)) && (local_14 == 0x60)) {
pbVar4 = local_20 + 2;
goto LAB_0019eee7;
}
if (local_40 != 0x5c) {
uVar2 = local_40;
local_20 = pbVar4;
if (0x7f < local_40) {
local_40 = utf8_decode(pbVar5,&local_38);
if (local_38 == local_20) {
LAB_0019ef4e:
if (local_18 != 0) {
js_parse_error(local_10,"invalid UTF-8 sequence");
}
goto LAB_0019ef86;
}
local_20 = local_38;
uVar2 = local_40;
}
break;
}
local_40 = (uint)*pbVar4;
uVar2 = local_40;
if (local_40 == 0) {
if ((byte *)local_10[0xf] <= pbVar4) {
local_20 = pbVar4;
if (local_14 != 0x60) goto LAB_0019ef6a;
if (local_18 != 0) {
js_parse_error(local_10,"Unexpected end of input");
}
goto LAB_0019ef86;
}
local_20 = local_20 + 2;
break;
}
if (local_40 == 10) {
LAB_0019eca4:
local_20 = pbVar4;
pbVar5 = local_20 + 1;
if (local_14 != 0x60) {
*(int *)(local_10 + 2) = *(int *)(local_10 + 2) + 1;
local_10[0x10] = local_20;
local_10[0x11] = pbVar5;
}
goto LAB_0019eb00;
}
if (local_40 == 0xd) {
if (local_20[2] == 10) {
pbVar4 = local_20 + 2;
}
goto LAB_0019eca4;
}
if (((local_40 == 0x22) || (local_40 == 0x27)) || (local_40 == 0x5c)) {
local_20 = local_20 + 2;
break;
}
if ((local_40 == 0x30) && ((local_20[2] < 0x30 || (0x39 < local_20[2])))) {
local_20 = local_20 + 2;
local_40 = 0;
uVar2 = local_40;
break;
}
if (((0x2f < local_40) && (local_40 < 0x3a)) &&
((*(short *)(local_10[0x12] + 0x84) < 0 || (local_14 == 0x60)))) {
local_20 = pbVar4;
if (local_18 != 0) {
pcVar7 = "Octal escape sequences";
if (0x37 < local_40) {
pcVar7 = "\\8 and \\9";
}
pcVar6 = "strict mode";
if (local_14 == 0x60) {
pcVar6 = "template strings";
}
js_parse_error(local_10,"%s are not allowed in %s",pcVar7,pcVar6);
}
goto LAB_0019ef86;
}
if (local_40 < 0x80) {
local_20 = pbVar4;
local_3c = lre_parse_escape(&local_20,1);
if (local_3c == 0xffffffff) {
if (local_18 != 0) {
pcVar7 = "hexadecimal";
if (local_40 == 0x75) {
pcVar7 = "Unicode";
}
js_parse_error(local_10,"Invalid %s escape sequence",pcVar7);
}
goto LAB_0019ef86;
}
uVar2 = local_3c;
if ((int)local_3c < 0) {
local_20 = local_20 + 1;
uVar2 = local_40;
}
break;
}
local_20 = pbVar4;
local_40 = utf8_decode(pbVar4,&local_38);
if (local_38 == local_20 + 1) goto LAB_0019ef4e;
local_20 = local_38;
pbVar5 = local_38;
if ((local_40 != 0x2028) && (uVar2 = local_40, local_40 != 0x2029)) break;
} while( true );
local_40 = uVar2;
iVar3 = string_buffer_putc(local_60,local_40);
goto joined_r0x0019eaf7;
}
| |
24,852 | js_parse_string | bluesky950520[P]quickjs/quickjs.c | static __exception int js_parse_string(JSParseState *s, int sep,
BOOL do_throw, const uint8_t *p,
JSToken *token, const uint8_t **pp)
{
const uint8_t *p_next;
int ret;
uint32_t c;
StringBuffer b_s, *b = &b_s;
/* string */
if (string_buffer_init(s->ctx, b, 32))
goto fail;
for(;;) {
if (p >= s->buf_end)
goto invalid_char;
c = *p;
if (c < 0x20) {
if (sep == '`') {
if (c == '\r') {
if (p[1] == '\n')
p++;
c = '\n';
}
/* do not update s->line_num */
} else if (c == '\n' || c == '\r')
goto invalid_char;
}
p++;
if (c == sep)
break;
if (c == '$' && *p == '{' && sep == '`') {
/* template start or middle part */
p++;
break;
}
if (c == '\\') {
c = *p;
switch(c) {
case '\0':
if (p >= s->buf_end) {
if (sep != '`')
goto invalid_char;
if (do_throw)
js_parse_error(s, "Unexpected end of input");
goto fail;
}
p++;
break;
case '\'':
case '\"':
case '\\':
p++;
break;
case '\r': /* accept DOS and MAC newline sequences */
if (p[1] == '\n') {
p++;
}
/* fall thru */
case '\n':
/* ignore escaped newline sequence */
p++;
if (sep != '`') {
s->line_num++;
s->eol = &p[-1];
s->mark = p;
}
continue;
default:
if (c == '0' && !(p[1] >= '0' && p[1] <= '9')) {
/* accept isolated \0 */
p++;
c = '\0';
} else
if ((c >= '0' && c <= '9')
&& (s->cur_func->is_strict_mode || sep == '`')) {
if (do_throw) {
js_parse_error(s, "%s are not allowed in %s",
(c >= '8') ? "\\8 and \\9" : "Octal escape sequences",
(sep == '`') ? "template strings" : "strict mode");
}
goto fail;
} else if (c >= 0x80) {
c = utf8_decode(p, &p_next);
if (p_next == p + 1) {
goto invalid_utf8;
}
p = p_next;
/* LS or PS are skipped */
if (c == CP_LS || c == CP_PS)
continue;
} else {
ret = lre_parse_escape(&p, TRUE);
if (ret == -1) {
if (do_throw) {
js_parse_error(s, "Invalid %s escape sequence",
c == 'u' ? "Unicode" : "hexadecimal");
}
goto fail;
} else if (ret < 0) {
/* ignore the '\' (could output a warning) */
p++;
} else {
c = ret;
}
}
break;
}
} else if (c >= 0x80) {
c = utf8_decode(p - 1, &p_next);
if (p_next == p)
goto invalid_utf8;
p = p_next;
}
if (string_buffer_putc(b, c))
goto fail;
}
token->val = TOK_STRING;
token->u.str.sep = c;
token->u.str.str = string_buffer_end(b);
*pp = p;
return 0;
invalid_utf8:
if (do_throw)
js_parse_error(s, "invalid UTF-8 sequence");
goto fail;
invalid_char:
if (do_throw)
js_parse_error(s, "unexpected end of string");
fail:
string_buffer_free(b);
return -1;
} | O1 | c | js_parse_string:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r14
movq %r8, %r15
movl %edx, %r12d
movl %esi, %ebp
movq %rdi, %rbx
movq %rcx, (%rsp)
movq (%rdi), %rdi
movq %rdi, 0x10(%rsp)
movsd 0x3f50b(%rip), %xmm0 # 0x9e780
movups %xmm0, 0x20(%rsp)
movl $0x20, %esi
xorl %edx, %edx
callq 0x20b73
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x5f5b1
movq %r14, 0x30(%rsp)
movq (%rsp), %rax
movq 0x78(%rbx), %rcx
cmpq %rcx, %rax
jae 0x5f4fb
leaq 0x10(%rsp), %r13
movzbl (%rax), %edx
cmpl $0x1f, %edx
ja 0x5f2e4
cmpl $0x60, %ebp
jne 0x5f2d2
cmpb $0xd, %dl
jne 0x5f2e4
movb $0xa, %dl
cmpb $0xa, 0x1(%rax)
jne 0x5f2e4
incq %rax
movq %rax, (%rsp)
jmp 0x5f2e4
cmpl $0xa, %edx
je 0x5f4fb
cmpl $0xd, %edx
je 0x5f4fb
movzbl %dl, %r14d
movq (%rsp), %rdi
leaq 0x1(%rdi), %rax
movq %rax, (%rsp)
cmpl %ebp, %r14d
je 0x5f4ad
cmpl $0x5c, %r14d
je 0x5f31d
cmpl $0x24, %r14d
jne 0x5f34a
cmpl $0x60, %ebp
jne 0x5f317
cmpb $0x7b, (%rax)
je 0x5f4a5
cmpl $0x5c, %r14d
jne 0x5f34a
movzbl (%rax), %r14d
cmpl $0x21, %r14d
jle 0x5f377
cmpl $0x2f, %r14d
jg 0x5f3c1
cmpl $0x22, %r14d
je 0x5f3cd
cmpl $0x27, %r14d
je 0x5f3cd
jmp 0x5f3ec
testb %dl, %dl
jns 0x5f442
leaq 0x8(%rsp), %rsi
callq 0x1b729
movl %eax, %r14d
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
je 0x5f4da
movq %rax, (%rsp)
jmp 0x5f442
testl %r14d, %r14d
je 0x5f3d7
cmpl $0xa, %r14d
je 0x5f396
cmpl $0xd, %r14d
jne 0x5f3ec
cmpb $0xa, 0x2(%rdi)
jne 0x5f396
addq $0x2, %rdi
movq %rdi, (%rsp)
movq (%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rsp)
cmpl $0x60, %ebp
je 0x5f455
incl 0x10(%rbx)
movq %rax, 0x80(%rbx)
movq %rcx, 0x88(%rbx)
jmp 0x5f455
cmpl $0x30, %r14d
je 0x5f3e1
cmpl $0x5c, %r14d
jne 0x5f3ec
addq $0x2, %rdi
movq %rdi, (%rsp)
jmp 0x5f442
cmpq %rcx, %rax
jb 0x5f437
jmp 0x5f4e8
movb 0x2(%rdi), %cl
addb $-0x30, %cl
cmpb $0xa, %cl
jae 0x5f437
leal -0x30(%r14), %ecx
cmpb $0x9, %cl
ja 0x5f413
cmpl $0x60, %ebp
je 0x5f56b
movq 0x90(%rbx), %rcx
cmpw $0x0, 0x84(%rcx)
js 0x5f56b
testb %r14b, %r14b
js 0x5f46b
movq %rsp, %rdi
movl $0x1, %esi
callq 0x9453f
cmpl $-0x1, %eax
je 0x5f53d
testl %eax, %eax
js 0x5f49f
movl %eax, %r14d
jmp 0x5f442
addq $0x2, %rdi
movq %rdi, (%rsp)
xorl %r14d, %r14d
movq %r13, %rdi
movl %r14d, %esi
callq 0x333f0
testl %eax, %eax
jne 0x5f511
movq (%rsp), %rax
movq 0x78(%rbx), %rcx
cmpq %rcx, %rax
jb 0x5f2af
jmp 0x5f4fb
movq %rax, %rdi
leaq 0x8(%rsp), %rsi
callq 0x1b729
movl %eax, %r14d
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
incq %rcx
cmpq %rcx, %rax
je 0x5f4da
movq %rax, (%rsp)
movl %r14d, %eax
andl $-0x2, %eax
cmpl $0x2028, %eax # imm = 0x2028
jne 0x5f442
jmp 0x5f455
incq (%rsp)
jmp 0x5f442
addq $0x2, %rdi
movq %rdi, (%rsp)
movl $0xffffff81, (%r15) # imm = 0xFFFFFF81
movl %r14d, 0x28(%r15)
leaq 0x10(%rsp), %rdi
callq 0x33444
movq %rax, 0x18(%r15)
movq %rdx, 0x20(%r15)
movq (%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rax, (%rcx)
xorl %eax, %eax
jmp 0x5f52e
testl %r12d, %r12d
je 0x5f511
leaq 0x4133a(%rip), %rsi # 0xa0820
jmp 0x5f507
cmpl $0x60, %ebp
jne 0x5f4fb
testl %r12d, %r12d
je 0x5f511
leaq 0x41357(%rip), %rsi # 0xa0850
jmp 0x5f507
testl %r12d, %r12d
je 0x5f511
leaq 0x41330(%rip), %rsi # 0xa0837
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2fce9
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1cb99
movq $0x0, 0x18(%rsp)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %r12d, %r12d
je 0x5f511
cmpl $0x75, %r14d
leaq 0x41381(%rip), %rax # 0xa08ce
leaq 0x41382(%rip), %rdx # 0xa08d6
cmoveq %rax, %rdx
leaq 0x41354(%rip), %rsi # 0xa08b3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2fce9
jmp 0x5f511
testl %r12d, %r12d
je 0x5f511
cmpb $0x38, %r14b
leaq 0x41306(%rip), %rax # 0xa0881
leaq 0x41309(%rip), %rdx # 0xa088b
cmovaeq %rax, %rdx
cmpl $0x60, %ebp
leaq 0x41312(%rip), %rax # 0xa08a2
leaq 0x4121f(%rip), %rcx # 0xa07b6
cmoveq %rax, %rcx
leaq 0x412c6(%rip), %rsi # 0xa0868
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2fce9
jmp 0x5f511
movl $0x0, 0x24(%rsp)
movl $0xffffffff, 0x2c(%rsp) # imm = 0xFFFFFFFF
jmp 0x5f511
| js_parse_string:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r14, r9
mov r15, r8
mov r12d, edx
mov ebp, esi
mov rbx, rdi
mov [rsp+68h+var_68], rcx
mov rdi, [rdi]
mov [rsp+68h+var_58], rdi
movsd xmm0, cs:qword_9E780
movups [rsp+68h+var_48], xmm0
mov esi, 20h ; ' '
xor edx, edx
call js_alloc_string
mov [rsp+68h+var_50], rax
test rax, rax
jz loc_5F5B1
mov [rsp+68h+var_38], r14
mov rax, [rsp+68h+var_68]
mov rcx, [rbx+78h]
cmp rax, rcx
jnb loc_5F4FB
lea r13, [rsp+68h+var_58]
loc_5F2AF:
movzx edx, byte ptr [rax]
cmp edx, 1Fh
ja short loc_5F2E4
cmp ebp, 60h ; '`'
jnz short loc_5F2D2
cmp dl, 0Dh
jnz short loc_5F2E4
mov dl, 0Ah
cmp byte ptr [rax+1], 0Ah
jnz short loc_5F2E4
inc rax
mov [rsp+68h+var_68], rax
jmp short loc_5F2E4
loc_5F2D2:
cmp edx, 0Ah
jz loc_5F4FB
cmp edx, 0Dh
jz loc_5F4FB
loc_5F2E4:
movzx r14d, dl
mov rdi, [rsp+68h+var_68]
lea rax, [rdi+1]
mov [rsp+68h+var_68], rax
cmp r14d, ebp
jz loc_5F4AD
cmp r14d, 5Ch ; '\'
jz short loc_5F31D
cmp r14d, 24h ; '$'
jnz short loc_5F34A
cmp ebp, 60h ; '`'
jnz short loc_5F317
cmp byte ptr [rax], 7Bh ; '{'
jz loc_5F4A5
loc_5F317:
cmp r14d, 5Ch ; '\'
jnz short loc_5F34A
loc_5F31D:
movzx r14d, byte ptr [rax]
cmp r14d, 21h ; '!'
jle short loc_5F377
cmp r14d, 2Fh ; '/'
jg loc_5F3C1
cmp r14d, 22h ; '"'
jz loc_5F3CD
cmp r14d, 27h ; '''
jz loc_5F3CD
jmp loc_5F3EC
loc_5F34A:
test dl, dl
jns loc_5F442
lea rsi, [rsp+68h+var_60]
call utf8_decode
mov r14d, eax
mov rax, [rsp+68h+var_60]
cmp rax, [rsp+68h+var_68]
jz loc_5F4DA
mov [rsp+68h+var_68], rax
jmp loc_5F442
loc_5F377:
test r14d, r14d
jz short loc_5F3D7
cmp r14d, 0Ah
jz short loc_5F396
cmp r14d, 0Dh
jnz short loc_5F3EC
cmp byte ptr [rdi+2], 0Ah
jnz short loc_5F396
add rdi, 2
mov [rsp+68h+var_68], rdi
loc_5F396:
mov rax, [rsp+68h+var_68]
lea rcx, [rax+1]
mov [rsp+68h+var_68], rcx
cmp ebp, 60h ; '`'
jz loc_5F455
inc dword ptr [rbx+10h]
mov [rbx+80h], rax
mov [rbx+88h], rcx
jmp loc_5F455
loc_5F3C1:
cmp r14d, 30h ; '0'
jz short loc_5F3E1
cmp r14d, 5Ch ; '\'
jnz short loc_5F3EC
loc_5F3CD:
add rdi, 2
mov [rsp+68h+var_68], rdi
jmp short loc_5F442
loc_5F3D7:
cmp rax, rcx
jb short loc_5F437
jmp loc_5F4E8
loc_5F3E1:
mov cl, [rdi+2]
add cl, 0D0h
cmp cl, 0Ah
jnb short loc_5F437
loc_5F3EC:
lea ecx, [r14-30h]
cmp cl, 9
ja short loc_5F413
cmp ebp, 60h ; '`'
jz loc_5F56B
mov rcx, [rbx+90h]
cmp word ptr [rcx+84h], 0
js loc_5F56B
loc_5F413:
test r14b, r14b
js short loc_5F46B
mov rdi, rsp
mov esi, 1
call lre_parse_escape
cmp eax, 0FFFFFFFFh
jz loc_5F53D
test eax, eax
js short loc_5F49F
mov r14d, eax
jmp short loc_5F442
loc_5F437:
add rdi, 2
mov [rsp+68h+var_68], rdi
xor r14d, r14d
loc_5F442:
mov rdi, r13
mov esi, r14d
call string_buffer_putc
test eax, eax
jnz loc_5F511
loc_5F455:
mov rax, [rsp+68h+var_68]
mov rcx, [rbx+78h]
cmp rax, rcx
jb loc_5F2AF
jmp loc_5F4FB
loc_5F46B:
mov rdi, rax
lea rsi, [rsp+68h+var_60]
call utf8_decode
mov r14d, eax
mov rax, [rsp+68h+var_60]
mov rcx, [rsp+68h+var_68]
inc rcx
cmp rax, rcx
jz short loc_5F4DA
mov [rsp+68h+var_68], rax
mov eax, r14d
and eax, 0FFFFFFFEh
cmp eax, 2028h
jnz short loc_5F442
jmp short loc_5F455
loc_5F49F:
inc [rsp+68h+var_68]
jmp short loc_5F442
loc_5F4A5:
add rdi, 2
mov [rsp+68h+var_68], rdi
loc_5F4AD:
mov dword ptr [r15], 0FFFFFF81h
mov [r15+28h], r14d
lea rdi, [rsp+68h+var_58]
call string_buffer_end
mov [r15+18h], rax
mov [r15+20h], rdx
mov rax, [rsp+68h+var_68]
mov rcx, [rsp+68h+var_38]
mov [rcx], rax
xor eax, eax
jmp short loc_5F52E
loc_5F4DA:
test r12d, r12d
jz short loc_5F511
lea rsi, aInvalidUtf8Seq; "invalid UTF-8 sequence"
jmp short loc_5F507
loc_5F4E8:
cmp ebp, 60h ; '`'
jnz short loc_5F4FB
test r12d, r12d
jz short loc_5F511
lea rsi, aUnexpectedEndO_2; "Unexpected end of input"
jmp short loc_5F507
loc_5F4FB:
test r12d, r12d
jz short loc_5F511
lea rsi, aUnexpectedEndO_1; "unexpected end of string"
loc_5F507:
mov rdi, rbx
xor eax, eax
call js_parse_error
loc_5F511:
mov rdi, [rsp+68h+var_58]
mov rsi, [rsp+68h+var_50]
call js_free
mov [rsp+68h+var_50], 0
mov eax, 0FFFFFFFFh
loc_5F52E:
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_5F53D:
test r12d, r12d
jz short loc_5F511
cmp r14d, 75h ; 'u'
lea rax, aUnicode; "Unicode"
lea rdx, aHexadecimal; "hexadecimal"
cmovz rdx, rax
lea rsi, aInvalidSEscape; "Invalid %s escape sequence"
mov rdi, rbx
xor eax, eax
call js_parse_error
jmp short loc_5F511
loc_5F56B:
test r12d, r12d
jz short loc_5F511
cmp r14b, 38h ; '8'
lea rax, a8And9; "\\8 and \\9"
lea rdx, aOctalEscapeSeq; "Octal escape sequences"
cmovnb rdx, rax
cmp ebp, 60h ; '`'
lea rax, aTemplateString; "template strings"
lea rcx, aOctalLiteralsA+22h; "strict mode"
cmovz rcx, rax
lea rsi, aSAreNotAllowed; "%s are not allowed in %s"
mov rdi, rbx
xor eax, eax
call js_parse_error
jmp loc_5F511
loc_5F5B1:
mov dword ptr [rsp+68h+var_48+4], 0
mov dword ptr [rsp+68h+var_48+0Ch], 0FFFFFFFFh
jmp loc_5F511
| long long js_parse_string(
long long a1,
int a2,
int a3,
char *a4,
long long a5,
char **a6,
double a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14)
{
long long v18; // rdx
long long v19; // r8
long long v20; // r9
__m128 v21; // xmm4
__m128 v22; // xmm5
char *v23; // rax
unsigned long long i; // rcx
unsigned int v25; // r14d
char *v26; // rdi
char *v27; // rax
char *v28; // rax
char *v29; // rcx
int v30; // eax
long long v31; // rcx
long long v32; // r8
long long v33; // r9
__m128 v34; // xmm4
__m128 v35; // xmm5
long long v36; // rdx
const char *v38; // rsi
const char *v39; // rdx
const char *v40; // rdx
char *v41; // rcx
char *v42; // [rsp+0h] [rbp-68h] BYREF
char *v43; // [rsp+8h] [rbp-60h] BYREF
long long v44; // [rsp+10h] [rbp-58h] BYREF
long long v45; // [rsp+18h] [rbp-50h]
__int128 v46; // [rsp+20h] [rbp-48h]
char **v47; // [rsp+30h] [rbp-38h]
v42 = a4;
v44 = *(_QWORD *)a1;
v46 = 0x2000000000uLL;
v45 = js_alloc_string(v44, 32LL, 0);
if ( !v45 )
{
DWORD1(v46) = 0;
HIDWORD(v46) = -1;
goto LABEL_62;
}
v47 = a6;
v23 = v42;
for ( i = *(_QWORD *)(a1 + 120); (unsigned long long)v42 < i; i = *(_QWORD *)(a1 + 120) )
{
v18 = (unsigned __int8)*v23;
if ( (unsigned int)v18 <= 0x1F )
{
if ( a2 == 96 )
{
if ( (_BYTE)v18 == 13 )
{
LOBYTE(v18) = 10;
if ( v23[1] == 10 )
v42 = v23 + 1;
}
}
else if ( (_DWORD)v18 == 10 || (_DWORD)v18 == 13 )
{
break;
}
}
v25 = (unsigned __int8)v18;
v26 = v42;
v27 = ++v42;
if ( (unsigned __int8)v18 == a2 )
goto LABEL_53;
if ( (unsigned __int8)v18 != 92 )
{
if ( (unsigned __int8)v18 == 36 && a2 == 96 && *v27 == 123 )
{
v42 = v26 + 2;
LABEL_53:
*(_DWORD *)a5 = -127;
*(_DWORD *)(a5 + 40) = (unsigned __int8)v18;
*(_QWORD *)(a5 + 24) = string_buffer_end((long long)&v44);
*(_QWORD *)(a5 + 32) = v36;
*v47 = v42;
return 0LL;
}
if ( (v18 & 0x80u) != 0LL )
{
v25 = utf8_decode(v26, &v43);
if ( v43 == v42 )
goto LABEL_54;
v42 = v43;
}
goto LABEL_45;
}
v25 = (unsigned __int8)*v27;
if ( v25 <= 0x21 )
{
if ( !*v27 )
{
if ( (unsigned long long)v27 >= i )
{
if ( a2 != 96 )
break;
if ( a3 )
{
v38 = "Unexpected end of input";
goto LABEL_61;
}
goto LABEL_62;
}
LABEL_44:
v42 = v26 + 2;
v25 = 0;
LABEL_45:
if ( (unsigned int)string_buffer_putc((long long)&v44, v25) )
goto LABEL_62;
goto LABEL_46;
}
if ( v25 == 10 )
goto LABEL_29;
if ( v25 == 13 )
{
if ( v26[2] == 10 )
v42 = v26 + 2;
LABEL_29:
v28 = v42;
v29 = ++v42;
if ( a2 != 96 )
{
++*(_DWORD *)(a1 + 16);
*(_QWORD *)(a1 + 128) = v28;
*(_QWORD *)(a1 + 136) = v29;
}
goto LABEL_46;
}
}
else if ( (unsigned __int8)*v27 > 0x2Fu )
{
if ( v25 == 48 )
{
if ( (unsigned __int8)(v26[2] - 48) >= 0xAu )
goto LABEL_44;
}
else if ( v25 == 92 )
{
goto LABEL_33;
}
}
else if ( v25 == 34 || v25 == 39 )
{
LABEL_33:
v42 = v26 + 2;
goto LABEL_45;
}
if ( (unsigned __int8)(v25 - 48) <= 9u && (a2 == 96 || *(__int16 *)(*(_QWORD *)(a1 + 144) + 132LL) < 0) )
{
if ( a3 )
{
v40 = "Octal escape sequences";
if ( (unsigned __int8)v25 >= 0x38u )
v40 = "\\8 and \\9";
v41 = "strict mode";
if ( a2 == 96 )
v41 = "template strings";
js_parse_error(
(long long *)a1,
(long long)"%s are not allowed in %s",
(long long)v40,
(long long)v41,
v19,
v20,
(__m128)0x2000000000uLL,
a8,
a9,
a10,
v21,
v22,
a13,
a14,
(char)v42);
}
goto LABEL_62;
}
if ( (v25 & 0x80u) == 0 )
{
v30 = lre_parse_escape(&v42, 1LL);
if ( v30 == -1 )
{
if ( a3 )
{
v39 = "hexadecimal";
if ( v25 == 117 )
v39 = "Unicode";
js_parse_error(
(long long *)a1,
(long long)"Invalid %s escape sequence",
(long long)v39,
v31,
v32,
v33,
(__m128)0x2000000000uLL,
a8,
a9,
a10,
v34,
v35,
a13,
a14,
(char)v42);
}
goto LABEL_62;
}
if ( v30 < 0 )
++v42;
else
v25 = v30;
goto LABEL_45;
}
v25 = utf8_decode(v27, &v43);
i = (unsigned long long)(v42 + 1);
if ( v43 == v42 + 1 )
{
LABEL_54:
if ( !a3 )
goto LABEL_62;
v38 = "invalid UTF-8 sequence";
goto LABEL_61;
}
v42 = v43;
if ( (v25 & 0xFFFFFFFE) != 0x2028 )
goto LABEL_45;
LABEL_46:
v23 = v42;
}
if ( a3 )
{
v38 = "unexpected end of string";
LABEL_61:
js_parse_error(
(long long *)a1,
(long long)v38,
v18,
i,
v19,
v20,
(__m128)0x2000000000uLL,
a8,
a9,
a10,
v21,
v22,
a13,
a14,
(char)v42);
}
LABEL_62:
js_free(v44, v45);
v45 = 0LL;
return 0xFFFFFFFFLL;
}
| js_parse_string:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R14,R9
MOV R15,R8
MOV R12D,EDX
MOV EBP,ESI
MOV RBX,RDI
MOV qword ptr [RSP],RCX
MOV RDI,qword ptr [RDI]
MOV qword ptr [RSP + 0x10],RDI
MOVSD XMM0,qword ptr [0x0019e780]
MOVUPS xmmword ptr [RSP + 0x20],XMM0
MOV ESI,0x20
XOR EDX,EDX
CALL 0x00120b73
MOV qword ptr [RSP + 0x18],RAX
TEST RAX,RAX
JZ 0x0015f5b1
MOV qword ptr [RSP + 0x30],R14
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [RBX + 0x78]
CMP RAX,RCX
JNC 0x0015f4fb
LEA R13,[RSP + 0x10]
LAB_0015f2af:
MOVZX EDX,byte ptr [RAX]
CMP EDX,0x1f
JA 0x0015f2e4
CMP EBP,0x60
JNZ 0x0015f2d2
CMP DL,0xd
JNZ 0x0015f2e4
MOV DL,0xa
CMP byte ptr [RAX + 0x1],0xa
JNZ 0x0015f2e4
INC RAX
MOV qword ptr [RSP],RAX
JMP 0x0015f2e4
LAB_0015f2d2:
CMP EDX,0xa
JZ 0x0015f4fb
CMP EDX,0xd
JZ 0x0015f4fb
LAB_0015f2e4:
MOVZX R14D,DL
MOV RDI,qword ptr [RSP]
LEA RAX,[RDI + 0x1]
MOV qword ptr [RSP],RAX
CMP R14D,EBP
JZ 0x0015f4ad
CMP R14D,0x5c
JZ 0x0015f31d
CMP R14D,0x24
JNZ 0x0015f34a
CMP EBP,0x60
JNZ 0x0015f317
CMP byte ptr [RAX],0x7b
JZ 0x0015f4a5
LAB_0015f317:
CMP R14D,0x5c
JNZ 0x0015f34a
LAB_0015f31d:
MOVZX R14D,byte ptr [RAX]
CMP R14D,0x21
JLE 0x0015f377
CMP R14D,0x2f
JG 0x0015f3c1
CMP R14D,0x22
JZ 0x0015f3cd
CMP R14D,0x27
JZ 0x0015f3cd
JMP 0x0015f3ec
LAB_0015f34a:
TEST DL,DL
JNS 0x0015f442
LEA RSI,[RSP + 0x8]
CALL 0x0011b729
MOV R14D,EAX
MOV RAX,qword ptr [RSP + 0x8]
CMP RAX,qword ptr [RSP]
JZ 0x0015f4da
MOV qword ptr [RSP],RAX
JMP 0x0015f442
LAB_0015f377:
TEST R14D,R14D
JZ 0x0015f3d7
CMP R14D,0xa
JZ 0x0015f396
CMP R14D,0xd
JNZ 0x0015f3ec
CMP byte ptr [RDI + 0x2],0xa
JNZ 0x0015f396
ADD RDI,0x2
MOV qword ptr [RSP],RDI
LAB_0015f396:
MOV RAX,qword ptr [RSP]
LEA RCX,[RAX + 0x1]
MOV qword ptr [RSP],RCX
CMP EBP,0x60
JZ 0x0015f455
INC dword ptr [RBX + 0x10]
MOV qword ptr [RBX + 0x80],RAX
MOV qword ptr [RBX + 0x88],RCX
JMP 0x0015f455
LAB_0015f3c1:
CMP R14D,0x30
JZ 0x0015f3e1
CMP R14D,0x5c
JNZ 0x0015f3ec
LAB_0015f3cd:
ADD RDI,0x2
MOV qword ptr [RSP],RDI
JMP 0x0015f442
LAB_0015f3d7:
CMP RAX,RCX
JC 0x0015f437
JMP 0x0015f4e8
LAB_0015f3e1:
MOV CL,byte ptr [RDI + 0x2]
ADD CL,0xd0
CMP CL,0xa
JNC 0x0015f437
LAB_0015f3ec:
LEA ECX,[R14 + -0x30]
CMP CL,0x9
JA 0x0015f413
CMP EBP,0x60
JZ 0x0015f56b
MOV RCX,qword ptr [RBX + 0x90]
CMP word ptr [RCX + 0x84],0x0
JS 0x0015f56b
LAB_0015f413:
TEST R14B,R14B
JS 0x0015f46b
MOV RDI,RSP
MOV ESI,0x1
CALL 0x0019453f
CMP EAX,-0x1
JZ 0x0015f53d
TEST EAX,EAX
JS 0x0015f49f
MOV R14D,EAX
JMP 0x0015f442
LAB_0015f437:
ADD RDI,0x2
MOV qword ptr [RSP],RDI
XOR R14D,R14D
LAB_0015f442:
MOV RDI,R13
MOV ESI,R14D
CALL 0x001333f0
TEST EAX,EAX
JNZ 0x0015f511
LAB_0015f455:
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [RBX + 0x78]
CMP RAX,RCX
JC 0x0015f2af
JMP 0x0015f4fb
LAB_0015f46b:
MOV RDI,RAX
LEA RSI,[RSP + 0x8]
CALL 0x0011b729
MOV R14D,EAX
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP]
INC RCX
CMP RAX,RCX
JZ 0x0015f4da
MOV qword ptr [RSP],RAX
MOV EAX,R14D
AND EAX,0xfffffffe
CMP EAX,0x2028
JNZ 0x0015f442
JMP 0x0015f455
LAB_0015f49f:
INC qword ptr [RSP]
JMP 0x0015f442
LAB_0015f4a5:
ADD RDI,0x2
MOV qword ptr [RSP],RDI
LAB_0015f4ad:
MOV dword ptr [R15],0xffffff81
MOV dword ptr [R15 + 0x28],R14D
LEA RDI,[RSP + 0x10]
CALL 0x00133444
MOV qword ptr [R15 + 0x18],RAX
MOV qword ptr [R15 + 0x20],RDX
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [RSP + 0x30]
MOV qword ptr [RCX],RAX
XOR EAX,EAX
JMP 0x0015f52e
LAB_0015f4da:
TEST R12D,R12D
JZ 0x0015f511
LEA RSI,[0x1a0820]
JMP 0x0015f507
LAB_0015f4e8:
CMP EBP,0x60
JNZ 0x0015f4fb
TEST R12D,R12D
JZ 0x0015f511
LEA RSI,[0x1a0850]
JMP 0x0015f507
LAB_0015f4fb:
TEST R12D,R12D
JZ 0x0015f511
LEA RSI,[0x1a0837]
LAB_0015f507:
MOV RDI,RBX
XOR EAX,EAX
CALL 0x0012fce9
LAB_0015f511:
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x0011cb99
MOV qword ptr [RSP + 0x18],0x0
MOV EAX,0xffffffff
LAB_0015f52e:
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0015f53d:
TEST R12D,R12D
JZ 0x0015f511
CMP R14D,0x75
LEA RAX,[0x1a08ce]
LEA RDX,[0x1a08d6]
CMOVZ RDX,RAX
LEA RSI,[0x1a08b3]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x0012fce9
JMP 0x0015f511
LAB_0015f56b:
TEST R12D,R12D
JZ 0x0015f511
CMP R14B,0x38
LEA RAX,[0x1a0881]
LEA RDX,[0x1a088b]
CMOVNC RDX,RAX
CMP EBP,0x60
LEA RAX,[0x1a08a2]
LEA RCX,[0x1a07b6]
CMOVZ RCX,RAX
LEA RSI,[0x1a0868]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x0012fce9
JMP 0x0015f511
LAB_0015f5b1:
MOV dword ptr [RSP + 0x24],0x0
MOV dword ptr [RSP + 0x2c],0xffffffff
JMP 0x0015f511
|
int8
js_parse_string(int8 *param_1,uint param_2,int param_3,byte *param_4,int4 *param_5,
ulong *param_6)
{
byte *pbVar1;
byte bVar2;
byte *pbVar3;
uint uVar4;
int iVar5;
byte *pbVar6;
char *pcVar7;
char *pcVar8;
int1 auVar9 [16];
byte *local_68;
byte *local_60;
int8 local_58;
long local_50;
ulong local_48;
int8 uStack_40;
ulong *local_38;
local_58 = *param_1;
local_48 = DAT_0019e780;
uStack_40 = 0;
local_68 = param_4;
local_50 = js_alloc_string(local_58,0x20,0);
if (local_50 == 0) {
local_48 = local_48 & 0xffffffff;
uStack_40 = CONCAT44(0xffffffff,(int4)uStack_40);
LAB_0015f511:
js_free(local_58,local_50);
return 0xffffffff;
}
pbVar6 = (byte *)param_1[0xf];
local_38 = param_6;
if (pbVar6 <= local_68) {
LAB_0015f4fb:
if (param_3 != 0) {
pcVar8 = "unexpected end of string";
LAB_0015f507:
js_parse_error(param_1,pcVar8);
}
goto LAB_0015f511;
}
LAB_0015f2af:
bVar2 = *local_68;
uVar4 = (uint)bVar2;
if (bVar2 < 0x20) {
if (param_2 == 0x60) {
if ((bVar2 == 0xd) && (uVar4 = 10, local_68[1] == 10)) {
local_68 = local_68 + 1;
}
}
else if ((bVar2 == 10) || (bVar2 == 0xd)) goto LAB_0015f4fb;
}
pbVar3 = local_68;
pbVar1 = local_68 + 1;
if (uVar4 == param_2) {
LAB_0015f4ad:
local_68 = pbVar1;
*param_5 = 0xffffff81;
param_5[10] = uVar4;
auVar9 = string_buffer_end(&local_58);
*(int1 (*) [16])(param_5 + 6) = auVar9;
*local_38 = (ulong)local_68;
return 0;
}
if (uVar4 == 0x5c) {
bVar2 = *pbVar1;
if (bVar2 < 0x22) {
if (bVar2 == 0) {
if (pbVar1 < pbVar6) {
LAB_0015f437:
uVar4 = 0;
local_68 = local_68 + 2;
goto LAB_0015f442;
}
local_68 = pbVar1;
if (param_2 == 0x60) {
if (param_3 == 0) goto LAB_0015f511;
pcVar8 = "Unexpected end of input";
goto LAB_0015f507;
}
goto LAB_0015f4fb;
}
if (bVar2 != 10) {
if (bVar2 != 0xd) goto LAB_0015f3ec;
if (local_68[2] == 10) {
pbVar1 = local_68 + 2;
}
}
local_68 = pbVar1;
pbVar6 = local_68 + 1;
if (param_2 != 0x60) {
*(int *)(param_1 + 2) = *(int *)(param_1 + 2) + 1;
param_1[0x10] = local_68;
param_1[0x11] = pbVar6;
}
goto LAB_0015f455;
}
if (bVar2 < 0x30) {
if ((bVar2 == 0x22) || (bVar2 == 0x27)) {
LAB_0015f3cd:
local_68 = local_68 + 2;
uVar4 = (uint)bVar2;
goto LAB_0015f442;
}
}
else if (bVar2 == 0x30) {
if (9 < (byte)(local_68[2] - 0x30)) goto LAB_0015f437;
}
else if (bVar2 == 0x5c) goto LAB_0015f3cd;
LAB_0015f3ec:
if (((byte)(bVar2 - 0x30) < 10) && ((param_2 == 0x60 || (*(short *)(param_1[0x12] + 0x84) < 0)))
) {
local_68 = pbVar1;
if (param_3 != 0) {
pcVar8 = "Octal escape sequences";
if (0x37 < bVar2) {
pcVar8 = "\\8 and \\9";
}
pcVar7 = "strict mode";
if (param_2 == 0x60) {
pcVar7 = "template strings";
}
js_parse_error(param_1,"%s are not allowed in %s",pcVar8,pcVar7);
}
goto LAB_0015f511;
}
if ((char)bVar2 < '\0') {
local_68 = pbVar1;
uVar4 = utf8_decode(pbVar1,&local_60);
if (local_60 == local_68 + 1) goto LAB_0015f4da;
local_68 = local_60;
pbVar6 = local_60;
if ((uVar4 & 0xfffffffe) == 0x2028) goto LAB_0015f455;
goto LAB_0015f442;
}
local_68 = pbVar1;
uVar4 = lre_parse_escape(&local_68,1);
if (uVar4 == 0xffffffff) {
if (param_3 != 0) {
pcVar8 = "hexadecimal";
if (bVar2 == 0x75) {
pcVar8 = "Unicode";
}
js_parse_error(param_1,"Invalid %s escape sequence",pcVar8);
}
goto LAB_0015f511;
}
if ((int)uVar4 < 0) {
local_68 = local_68 + 1;
uVar4 = (uint)bVar2;
}
}
else {
if (((uVar4 == 0x24) && (param_2 == 0x60)) && (*pbVar1 == 0x7b)) {
pbVar1 = local_68 + 2;
goto LAB_0015f4ad;
}
local_68 = pbVar1;
if ((char)uVar4 < '\0') {
uVar4 = utf8_decode(pbVar3,&local_60);
if (local_60 == local_68) {
LAB_0015f4da:
if (param_3 == 0) goto LAB_0015f511;
pcVar8 = "invalid UTF-8 sequence";
goto LAB_0015f507;
}
local_68 = local_60;
}
}
LAB_0015f442:
iVar5 = string_buffer_putc(&local_58,uVar4);
pbVar6 = local_68;
if (iVar5 != 0) goto LAB_0015f511;
LAB_0015f455:
local_68 = pbVar6;
pbVar6 = (byte *)param_1[0xf];
if (pbVar6 <= local_68) goto LAB_0015f4fb;
goto LAB_0015f2af;
}
| |
24,853 | js_parse_string | bluesky950520[P]quickjs/quickjs.c | static __exception int js_parse_string(JSParseState *s, int sep,
BOOL do_throw, const uint8_t *p,
JSToken *token, const uint8_t **pp)
{
const uint8_t *p_next;
int ret;
uint32_t c;
StringBuffer b_s, *b = &b_s;
/* string */
if (string_buffer_init(s->ctx, b, 32))
goto fail;
for(;;) {
if (p >= s->buf_end)
goto invalid_char;
c = *p;
if (c < 0x20) {
if (sep == '`') {
if (c == '\r') {
if (p[1] == '\n')
p++;
c = '\n';
}
/* do not update s->line_num */
} else if (c == '\n' || c == '\r')
goto invalid_char;
}
p++;
if (c == sep)
break;
if (c == '$' && *p == '{' && sep == '`') {
/* template start or middle part */
p++;
break;
}
if (c == '\\') {
c = *p;
switch(c) {
case '\0':
if (p >= s->buf_end) {
if (sep != '`')
goto invalid_char;
if (do_throw)
js_parse_error(s, "Unexpected end of input");
goto fail;
}
p++;
break;
case '\'':
case '\"':
case '\\':
p++;
break;
case '\r': /* accept DOS and MAC newline sequences */
if (p[1] == '\n') {
p++;
}
/* fall thru */
case '\n':
/* ignore escaped newline sequence */
p++;
if (sep != '`') {
s->line_num++;
s->eol = &p[-1];
s->mark = p;
}
continue;
default:
if (c == '0' && !(p[1] >= '0' && p[1] <= '9')) {
/* accept isolated \0 */
p++;
c = '\0';
} else
if ((c >= '0' && c <= '9')
&& (s->cur_func->is_strict_mode || sep == '`')) {
if (do_throw) {
js_parse_error(s, "%s are not allowed in %s",
(c >= '8') ? "\\8 and \\9" : "Octal escape sequences",
(sep == '`') ? "template strings" : "strict mode");
}
goto fail;
} else if (c >= 0x80) {
c = utf8_decode(p, &p_next);
if (p_next == p + 1) {
goto invalid_utf8;
}
p = p_next;
/* LS or PS are skipped */
if (c == CP_LS || c == CP_PS)
continue;
} else {
ret = lre_parse_escape(&p, TRUE);
if (ret == -1) {
if (do_throw) {
js_parse_error(s, "Invalid %s escape sequence",
c == 'u' ? "Unicode" : "hexadecimal");
}
goto fail;
} else if (ret < 0) {
/* ignore the '\' (could output a warning) */
p++;
} else {
c = ret;
}
}
break;
}
} else if (c >= 0x80) {
c = utf8_decode(p - 1, &p_next);
if (p_next == p)
goto invalid_utf8;
p = p_next;
}
if (string_buffer_putc(b, c))
goto fail;
}
token->val = TOK_STRING;
token->u.str.sep = c;
token->u.str.str = string_buffer_end(b);
*pp = p;
return 0;
invalid_utf8:
if (do_throw)
js_parse_error(s, "invalid UTF-8 sequence");
goto fail;
invalid_char:
if (do_throw)
js_parse_error(s, "unexpected end of string");
fail:
string_buffer_free(b);
return -1;
} | O2 | c | js_parse_string:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, 0x20(%rsp)
movq %r8, %r15
movq %rcx, %r14
movl %edx, 0x14(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
movq %rcx, 0x8(%rsp)
movq (%rdi), %rdi
leaq 0x28(%rsp), %rsi
pushq $0x20
popq %rdx
callq 0x2e042
testl %eax, %eax
je 0x51543
leaq 0x28(%rsp), %rdi
callq 0x2ef01
pushq $-0x1
popq %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28(%rsp), %r13
movq 0x78(%rbx), %rax
cmpq %rax, %r14
jae 0x517e0
movzbl (%r14), %ecx
cmpl $0x1f, %ecx
ja 0x51588
cmpl $0x60, %ebp
jne 0x51576
cmpb $0xd, %cl
jne 0x51588
cmpb $0xa, 0x1(%r14)
jne 0x51572
incq %r14
movb $0xa, %cl
jmp 0x51588
cmpl $0xa, %ecx
je 0x517e0
cmpl $0xd, %ecx
je 0x517e0
movzbl %cl, %r12d
leaq 0x1(%r14), %rdi
movq %rdi, 0x8(%rsp)
cmpl %ebp, %r12d
je 0x5174b
cmpl $0x5c, %r12d
je 0x515ca
cmpl $0x24, %r12d
jne 0x51609
pushq $0x24
popq %rax
movl %eax, %r12d
cmpl $0x60, %ebp
jne 0x516eb
cmpb $0x7b, (%rdi)
movl %eax, %r12d
jne 0x516eb
jmp 0x5173f
movzbl (%rdi), %r12d
cmpl $0x5c, %r12d
je 0x5163b
cmpl $0xa, %r12d
je 0x5169a
cmpl $0xd, %r12d
je 0x5168c
cmpl $0x22, %r12d
je 0x5163b
cmpl $0x27, %r12d
je 0x5163b
cmpl $0x30, %r12d
je 0x51649
testl %r12d, %r12d
jne 0x51664
cmpq %rax, %rdi
jb 0x51653
jmp 0x517c7
testb %cl, %cl
jns 0x516eb
movq %r14, %rdi
leaq 0x18(%rsp), %rsi
callq 0x15f80
movl %eax, %r12d
movq 0x18(%rsp), %rax
cmpq 0x8(%rsp), %rax
je 0x5177c
movq %rax, 0x8(%rsp)
jmp 0x516eb
addq $0x2, %r14
movq %r14, 0x8(%rsp)
jmp 0x516eb
movb 0x2(%r14), %al
addb $-0x30, %al
cmpb $0xa, %al
jb 0x5166d
addq $0x2, %r14
movq %r14, 0x8(%rsp)
xorl %r12d, %r12d
jmp 0x516eb
leal -0x30(%r12), %eax
cmpb $0x9, %al
ja 0x516c2
cmpl $0x60, %ebp
je 0x51801
movq 0x90(%rbx), %rax
cmpw $0x0, 0x84(%rax)
jns 0x516c7
jmp 0x51801
cmpb $0xa, 0x2(%r14)
jne 0x5169a
addq $0x2, %r14
movq %r14, %rdi
leaq 0x1(%rdi), %r14
movq %r14, 0x8(%rsp)
cmpl $0x60, %ebp
je 0x51548
incl 0x10(%rbx)
movq %rdi, 0x80(%rbx)
movq %r14, 0x88(%rbx)
jmp 0x51548
testb %r12b, %r12b
js 0x51708
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x7b936
cmpl $-0x1, %eax
je 0x51790
testl %eax, %eax
js 0x516e6
movl %eax, %r12d
jmp 0x516eb
incq 0x8(%rsp)
movq %r13, %rdi
movl %r12d, %esi
callq 0x2ca82
testl %eax, %eax
jne 0x51527
movq 0x8(%rsp), %r14
jmp 0x51548
leaq 0x18(%rsp), %rsi
callq 0x15f80
movl %eax, %r12d
movq 0x18(%rsp), %r14
movq 0x8(%rsp), %rax
incq %rax
cmpq %rax, %r14
je 0x5177c
movq %r14, 0x8(%rsp)
movl %r12d, %eax
andl $-0x2, %eax
cmpl $0x2028, %eax # imm = 0x2028
je 0x51548
jmp 0x516eb
addq $0x2, %r14
movq %r14, 0x8(%rsp)
pushq $0x24
popq %rbp
movl $0xffffff81, (%r15) # imm = 0xFFFFFF81
movl %ebp, 0x28(%r15)
leaq 0x28(%rsp), %rdi
callq 0x2cad4
movq %rax, 0x18(%r15)
movq %rdx, 0x20(%r15)
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rax, (%rcx)
xorl %eax, %eax
jmp 0x51534
cmpl $0x0, 0x14(%rsp)
je 0x51527
leaq 0x35fcc(%rip), %rsi # 0x8775a
jmp 0x517f2
cmpl $0x0, 0x14(%rsp)
je 0x51527
cmpl $0x75, %r12d
leaq 0x36062(%rip), %rax # 0x87808
leaq 0x36063(%rip), %rdx # 0x87810
cmoveq %rax, %rdx
leaq 0x36035(%rip), %rsi # 0x877ed
movq %rbx, %rdi
xorl %eax, %eax
callq 0x28457
jmp 0x51527
cmpl $0x60, %ebp
jne 0x517e0
cmpl $0x0, 0x14(%rsp)
je 0x51527
leaq 0x35fac(%rip), %rsi # 0x8778a
jmp 0x517f2
cmpl $0x0, 0x14(%rsp)
je 0x51527
leaq 0x35f7f(%rip), %rsi # 0x87771
movq %rbx, %rdi
xorl %eax, %eax
callq 0x28457
jmp 0x51527
cmpl $0x0, 0x14(%rsp)
je 0x51527
cmpb $0x38, %r12b
leaq 0x35fa4(%rip), %rax # 0x877bb
leaq 0x35fa7(%rip), %rdx # 0x877c5
cmovaeq %rax, %rdx
cmpl $0x60, %ebp
leaq 0x35fb0(%rip), %rax # 0x877dc
leaq 0x35ebd(%rip), %rcx # 0x876f0
cmoveq %rax, %rcx
leaq 0x35f64(%rip), %rsi # 0x877a2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x28457
jmp 0x51527
| js_parse_string:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov [rsp+78h+var_58], r9
mov r15, r8
mov r14, rcx
mov [rsp+78h+var_64], edx
mov ebp, esi
mov rbx, rdi
mov [rsp+78h+var_70], rcx
mov rdi, [rdi]
lea rsi, [rsp+78h+var_50]
push 20h ; ' '
pop rdx
call string_buffer_init
test eax, eax
jz short loc_51543
loc_51527:
lea rdi, [rsp+78h+var_50]
call string_buffer_free
push 0FFFFFFFFFFFFFFFFh
pop rax
loc_51534:
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_51543:
lea r13, [rsp+78h+var_50]
loc_51548:
mov rax, [rbx+78h]
cmp r14, rax
jnb loc_517E0
movzx ecx, byte ptr [r14]
cmp ecx, 1Fh
ja short loc_51588
cmp ebp, 60h ; '`'
jnz short loc_51576
cmp cl, 0Dh
jnz short loc_51588
cmp byte ptr [r14+1], 0Ah
jnz short loc_51572
inc r14
loc_51572:
mov cl, 0Ah
jmp short loc_51588
loc_51576:
cmp ecx, 0Ah
jz loc_517E0
cmp ecx, 0Dh
jz loc_517E0
loc_51588:
movzx r12d, cl
lea rdi, [r14+1]
mov [rsp+78h+var_70], rdi
cmp r12d, ebp
jz loc_5174B
cmp r12d, 5Ch ; '\'
jz short loc_515CA
cmp r12d, 24h ; '$'
jnz short loc_51609
push 24h ; '$'
pop rax
mov r12d, eax
cmp ebp, 60h ; '`'
jnz loc_516EB
cmp byte ptr [rdi], 7Bh ; '{'
mov r12d, eax
jnz loc_516EB
jmp loc_5173F
loc_515CA:
movzx r12d, byte ptr [rdi]
cmp r12d, 5Ch ; '\'
jz short loc_5163B
cmp r12d, 0Ah
jz loc_5169A
cmp r12d, 0Dh
jz loc_5168C
cmp r12d, 22h ; '"'
jz short loc_5163B
cmp r12d, 27h ; '''
jz short loc_5163B
cmp r12d, 30h ; '0'
jz short loc_51649
test r12d, r12d
jnz short loc_51664
cmp rdi, rax
jb short loc_51653
jmp loc_517C7
loc_51609:
test cl, cl
jns loc_516EB
mov rdi, r14
lea rsi, [rsp+78h+var_60]
call utf8_decode
mov r12d, eax
mov rax, [rsp+78h+var_60]
cmp rax, [rsp+78h+var_70]
jz loc_5177C
mov [rsp+78h+var_70], rax
jmp loc_516EB
loc_5163B:
add r14, 2
mov [rsp+78h+var_70], r14
jmp loc_516EB
loc_51649:
mov al, [r14+2]
add al, 0D0h
cmp al, 0Ah
jb short loc_5166D
loc_51653:
add r14, 2
mov [rsp+78h+var_70], r14
xor r12d, r12d
jmp loc_516EB
loc_51664:
lea eax, [r12-30h]
cmp al, 9
ja short loc_516C2
loc_5166D:
cmp ebp, 60h ; '`'
jz loc_51801
mov rax, [rbx+90h]
cmp word ptr [rax+84h], 0
jns short loc_516C7
jmp loc_51801
loc_5168C:
cmp byte ptr [r14+2], 0Ah
jnz short loc_5169A
add r14, 2
mov rdi, r14
loc_5169A:
lea r14, [rdi+1]
mov [rsp+78h+var_70], r14
cmp ebp, 60h ; '`'
jz loc_51548
inc dword ptr [rbx+10h]
mov [rbx+80h], rdi
mov [rbx+88h], r14
jmp loc_51548
loc_516C2:
test r12b, r12b
js short loc_51708
loc_516C7:
lea rdi, [rsp+78h+var_70]
push 1
pop rsi
call lre_parse_escape
cmp eax, 0FFFFFFFFh
jz loc_51790
test eax, eax
js short loc_516E6
mov r12d, eax
jmp short loc_516EB
loc_516E6:
inc [rsp+78h+var_70]
loc_516EB:
mov rdi, r13
mov esi, r12d
call string_buffer_putc
test eax, eax
jnz loc_51527
mov r14, [rsp+78h+var_70]
jmp loc_51548
loc_51708:
lea rsi, [rsp+78h+var_60]
call utf8_decode
mov r12d, eax
mov r14, [rsp+78h+var_60]
mov rax, [rsp+78h+var_70]
inc rax
cmp r14, rax
jz short loc_5177C
mov [rsp+78h+var_70], r14
mov eax, r12d
and eax, 0FFFFFFFEh
cmp eax, 2028h
jz loc_51548
jmp short loc_516EB
loc_5173F:
add r14, 2
mov [rsp+78h+var_70], r14
push 24h ; '$'
pop rbp
loc_5174B:
mov dword ptr [r15], 0FFFFFF81h
mov [r15+28h], ebp
lea rdi, [rsp+78h+var_50]
call string_buffer_end
mov [r15+18h], rax
mov [r15+20h], rdx
mov rax, [rsp+78h+var_70]
mov rcx, [rsp+78h+var_58]
mov [rcx], rax
xor eax, eax
jmp loc_51534
loc_5177C:
cmp [rsp+78h+var_64], 0
jz loc_51527
lea rsi, aInvalidUtf8Seq; "invalid UTF-8 sequence"
jmp short loc_517F2
loc_51790:
cmp [rsp+78h+var_64], 0
jz loc_51527
cmp r12d, 75h ; 'u'
lea rax, aUnicode; "Unicode"
lea rdx, aHexadecimal; "hexadecimal"
cmovz rdx, rax
lea rsi, aInvalidSEscape; "Invalid %s escape sequence"
mov rdi, rbx
xor eax, eax
call js_parse_error
jmp loc_51527
loc_517C7:
cmp ebp, 60h ; '`'
jnz short loc_517E0
cmp [rsp+78h+var_64], 0
jz loc_51527
lea rsi, aUnexpectedEndO_2; "Unexpected end of input"
jmp short loc_517F2
loc_517E0:
cmp [rsp+78h+var_64], 0
jz loc_51527
lea rsi, aUnexpectedEndO_1; "unexpected end of string"
loc_517F2:
mov rdi, rbx
xor eax, eax
call js_parse_error
jmp loc_51527
loc_51801:
cmp [rsp+78h+var_64], 0
jz loc_51527
cmp r12b, 38h ; '8'
lea rax, a8And9; "\\8 and \\9"
lea rdx, aOctalEscapeSeq; "Octal escape sequences"
cmovnb rdx, rax
cmp ebp, 60h ; '`'
lea rax, aTemplateString; "template strings"
lea rcx, aOctalLiteralsA+22h; "strict mode"
cmovz rcx, rax
lea rsi, aSAreNotAllowed; "%s are not allowed in %s"
mov rdi, rbx
xor eax, eax
call js_parse_error
jmp loc_51527
| long long js_parse_string(
long long a1,
int a2,
int a3,
char *a4,
long long a5,
char **a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14)
{
char *v15; // r14
int v16; // ebp
long long v18; // rdx
long long v19; // rcx
long long v20; // r8
long long v21; // r9
__m128 v22; // xmm4
__m128 v23; // xmm5
unsigned long long v25; // rax
unsigned int v26; // r12d
char *v27; // rdi
int v28; // eax
long long v29; // rcx
long long v30; // r8
long long v31; // r9
__m128 v32; // xmm4
__m128 v33; // xmm5
long long v34; // rdx
const char *v35; // rsi
const char *v36; // rdx
const char *v37; // rdx
char *v38; // rcx
char v39; // [rsp+0h] [rbp-78h]
char *v40; // [rsp+8h] [rbp-70h] BYREF
int v41; // [rsp+14h] [rbp-64h]
char *v42; // [rsp+18h] [rbp-60h] BYREF
char **v43; // [rsp+20h] [rbp-58h]
long long v44[10]; // [rsp+28h] [rbp-50h] BYREF
v43 = a6;
v15 = a4;
v41 = a3;
v16 = a2;
v40 = a4;
if ( !(unsigned int)string_buffer_init(*(_QWORD *)a1, (long long)v44, 0x20u) )
{
while ( 1 )
{
while ( 1 )
{
v25 = *(_QWORD *)(a1 + 120);
if ( (unsigned long long)v15 >= v25 )
goto LABEL_61;
v19 = (unsigned __int8)*v15;
if ( (unsigned int)v19 <= 0x1F )
{
if ( a2 == 96 )
{
if ( (_BYTE)v19 == 13 )
{
if ( v15[1] == 10 )
++v15;
LOBYTE(v19) = 10;
}
}
else if ( (_DWORD)v19 == 10 || (_DWORD)v19 == 13 )
{
goto LABEL_61;
}
}
v26 = (unsigned __int8)v19;
v27 = v15 + 1;
v40 = v15 + 1;
if ( (unsigned __int8)v19 == a2 )
goto LABEL_51;
if ( (unsigned __int8)v19 != 92 )
{
if ( (unsigned __int8)v19 == 36 )
{
v26 = 36;
if ( a2 == 96 )
{
v26 = 36;
if ( *v27 == 123 )
{
v40 = v15 + 2;
v16 = 36;
LABEL_51:
*(_DWORD *)a5 = -127;
*(_DWORD *)(a5 + 40) = v16;
*(_QWORD *)(a5 + 24) = string_buffer_end(v44);
*(_QWORD *)(a5 + 32) = v34;
*v43 = v40;
return 0LL;
}
}
}
else if ( (v19 & 0x80u) != 0LL )
{
v26 = utf8_decode(v15, &v42);
if ( v42 == v40 )
goto LABEL_52;
v40 = v42;
}
goto LABEL_46;
}
v26 = (unsigned __int8)*v27;
if ( v26 == 92 )
goto LABEL_30;
if ( v26 != 10 )
break;
LABEL_39:
v15 = v27 + 1;
v40 = v27 + 1;
if ( a2 != 96 )
{
++*(_DWORD *)(a1 + 16);
*(_QWORD *)(a1 + 128) = v27;
*(_QWORD *)(a1 + 136) = v15;
}
}
switch ( v26 )
{
case 0xDu:
if ( v15[2] == 10 )
v27 = v15 + 2;
goto LABEL_39;
case 0x22u:
case 0x27u:
LABEL_30:
v40 = v15 + 2;
goto LABEL_46;
case 0x30u:
if ( (unsigned __int8)(v15[2] - 48) >= 0xAu )
goto LABEL_32;
LABEL_34:
if ( a2 == 96 || *(__int16 *)(*(_QWORD *)(a1 + 144) + 132LL) < 0 )
{
if ( v41 )
{
v37 = "Octal escape sequences";
if ( (unsigned __int8)v26 >= 0x38u )
v37 = "\\8 and \\9";
v38 = "strict mode";
if ( a2 == 96 )
v38 = "template strings";
js_parse_error(
(long long *)a1,
(long long)"%s are not allowed in %s",
(long long)v37,
(long long)v38,
v20,
v21,
a7,
a8,
a9,
a10,
v22,
v23,
a13,
a14,
v39);
}
goto LABEL_2;
}
LABEL_42:
v28 = lre_parse_escape(&v40, 1LL);
if ( v28 == -1 )
{
if ( v41 )
{
v36 = "hexadecimal";
if ( v26 == 117 )
v36 = "Unicode";
js_parse_error(
(long long *)a1,
(long long)"Invalid %s escape sequence",
(long long)v36,
v29,
v30,
v31,
a7,
a8,
a9,
a10,
v32,
v33,
a13,
a14,
v39);
}
goto LABEL_2;
}
if ( v28 < 0 )
++v40;
else
v26 = v28;
goto LABEL_46;
}
if ( !*v27 )
{
if ( (unsigned long long)v27 >= v25 )
{
if ( a2 == 96 )
{
if ( !v41 )
break;
v35 = "Unexpected end of input";
}
else
{
LABEL_61:
if ( !v41 )
break;
v35 = "unexpected end of string";
}
LABEL_63:
js_parse_error((long long *)a1, (long long)v35, v18, v19, v20, v21, a7, a8, a9, a10, v22, v23, a13, a14, v39);
break;
}
LABEL_32:
v40 = v15 + 2;
v26 = 0;
goto LABEL_46;
}
if ( (unsigned __int8)(v26 - 48) <= 9u )
goto LABEL_34;
if ( (v26 & 0x80u) == 0 )
goto LABEL_42;
v26 = utf8_decode(v27, &v42);
v15 = v42;
if ( v42 == v40 + 1 )
{
LABEL_52:
if ( !v41 )
break;
v35 = "invalid UTF-8 sequence";
goto LABEL_63;
}
v40 = v42;
if ( (v26 & 0xFFFFFFFE) != 0x2028 )
{
LABEL_46:
if ( (unsigned int)string_buffer_putc((long long)v44, v26) )
break;
v15 = v40;
}
}
}
LABEL_2:
string_buffer_free(v44);
return -1LL;
}
| js_parse_string:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RSP + 0x20],R9
MOV R15,R8
MOV R14,RCX
MOV dword ptr [RSP + 0x14],EDX
MOV EBP,ESI
MOV RBX,RDI
MOV qword ptr [RSP + 0x8],RCX
MOV RDI,qword ptr [RDI]
LEA RSI,[RSP + 0x28]
PUSH 0x20
POP RDX
CALL 0x0012e042
TEST EAX,EAX
JZ 0x00151543
LAB_00151527:
LEA RDI,[RSP + 0x28]
CALL 0x0012ef01
PUSH -0x1
POP RAX
LAB_00151534:
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00151543:
LEA R13,[RSP + 0x28]
LAB_00151548:
MOV RAX,qword ptr [RBX + 0x78]
CMP R14,RAX
JNC 0x001517e0
MOVZX ECX,byte ptr [R14]
CMP ECX,0x1f
JA 0x00151588
CMP EBP,0x60
JNZ 0x00151576
CMP CL,0xd
JNZ 0x00151588
CMP byte ptr [R14 + 0x1],0xa
JNZ 0x00151572
INC R14
LAB_00151572:
MOV CL,0xa
JMP 0x00151588
LAB_00151576:
CMP ECX,0xa
JZ 0x001517e0
CMP ECX,0xd
JZ 0x001517e0
LAB_00151588:
MOVZX R12D,CL
LEA RDI,[R14 + 0x1]
MOV qword ptr [RSP + 0x8],RDI
CMP R12D,EBP
JZ 0x0015174b
CMP R12D,0x5c
JZ 0x001515ca
CMP R12D,0x24
JNZ 0x00151609
PUSH 0x24
POP RAX
MOV R12D,EAX
CMP EBP,0x60
JNZ 0x001516eb
CMP byte ptr [RDI],0x7b
MOV R12D,EAX
JNZ 0x001516eb
JMP 0x0015173f
LAB_001515ca:
MOVZX R12D,byte ptr [RDI]
CMP R12D,0x5c
JZ 0x0015163b
CMP R12D,0xa
JZ 0x0015169a
CMP R12D,0xd
JZ 0x0015168c
CMP R12D,0x22
JZ 0x0015163b
CMP R12D,0x27
JZ 0x0015163b
CMP R12D,0x30
JZ 0x00151649
TEST R12D,R12D
JNZ 0x00151664
CMP RDI,RAX
JC 0x00151653
JMP 0x001517c7
LAB_00151609:
TEST CL,CL
JNS 0x001516eb
MOV RDI,R14
LEA RSI,[RSP + 0x18]
CALL 0x00115f80
MOV R12D,EAX
MOV RAX,qword ptr [RSP + 0x18]
CMP RAX,qword ptr [RSP + 0x8]
JZ 0x0015177c
MOV qword ptr [RSP + 0x8],RAX
JMP 0x001516eb
LAB_0015163b:
ADD R14,0x2
MOV qword ptr [RSP + 0x8],R14
JMP 0x001516eb
LAB_00151649:
MOV AL,byte ptr [R14 + 0x2]
ADD AL,0xd0
CMP AL,0xa
JC 0x0015166d
LAB_00151653:
ADD R14,0x2
MOV qword ptr [RSP + 0x8],R14
XOR R12D,R12D
JMP 0x001516eb
LAB_00151664:
LEA EAX,[R12 + -0x30]
CMP AL,0x9
JA 0x001516c2
LAB_0015166d:
CMP EBP,0x60
JZ 0x00151801
MOV RAX,qword ptr [RBX + 0x90]
CMP word ptr [RAX + 0x84],0x0
JNS 0x001516c7
JMP 0x00151801
LAB_0015168c:
CMP byte ptr [R14 + 0x2],0xa
JNZ 0x0015169a
ADD R14,0x2
MOV RDI,R14
LAB_0015169a:
LEA R14,[RDI + 0x1]
MOV qword ptr [RSP + 0x8],R14
CMP EBP,0x60
JZ 0x00151548
INC dword ptr [RBX + 0x10]
MOV qword ptr [RBX + 0x80],RDI
MOV qword ptr [RBX + 0x88],R14
JMP 0x00151548
LAB_001516c2:
TEST R12B,R12B
JS 0x00151708
LAB_001516c7:
LEA RDI,[RSP + 0x8]
PUSH 0x1
POP RSI
CALL 0x0017b936
CMP EAX,-0x1
JZ 0x00151790
TEST EAX,EAX
JS 0x001516e6
MOV R12D,EAX
JMP 0x001516eb
LAB_001516e6:
INC qword ptr [RSP + 0x8]
LAB_001516eb:
MOV RDI,R13
MOV ESI,R12D
CALL 0x0012ca82
TEST EAX,EAX
JNZ 0x00151527
MOV R14,qword ptr [RSP + 0x8]
JMP 0x00151548
LAB_00151708:
LEA RSI,[RSP + 0x18]
CALL 0x00115f80
MOV R12D,EAX
MOV R14,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RSP + 0x8]
INC RAX
CMP R14,RAX
JZ 0x0015177c
MOV qword ptr [RSP + 0x8],R14
MOV EAX,R12D
AND EAX,0xfffffffe
CMP EAX,0x2028
JZ 0x00151548
JMP 0x001516eb
LAB_0015173f:
ADD R14,0x2
MOV qword ptr [RSP + 0x8],R14
PUSH 0x24
POP RBP
LAB_0015174b:
MOV dword ptr [R15],0xffffff81
MOV dword ptr [R15 + 0x28],EBP
LEA RDI,[RSP + 0x28]
CALL 0x0012cad4
MOV qword ptr [R15 + 0x18],RAX
MOV qword ptr [R15 + 0x20],RDX
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x20]
MOV qword ptr [RCX],RAX
XOR EAX,EAX
JMP 0x00151534
LAB_0015177c:
CMP dword ptr [RSP + 0x14],0x0
JZ 0x00151527
LEA RSI,[0x18775a]
JMP 0x001517f2
LAB_00151790:
CMP dword ptr [RSP + 0x14],0x0
JZ 0x00151527
CMP R12D,0x75
LEA RAX,[0x187808]
LEA RDX,[0x187810]
CMOVZ RDX,RAX
LEA RSI,[0x1877ed]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x00128457
JMP 0x00151527
LAB_001517c7:
CMP EBP,0x60
JNZ 0x001517e0
CMP dword ptr [RSP + 0x14],0x0
JZ 0x00151527
LEA RSI,[0x18778a]
JMP 0x001517f2
LAB_001517e0:
CMP dword ptr [RSP + 0x14],0x0
JZ 0x00151527
LEA RSI,[0x187771]
LAB_001517f2:
MOV RDI,RBX
XOR EAX,EAX
CALL 0x00128457
JMP 0x00151527
LAB_00151801:
CMP dword ptr [RSP + 0x14],0x0
JZ 0x00151527
CMP R12B,0x38
LEA RAX,[0x1877bb]
LEA RDX,[0x1877c5]
CMOVNC RDX,RAX
CMP EBP,0x60
LEA RAX,[0x1877dc]
LEA RCX,[0x1876f0]
CMOVZ RCX,RAX
LEA RSI,[0x1877a2]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x00128457
JMP 0x00151527
|
int8
js_parse_string(int8 *param_1,uint param_2,int param_3,byte *param_4,int4 *param_5,
ulong *param_6)
{
byte bVar1;
byte *pbVar2;
int iVar3;
uint uVar4;
char *pcVar5;
char *pcVar6;
int1 auVar7 [16];
byte *local_70;
int local_64;
byte *local_60;
ulong *local_58;
int1 local_50 [32];
local_70 = param_4;
local_64 = param_3;
local_58 = param_6;
iVar3 = string_buffer_init(*param_1,local_50,0x20);
if (iVar3 == 0) {
pbVar2 = local_70;
LAB_00151548:
do {
local_70 = pbVar2;
if ((byte *)param_1[0xf] <= param_4) {
LAB_001517e0:
if (local_64 != 0) {
pcVar6 = "unexpected end of string";
LAB_001517f2:
js_parse_error(param_1,pcVar6);
}
break;
}
bVar1 = *param_4;
uVar4 = (uint)bVar1;
if (bVar1 < 0x20) {
if (param_2 == 0x60) {
if (bVar1 == 0xd) {
if (param_4[1] == 10) {
param_4 = param_4 + 1;
}
uVar4 = 10;
}
}
else if ((bVar1 == 10) || (bVar1 == 0xd)) goto LAB_001517e0;
}
local_70 = param_4 + 1;
if (uVar4 == param_2) {
LAB_0015174b:
*param_5 = 0xffffff81;
param_5[10] = param_2;
auVar7 = string_buffer_end(local_50);
*(int1 (*) [16])(param_5 + 6) = auVar7;
*local_58 = (ulong)local_70;
return 0;
}
if (uVar4 == 0x5c) {
bVar1 = *local_70;
if (bVar1 != 0x5c) {
if (bVar1 != 10) {
if (bVar1 != 0xd) {
if ((bVar1 == 0x22) || (bVar1 == 0x27)) goto LAB_0015163b;
if (bVar1 == 0x30) {
if ((byte)(param_4[2] - 0x30) < 10) {
LAB_0015166d:
if ((param_2 != 0x60) && (-1 < *(short *)(param_1[0x12] + 0x84)))
goto LAB_001516c7;
if (local_64 != 0) {
pcVar6 = "Octal escape sequences";
if (0x37 < bVar1) {
pcVar6 = "\\8 and \\9";
}
pcVar5 = "strict mode";
if (param_2 == 0x60) {
pcVar5 = "template strings";
}
js_parse_error(param_1,"%s are not allowed in %s",pcVar6,pcVar5);
}
break;
}
}
else {
if (bVar1 != 0) {
if ((byte)(bVar1 - 0x30) < 10) goto LAB_0015166d;
if (-1 < (char)bVar1) {
LAB_001516c7:
uVar4 = lre_parse_escape(&local_70,1);
if (uVar4 != 0xffffffff) {
if ((int)uVar4 < 0) {
local_70 = local_70 + 1;
uVar4 = (uint)bVar1;
}
goto LAB_001516eb;
}
if (local_64 != 0) {
pcVar6 = "hexadecimal";
if (bVar1 == 0x75) {
pcVar6 = "Unicode";
}
js_parse_error(param_1,"Invalid %s escape sequence",pcVar6);
}
break;
}
uVar4 = utf8_decode(local_70,&local_60);
if (local_60 == local_70 + 1) goto LAB_0015177c;
local_70 = local_60;
param_4 = local_60;
pbVar2 = local_60;
if ((uVar4 & 0xfffffffe) != 0x2028) goto LAB_001516eb;
goto LAB_00151548;
}
if ((byte *)param_1[0xf] <= local_70) {
if (param_2 != 0x60) goto LAB_001517e0;
if (local_64 != 0) {
pcVar6 = "Unexpected end of input";
goto LAB_001517f2;
}
break;
}
}
local_70 = param_4 + 2;
uVar4 = 0;
goto LAB_001516eb;
}
if (param_4[2] == 10) {
local_70 = param_4 + 2;
}
}
param_4 = local_70 + 1;
pbVar2 = param_4;
if (param_2 != 0x60) {
*(int *)(param_1 + 2) = *(int *)(param_1 + 2) + 1;
param_1[0x10] = local_70;
param_1[0x11] = param_4;
pbVar2 = param_4;
}
goto LAB_00151548;
}
LAB_0015163b:
local_70 = param_4 + 2;
uVar4 = (uint)bVar1;
}
else if (uVar4 == 0x24) {
uVar4 = 0x24;
if ((param_2 == 0x60) && (uVar4 = 0x24, *local_70 == 0x7b)) {
local_70 = param_4 + 2;
param_2 = 0x24;
goto LAB_0015174b;
}
}
else if ((char)uVar4 < '\0') {
uVar4 = utf8_decode(param_4,&local_60);
if (local_60 == local_70) {
LAB_0015177c:
if (local_64 != 0) {
pcVar6 = "invalid UTF-8 sequence";
goto LAB_001517f2;
}
break;
}
local_70 = local_60;
}
LAB_001516eb:
iVar3 = string_buffer_putc(local_50,uVar4);
param_4 = local_70;
pbVar2 = local_70;
} while (iVar3 == 0);
}
string_buffer_free(local_50);
return 0xffffffffffffffff;
}
| |
24,854 | JS_ArraySpeciesCreate | bluesky950520[P]quickjs/quickjs.c | static JSValue JS_ArraySpeciesCreate(JSContext *ctx, JSValue obj,
JSValue len_val)
{
JSValue ctor, ret, species;
int res;
JSContext *realm;
res = JS_IsArray(ctx, obj);
if (res < 0)
return JS_EXCEPTION;
if (!res)
return js_array_constructor(ctx, JS_UNDEFINED, 1, &len_val);
ctor = JS_GetProperty(ctx, obj, JS_ATOM_constructor);
if (JS_IsException(ctor))
return ctor;
if (JS_IsConstructor(ctx, ctor)) {
/* legacy web compatibility */
realm = JS_GetFunctionRealm(ctx, ctor);
if (!realm) {
JS_FreeValue(ctx, ctor);
return JS_EXCEPTION;
}
if (realm != ctx &&
js_same_value(ctx, ctor, realm->array_ctor)) {
JS_FreeValue(ctx, ctor);
ctor = JS_UNDEFINED;
}
}
if (JS_IsObject(ctor)) {
species = JS_GetProperty(ctx, ctor, JS_ATOM_Symbol_species);
JS_FreeValue(ctx, ctor);
if (JS_IsException(species))
return species;
ctor = species;
if (JS_IsNull(ctor))
ctor = JS_UNDEFINED;
}
if (JS_IsUndefined(ctor)) {
return js_array_constructor(ctx, JS_UNDEFINED, 1, &len_val);
} else {
ret = JS_CallConstructor(ctx, ctor, 1, &len_val);
JS_FreeValue(ctx, ctor);
return ret;
}
} | O3 | c | JS_ArraySpeciesCreate:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rcx, 0x8(%rsp)
movq %r8, 0x10(%rsp)
cmpl $-0x1, %r14d
jne 0x79bd7
movq %rsi, %r15
movzwl 0x6(%rsi), %ecx
cmpw $0x30, %cx
je 0x79d42
xorl %eax, %eax
cmpw $0x2, %cx
sete %al
testl %eax, %eax
je 0x79bd7
movabsq $-0x100000000, %rbp # imm = 0xFFFFFFFF00000000
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0x3d, %ecx
movq %r15, %r8
movq %r14, %r9
pushq $0x0
pushq $0x0
callq 0x22c0f
addq $0x10, %rsp
movq %rax, %r14
movq %rdx, %r13
movq %rax, %r15
andq %rbp, %r15
cmpl $0x6, %r13d
je 0x79d0c
cmpl $-0x1, %r13d
jne 0x79b60
testb $0x10, 0x5(%r14)
jne 0x79c23
movl %r13d, %edx
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
cmpq %rcx, %rdx
jne 0x79c1b
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movl $0xdd, %ecx
movq %r14, %r8
movq %r13, %r9
pushq $0x0
pushq $0x0
callq 0x22c0f
addq $0x10, %rsp
movq %rdx, %r12
movq 0x18(%rbx), %rdi
movl (%r14), %edx
leal -0x1(%rdx), %ecx
movl %ecx, (%r14)
cmpl $0x1, %edx
jg 0x79bb8
movq %rax, %r15
movq %r14, %rsi
movq %r13, %rdx
callq 0x20d90
movq %r15, %rax
cmpl $0x2, %r12d
je 0x79c88
movq %rax, %r15
andq %rbp, %r15
cmpl $0x6, %r12d
jne 0x79c80
movq %rax, %r14
jmp 0x79c03
leaq 0x8(%rsp), %r8
movl $0x3, %edx
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %ecx
callq 0x38d59
movq %rax, %r14
movq %rdx, %r12
movabsq $-0x100000000, %r15 # imm = 0xFFFFFFFF00000000
andq %rax, %r15
movl %r14d, %eax
orq %r15, %rax
movq %r12, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %r12
movq %r14, %rax
jmp 0x79c83
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x5717d
testq %rax, %rax
je 0x79d14
cmpq %rbx, %rax
je 0x79b60
movq 0x68(%rax), %rcx
movq 0x70(%rax), %r8
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x25ea9
testl %eax, %eax
je 0x79b60
movq 0x18(%rbx), %rdi
movl (%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r14)
cmpl $0x1, %eax
jg 0x79c88
movq %r14, %rsi
movq %r13, %rdx
callq 0x20d90
jmp 0x79c88
movl %r12d, %edx
cmpl $0x3, %edx
jne 0x79cb2
leaq 0x8(%rsp), %r8
movl $0x3, %edx
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %ecx
callq 0x38d59
movq %rax, %r14
movq %rdx, %r12
andq %rax, %rbp
movq %rbp, %r15
jmp 0x79c03
movl %eax, %eax
orq %rax, %r15
leaq 0x8(%rsp), %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r12, %r8
movl $0x1, %r9d
pushq $0x2
pushq %rax
callq 0x2fc36
addq $0x10, %rsp
movq %rax, %r14
movq %rdx, %r13
cmpl $-0x9, %r12d
jb 0x79d06
movq 0x18(%rbx), %rdi
movl (%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r15)
cmpl $0x1, %eax
jg 0x79d06
movq %r15, %rsi
movq %r12, %rdx
callq 0x20d90
andq %r14, %rbp
movq %rbp, %r15
movq %r13, %r12
jmp 0x79c03
movq 0x18(%rbx), %rdi
movl (%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r14)
movl $0x6, %r12d
cmpl $0x1, %eax
jg 0x79d37
movq %r14, %rsi
movq %r13, %rdx
callq 0x20d90
xorl %r14d, %r14d
xorl %r15d, %r15d
jmp 0x79c03
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x27d0d
testl %eax, %eax
jns 0x79b06
movl $0x6, %r12d
jmp 0x79d37
| JS_ArraySpeciesCreate:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r14, rdx
mov rbx, rdi
mov [rsp+48h+var_40], rcx
mov [rsp+48h+var_38], r8
cmp r14d, 0FFFFFFFFh
jnz loc_79BD7
mov r15, rsi
movzx ecx, word ptr [rsi+6]
cmp cx, 30h ; '0'
jz loc_79D42
xor eax, eax
cmp cx, 2
setz al
loc_79B06:
test eax, eax
jz loc_79BD7
mov rbp, 0FFFFFFFF00000000h
mov rdi, rbx
mov rsi, r15
mov rdx, r14
mov ecx, 3Dh ; '='
mov r8, r15
mov r9, r14
push 0
push 0
call JS_GetPropertyInternal2
add rsp, 10h
mov r14, rax
mov r13, rdx
mov r15, rax
and r15, rbp
cmp r13d, 6
jz loc_79D0C
cmp r13d, 0FFFFFFFFh
jnz short loc_79B60
test byte ptr [r14+5], 10h
jnz loc_79C23
loc_79B60:
mov edx, r13d
mov ecx, 0FFFFFFFFh
cmp rdx, rcx
jnz loc_79C1B
mov rdi, rbx
mov rsi, r14
mov rdx, r13
mov ecx, 0DDh
mov r8, r14
mov r9, r13
push 0
push 0
call JS_GetPropertyInternal2
add rsp, 10h
mov r12, rdx
mov rdi, [rbx+18h]
mov edx, [r14]
lea ecx, [rdx-1]
mov [r14], ecx
cmp edx, 1
jg short loc_79BB8
mov r15, rax
mov rsi, r14
mov rdx, r13
call js_free_value_rt
mov rax, r15
loc_79BB8:
cmp r12d, 2
jz loc_79C88
mov r15, rax
and r15, rbp
cmp r12d, 6
jnz loc_79C80
mov r14, rax
jmp short loc_79C03
loc_79BD7:
lea r8, [rsp+48h+var_40]
mov edx, 3
mov rdi, rbx
xor esi, esi
mov ecx, 1
call js_array_constructor
mov r14, rax
mov r12, rdx
mov r15, 0FFFFFFFF00000000h
and r15, rax
loc_79C03:
mov eax, r14d
or rax, r15
mov rdx, r12
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_79C1B:
mov r12, r13
mov rax, r14
jmp short loc_79C83
loc_79C23:
mov rdi, rbx
mov rsi, r14
mov rdx, r13
call JS_GetFunctionRealm
test rax, rax
jz loc_79D14
cmp rax, rbx
jz loc_79B60
mov rcx, [rax+68h]
mov r8, [rax+70h]
mov rdi, rbx
mov rsi, r14
mov rdx, r13
call js_same_value
test eax, eax
jz loc_79B60
mov rdi, [rbx+18h]
mov eax, [r14]
lea ecx, [rax-1]
mov [r14], ecx
cmp eax, 1
jg short loc_79C88
mov rsi, r14
mov rdx, r13
call js_free_value_rt
jmp short loc_79C88
loc_79C80:
mov edx, r12d
loc_79C83:
cmp edx, 3
jnz short loc_79CB2
loc_79C88:
lea r8, [rsp+48h+var_40]
mov edx, 3
mov rdi, rbx
xor esi, esi
mov ecx, 1
call js_array_constructor
mov r14, rax
mov r12, rdx
and rbp, rax
mov r15, rbp
jmp loc_79C03
loc_79CB2:
mov eax, eax
or r15, rax
lea rax, [rsp+48h+var_40]
mov rdi, rbx
mov rsi, r15
mov rdx, r12
mov rcx, r15
mov r8, r12
mov r9d, 1
push 2
push rax
call JS_CallConstructorInternal
add rsp, 10h
mov r14, rax
mov r13, rdx
cmp r12d, 0FFFFFFF7h
jb short loc_79D06
mov rdi, [rbx+18h]
mov eax, [r15]
lea ecx, [rax-1]
mov [r15], ecx
cmp eax, 1
jg short loc_79D06
mov rsi, r15
mov rdx, r12
call js_free_value_rt
loc_79D06:
and rbp, r14
mov r15, rbp
loc_79D0C:
mov r12, r13
jmp loc_79C03
loc_79D14:
mov rdi, [rbx+18h]
mov eax, [r14]
lea ecx, [rax-1]
mov [r14], ecx
mov r12d, 6
cmp eax, 1
jg short loc_79D37
mov rsi, r14
mov rdx, r13
call js_free_value_rt
loc_79D37:
xor r14d, r14d
xor r15d, r15d
jmp loc_79C03
loc_79D42:
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call js_proxy_isArray
test eax, eax
jns loc_79B06
mov r12d, 6
jmp short loc_79D37
| unsigned long long JS_ArraySpeciesCreate(
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 v16; // rcx
int isArray; // eax
unsigned long long PropertyInternal2; // rax
long long v19; // rdx
long long v20; // rcx
long long v21; // r8
long long v22; // r9
unsigned long long v23; // r14
long long v24; // r13
unsigned long long v25; // r15
int v26; // edx
unsigned long long v27; // rax
long long v28; // r8
long long v29; // r9
long long v30; // rdx
long long v31; // r12
long long v32; // rdi
long long v33; // rcx
unsigned long long v34; // r15
unsigned long long v35; // rax
long long FunctionRealm; // rax
long long v38; // r8
long long v39; // r9
long long v40; // r8
long long v41; // r9
long long v42; // rdi
int v43; // eax
long long v44; // rcx
_QWORD *v45; // r15
long long v46; // r8
long long v47; // r9
long long v48; // rdi
int v49; // eax
long long v50; // rcx
long long v51; // rdi
int v52; // eax
long long v53; // rcx
_QWORD v54[8]; // [rsp+8h] [rbp-40h] BYREF
v54[0] = a4;
v54[1] = a5;
if ( (_DWORD)a3 != -1 )
goto LABEL_14;
v16 = *(unsigned __int16 *)(a2 + 6);
if ( (_WORD)v16 == 48 )
{
isArray = js_proxy_isArray(a1, a2, a3, a7, a8, a9, a10, a11, a12, a13, a14, v16, a5, a6);
if ( isArray < 0 )
{
LABEL_32:
LODWORD(v23) = 0;
v25 = 0LL;
return v25 | (unsigned int)v23;
}
}
else
{
isArray = (_WORD)v16 == 2;
}
if ( !isArray )
goto LABEL_14;
PropertyInternal2 = JS_GetPropertyInternal2(a1, a2, a3, 0x3Du, a2, a3, 0LL, 0);
v23 = PropertyInternal2;
v24 = v19;
v25 = PropertyInternal2 & 0xFFFFFFFF00000000LL;
if ( (_DWORD)v19 == 6 )
return v25 | (unsigned int)v23;
if ( (_DWORD)v19 != -1 || (*(_BYTE *)(PropertyInternal2 + 5) & 0x10) == 0 )
goto LABEL_8;
FunctionRealm = JS_GetFunctionRealm(a1, PropertyInternal2, v19, a7, a8, a9, a10, a11, a12, a13, a14, v20, v21, v22);
if ( !FunctionRealm )
{
v51 = *(_QWORD *)(a1 + 24);
v52 = *(_DWORD *)v23;
v53 = (unsigned int)(*(_DWORD *)v23 - 1);
*(_DWORD *)v23 = v53;
if ( v52 <= 1 )
js_free_value_rt(v51, (_QWORD *)v23, v24, v53, v38, v39);
goto LABEL_32;
}
if ( FunctionRealm != a1
&& (unsigned int)js_same_value(
a1,
(_DWORD *)v23,
v24,
*(_DWORD **)(FunctionRealm + 104),
*(_QWORD *)(FunctionRealm + 112)) )
{
v42 = *(_QWORD *)(a1 + 24);
v43 = *(_DWORD *)v23;
v44 = (unsigned int)(*(_DWORD *)v23 - 1);
*(_DWORD *)v23 = v44;
if ( v43 <= 1 )
js_free_value_rt(v42, (_QWORD *)v23, v24, v44, v40, v41);
goto LABEL_14;
}
LABEL_8:
v26 = v24;
if ( (unsigned int)v24 == 0xFFFFFFFFLL )
{
v27 = JS_GetPropertyInternal2(a1, v23, v24, 0xDDu, v23, v24, 0LL, 0);
v31 = v30;
v32 = *(_QWORD *)(a1 + 24);
LODWORD(v30) = *(_DWORD *)v23;
v33 = (unsigned int)(*(_DWORD *)v23 - 1);
*(_DWORD *)v23 = v33;
if ( (int)v30 <= 1 )
{
v34 = v27;
js_free_value_rt(v32, (_QWORD *)v23, v24, v33, v28, v29);
v27 = v34;
}
if ( (_DWORD)v31 == 2 )
goto LABEL_14;
v25 = v27 & 0xFFFFFFFF00000000LL;
if ( (_DWORD)v31 == 6 )
{
LODWORD(v23) = v27;
return v25 | (unsigned int)v23;
}
v26 = v31;
}
else
{
v31 = v24;
LODWORD(v27) = v23;
}
if ( v26 == 3 )
{
LABEL_14:
v35 = js_array_constructor(
a1,
0LL,
3LL,
1,
(long long)v54,
a7,
a8,
a9,
a10,
*(double *)a11.m128_u64,
*(double *)a12.m128_u64,
a13,
a14);
LODWORD(v23) = v35;
v25 = v35 & 0xFFFFFFFF00000000LL;
return v25 | (unsigned int)v23;
}
v45 = (_QWORD *)((unsigned int)v27 | v25);
v23 = JS_CallConstructorInternal(
a1,
(long long)v45,
v31,
(long long)v45,
v31,
1LL,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
(long long)v54,
2);
if ( (unsigned int)v31 >= 0xFFFFFFF7 )
{
v48 = *(_QWORD *)(a1 + 24);
v49 = *(_DWORD *)v45;
v50 = (unsigned int)(*(_DWORD *)v45 - 1);
*(_DWORD *)v45 = v50;
if ( v49 <= 1 )
js_free_value_rt(v48, v45, v31, v50, v46, v47);
}
v25 = v23 & 0xFFFFFFFF00000000LL;
return v25 | (unsigned int)v23;
}
| JS_ArraySpeciesCreate:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R14,RDX
MOV RBX,RDI
MOV qword ptr [RSP + 0x8],RCX
MOV qword ptr [RSP + 0x10],R8
CMP R14D,-0x1
JNZ 0x00179bd7
MOV R15,RSI
MOVZX ECX,word ptr [RSI + 0x6]
CMP CX,0x30
JZ 0x00179d42
XOR EAX,EAX
CMP CX,0x2
SETZ AL
LAB_00179b06:
TEST EAX,EAX
JZ 0x00179bd7
MOV RBP,-0x100000000
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
MOV ECX,0x3d
MOV R8,R15
MOV R9,R14
PUSH 0x0
PUSH 0x0
CALL 0x00122c0f
ADD RSP,0x10
MOV R14,RAX
MOV R13,RDX
MOV R15,RAX
AND R15,RBP
CMP R13D,0x6
JZ 0x00179d0c
CMP R13D,-0x1
JNZ 0x00179b60
TEST byte ptr [R14 + 0x5],0x10
JNZ 0x00179c23
LAB_00179b60:
MOV EDX,R13D
MOV ECX,0xffffffff
CMP RDX,RCX
JNZ 0x00179c1b
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R13
MOV ECX,0xdd
MOV R8,R14
MOV R9,R13
PUSH 0x0
PUSH 0x0
CALL 0x00122c0f
ADD RSP,0x10
MOV R12,RDX
MOV RDI,qword ptr [RBX + 0x18]
MOV EDX,dword ptr [R14]
LEA ECX,[RDX + -0x1]
MOV dword ptr [R14],ECX
CMP EDX,0x1
JG 0x00179bb8
MOV R15,RAX
MOV RSI,R14
MOV RDX,R13
CALL 0x00120d90
MOV RAX,R15
LAB_00179bb8:
CMP R12D,0x2
JZ 0x00179c88
MOV R15,RAX
AND R15,RBP
CMP R12D,0x6
JNZ 0x00179c80
MOV R14,RAX
JMP 0x00179c03
LAB_00179bd7:
LEA R8,[RSP + 0x8]
MOV EDX,0x3
MOV RDI,RBX
XOR ESI,ESI
MOV ECX,0x1
CALL 0x00138d59
MOV R14,RAX
MOV R12,RDX
MOV R15,-0x100000000
AND R15,RAX
LAB_00179c03:
MOV EAX,R14D
OR RAX,R15
MOV RDX,R12
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00179c1b:
MOV R12,R13
MOV RAX,R14
JMP 0x00179c83
LAB_00179c23:
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R13
CALL 0x0015717d
TEST RAX,RAX
JZ 0x00179d14
CMP RAX,RBX
JZ 0x00179b60
MOV RCX,qword ptr [RAX + 0x68]
MOV R8,qword ptr [RAX + 0x70]
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R13
CALL 0x00125ea9
TEST EAX,EAX
JZ 0x00179b60
MOV RDI,qword ptr [RBX + 0x18]
MOV EAX,dword ptr [R14]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R14],ECX
CMP EAX,0x1
JG 0x00179c88
MOV RSI,R14
MOV RDX,R13
CALL 0x00120d90
JMP 0x00179c88
LAB_00179c80:
MOV EDX,R12D
LAB_00179c83:
CMP EDX,0x3
JNZ 0x00179cb2
LAB_00179c88:
LEA R8,[RSP + 0x8]
MOV EDX,0x3
MOV RDI,RBX
XOR ESI,ESI
MOV ECX,0x1
CALL 0x00138d59
MOV R14,RAX
MOV R12,RDX
AND RBP,RAX
MOV R15,RBP
JMP 0x00179c03
LAB_00179cb2:
MOV EAX,EAX
OR R15,RAX
LEA RAX,[RSP + 0x8]
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R12
MOV RCX,R15
MOV R8,R12
MOV R9D,0x1
PUSH 0x2
PUSH RAX
CALL 0x0012fc36
ADD RSP,0x10
MOV R14,RAX
MOV R13,RDX
CMP R12D,-0x9
JC 0x00179d06
MOV RDI,qword ptr [RBX + 0x18]
MOV EAX,dword ptr [R15]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R15],ECX
CMP EAX,0x1
JG 0x00179d06
MOV RSI,R15
MOV RDX,R12
CALL 0x00120d90
LAB_00179d06:
AND RBP,R14
MOV R15,RBP
LAB_00179d0c:
MOV R12,R13
JMP 0x00179c03
LAB_00179d14:
MOV RDI,qword ptr [RBX + 0x18]
MOV EAX,dword ptr [R14]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R14],ECX
MOV R12D,0x6
CMP EAX,0x1
JG 0x00179d37
MOV RSI,R14
MOV RDX,R13
CALL 0x00120d90
LAB_00179d37:
XOR R14D,R14D
XOR R15D,R15D
JMP 0x00179c03
LAB_00179d42:
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x00127d0d
TEST EAX,EAX
JNS 0x00179b06
MOV R12D,0x6
JMP 0x00179d37
|
int1 [16]
JS_ArraySpeciesCreate
(long param_1,long param_2,int8 param_3,int8 param_4,int8 param_5)
{
int8 uVar1;
int iVar2;
uint uVar3;
long lVar4;
int iVar6;
int8 uVar7;
ulong uVar8;
int *piVar9;
int1 auVar10 [16];
int1 auVar11 [16];
int8 local_40;
int8 local_38;
ulong uVar5;
local_40 = param_4;
local_38 = param_5;
if ((int)param_3 == -1) {
if (*(short *)(param_2 + 6) == 0x30) {
uVar3 = js_proxy_isArray(param_1,param_2,param_3);
if (-1 < (int)uVar3) goto LAB_00179b06;
LAB_00179d37:
uVar8 = 0;
auVar11 = ZEXT816(6) << 0x40;
goto LAB_00179c03;
}
uVar3 = (uint)(*(short *)(param_2 + 6) == 2);
LAB_00179b06:
if (uVar3 != 0) {
auVar10 = JS_GetPropertyInternal2(param_1,param_2,param_3,0x3d,param_2,param_3,0,0);
uVar5 = auVar10._8_8_;
piVar9 = auVar10._0_8_;
uVar8 = (ulong)piVar9 & 0xffffffff00000000;
iVar6 = auVar10._8_4_;
auVar11 = auVar10;
if (iVar6 == 6) goto LAB_00179c03;
if ((iVar6 == -1) && ((*(byte *)((long)piVar9 + 5) & 0x10) != 0)) {
lVar4 = JS_GetFunctionRealm(param_1,piVar9,uVar5);
if (lVar4 == 0) {
uVar7 = *(int8 *)(param_1 + 0x18);
iVar6 = *piVar9;
*piVar9 = iVar6 + -1;
if (iVar6 < 2) {
js_free_value_rt(uVar7,piVar9,uVar5);
}
goto LAB_00179d37;
}
if ((lVar4 == param_1) ||
(iVar2 = js_same_value(param_1,piVar9,uVar5,*(int8 *)(lVar4 + 0x68),
*(int8 *)(lVar4 + 0x70)), iVar2 == 0)) goto LAB_00179b60;
uVar7 = *(int8 *)(param_1 + 0x18);
iVar6 = *piVar9;
*piVar9 = iVar6 + -1;
if (iVar6 < 2) {
js_free_value_rt(uVar7,piVar9,uVar5);
}
}
else {
LAB_00179b60:
if ((uVar5 & 0xffffffff) == 0xffffffff) {
auVar10 = JS_GetPropertyInternal2(param_1,piVar9,uVar5,0xdd,piVar9,uVar5,0,0);
uVar7 = *(int8 *)(param_1 + 0x18);
iVar6 = *piVar9;
*piVar9 = iVar6 + -1;
if (iVar6 < 2) {
js_free_value_rt(uVar7,piVar9,uVar5);
}
iVar6 = auVar10._8_4_;
if (iVar6 == 2) goto LAB_00179c88;
uVar8 = auVar10._0_8_ & 0xffffffff00000000;
auVar11 = auVar10;
if (iVar6 == 6) goto LAB_00179c03;
}
uVar7 = auVar10._8_8_;
if (iVar6 != 3) {
piVar9 = (int *)(uVar8 | auVar10._0_8_ & 0xffffffff);
auVar11 = JS_CallConstructorInternal(param_1,piVar9,uVar7,piVar9,uVar7,1,&local_40,2);
if (0xfffffff6 < auVar10._8_4_) {
uVar1 = *(int8 *)(param_1 + 0x18);
iVar6 = *piVar9;
*piVar9 = iVar6 + -1;
if (iVar6 < 2) {
js_free_value_rt(uVar1,piVar9,uVar7);
}
}
uVar8 = auVar11._0_8_ & 0xffffffff00000000;
goto LAB_00179c03;
}
}
LAB_00179c88:
auVar11 = js_array_constructor(param_1,0,3,1,&local_40);
uVar8 = auVar11._0_8_ & 0xffffffff00000000;
goto LAB_00179c03;
}
}
auVar11 = js_array_constructor(param_1,0,3,1,&local_40);
uVar8 = auVar11._0_8_ & 0xffffffff00000000;
LAB_00179c03:
auVar10._0_8_ = auVar11._0_8_ & 0xffffffff | uVar8;
auVar10._8_8_ = auVar11._8_8_;
return auVar10;
}
| |
24,855 | pm_accelerate(glm::vec<3, float, (glm::qualifier)0> const&, glm::vec<3, float, (glm::qualifier)0> const&, float, float) | untodesu[P]voxelius/game/client/player_move.cc | static glm::fvec3 pm_accelerate(const glm::fvec3 &wishdir, const glm::fvec3 &velocity, float wishspeed, float accel)
{
auto current_speed = glm::dot(velocity, wishdir);
auto add_speed = wishspeed - current_speed;
if(add_speed <= 0.0f) {
// Not accelerating
return velocity;
}
auto accel_speed = cxpr::min(add_speed, accel * globals::fixed_frametime * wishspeed);
auto result = glm::fvec3(velocity);
result.x += accel_speed * wishdir.x;
result.z += accel_speed * wishdir.z;
return result;
} | O0 | cpp | pm_accelerate(glm::vec<3, float, (glm::qualifier)0> const&, glm::vec<3, float, (glm::qualifier)0> const&, float, float):
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movss %xmm0, -0x24(%rbp)
movss %xmm1, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x40340
movss %xmm0, -0x2c(%rbp)
movss -0x24(%rbp), %xmm0
subss -0x2c(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x30(%rbp), %xmm0
jb 0xf26d7
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0xc(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xf274b
movss -0x30(%rbp), %xmm0
movss -0x28(%rbp), %xmm1
leaq 0x41e3a0(%rip), %rax # 0x510a88
mulss (%rax), %xmm1
mulss -0x24(%rbp), %xmm1
callq 0xf2770
movss %xmm0, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0xc(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
movss -0x34(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss (%rax), %xmm2
movss -0xc(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0x34(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm2
movss -0x4(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movss -0x40(%rbp), %xmm1
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
| _ZL13pm_accelerateRKN3glm3vecILi3EfLNS_9qualifierE0EEES4_ff:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
movss [rbp+var_24], xmm0
movss [rbp+var_28], xmm1
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_18]
call _ZN3glm3dotILi3EfLNS_9qualifierE0EEET0_RKNS_3vecIXT_ES2_XT1_EEES6_; glm::dot<3,float,(glm::qualifier)0>(glm::vec<3,float,(glm::qualifier)0> const&,glm::vec<3,float,(glm::qualifier)0> const&)
movss [rbp+var_2C], xmm0
movss xmm0, [rbp+var_24]
subss xmm0, [rbp+var_2C]
movss [rbp+var_30], xmm0
xorps xmm0, xmm0
ucomiss xmm0, [rbp+var_30]
jb short loc_F26D7
mov rax, [rbp+var_20]
mov rcx, [rax]
mov [rbp+var_C], rcx
mov eax, [rax+8]
mov [rbp+var_4], eax
jmp short loc_F274B
loc_F26D7:
movss xmm0, [rbp+var_30]
movss xmm1, [rbp+var_28]
lea rax, _ZN7globals15fixed_frametimeE; globals::fixed_frametime
mulss xmm1, dword ptr [rax]
mulss xmm1, [rbp+var_24]
call _ZN4cxprL3minIfEEKT_S1_S1__0; cxpr::min<float>(float,float)
movss [rbp+var_34], xmm0
mov rax, [rbp+var_20]
mov rcx, [rax]
mov [rbp+var_C], rcx
mov eax, [rax+8]
mov [rbp+var_4], eax
movss xmm0, [rbp+var_34]
mov rax, [rbp+var_18]
movss xmm2, dword ptr [rax]
movss xmm1, dword ptr [rbp+var_C]
mulss xmm0, xmm2
addss xmm0, xmm1
movss dword ptr [rbp+var_C], xmm0
movss xmm0, [rbp+var_34]
mov rax, [rbp+var_18]
movss xmm2, dword ptr [rax+8]
movss xmm1, [rbp+var_4]
mulss xmm0, xmm2
addss xmm0, xmm1
movss [rbp+var_4], xmm0
loc_F274B:
mov eax, [rbp+var_4]
mov [rbp+var_40], eax
mov rax, [rbp+var_C]
mov [rbp+var_48], rax
movsd xmm0, [rbp+var_48]
movss xmm1, [rbp+var_40]
add rsp, 50h
pop rbp
retn
| double pm_accelerate(float *a1, _QWORD *a2, float a3, float a4)
{
float v5; // [rsp+1Ch] [rbp-34h]
double v6; // [rsp+44h] [rbp-Ch]
glm::dot<3,float,(glm::qualifier)0>((long long)a2, (long long)a1);
if ( (float)(a3 - a3) <= 0.0 )
return *(double *)a2;
v5 = cxpr::min<float>(a3 - a3, (float)(a4 * globals::fixed_frametime) * a3);
v6 = *(double *)a2;
*(float *)&v6 = (float)(v5 * *a1) + COERCE_FLOAT(*a2);
return v6;
}
| pm_accelerate:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOVSS dword ptr [RBP + -0x24],XMM0
MOVSS dword ptr [RBP + -0x28],XMM1
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00140340
MOVSS dword ptr [RBP + -0x2c],XMM0
MOVSS XMM0,dword ptr [RBP + -0x24]
SUBSS XMM0,dword ptr [RBP + -0x2c]
MOVSS dword ptr [RBP + -0x30],XMM0
XORPS XMM0,XMM0
UCOMISS XMM0,dword ptr [RBP + -0x30]
JC 0x001f26d7
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RBP + -0xc],RCX
MOV EAX,dword ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001f274b
LAB_001f26d7:
MOVSS XMM0,dword ptr [RBP + -0x30]
MOVSS XMM1,dword ptr [RBP + -0x28]
LEA RAX,[0x610a88]
MULSS XMM1,dword ptr [RAX]
MULSS XMM1,dword ptr [RBP + -0x24]
CALL 0x001f2770
MOVSS dword ptr [RBP + -0x34],XMM0
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RBP + -0xc],RCX
MOV EAX,dword ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x4],EAX
MOVSS XMM0,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x18]
MOVSS XMM2,dword ptr [RAX]
MOVSS XMM1,dword ptr [RBP + -0xc]
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOVSS dword ptr [RBP + -0xc],XMM0
MOVSS XMM0,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x18]
MOVSS XMM2,dword ptr [RAX + 0x8]
MOVSS XMM1,dword ptr [RBP + -0x4]
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x4],XMM0
LAB_001f274b:
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x40],EAX
MOV RAX,qword ptr [RBP + -0xc]
MOV qword ptr [RBP + -0x48],RAX
MOVSD XMM0,qword ptr [RBP + -0x48]
MOVSS XMM1,dword ptr [RBP + -0x40]
ADD RSP,0x50
POP RBP
RET
|
/* pm_accelerate(glm::vec<3, float, (glm::qualifier)0> const&, glm::vec<3, float, (glm::qualifier)0>
const&, float, float) */
int8 pm_accelerate(vec *param_1,vec *param_2,float param_3,float param_4)
{
float fVar1;
int8 local_14;
fVar1 = glm::dot<3,float,(glm::qualifier)0>(param_2,param_1);
if (0.0 < param_3 - fVar1) {
fVar1 = cxpr::min<float>(param_3 - fVar1,param_4 * globals::fixed_frametime * param_3);
local_14._0_4_ = (float)*(int8 *)param_2;
local_14 = CONCAT44((int)((ulong)*(int8 *)param_2 >> 0x20),
fVar1 * *(float *)param_1 + (float)local_14);
}
else {
local_14 = *(int8 *)param_2;
}
return local_14;
}
| |
24,856 | mysql_client_find_plugin | eloqsql/build_O0/libmariadb/libmariadb/ma_client_plugin.c | struct st_mysql_client_plugin * STDCALL
mysql_client_find_plugin(MYSQL *mysql, const char *name, int type)
{
struct st_mysql_client_plugin *p;
int plugin_nr= get_plugin_nr(type);
if (is_not_initialized(mysql, name))
return NULL;
if (plugin_nr == -1)
{
my_set_error(mysql, CR_AUTH_PLUGIN_CANNOT_LOAD, SQLSTATE_UNKNOWN,
ER(CR_AUTH_PLUGIN_CANNOT_LOAD), name, "invalid type");
}
if ((p= find_plugin(name, type)))
return p;
/* not found, load it */
return mysql_load_plugin(mysql, name, type, 0);
} | O0 | c | mysql_client_find_plugin:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0x36450
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x35de0
cmpl $0x0, %eax
je 0x363ca
movq $0x0, -0x8(%rbp)
jmp 0x3643b
cmpl $-0x1, -0x2c(%rbp)
jne 0x36403
movq -0x10(%rbp), %rdi
leaq 0x29b05(%rip), %rax # 0x5fee0
movq (%rax), %rdx
leaq 0x29b0b(%rip), %rax # 0x5fef0
movq 0x1d8(%rax), %rcx
movq -0x18(%rbp), %r8
movl $0x80b, %esi # imm = 0x80B
leaq 0x15bb5(%rip), %r9 # 0x4bfb1
movb $0x0, %al
callq 0x16150
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x35e50
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x36423
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3643b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
xorl %ecx, %ecx
movb $0x0, %al
callq 0x362f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| mysql_client_find_plugin:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov edi, [rbp+var_1C]
call get_plugin_nr
mov [rbp+var_2C], eax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call is_not_initialized
cmp eax, 0
jz short loc_363CA
mov [rbp+var_8], 0
jmp short loc_3643B
loc_363CA:
cmp [rbp+var_2C], 0FFFFFFFFh
jnz short loc_36403
mov rdi, [rbp+var_10]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rax, client_errors
mov rcx, [rax+1D8h]
mov r8, [rbp+var_18]
mov esi, 80Bh
lea r9, aInvalidType; "invalid type"
mov al, 0
call my_set_error
loc_36403:
mov rdi, [rbp+var_18]
mov esi, [rbp+var_1C]
call find_plugin
mov [rbp+var_28], rax
cmp rax, 0
jz short loc_36423
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
jmp short loc_3643B
loc_36423:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
xor ecx, ecx
mov al, 0
call mysql_load_plugin
mov [rbp+var_8], rax
loc_3643B:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| void (** mysql_client_find_plugin(long long a1, const char *a2, unsigned int a3))(void)
{
int plugin_nr; // [rsp+4h] [rbp-2Ch]
long long plugin; // [rsp+8h] [rbp-28h]
plugin_nr = get_plugin_nr(a3);
if ( (unsigned int)is_not_initialized(a1, (long long)a2) )
return 0LL;
if ( plugin_nr == -1 )
my_set_error(a1, 0x80Bu, (long long)SQLSTATE_UNKNOWN, (long long)client_errors[59], a2, "invalid type");
plugin = find_plugin((long long)a2, a3);
if ( plugin )
return (void (**)(void))plugin;
else
return mysql_load_plugin(a1, a2, a3, 0);
}
| mysql_client_find_plugin:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV EDI,dword ptr [RBP + -0x1c]
CALL 0x00136450
MOV dword ptr [RBP + -0x2c],EAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00135de0
CMP EAX,0x0
JZ 0x001363ca
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0013643b
LAB_001363ca:
CMP dword ptr [RBP + -0x2c],-0x1
JNZ 0x00136403
MOV RDI,qword ptr [RBP + -0x10]
LEA RAX,[0x15fee0]
MOV RDX,qword ptr [RAX]
LEA RAX,[0x15fef0]
MOV RCX,qword ptr [RAX + 0x1d8]
MOV R8,qword ptr [RBP + -0x18]
MOV ESI,0x80b
LEA R9,[0x14bfb1]
MOV AL,0x0
CALL 0x00116150
LAB_00136403:
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,dword ptr [RBP + -0x1c]
CALL 0x00135e50
MOV qword ptr [RBP + -0x28],RAX
CMP RAX,0x0
JZ 0x00136423
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0013643b
LAB_00136423:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
XOR ECX,ECX
MOV AL,0x0
CALL 0x001362f0
MOV qword ptr [RBP + -0x8],RAX
LAB_0013643b:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
long mysql_client_find_plugin(int8 param_1,int8 param_2,int4 param_3)
{
int iVar1;
int iVar2;
long local_10;
iVar1 = get_plugin_nr(param_3);
iVar2 = is_not_initialized(param_1,param_2);
if (iVar2 == 0) {
if (iVar1 == -1) {
my_set_error(param_1,0x80b,SQLSTATE_UNKNOWN,PTR_s_Plugin__s_could_not_be_loaded____001600c8,
param_2,"invalid type");
}
local_10 = find_plugin(param_2,param_3);
if (local_10 == 0) {
local_10 = mysql_load_plugin(param_1,param_2,param_3,0);
}
}
else {
local_10 = 0;
}
return local_10;
}
| |
24,857 | ftxui::Color::Interpolate(float, ftxui::Color const&, ftxui::Color const&) | Andrewchistyakov[P]flashcards_lyc/build_O1/_deps/ftxui-src/src/ftxui/screen/color.cpp | Color Color::Interpolate(float t, const Color& a, const Color& b) {
if (a.type_ == ColorType::Palette1 || //
b.type_ == ColorType::Palette1) {
if (t < 0.5F) { // NOLINT
return a;
} else {
return b;
}
}
auto get_color = [](const Color& color, //
uint8_t* red, uint8_t* green, uint8_t* blue) {
switch (color.type_) {
case ColorType::Palette1: {
return;
}
case ColorType::Palette16: {
const ColorInfo info = GetColorInfo(Color::Palette16(color.red_));
*red = info.red;
*green = info.green;
*blue = info.blue;
return;
}
case ColorType::Palette256: {
const ColorInfo info = GetColorInfo(Color::Palette256(color.red_));
*red = info.red;
*green = info.green;
*blue = info.blue;
return;
}
case ColorType::TrueColor:
default: {
*red = color.red_;
*green = color.green_;
*blue = color.blue_;
return;
}
}
};
uint8_t a_r = 0;
uint8_t a_g = 0;
uint8_t a_b = 0;
uint8_t b_r = 0;
uint8_t b_g = 0;
uint8_t b_b = 0;
get_color(a, &a_r, &a_g, &a_b);
get_color(b, &b_r, &b_g, &b_b);
// Gamma correction:
// https://en.wikipedia.org/wiki/Gamma_correction
auto interp = [t](uint8_t a_u, uint8_t b_u) {
constexpr float gamma = 2.2F;
const float a_f = powf(a_u, gamma);
const float b_f = powf(b_u, gamma);
const float c_f = a_f * (1.0F - t) + //
b_f * t;
return static_cast<uint8_t>(powf(c_f, 1.F / gamma));
};
return Color::RGB(interp(a_r, b_r), //
interp(a_g, b_g), //
interp(a_b, b_b)); //
} | O1 | cpp | ftxui::Color::Interpolate(float, ftxui::Color const&, ftxui::Color const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movzbl (%rdi), %r15d
testl %r15d, %r15d
je 0x20eca
cmpb $0x0, (%r14)
je 0x20eca
testl %r15d, %r15d
movss %xmm0, 0xc(%rsp)
je 0x20f04
cmpl $0x2, %r15d
je 0x20ee6
cmpl $0x1, %r15d
jne 0x20f0c
movzbl 0x1(%rdi), %edi
callq 0x21110
jmp 0x20eef
movss 0x1cf2e(%rip), %xmm1 # 0x3de00
ucomiss %xmm0, %xmm1
jbe 0x20ede
movl (%rdi), %eax
jmp 0x210b8
movl (%r14), %eax
jmp 0x210b8
movzbl 0x1(%rdi), %edi
callq 0x210fc
movq %rdx, %rbx
movl %ebx, %ebp
shrl $0x10, %ebp
movl %ebx, %r15d
shrl $0x18, %r15d
shrq $0x20, %rbx
jmp 0x20f17
movl %r15d, %ebx
movl %r15d, %ebp
jmp 0x20f17
movb 0x1(%rdi), %bpl
movb 0x2(%rdi), %r15b
movb 0x3(%rdi), %bl
movzbl (%r14), %r13d
testl %r13d, %r13d
je 0x20f59
cmpl $0x2, %r13d
je 0x20f38
cmpl $0x1, %r13d
jne 0x20f61
movzbl 0x1(%r14), %edi
callq 0x21110
jmp 0x20f42
movzbl 0x1(%r14), %edi
callq 0x210fc
movq %rdx, %r14
movl %r14d, %r13d
shrl $0x10, %r13d
movl %r14d, %r12d
shrl $0x18, %r12d
shrq $0x20, %r14
jmp 0x20f6d
movl %r13d, %r12d
movl %r13d, %r14d
jmp 0x20f6d
movb 0x1(%r14), %r13b
movb 0x2(%r14), %r12b
movb 0x3(%r14), %r14b
movzbl %bpl, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss 0x1ce74(%rip), %xmm1 # 0x3ddf4
callq 0xb690
movss %xmm0, 0x8(%rsp)
movzbl %r13b, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss 0x1ce56(%rip), %xmm1 # 0x3ddf4
callq 0xb690
movss 0x1ce4d(%rip), %xmm1 # 0x3ddf8
movss 0xc(%rsp), %xmm2
subss %xmm2, %xmm1
movss %xmm1, 0x10(%rsp)
mulss %xmm2, %xmm0
movss 0x8(%rsp), %xmm2
mulss %xmm1, %xmm2
addss %xmm2, %xmm0
movss 0x1ce27(%rip), %xmm1 # 0x3ddfc
callq 0xb690
cvttss2si %xmm0, %ebp
movzbl %r15b, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss 0x1ce03(%rip), %xmm1 # 0x3ddf4
callq 0xb690
movss %xmm0, 0x8(%rsp)
movzbl %r12b, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss 0x1cde5(%rip), %xmm1 # 0x3ddf4
callq 0xb690
mulss 0xc(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
mulss 0x10(%rsp), %xmm1
addss %xmm1, %xmm0
movss 0x1cdca(%rip), %xmm1 # 0x3ddfc
callq 0xb690
cvttss2si %xmm0, %r15d
movzbl %bl, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss 0x1cda6(%rip), %xmm1 # 0x3ddf4
callq 0xb690
movss %xmm0, 0x8(%rsp)
movzbl %r14b, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss 0x1cd88(%rip), %xmm1 # 0x3ddf4
callq 0xb690
mulss 0xc(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
mulss 0x10(%rsp), %xmm1
addss %xmm1, %xmm0
movss 0x1cd6d(%rip), %xmm1 # 0x3ddfc
callq 0xb690
cvttss2si %xmm0, %ecx
movl $0xff, %eax
andl %eax, %ebp
andl %eax, %r15d
andl %eax, %ecx
leaq 0x14(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x20ca4
movl (%rbx), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN5ftxui5Color11InterpolateEfRKS0_S2_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r14, rsi
movzx r15d, byte ptr [rdi]
test r15d, r15d
jz short loc_20ECA
cmp byte ptr [r14], 0
jz short loc_20ECA
test r15d, r15d
movss [rsp+48h+var_3C], xmm0
jz short loc_20F04
cmp r15d, 2
jz short loc_20EE6
cmp r15d, 1
jnz short loc_20F0C
movzx edi, byte ptr [rdi+1]
call _ZN5ftxui12GetColorInfoENS_5Color9Palette16E; ftxui::GetColorInfo(ftxui::Color::Palette16)
jmp short loc_20EEF
loc_20ECA:
movss xmm1, cs:dword_3DE00
ucomiss xmm1, xmm0
jbe short loc_20EDE
mov eax, [rdi]
jmp loc_210B8
loc_20EDE:
mov eax, [r14]
jmp loc_210B8
loc_20EE6:
movzx edi, byte ptr [rdi+1]
call _ZN5ftxui12GetColorInfoENS_5Color10Palette256E; ftxui::GetColorInfo(ftxui::Color::Palette256)
loc_20EEF:
mov rbx, rdx
mov ebp, ebx
shr ebp, 10h
mov r15d, ebx
shr r15d, 18h
shr rbx, 20h
jmp short loc_20F17
loc_20F04:
mov ebx, r15d
mov ebp, r15d
jmp short loc_20F17
loc_20F0C:
mov bpl, [rdi+1]
mov r15b, [rdi+2]
mov bl, [rdi+3]
loc_20F17:
movzx r13d, byte ptr [r14]
test r13d, r13d
jz short loc_20F59
cmp r13d, 2
jz short loc_20F38
cmp r13d, 1
jnz short loc_20F61
movzx edi, byte ptr [r14+1]
call _ZN5ftxui12GetColorInfoENS_5Color9Palette16E; ftxui::GetColorInfo(ftxui::Color::Palette16)
jmp short loc_20F42
loc_20F38:
movzx edi, byte ptr [r14+1]
call _ZN5ftxui12GetColorInfoENS_5Color10Palette256E; ftxui::GetColorInfo(ftxui::Color::Palette256)
loc_20F42:
mov r14, rdx
mov r13d, r14d
shr r13d, 10h
mov r12d, r14d
shr r12d, 18h
shr r14, 20h
jmp short loc_20F6D
loc_20F59:
mov r12d, r13d
mov r14d, r13d
jmp short loc_20F6D
loc_20F61:
mov r13b, [r14+1]
mov r12b, [r14+2]
mov r14b, [r14+3]
loc_20F6D:
movzx eax, bpl
xorps xmm0, xmm0
cvtsi2ss xmm0, eax
movss xmm1, cs:dword_3DDF4
call _powf
movss [rsp+48h+var_40], xmm0
movzx eax, r13b
xorps xmm0, xmm0
cvtsi2ss xmm0, eax
movss xmm1, cs:dword_3DDF4
call _powf
movss xmm1, cs:dword_3DDF8
movss xmm2, [rsp+48h+var_3C]
subss xmm1, xmm2
movss [rsp+48h+var_38], xmm1
mulss xmm0, xmm2
movss xmm2, [rsp+48h+var_40]
mulss xmm2, xmm1
addss xmm0, xmm2
movss xmm1, cs:dword_3DDFC
call _powf
cvttss2si ebp, xmm0
movzx eax, r15b
xorps xmm0, xmm0
cvtsi2ss xmm0, eax
movss xmm1, cs:dword_3DDF4
call _powf
movss [rsp+48h+var_40], xmm0
movzx eax, r12b
xorps xmm0, xmm0
cvtsi2ss xmm0, eax
movss xmm1, cs:dword_3DDF4
call _powf
mulss xmm0, [rsp+48h+var_3C]
movss xmm1, [rsp+48h+var_40]
mulss xmm1, [rsp+48h+var_38]
addss xmm0, xmm1
movss xmm1, cs:dword_3DDFC
call _powf
cvttss2si r15d, xmm0
movzx eax, bl
xorps xmm0, xmm0
cvtsi2ss xmm0, eax
movss xmm1, cs:dword_3DDF4
call _powf
movss [rsp+48h+var_40], xmm0
movzx eax, r14b
xorps xmm0, xmm0
cvtsi2ss xmm0, eax
movss xmm1, cs:dword_3DDF4
call _powf
mulss xmm0, [rsp+48h+var_3C]
movss xmm1, [rsp+48h+var_40]
mulss xmm1, [rsp+48h+var_38]
addss xmm0, xmm1
movss xmm1, cs:dword_3DDFC
call _powf
cvttss2si ecx, xmm0
mov eax, 0FFh
and ebp, eax
and r15d, eax
and ecx, eax; unsigned __int8
lea rbx, [rsp+48h+var_34]
mov rdi, rbx; this
mov esi, ebp; unsigned __int8
mov edx, r15d; unsigned __int8
call _ZN5ftxui5ColorC2Ehhh; ftxui::Color::Color(uchar,uchar,uchar)
mov eax, [rbx]
loc_210B8:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ftxui::Color::Interpolate(ftxui::Color *this, float a2, const ftxui::Color *a3, unsigned long long a4)
{
unsigned int v4; // r15d
unsigned int v6; // ebp
unsigned long long v7; // rbx
unsigned int v8; // r13d
unsigned long long v9; // rdx
unsigned int v10; // r12d
unsigned long long v11; // r14
float v12; // xmm0_4
int v13; // ebp
float v14; // xmm0_4
int v15; // r15d
float v16; // xmm0_4
float v17; // xmm0_4
float v18; // [rsp+8h] [rbp-40h]
float v19; // [rsp+8h] [rbp-40h]
float v20; // [rsp+8h] [rbp-40h]
_DWORD v22[13]; // [rsp+14h] [rbp-34h] BYREF
v4 = *(unsigned __int8 *)this;
if ( *(_BYTE *)this && *(_BYTE *)a3 )
{
if ( *(_BYTE *)this )
{
if ( v4 == 2 )
{
ftxui::GetColorInfo(*((unsigned __int8 *)this + 1));
goto LABEL_11;
}
if ( v4 == 1 )
{
ftxui::GetColorInfo(*((unsigned __int8 *)this + 1), a3, a4);
LABEL_11:
v6 = WORD1(a4);
v4 = BYTE3(a4);
v7 = HIDWORD(a4);
goto LABEL_14;
}
LOBYTE(v6) = *((_BYTE *)this + 1);
LOBYTE(v4) = *((_BYTE *)this + 2);
LOBYTE(v7) = *((_BYTE *)this + 3);
}
else
{
LOBYTE(v7) = 0;
LOBYTE(v6) = 0;
}
LABEL_14:
v8 = *(unsigned __int8 *)a3;
if ( *(_BYTE *)a3 )
{
if ( v8 == 2 )
{
ftxui::GetColorInfo(*((unsigned __int8 *)a3 + 1));
}
else
{
if ( v8 != 1 )
{
LOBYTE(v8) = *((_BYTE *)a3 + 1);
LOBYTE(v10) = *((_BYTE *)a3 + 2);
LOBYTE(v11) = *((_BYTE *)a3 + 3);
goto LABEL_22;
}
ftxui::GetColorInfo(*((unsigned __int8 *)a3 + 1), a3, a4);
}
v8 = WORD1(v9);
v10 = BYTE3(v9);
v11 = HIDWORD(v9);
}
else
{
LOBYTE(v10) = *(_BYTE *)a3;
LOBYTE(v11) = *(_BYTE *)a3;
}
LABEL_22:
v18 = powf((float)(unsigned __int8)v6, 2.2);
v12 = powf((float)(unsigned __int8)v8, 2.2);
v13 = (int)powf((float)(v12 * a2) + (float)(v18 * (float)(1.0 - a2)), 0.45454544);
v19 = powf((float)(unsigned __int8)v4, 2.2);
v14 = powf((float)(unsigned __int8)v10, 2.2);
v15 = (int)powf((float)(v14 * a2) + (float)(v19 * (float)(1.0 - a2)), 0.45454544);
v20 = powf((float)(unsigned __int8)v7, 2.2);
v16 = powf((float)(unsigned __int8)v11, 2.2);
v17 = powf((float)(v16 * a2) + (float)(v20 * (float)(1.0 - a2)), 0.45454544);
ftxui::Color::Color((ftxui::Color *)v22, v13, v15, (int)v17);
return v22[0];
}
if ( a2 >= 0.5 )
return *(unsigned int *)a3;
else
return *(unsigned int *)this;
}
| Interpolate:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R14,RSI
MOVZX R15D,byte ptr [RDI]
TEST R15D,R15D
JZ 0x00120eca
CMP byte ptr [R14],0x0
JZ 0x00120eca
TEST R15D,R15D
MOVSS dword ptr [RSP + 0xc],XMM0
JZ 0x00120f04
CMP R15D,0x2
JZ 0x00120ee6
CMP R15D,0x1
JNZ 0x00120f0c
MOVZX EDI,byte ptr [RDI + 0x1]
CALL 0x00121110
JMP 0x00120eef
LAB_00120eca:
MOVSS XMM1,dword ptr [0x0013de00]
UCOMISS XMM1,XMM0
JBE 0x00120ede
MOV EAX,dword ptr [RDI]
JMP 0x001210b8
LAB_00120ede:
MOV EAX,dword ptr [R14]
JMP 0x001210b8
LAB_00120ee6:
MOVZX EDI,byte ptr [RDI + 0x1]
CALL 0x001210fc
LAB_00120eef:
MOV RBX,RDX
MOV EBP,EBX
SHR EBP,0x10
MOV R15D,EBX
SHR R15D,0x18
SHR RBX,0x20
JMP 0x00120f17
LAB_00120f04:
MOV EBX,R15D
MOV EBP,R15D
JMP 0x00120f17
LAB_00120f0c:
MOV BPL,byte ptr [RDI + 0x1]
MOV R15B,byte ptr [RDI + 0x2]
MOV BL,byte ptr [RDI + 0x3]
LAB_00120f17:
MOVZX R13D,byte ptr [R14]
TEST R13D,R13D
JZ 0x00120f59
CMP R13D,0x2
JZ 0x00120f38
CMP R13D,0x1
JNZ 0x00120f61
MOVZX EDI,byte ptr [R14 + 0x1]
CALL 0x00121110
JMP 0x00120f42
LAB_00120f38:
MOVZX EDI,byte ptr [R14 + 0x1]
CALL 0x001210fc
LAB_00120f42:
MOV R14,RDX
MOV R13D,R14D
SHR R13D,0x10
MOV R12D,R14D
SHR R12D,0x18
SHR R14,0x20
JMP 0x00120f6d
LAB_00120f59:
MOV R12D,R13D
MOV R14D,R13D
JMP 0x00120f6d
LAB_00120f61:
MOV R13B,byte ptr [R14 + 0x1]
MOV R12B,byte ptr [R14 + 0x2]
MOV R14B,byte ptr [R14 + 0x3]
LAB_00120f6d:
MOVZX EAX,BPL
XORPS XMM0,XMM0
CVTSI2SS XMM0,EAX
MOVSS XMM1,dword ptr [0x0013ddf4]
CALL 0x0010b690
MOVSS dword ptr [RSP + 0x8],XMM0
MOVZX EAX,R13B
XORPS XMM0,XMM0
CVTSI2SS XMM0,EAX
MOVSS XMM1,dword ptr [0x0013ddf4]
CALL 0x0010b690
MOVSS XMM1,dword ptr [0x0013ddf8]
MOVSS XMM2,dword ptr [RSP + 0xc]
SUBSS XMM1,XMM2
MOVSS dword ptr [RSP + 0x10],XMM1
MULSS XMM0,XMM2
MOVSS XMM2,dword ptr [RSP + 0x8]
MULSS XMM2,XMM1
ADDSS XMM0,XMM2
MOVSS XMM1,dword ptr [0x0013ddfc]
CALL 0x0010b690
CVTTSS2SI EBP,XMM0
MOVZX EAX,R15B
XORPS XMM0,XMM0
CVTSI2SS XMM0,EAX
MOVSS XMM1,dword ptr [0x0013ddf4]
CALL 0x0010b690
MOVSS dword ptr [RSP + 0x8],XMM0
MOVZX EAX,R12B
XORPS XMM0,XMM0
CVTSI2SS XMM0,EAX
MOVSS XMM1,dword ptr [0x0013ddf4]
CALL 0x0010b690
MULSS XMM0,dword ptr [RSP + 0xc]
MOVSS XMM1,dword ptr [RSP + 0x8]
MULSS XMM1,dword ptr [RSP + 0x10]
ADDSS XMM0,XMM1
MOVSS XMM1,dword ptr [0x0013ddfc]
CALL 0x0010b690
CVTTSS2SI R15D,XMM0
MOVZX EAX,BL
XORPS XMM0,XMM0
CVTSI2SS XMM0,EAX
MOVSS XMM1,dword ptr [0x0013ddf4]
CALL 0x0010b690
MOVSS dword ptr [RSP + 0x8],XMM0
MOVZX EAX,R14B
XORPS XMM0,XMM0
CVTSI2SS XMM0,EAX
MOVSS XMM1,dword ptr [0x0013ddf4]
CALL 0x0010b690
MULSS XMM0,dword ptr [RSP + 0xc]
MOVSS XMM1,dword ptr [RSP + 0x8]
MULSS XMM1,dword ptr [RSP + 0x10]
ADDSS XMM0,XMM1
MOVSS XMM1,dword ptr [0x0013ddfc]
CALL 0x0010b690
CVTTSS2SI ECX,XMM0
MOV EAX,0xff
AND EBP,EAX
AND R15D,EAX
AND ECX,EAX
LEA RBX,[RSP + 0x14]
MOV RDI,RBX
MOV ESI,EBP
MOV EDX,R15D
CALL 0x00120ca4
MOV EAX,dword ptr [RBX]
LAB_001210b8:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* ftxui::Color::Interpolate(float, ftxui::Color const&, ftxui::Color const&) */
int4 ftxui::Color::Interpolate(float param_1,Color *param_2,Color *param_3)
{
Color CVar1;
int8 extraout_RDX;
int8 extraout_RDX_00;
int8 extraout_RDX_01;
int8 extraout_RDX_02;
int8 uVar2;
uint uVar3;
uint uVar4;
uint uVar5;
uint uVar6;
uint uVar7;
uint uVar8;
float fVar9;
float fVar10;
float fVar11;
float fVar12;
float fVar13;
int4 local_34;
CVar1 = *param_2;
uVar8 = (uint)(byte)CVar1;
if ((CVar1 == (Color)0x0) || (*param_3 == (Color)0x0)) {
if (param_1 < DAT_0013de00) {
return *(int4 *)param_2;
}
return *(int4 *)param_3;
}
if (CVar1 == (Color)0x0) {
uVar4 = 0;
uVar3 = 0;
}
else {
if (CVar1 == (Color)0x2) {
GetColorInfo(param_2[1]);
uVar2 = extraout_RDX_00;
}
else {
if (CVar1 != (Color)0x1) {
uVar4 = (uint)(byte)param_2[1];
uVar8 = (uint)(byte)param_2[2];
uVar3 = (uint)(byte)param_2[3];
goto LAB_00120f17;
}
GetColorInfo(param_2[1]);
uVar2 = extraout_RDX;
}
uVar4 = (uint)((ulong)uVar2 >> 0x10) & 0xffff;
uVar8 = (uint)((ulong)uVar2 >> 0x18) & 0xff;
uVar3 = (uint)((ulong)uVar2 >> 0x20);
}
LAB_00120f17:
CVar1 = *param_3;
uVar6 = (uint)(byte)CVar1;
uVar5 = uVar6;
uVar7 = uVar6;
if (CVar1 != (Color)0x0) {
if (CVar1 == (Color)0x2) {
GetColorInfo(param_3[1]);
uVar2 = extraout_RDX_02;
}
else {
if (CVar1 != (Color)0x1) {
uVar6 = (uint)(byte)param_3[1];
uVar5 = (uint)(byte)param_3[2];
uVar7 = (uint)(byte)param_3[3];
goto LAB_00120f6d;
}
GetColorInfo(param_3[1]);
uVar2 = extraout_RDX_01;
}
uVar6 = (uint)((ulong)uVar2 >> 0x10) & 0xffff;
uVar5 = (uint)((ulong)uVar2 >> 0x18) & 0xff;
uVar7 = (uint)((ulong)uVar2 >> 0x20);
}
LAB_00120f6d:
fVar9 = powf((float)(uVar4 & 0xff),DAT_0013ddf4);
fVar10 = powf((float)(uVar6 & 0xff),DAT_0013ddf4);
fVar13 = DAT_0013ddf8 - param_1;
fVar9 = powf(fVar10 * param_1 + fVar9 * fVar13,DAT_0013ddfc);
fVar10 = powf((float)uVar8,DAT_0013ddf4);
fVar11 = powf((float)uVar5,DAT_0013ddf4);
fVar10 = powf(fVar11 * param_1 + fVar10 * fVar13,DAT_0013ddfc);
fVar11 = powf((float)(uVar3 & 0xff),DAT_0013ddf4);
fVar12 = powf((float)(uVar7 & 0xff),DAT_0013ddf4);
fVar11 = powf(fVar12 * param_1 + fVar11 * fVar13,DAT_0013ddfc);
Color((Color *)&local_34,(uchar)(int)fVar9,(uchar)(int)fVar10,(uchar)(int)fVar11);
return local_34;
}
| |
24,858 | lf_pinbox_get_pins | eloqsql/mysys/lf_alloc-pin.c | LF_PINS *lf_pinbox_get_pins(LF_PINBOX *pinbox)
{
uint32 pins, next, top_ver;
LF_PINS *el;
/*
We have an array of max. 64k elements.
The highest index currently allocated is pinbox->pins_in_array.
Freed elements are in a lifo stack, pinstack_top_ver.
pinstack_top_ver is 32 bits; 16 low bits are the index in the
array, to the first element of the list. 16 high bits are a version
(every time the 16 low bits are updated, the 16 high bits are
incremented). Versioning prevents the ABA problem.
*/
top_ver= pinbox->pinstack_top_ver;
do
{
if (!(pins= top_ver % LF_PINBOX_MAX_PINS))
{
/* the stack of free elements is empty */
pins= my_atomic_add32((int32 volatile*) &pinbox->pins_in_array, 1)+1;
if (unlikely(pins >= LF_PINBOX_MAX_PINS))
return 0;
/*
note that the first allocated element has index 1 (pins==1).
index 0 is reserved to mean "NULL pointer"
*/
el= (LF_PINS *)lf_dynarray_lvalue(&pinbox->pinarray, pins);
if (unlikely(!el))
return 0;
break;
}
el= (LF_PINS *)lf_dynarray_value(&pinbox->pinarray, pins);
next= el->link;
} while (!my_atomic_cas32((int32 volatile*) &pinbox->pinstack_top_ver,
(int32*) &top_ver,
top_ver-pins+next+LF_PINBOX_MAX_PINS));
/*
set el->link to the index of el in the dynarray (el->link has two usages:
- if element is allocated, it's its own index
- if element is free, it's its next element in the free stack
*/
el->link= pins;
el->purgatory_count= 0;
el->pinbox= pinbox;
return el;
} | O3 | c | lf_pinbox_get_pins:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x3c(%rdi), %r15d
movl %r15d, %r14d
andl $0xffff, %r14d # imm = 0xFFFF
je 0x30fb3
movq %rbx, %rdi
movl %r14d, %esi
callq 0xb08b4
movq %rax, %rcx
movl 0x34(%rax), %eax
movl %r15d, %edx
andl $0xffff0000, %edx # imm = 0xFFFF0000
addl %eax, %edx
addl $0x10000, %edx # imm = 0x10000
movl %r15d, %eax
lock
cmpxchgl %edx, 0x3c(%rbx)
movl %eax, %r15d
jne 0x30f76
jmp 0x30fdc
pushq $0x1
popq %r14
lock
xaddl %r14d, 0x40(%rbx)
incl %r14d
cmpl $0xffff, %r14d # imm = 0xFFFF
ja 0x30ff6
movq %rbx, %rdi
movl %r14d, %esi
callq 0x30ffa
testq %rax, %rax
je 0x30ff6
movq %rax, %rcx
movl %r14d, 0x34(%rcx)
andl $0x0, 0x30(%rcx)
movq %rbx, 0x20(%rcx)
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %ecx, %ecx
jmp 0x30fe8
| lf_pinbox_get_pins:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdi
mov r15d, [rdi+3Ch]
loc_30F76:
mov r14d, r15d
and r14d, 0FFFFh
jz short loc_30FB3
mov rdi, rbx
mov esi, r14d
call lf_dynarray_value
mov rcx, rax
mov eax, [rax+34h]
mov edx, r15d
and edx, 0FFFF0000h
add edx, eax
add edx, 10000h
mov eax, r15d
lock cmpxchg [rbx+3Ch], edx
mov r15d, eax
jnz short loc_30F76
jmp short loc_30FDC
loc_30FB3:
push 1
pop r14
lock xadd [rbx+40h], r14d
inc r14d
cmp r14d, 0FFFFh
ja short loc_30FF6
mov rdi, rbx
mov esi, r14d
call lf_dynarray_lvalue
test rax, rax
jz short loc_30FF6
mov rcx, rax
loc_30FDC:
mov [rcx+34h], r14d
and dword ptr [rcx+30h], 0
mov [rcx+20h], rbx
loc_30FE8:
mov rax, rcx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_30FF6:
xor ecx, ecx
jmp short loc_30FE8
| long long lf_pinbox_get_pins(long long a1)
{
signed __int32 v1; // r15d
unsigned __int32 v2; // r14d
long long v3; // rcx
bool v4; // zf
signed __int32 v5; // eax
long long v6; // rax
v1 = *(_DWORD *)(a1 + 60);
while ( 1 )
{
v2 = (unsigned __int16)v1;
if ( !(_WORD)v1 )
break;
v3 = lf_dynarray_value(a1, (unsigned __int16)v1);
v5 = _InterlockedCompareExchange(
(volatile signed __int32 *)(a1 + 60),
*(_DWORD *)(v3 + 52) + (v1 & 0xFFFF0000) + 0x10000,
v1);
v4 = v1 == v5;
v1 = v5;
if ( v4 )
goto LABEL_8;
}
v2 = _InterlockedIncrement((volatile signed __int32 *)(a1 + 64));
if ( v2 <= 0xFFFF )
{
v6 = lf_dynarray_lvalue(a1, v2);
if ( v6 )
{
v3 = v6;
LABEL_8:
*(_DWORD *)(v3 + 52) = v2;
*(_DWORD *)(v3 + 48) = 0;
*(_QWORD *)(v3 + 32) = a1;
return v3;
}
}
return 0LL;
}
| lf_pinbox_get_pins:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R15D,dword ptr [RDI + 0x3c]
LAB_00130f76:
MOV R14D,R15D
AND R14D,0xffff
JZ 0x00130fb3
MOV RDI,RBX
MOV ESI,R14D
CALL 0x001b08b4
MOV RCX,RAX
MOV EAX,dword ptr [RAX + 0x34]
MOV EDX,R15D
AND EDX,0xffff0000
ADD EDX,EAX
ADD EDX,0x10000
MOV EAX,R15D
CMPXCHG.LOCK dword ptr [RBX + 0x3c],EDX
MOV R15D,EAX
JNZ 0x00130f76
JMP 0x00130fdc
LAB_00130fb3:
PUSH 0x1
POP R14
XADD.LOCK dword ptr [RBX + 0x40],R14D
INC R14D
CMP R14D,0xffff
JA 0x00130ff6
MOV RDI,RBX
MOV ESI,R14D
CALL 0x00130ffa
TEST RAX,RAX
JZ 0x00130ff6
MOV RCX,RAX
LAB_00130fdc:
MOV dword ptr [RCX + 0x34],R14D
AND dword ptr [RCX + 0x30],0x0
MOV qword ptr [RCX + 0x20],RBX
LAB_00130fe8:
MOV RAX,RCX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00130ff6:
XOR ECX,ECX
JMP 0x00130fe8
|
long lf_pinbox_get_pins(long param_1)
{
int *piVar1;
uint uVar2;
int iVar3;
long lVar4;
uint uVar5;
uint uVar6;
bool bVar7;
uVar6 = *(uint *)(param_1 + 0x3c);
do {
uVar5 = uVar6 & 0xffff;
if (uVar5 == 0) {
LOCK();
piVar1 = (int *)(param_1 + 0x40);
iVar3 = *piVar1;
*piVar1 = *piVar1 + 1;
UNLOCK();
uVar5 = iVar3 + 1;
if ((0xffff < uVar5) || (lVar4 = lf_dynarray_lvalue(param_1,uVar5), lVar4 == 0)) {
return 0;
}
break;
}
lVar4 = lf_dynarray_value(param_1,uVar5);
LOCK();
uVar2 = *(uint *)(param_1 + 0x3c);
bVar7 = uVar6 == uVar2;
if (bVar7) {
*(uint *)(param_1 + 0x3c) = (uVar6 & 0xffff0000) + *(int *)(lVar4 + 0x34) + 0x10000;
uVar2 = uVar6;
}
uVar6 = uVar2;
UNLOCK();
} while (!bVar7);
*(uint *)(lVar4 + 0x34) = uVar5;
*(int4 *)(lVar4 + 0x30) = 0;
*(long *)(lVar4 + 0x20) = param_1;
return lVar4;
}
| |
24,859 | ma_tls_write | eloqsql/libmariadb/libmariadb/secure/openssl.c | ssize_t ma_tls_write(MARIADB_TLS *ctls, const uchar* buffer, size_t length)
{
int rc;
MARIADB_PVIO *pvio= ctls->pvio;
while ((rc= SSL_write((SSL *)ctls->ssl, (void *)buffer, (int)length)) <= 0)
{
int error= SSL_get_error((SSL *)ctls->ssl, rc);
if (error != SSL_ERROR_WANT_WRITE)
break;
if (pvio->methods->wait_io_or_timeout(pvio, TRUE, pvio->mysql->options.write_timeout) < 1)
break;
}
if (rc <= 0)
{
MYSQL *mysql= SSL_get_app_data(ctls->ssl);
ma_tls_set_error(mysql);
}
return rc;
} | O3 | c | ma_tls_write:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movq 0x8(%rdi), %r13
movq 0x10(%r15), %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x13830
movl %eax, %r14d
testl %eax, %eax
jg 0x2861b
movq 0x10(%r15), %rdi
movl %r14d, %esi
callq 0x13050
cmpl $0x3, %eax
jne 0x28608
movq 0x40(%r13), %rax
movq 0x48(%r13), %rcx
movl 0x398(%rax), %edx
movq %r13, %rdi
movl $0x1, %esi
callq *0x30(%rcx)
testl %eax, %eax
jg 0x285c5
movq 0x10(%r15), %rdi
xorl %esi, %esi
callq 0x13160
movq %rax, %rdi
callq 0x28318
movslq %r14d, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| ma_tls_write:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdx
mov r12, rsi
mov r15, rdi
mov r13, [rdi+8]
loc_285C5:
mov rdi, [r15+10h]
mov rsi, r12
mov edx, ebx
call _SSL_write
mov r14d, eax
test eax, eax
jg short loc_2861B
mov rdi, [r15+10h]
mov esi, r14d
call _SSL_get_error
cmp eax, 3
jnz short loc_28608
mov rax, [r13+40h]
mov rcx, [r13+48h]
mov edx, [rax+398h]
mov rdi, r13
mov esi, 1
call qword ptr [rcx+30h]
test eax, eax
jg short loc_285C5
loc_28608:
mov rdi, [r15+10h]
xor esi, esi
call _SSL_get_ex_data
mov rdi, rax
call ma_tls_set_error
loc_2861B:
movsxd rax, r14d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ma_tls_write(long long a1, long long a2, unsigned int a3)
{
long long v4; // r13
int v5; // eax
int v6; // r14d
long long *v7; // rax
v4 = *(_QWORD *)(a1 + 8);
while ( 1 )
{
v5 = SSL_write(*(_QWORD *)(a1 + 16), a2, a3);
v6 = v5;
if ( v5 > 0 )
break;
if ( (unsigned int)SSL_get_error(*(_QWORD *)(a1 + 16), (unsigned int)v5) != 3
|| (*(int ( **)(long long, long long, _QWORD))(*(_QWORD *)(v4 + 72) + 48LL))(
v4,
1LL,
*(unsigned int *)(*(_QWORD *)(v4 + 64) + 920LL)) <= 0 )
{
v7 = (long long *)SSL_get_ex_data(*(_QWORD *)(a1 + 16), 0LL);
ma_tls_set_error(v7);
return v6;
}
}
return v6;
}
| ma_tls_write:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R12,RSI
MOV R15,RDI
MOV R13,qword ptr [RDI + 0x8]
LAB_001285c5:
MOV RDI,qword ptr [R15 + 0x10]
MOV RSI,R12
MOV EDX,EBX
CALL 0x00113830
MOV R14D,EAX
TEST EAX,EAX
JG 0x0012861b
MOV RDI,qword ptr [R15 + 0x10]
MOV ESI,R14D
CALL 0x00113050
CMP EAX,0x3
JNZ 0x00128608
MOV RAX,qword ptr [R13 + 0x40]
MOV RCX,qword ptr [R13 + 0x48]
MOV EDX,dword ptr [RAX + 0x398]
MOV RDI,R13
MOV ESI,0x1
CALL qword ptr [RCX + 0x30]
TEST EAX,EAX
JG 0x001285c5
LAB_00128608:
MOV RDI,qword ptr [R15 + 0x10]
XOR ESI,ESI
CALL 0x00113160
MOV RDI,RAX
CALL 0x00128318
LAB_0012861b:
MOVSXD RAX,R14D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long ma_tls_write(long param_1,void *param_2,int param_3)
{
long lVar1;
int ret_code;
int iVar2;
void *pvVar3;
lVar1 = *(long *)(param_1 + 8);
do {
ret_code = SSL_write(*(SSL **)(param_1 + 0x10),param_2,param_3);
if (0 < ret_code) goto LAB_0012861b;
iVar2 = SSL_get_error(*(SSL **)(param_1 + 0x10),ret_code);
if (iVar2 != 3) break;
iVar2 = (**(code **)(*(long *)(lVar1 + 0x48) + 0x30))
(lVar1,1,*(int4 *)(*(long *)(lVar1 + 0x40) + 0x398));
} while (0 < iVar2);
pvVar3 = SSL_get_ex_data(*(SSL **)(param_1 + 0x10),0);
ma_tls_set_error(pvVar3);
LAB_0012861b:
return (long)ret_code;
}
| |
24,860 | void rapidjson::GenericReader<rapidjson::UTF8<char>, rapidjson::UTF8<char>, rapidjson::CrtAllocator>::ParseArray<0u, rapidjson::GenericStringStream<rapidjson::UTF8<char>>, rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>>(rapidjson::GenericStringStream<rapidjson::UTF8<char>>&, rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>&) | mnn-tts/MNN/3rd_party/rapidjson/reader.h | void ParseArray(InputStream& is, Handler& handler) {
RAPIDJSON_ASSERT(is.Peek() == '[');
is.Take(); // Skip '['
if (RAPIDJSON_UNLIKELY(!handler.StartArray()))
RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
SkipWhitespaceAndComments<parseFlags>(is);
RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
if (Consume(is, ']')) {
if (RAPIDJSON_UNLIKELY(!handler.EndArray(0))) // empty array
RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
return;
}
for (SizeType elementCount = 0;;) {
ParseValue<parseFlags>(is, handler);
RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
++elementCount;
SkipWhitespaceAndComments<parseFlags>(is);
RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
if (Consume(is, ',')) {
SkipWhitespaceAndComments<parseFlags>(is);
RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
}
else if (Consume(is, ']')) {
if (RAPIDJSON_UNLIKELY(!handler.EndArray(elementCount)))
RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
return;
}
else
RAPIDJSON_PARSE_ERROR(kParseErrorArrayMissCommaOrSquareBracket, is.Tell());
if (parseFlags & kParseTrailingCommasFlag) {
if (is.Peek() == ']') {
if (RAPIDJSON_UNLIKELY(!handler.EndArray(elementCount)))
RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
is.Take();
return;
}
}
}
} | O0 | c | void rapidjson::GenericReader<rapidjson::UTF8<char>, rapidjson::UTF8<char>, rapidjson::CrtAllocator>::ParseArray<0u, rapidjson::GenericStringStream<rapidjson::UTF8<char>>, rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>>(rapidjson::GenericStringStream<rapidjson::UTF8<char>>&, rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>&):
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x196d0
movsbl %al, %eax
cmpl $0x5b, %eax
jne 0x1a670
jmp 0x1a68f
leaq 0xa539(%rip), %rdi # 0x24bb0
leaq 0x92a9(%rip), %rsi # 0x23927
movl $0x327, %edx # imm = 0x327
leaq 0xa537(%rip), %rcx # 0x24bc1
callq 0x4100
movq 0x18(%rsp), %rdi
callq 0x19960
movq 0x10(%rsp), %rdi
callq 0x1d5d0
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1a6af
jmp 0x1a720
jmp 0x1a6b1
jmp 0x1a6b3
movq (%rsp), %rdi
callq 0x196b0
xorb $-0x1, %al
testb $0x1, %al
jne 0x1a6c4
jmp 0x1a6c6
jmp 0x1a6e5
leaq 0x9249(%rip), %rdi # 0x23916
leaq 0x9253(%rip), %rsi # 0x23927
movl $0x32b, %edx # imm = 0x32B
leaq 0xa4e1(%rip), %rcx # 0x24bc1
callq 0x4100
movq 0x18(%rsp), %rdi
callq 0x19710
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x10, %esi
callq 0x196e0
jmp 0x1a702
movq (%rsp), %rdi
callq 0x196b0
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1a715
jmp 0x1a71a
jmp 0x1a9af
jmp 0x1a71c
jmp 0x1a71e
jmp 0x1a720
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x19690
movq (%rsp), %rdi
callq 0x196b0
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1a741
jmp 0x1a746
jmp 0x1a9af
jmp 0x1a748
movq 0x18(%rsp), %rdi
movl $0x5d, %esi
callq 0x1bc30
testb $0x1, %al
jne 0x1a760
jmp 0x1a7ee
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x1d600
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1a778
jmp 0x1a7e9
jmp 0x1a77a
jmp 0x1a77c
movq (%rsp), %rdi
callq 0x196b0
xorb $-0x1, %al
testb $0x1, %al
jne 0x1a78d
jmp 0x1a78f
jmp 0x1a7ae
leaq 0x9180(%rip), %rdi # 0x23916
leaq 0x918a(%rip), %rsi # 0x23927
movl $0x332, %edx # imm = 0x332
leaq 0xa418(%rip), %rcx # 0x24bc1
callq 0x4100
movq 0x18(%rsp), %rdi
callq 0x19710
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x10, %esi
callq 0x196e0
jmp 0x1a7cb
movq (%rsp), %rdi
callq 0x196b0
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1a7de
jmp 0x1a7e3
jmp 0x1a9af
jmp 0x1a7e5
jmp 0x1a7e7
jmp 0x1a7e9
jmp 0x1a9af
movl $0x0, 0xc(%rsp)
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x19730
movq (%rsp), %rdi
callq 0x196b0
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1a81c
jmp 0x1a821
jmp 0x1a9af
jmp 0x1a823
movq (%rsp), %rdi
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rsi
callq 0x19690
movq (%rsp), %rdi
callq 0x196b0
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1a84f
jmp 0x1a854
jmp 0x1a9af
jmp 0x1a856
movq 0x18(%rsp), %rdi
movl $0x2c, %esi
callq 0x1bc30
testb $0x1, %al
jne 0x1a86b
jmp 0x1a898
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x19690
movq (%rsp), %rdi
callq 0x196b0
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1a88c
jmp 0x1a891
jmp 0x1a9af
jmp 0x1a893
jmp 0x1a9aa
movq 0x18(%rsp), %rdi
movl $0x5d, %esi
callq 0x1bc30
testb $0x1, %al
jne 0x1a8b0
jmp 0x1a93a
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x1d600
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1a8ca
jmp 0x1a938
jmp 0x1a8cc
jmp 0x1a8ce
movq (%rsp), %rdi
callq 0x196b0
xorb $-0x1, %al
testb $0x1, %al
jne 0x1a8df
jmp 0x1a8e1
jmp 0x1a900
leaq 0x902e(%rip), %rdi # 0x23916
leaq 0x9038(%rip), %rsi # 0x23927
movl $0x344, %edx # imm = 0x344
leaq 0xa2c6(%rip), %rcx # 0x24bc1
callq 0x4100
movq 0x18(%rsp), %rdi
callq 0x19710
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x10, %esi
callq 0x196e0
jmp 0x1a91d
movq (%rsp), %rdi
callq 0x196b0
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1a930
jmp 0x1a932
jmp 0x1a9af
jmp 0x1a934
jmp 0x1a936
jmp 0x1a938
jmp 0x1a9af
jmp 0x1a93c
jmp 0x1a93e
movq (%rsp), %rdi
callq 0x196b0
xorb $-0x1, %al
testb $0x1, %al
jne 0x1a94f
jmp 0x1a951
jmp 0x1a970
leaq 0x8fbe(%rip), %rdi # 0x23916
leaq 0x8fc8(%rip), %rsi # 0x23927
movl $0x348, %edx # imm = 0x348
leaq 0xa256(%rip), %rcx # 0x24bc1
callq 0x4100
movq 0x18(%rsp), %rdi
callq 0x19710
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x7, %esi
callq 0x196e0
jmp 0x1a98d
movq (%rsp), %rdi
callq 0x196b0
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1a9a0
jmp 0x1a9a2
jmp 0x1a9af
jmp 0x1a9a4
jmp 0x1a9a6
jmp 0x1a9a8
jmp 0x1a9aa
jmp 0x1a7f6
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| _ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE10ParseArrayILj0ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_10], rsi
mov [rsp+28h+var_18], rdx
mov rax, [rsp+28h+var_8]
mov [rsp+28h+var_28], rax
mov rdi, [rsp+28h+var_10]
call _ZNK9rapidjson19GenericStringStreamINS_4UTF8IcEEE4PeekEv; rapidjson::GenericStringStream<rapidjson::UTF8<char>>::Peek(void)
movsx eax, al
cmp eax, 5Bh ; '['
jnz short loc_1A670
jmp short loc_1A68F
loc_1A670:
lea rdi, aIsPeek_0; "is.Peek() == '['"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github2025/mnn-tt"...
mov edx, 327h
lea rcx, aVoidRapidjsonG_4; "void rapidjson::GenericReader<rapidjson"...
call ___assert_fail
loc_1A68F:
mov rdi, [rsp+28h+var_10]
call _ZN9rapidjson19GenericStringStreamINS_4UTF8IcEEE4TakeEv; rapidjson::GenericStringStream<rapidjson::UTF8<char>>::Take(void)
mov rdi, [rsp+28h+var_18]
call _ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E10StartArrayEv; rapidjson::GenericDocument<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>,rapidjson::CrtAllocator>::StartArray(void)
xor al, 0FFh
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_1A6AF
jmp short loc_1A720
loc_1A6AF:
jmp short $+2
loc_1A6B1:
jmp short $+2
loc_1A6B3:
mov rdi, [rsp+28h+var_28]
call _ZNK9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE13HasParseErrorEv; rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::HasParseError(void)
xor al, 0FFh
test al, 1
jnz short loc_1A6C4
jmp short loc_1A6C6
loc_1A6C4:
jmp short loc_1A6E5
loc_1A6C6:
lea rdi, aHasparseerror; "!HasParseError()"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github2025/mnn-tt"...
mov edx, 32Bh
lea rcx, aVoidRapidjsonG_4; "void rapidjson::GenericReader<rapidjson"...
call ___assert_fail
loc_1A6E5:
mov rdi, [rsp+28h+var_10]
call _ZNK9rapidjson19GenericStringStreamINS_4UTF8IcEEE4TellEv; rapidjson::GenericStringStream<rapidjson::UTF8<char>>::Tell(void)
mov rdi, [rsp+28h+var_28]
mov rdx, rax
mov esi, 10h
call _ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE13SetParseErrorENS_14ParseErrorCodeEm; rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::SetParseError(rapidjson::ParseErrorCode,ulong)
jmp short $+2
loc_1A702:
mov rdi, [rsp+28h+var_28]
call _ZNK9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE13HasParseErrorEv; rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::HasParseError(void)
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_1A715
jmp short loc_1A71A
loc_1A715:
jmp loc_1A9AF
loc_1A71A:
jmp short $+2
loc_1A71C:
jmp short $+2
loc_1A71E:
jmp short $+2
loc_1A720:
mov rdi, [rsp+28h+var_28]
mov rsi, [rsp+28h+var_10]
call _ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE25SkipWhitespaceAndCommentsILj0ENS_19GenericStringStreamIS2_EEEEvRT0_; rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::SkipWhitespaceAndComments<0u,rapidjson::GenericStringStream<rapidjson::UTF8<char>>>(rapidjson::GenericStringStream<rapidjson::UTF8<char>> &)
mov rdi, [rsp+28h+var_28]
call _ZNK9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE13HasParseErrorEv; rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::HasParseError(void)
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_1A741
jmp short loc_1A746
loc_1A741:
jmp loc_1A9AF
loc_1A746:
jmp short $+2
loc_1A748:
mov rdi, [rsp+28h+var_10]
mov esi, 5Dh ; ']'
call _ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE7ConsumeINS_19GenericStringStreamIS2_EEEEbRT_NS8_2ChE; rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::Consume<rapidjson::GenericStringStream<rapidjson::UTF8<char>>>(rapidjson::GenericStringStream<rapidjson::UTF8<char>> &,rapidjson::GenericStringStream<rapidjson::UTF8<char>>::Ch)
test al, 1
jnz short loc_1A760
jmp loc_1A7EE
loc_1A760:
mov rdi, [rsp+28h+var_18]
xor esi, esi
call _ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E8EndArrayEj; rapidjson::GenericDocument<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>,rapidjson::CrtAllocator>::EndArray(uint)
xor al, 0FFh
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_1A778
jmp short loc_1A7E9
loc_1A778:
jmp short $+2
loc_1A77A:
jmp short $+2
loc_1A77C:
mov rdi, [rsp+28h+var_28]
call _ZNK9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE13HasParseErrorEv; rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::HasParseError(void)
xor al, 0FFh
test al, 1
jnz short loc_1A78D
jmp short loc_1A78F
loc_1A78D:
jmp short loc_1A7AE
loc_1A78F:
lea rdi, aHasparseerror; "!HasParseError()"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github2025/mnn-tt"...
mov edx, 332h
lea rcx, aVoidRapidjsonG_4; "void rapidjson::GenericReader<rapidjson"...
call ___assert_fail
loc_1A7AE:
mov rdi, [rsp+28h+var_10]
call _ZNK9rapidjson19GenericStringStreamINS_4UTF8IcEEE4TellEv; rapidjson::GenericStringStream<rapidjson::UTF8<char>>::Tell(void)
mov rdi, [rsp+28h+var_28]
mov rdx, rax
mov esi, 10h
call _ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE13SetParseErrorENS_14ParseErrorCodeEm; rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::SetParseError(rapidjson::ParseErrorCode,ulong)
jmp short $+2
loc_1A7CB:
mov rdi, [rsp+28h+var_28]
call _ZNK9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE13HasParseErrorEv; rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::HasParseError(void)
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_1A7DE
jmp short loc_1A7E3
loc_1A7DE:
jmp loc_1A9AF
loc_1A7E3:
jmp short $+2
loc_1A7E5:
jmp short $+2
loc_1A7E7:
jmp short $+2
loc_1A7E9:
jmp loc_1A9AF
loc_1A7EE:
mov [rsp+28h+var_1C], 0
loc_1A7F6:
mov rdi, [rsp+28h+var_28]
mov rsi, [rsp+28h+var_10]
mov rdx, [rsp+28h+var_18]
call _ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE10ParseValueILj0ENS_19GenericStringStreamIS2_EENS_15GenericDocumentIS2_NS_19MemoryPoolAllocatorIS3_EES3_EEEEvRT0_RT1_; rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::ParseValue<0u,rapidjson::GenericStringStream<rapidjson::UTF8<char>>,rapidjson::GenericDocument<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>,rapidjson::CrtAllocator>>(rapidjson::GenericStringStream<rapidjson::UTF8<char>> &,rapidjson::GenericDocument<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>,rapidjson::CrtAllocator> &)
mov rdi, [rsp+28h+var_28]
call _ZNK9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE13HasParseErrorEv; rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::HasParseError(void)
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_1A81C
jmp short loc_1A821
loc_1A81C:
jmp loc_1A9AF
loc_1A821:
jmp short $+2
loc_1A823:
mov rdi, [rsp+28h+var_28]
mov eax, [rsp+28h+var_1C]
add eax, 1
mov [rsp+28h+var_1C], eax
mov rsi, [rsp+28h+var_10]
call _ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE25SkipWhitespaceAndCommentsILj0ENS_19GenericStringStreamIS2_EEEEvRT0_; rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::SkipWhitespaceAndComments<0u,rapidjson::GenericStringStream<rapidjson::UTF8<char>>>(rapidjson::GenericStringStream<rapidjson::UTF8<char>> &)
mov rdi, [rsp+28h+var_28]
call _ZNK9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE13HasParseErrorEv; rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::HasParseError(void)
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_1A84F
jmp short loc_1A854
loc_1A84F:
jmp loc_1A9AF
loc_1A854:
jmp short $+2
loc_1A856:
mov rdi, [rsp+28h+var_10]
mov esi, 2Ch ; ','
call _ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE7ConsumeINS_19GenericStringStreamIS2_EEEEbRT_NS8_2ChE; rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::Consume<rapidjson::GenericStringStream<rapidjson::UTF8<char>>>(rapidjson::GenericStringStream<rapidjson::UTF8<char>> &,rapidjson::GenericStringStream<rapidjson::UTF8<char>>::Ch)
test al, 1
jnz short loc_1A86B
jmp short loc_1A898
loc_1A86B:
mov rdi, [rsp+28h+var_28]
mov rsi, [rsp+28h+var_10]
call _ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE25SkipWhitespaceAndCommentsILj0ENS_19GenericStringStreamIS2_EEEEvRT0_; rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::SkipWhitespaceAndComments<0u,rapidjson::GenericStringStream<rapidjson::UTF8<char>>>(rapidjson::GenericStringStream<rapidjson::UTF8<char>> &)
mov rdi, [rsp+28h+var_28]
call _ZNK9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE13HasParseErrorEv; rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::HasParseError(void)
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_1A88C
jmp short loc_1A891
loc_1A88C:
jmp loc_1A9AF
loc_1A891:
jmp short $+2
loc_1A893:
jmp loc_1A9AA
loc_1A898:
mov rdi, [rsp+28h+var_10]
mov esi, 5Dh ; ']'
call _ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE7ConsumeINS_19GenericStringStreamIS2_EEEEbRT_NS8_2ChE; rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::Consume<rapidjson::GenericStringStream<rapidjson::UTF8<char>>>(rapidjson::GenericStringStream<rapidjson::UTF8<char>> &,rapidjson::GenericStringStream<rapidjson::UTF8<char>>::Ch)
test al, 1
jnz short loc_1A8B0
jmp loc_1A93A
loc_1A8B0:
mov rdi, [rsp+28h+var_18]
mov esi, [rsp+28h+var_1C]
call _ZN9rapidjson15GenericDocumentINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEES4_E8EndArrayEj; rapidjson::GenericDocument<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>,rapidjson::CrtAllocator>::EndArray(uint)
xor al, 0FFh
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_1A8CA
jmp short loc_1A938
loc_1A8CA:
jmp short $+2
loc_1A8CC:
jmp short $+2
loc_1A8CE:
mov rdi, [rsp+28h+var_28]
call _ZNK9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE13HasParseErrorEv; rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::HasParseError(void)
xor al, 0FFh
test al, 1
jnz short loc_1A8DF
jmp short loc_1A8E1
loc_1A8DF:
jmp short loc_1A900
loc_1A8E1:
lea rdi, aHasparseerror; "!HasParseError()"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github2025/mnn-tt"...
mov edx, 344h
lea rcx, aVoidRapidjsonG_4; "void rapidjson::GenericReader<rapidjson"...
call ___assert_fail
loc_1A900:
mov rdi, [rsp+28h+var_10]
call _ZNK9rapidjson19GenericStringStreamINS_4UTF8IcEEE4TellEv; rapidjson::GenericStringStream<rapidjson::UTF8<char>>::Tell(void)
mov rdi, [rsp+28h+var_28]
mov rdx, rax
mov esi, 10h
call _ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE13SetParseErrorENS_14ParseErrorCodeEm; rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::SetParseError(rapidjson::ParseErrorCode,ulong)
jmp short $+2
loc_1A91D:
mov rdi, [rsp+28h+var_28]
call _ZNK9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE13HasParseErrorEv; rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::HasParseError(void)
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_1A930
jmp short loc_1A932
loc_1A930:
jmp short loc_1A9AF
loc_1A932:
jmp short $+2
loc_1A934:
jmp short $+2
loc_1A936:
jmp short $+2
loc_1A938:
jmp short loc_1A9AF
loc_1A93A:
jmp short $+2
loc_1A93C:
jmp short $+2
loc_1A93E:
mov rdi, [rsp+28h+var_28]
call _ZNK9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE13HasParseErrorEv; rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::HasParseError(void)
xor al, 0FFh
test al, 1
jnz short loc_1A94F
jmp short loc_1A951
loc_1A94F:
jmp short loc_1A970
loc_1A951:
lea rdi, aHasparseerror; "!HasParseError()"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github2025/mnn-tt"...
mov edx, 348h
lea rcx, aVoidRapidjsonG_4; "void rapidjson::GenericReader<rapidjson"...
call ___assert_fail
loc_1A970:
mov rdi, [rsp+28h+var_10]
call _ZNK9rapidjson19GenericStringStreamINS_4UTF8IcEEE4TellEv; rapidjson::GenericStringStream<rapidjson::UTF8<char>>::Tell(void)
mov rdi, [rsp+28h+var_28]
mov rdx, rax
mov esi, 7
call _ZN9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE13SetParseErrorENS_14ParseErrorCodeEm; rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::SetParseError(rapidjson::ParseErrorCode,ulong)
jmp short $+2
loc_1A98D:
mov rdi, [rsp+28h+var_28]
call _ZNK9rapidjson13GenericReaderINS_4UTF8IcEES2_NS_12CrtAllocatorEE13HasParseErrorEv; rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::HasParseError(void)
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_1A9A0
jmp short loc_1A9A2
loc_1A9A0:
jmp short loc_1A9AF
loc_1A9A2:
jmp short $+2
loc_1A9A4:
jmp short $+2
loc_1A9A6:
jmp short $+2
loc_1A9A8:
jmp short $+2
loc_1A9AA:
jmp loc_1A7F6
loc_1A9AF:
add rsp, 28h
retn
| char rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::ParseArray<0u,rapidjson::GenericStringStream<rapidjson::UTF8<char>>,rapidjson::GenericDocument<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>,rapidjson::CrtAllocator>>(
long long a1,
_QWORD *a2,
long long a3)
{
long long v3; // rax
char result; // al
long long v5; // rax
long long v6; // rax
unsigned int v7; // [rsp+Ch] [rbp-1Ch]
if ( rapidjson::GenericStringStream<rapidjson::UTF8<char>>::Peek((long long)a2) != 91 )
__assert_fail(
"is.Peek() == '['",
"/workspace/llm4binary/github2025/mnn-tts/MNN/3rd_party/rapidjson/reader.h",
807LL,
"void rapidjson::GenericReader<rapidjson::UTF8<>, rapidjson::UTF8<>>::ParseArray(InputStream &, Handler &) [SourceE"
"ncoding = rapidjson::UTF8<>, TargetEncoding = rapidjson::UTF8<>, StackAllocator = rapidjson::CrtAllocator, parseFl"
"ags = 0U, InputStream = rapidjson::GenericStringStream<rapidjson::UTF8<>>, Handler = rapidjson::GenericDocument<ra"
"pidjson::UTF8<>>]");
rapidjson::GenericStringStream<rapidjson::UTF8<char>>::Take(a2);
if ( (rapidjson::GenericDocument<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>,rapidjson::CrtAllocator>::StartArray(a3) & 1) != 0 )
goto LABEL_32;
if ( (rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::HasParseError(a1) & 1) != 0 )
__assert_fail(
"!HasParseError()",
"/workspace/llm4binary/github2025/mnn-tts/MNN/3rd_party/rapidjson/reader.h",
811LL,
"void rapidjson::GenericReader<rapidjson::UTF8<>, rapidjson::UTF8<>>::ParseArray(InputStream &, Handler &) [SourceE"
"ncoding = rapidjson::UTF8<>, TargetEncoding = rapidjson::UTF8<>, StackAllocator = rapidjson::CrtAllocator, parseFl"
"ags = 0U, InputStream = rapidjson::GenericStringStream<rapidjson::UTF8<>>, Handler = rapidjson::GenericDocument<ra"
"pidjson::UTF8<>>]");
v3 = rapidjson::GenericStringStream<rapidjson::UTF8<char>>::Tell(a2);
rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::SetParseError(
a1,
0x10u,
v3);
result = rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::HasParseError(a1);
if ( (result & 1) == 0 )
{
LABEL_32:
rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::SkipWhitespaceAndComments<0u,rapidjson::GenericStringStream<rapidjson::UTF8<char>>>(
a1,
(long long)a2);
result = rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::HasParseError(a1);
if ( (result & 1) == 0 )
{
if ( (rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::Consume<rapidjson::GenericStringStream<rapidjson::UTF8<char>>>(
a2,
93LL) & 1) != 0 )
{
result = ~(unsigned __int8)rapidjson::GenericDocument<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>,rapidjson::CrtAllocator>::EndArray(
a3,
0LL);
if ( (result & 1) != 0 )
{
if ( (rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::HasParseError(a1) & 1) != 0 )
__assert_fail(
"!HasParseError()",
"/workspace/llm4binary/github2025/mnn-tts/MNN/3rd_party/rapidjson/reader.h",
818LL,
"void rapidjson::GenericReader<rapidjson::UTF8<>, rapidjson::UTF8<>>::ParseArray(InputStream &, Handler &) "
"[SourceEncoding = rapidjson::UTF8<>, TargetEncoding = rapidjson::UTF8<>, StackAllocator = rapidjson::CrtAl"
"locator, parseFlags = 0U, InputStream = rapidjson::GenericStringStream<rapidjson::UTF8<>>, Handler = rapid"
"json::GenericDocument<rapidjson::UTF8<>>]");
LABEL_12:
v5 = rapidjson::GenericStringStream<rapidjson::UTF8<char>>::Tell(a2);
rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::SetParseError(
a1,
0x10u,
v5);
return rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::HasParseError(a1);
}
}
else
{
v7 = 0;
while ( 1 )
{
rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::ParseValue<0u,rapidjson::GenericStringStream<rapidjson::UTF8<char>>,rapidjson::GenericDocument<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>,rapidjson::CrtAllocator>>(
a1,
(long long)a2,
a3);
result = rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::HasParseError(a1);
if ( (result & 1) != 0 )
break;
++v7;
rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::SkipWhitespaceAndComments<0u,rapidjson::GenericStringStream<rapidjson::UTF8<char>>>(
a1,
(long long)a2);
result = rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::HasParseError(a1);
if ( (result & 1) != 0 )
break;
if ( (rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::Consume<rapidjson::GenericStringStream<rapidjson::UTF8<char>>>(
a2,
44LL) & 1) != 0 )
{
rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::SkipWhitespaceAndComments<0u,rapidjson::GenericStringStream<rapidjson::UTF8<char>>>(
a1,
(long long)a2);
result = rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::HasParseError(a1);
if ( (result & 1) != 0 )
return result;
}
else
{
if ( (rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::Consume<rapidjson::GenericStringStream<rapidjson::UTF8<char>>>(
a2,
93LL) & 1) != 0 )
{
result = ~(unsigned __int8)rapidjson::GenericDocument<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>,rapidjson::CrtAllocator>::EndArray(
a3,
v7);
if ( (result & 1) == 0 )
return result;
if ( (rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::HasParseError(a1) & 1) != 0 )
__assert_fail(
"!HasParseError()",
"/workspace/llm4binary/github2025/mnn-tts/MNN/3rd_party/rapidjson/reader.h",
836LL,
"void rapidjson::GenericReader<rapidjson::UTF8<>, rapidjson::UTF8<>>::ParseArray(InputStream &, Handler"
" &) [SourceEncoding = rapidjson::UTF8<>, TargetEncoding = rapidjson::UTF8<>, StackAllocator = rapidjso"
"n::CrtAllocator, parseFlags = 0U, InputStream = rapidjson::GenericStringStream<rapidjson::UTF8<>>, Han"
"dler = rapidjson::GenericDocument<rapidjson::UTF8<>>]");
goto LABEL_12;
}
if ( (rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::HasParseError(a1) & 1) != 0 )
__assert_fail(
"!HasParseError()",
"/workspace/llm4binary/github2025/mnn-tts/MNN/3rd_party/rapidjson/reader.h",
840LL,
"void rapidjson::GenericReader<rapidjson::UTF8<>, rapidjson::UTF8<>>::ParseArray(InputStream &, Handler &"
") [SourceEncoding = rapidjson::UTF8<>, TargetEncoding = rapidjson::UTF8<>, StackAllocator = rapidjson::C"
"rtAllocator, parseFlags = 0U, InputStream = rapidjson::GenericStringStream<rapidjson::UTF8<>>, Handler ="
" rapidjson::GenericDocument<rapidjson::UTF8<>>]");
v6 = rapidjson::GenericStringStream<rapidjson::UTF8<char>>::Tell(a2);
rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::SetParseError(
a1,
7u,
v6);
result = rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::HasParseError(a1);
if ( (result & 1) != 0 )
return result;
}
}
}
}
}
return result;
}
| ParseArray<0u,rapidjson::GenericStringStream<rapidjson::UTF8<char>>,rapidjson::GenericDocument<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>,rapidjson::CrtAllocator>>:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RSI
MOV qword ptr [RSP + 0x10],RDX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001196d0
MOVSX EAX,AL
CMP EAX,0x5b
JNZ 0x0011a670
JMP 0x0011a68f
LAB_0011a670:
LEA RDI,[0x124bb0]
LEA RSI,[0x123927]
MOV EDX,0x327
LEA RCX,[0x124bc1]
CALL 0x00104100
LAB_0011a68f:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x00119960
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x0011d5d0
XOR AL,0xff
XOR AL,0xff
XOR AL,0xff
TEST AL,0x1
JNZ 0x0011a6af
JMP 0x0011a720
LAB_0011a6af:
JMP 0x0011a6b1
LAB_0011a6b1:
JMP 0x0011a6b3
LAB_0011a6b3:
MOV RDI,qword ptr [RSP]
CALL 0x001196b0
XOR AL,0xff
TEST AL,0x1
JNZ 0x0011a6c4
JMP 0x0011a6c6
LAB_0011a6c4:
JMP 0x0011a6e5
LAB_0011a6c6:
LEA RDI,[0x123916]
LEA RSI,[0x123927]
MOV EDX,0x32b
LEA RCX,[0x124bc1]
CALL 0x00104100
LAB_0011a6e5:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x00119710
MOV RDI,qword ptr [RSP]
MOV RDX,RAX
MOV ESI,0x10
CALL 0x001196e0
JMP 0x0011a702
LAB_0011a702:
MOV RDI,qword ptr [RSP]
CALL 0x001196b0
XOR AL,0xff
XOR AL,0xff
TEST AL,0x1
JNZ 0x0011a715
JMP 0x0011a71a
LAB_0011a715:
JMP 0x0011a9af
LAB_0011a71a:
JMP 0x0011a71c
LAB_0011a71c:
JMP 0x0011a71e
LAB_0011a71e:
JMP 0x0011a720
LAB_0011a720:
MOV RDI,qword ptr [RSP]
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x00119690
MOV RDI,qword ptr [RSP]
CALL 0x001196b0
XOR AL,0xff
XOR AL,0xff
TEST AL,0x1
JNZ 0x0011a741
JMP 0x0011a746
LAB_0011a741:
JMP 0x0011a9af
LAB_0011a746:
JMP 0x0011a748
LAB_0011a748:
MOV RDI,qword ptr [RSP + 0x18]
MOV ESI,0x5d
CALL 0x0011bc30
TEST AL,0x1
JNZ 0x0011a760
JMP 0x0011a7ee
LAB_0011a760:
MOV RDI,qword ptr [RSP + 0x10]
XOR ESI,ESI
CALL 0x0011d600
XOR AL,0xff
XOR AL,0xff
XOR AL,0xff
TEST AL,0x1
JNZ 0x0011a778
JMP 0x0011a7e9
LAB_0011a778:
JMP 0x0011a77a
LAB_0011a77a:
JMP 0x0011a77c
LAB_0011a77c:
MOV RDI,qword ptr [RSP]
CALL 0x001196b0
XOR AL,0xff
TEST AL,0x1
JNZ 0x0011a78d
JMP 0x0011a78f
LAB_0011a78d:
JMP 0x0011a7ae
LAB_0011a78f:
LEA RDI,[0x123916]
LEA RSI,[0x123927]
MOV EDX,0x332
LEA RCX,[0x124bc1]
CALL 0x00104100
LAB_0011a7ae:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x00119710
MOV RDI,qword ptr [RSP]
MOV RDX,RAX
MOV ESI,0x10
CALL 0x001196e0
JMP 0x0011a7cb
LAB_0011a7cb:
MOV RDI,qword ptr [RSP]
CALL 0x001196b0
XOR AL,0xff
XOR AL,0xff
TEST AL,0x1
JNZ 0x0011a7de
JMP 0x0011a7e3
LAB_0011a7de:
JMP 0x0011a9af
LAB_0011a7e3:
JMP 0x0011a7e5
LAB_0011a7e5:
JMP 0x0011a7e7
LAB_0011a7e7:
JMP 0x0011a7e9
LAB_0011a7e9:
JMP 0x0011a9af
LAB_0011a7ee:
MOV dword ptr [RSP + 0xc],0x0
LAB_0011a7f6:
MOV RDI,qword ptr [RSP]
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x10]
CALL 0x00119730
MOV RDI,qword ptr [RSP]
CALL 0x001196b0
XOR AL,0xff
XOR AL,0xff
TEST AL,0x1
JNZ 0x0011a81c
JMP 0x0011a821
LAB_0011a81c:
JMP 0x0011a9af
LAB_0011a821:
JMP 0x0011a823
LAB_0011a823:
MOV RDI,qword ptr [RSP]
MOV EAX,dword ptr [RSP + 0xc]
ADD EAX,0x1
MOV dword ptr [RSP + 0xc],EAX
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x00119690
MOV RDI,qword ptr [RSP]
CALL 0x001196b0
XOR AL,0xff
XOR AL,0xff
TEST AL,0x1
JNZ 0x0011a84f
JMP 0x0011a854
LAB_0011a84f:
JMP 0x0011a9af
LAB_0011a854:
JMP 0x0011a856
LAB_0011a856:
MOV RDI,qword ptr [RSP + 0x18]
MOV ESI,0x2c
CALL 0x0011bc30
TEST AL,0x1
JNZ 0x0011a86b
JMP 0x0011a898
LAB_0011a86b:
MOV RDI,qword ptr [RSP]
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x00119690
MOV RDI,qword ptr [RSP]
CALL 0x001196b0
XOR AL,0xff
XOR AL,0xff
TEST AL,0x1
JNZ 0x0011a88c
JMP 0x0011a891
LAB_0011a88c:
JMP 0x0011a9af
LAB_0011a891:
JMP 0x0011a893
LAB_0011a893:
JMP 0x0011a9aa
LAB_0011a898:
MOV RDI,qword ptr [RSP + 0x18]
MOV ESI,0x5d
CALL 0x0011bc30
TEST AL,0x1
JNZ 0x0011a8b0
JMP 0x0011a93a
LAB_0011a8b0:
MOV RDI,qword ptr [RSP + 0x10]
MOV ESI,dword ptr [RSP + 0xc]
CALL 0x0011d600
XOR AL,0xff
XOR AL,0xff
XOR AL,0xff
TEST AL,0x1
JNZ 0x0011a8ca
JMP 0x0011a938
LAB_0011a8ca:
JMP 0x0011a8cc
LAB_0011a8cc:
JMP 0x0011a8ce
LAB_0011a8ce:
MOV RDI,qword ptr [RSP]
CALL 0x001196b0
XOR AL,0xff
TEST AL,0x1
JNZ 0x0011a8df
JMP 0x0011a8e1
LAB_0011a8df:
JMP 0x0011a900
LAB_0011a8e1:
LEA RDI,[0x123916]
LEA RSI,[0x123927]
MOV EDX,0x344
LEA RCX,[0x124bc1]
CALL 0x00104100
LAB_0011a900:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x00119710
MOV RDI,qword ptr [RSP]
MOV RDX,RAX
MOV ESI,0x10
CALL 0x001196e0
JMP 0x0011a91d
LAB_0011a91d:
MOV RDI,qword ptr [RSP]
CALL 0x001196b0
XOR AL,0xff
XOR AL,0xff
TEST AL,0x1
JNZ 0x0011a930
JMP 0x0011a932
LAB_0011a930:
JMP 0x0011a9af
LAB_0011a932:
JMP 0x0011a934
LAB_0011a934:
JMP 0x0011a936
LAB_0011a936:
JMP 0x0011a938
LAB_0011a938:
JMP 0x0011a9af
LAB_0011a93a:
JMP 0x0011a93c
LAB_0011a93c:
JMP 0x0011a93e
LAB_0011a93e:
MOV RDI,qword ptr [RSP]
CALL 0x001196b0
XOR AL,0xff
TEST AL,0x1
JNZ 0x0011a94f
JMP 0x0011a951
LAB_0011a94f:
JMP 0x0011a970
LAB_0011a951:
LEA RDI,[0x123916]
LEA RSI,[0x123927]
MOV EDX,0x348
LEA RCX,[0x124bc1]
CALL 0x00104100
LAB_0011a970:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x00119710
MOV RDI,qword ptr [RSP]
MOV RDX,RAX
MOV ESI,0x7
CALL 0x001196e0
JMP 0x0011a98d
LAB_0011a98d:
MOV RDI,qword ptr [RSP]
CALL 0x001196b0
XOR AL,0xff
XOR AL,0xff
TEST AL,0x1
JNZ 0x0011a9a0
JMP 0x0011a9a2
LAB_0011a9a0:
JMP 0x0011a9af
LAB_0011a9a2:
JMP 0x0011a9a4
LAB_0011a9a4:
JMP 0x0011a9a6
LAB_0011a9a6:
JMP 0x0011a9a8
LAB_0011a9a8:
JMP 0x0011a9aa
LAB_0011a9aa:
JMP 0x0011a7f6
LAB_0011a9af:
ADD RSP,0x28
RET
|
/* void rapidjson::GenericReader<rapidjson::UTF8<char>, rapidjson::UTF8<char>,
rapidjson::CrtAllocator>::ParseArray<0u, rapidjson::GenericStringStream<rapidjson::UTF8<char> >,
rapidjson::GenericDocument<rapidjson::UTF8<char>,
rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>
>(rapidjson::GenericStringStream<rapidjson::UTF8<char> >&,
rapidjson::GenericDocument<rapidjson::UTF8<char>,
rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>&) */
void __thiscall
rapidjson::GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator>::
ParseArray<0u,rapidjson::GenericStringStream<rapidjson::UTF8<char>>,rapidjson::GenericDocument<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>,rapidjson::CrtAllocator>>
(GenericReader<rapidjson::UTF8<char>,rapidjson::UTF8<char>,rapidjson::CrtAllocator> *this,
GenericStringStream *param_1,GenericDocument *param_2)
{
char cVar1;
byte bVar2;
bool bVar3;
int8 uVar4;
uint local_1c;
cVar1 = GenericStringStream<rapidjson::UTF8<char>>::Peek
((GenericStringStream<rapidjson::UTF8<char>> *)param_1);
if (cVar1 != '[') {
/* WARNING: Subroutine does not return */
__assert_fail("is.Peek() == \'[\'",
"/workspace/llm4binary/github2025/mnn-tts/MNN/3rd_party/rapidjson/reader.h",0x327,
"void rapidjson::GenericReader<rapidjson::UTF8<>, rapidjson::UTF8<>>::ParseArray(InputStream &, Handler &) [SourceEncoding = rapidjson::UTF8<>, TargetEncoding = rapidjson::UTF8<>, StackAllocator = rapidjson::CrtAllocator, parseFlags = 0U, InputStream = rapidjson::GenericStringStream<rapidjson::UTF8<>>, Handler = rapidjson::GenericDocument<rapidjson::UTF8<>>]"
);
}
GenericStringStream<rapidjson::UTF8<char>>::Take
((GenericStringStream<rapidjson::UTF8<char>> *)param_1);
bVar2 = GenericDocument<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>,rapidjson::CrtAllocator>
::StartArray((GenericDocument<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>,rapidjson::CrtAllocator>
*)param_2);
if (((bVar2 ^ 0xff) & 1) != 0) {
bVar2 = HasParseError(this);
if (((bVar2 ^ 0xff) & 1) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("!HasParseError()",
"/workspace/llm4binary/github2025/mnn-tts/MNN/3rd_party/rapidjson/reader.h",
0x32b,
"void rapidjson::GenericReader<rapidjson::UTF8<>, rapidjson::UTF8<>>::ParseArray(InputStream &, Handler &) [SourceEncoding = rapidjson::UTF8<>, TargetEncoding = rapidjson::UTF8<>, StackAllocator = rapidjson::CrtAllocator, parseFlags = 0U, InputStream = rapidjson::GenericStringStream<rapidjson::UTF8<>>, Handler = rapidjson::GenericDocument<rapidjson::UTF8<>>]"
);
}
uVar4 = GenericStringStream<rapidjson::UTF8<char>>::Tell
((GenericStringStream<rapidjson::UTF8<char>> *)param_1);
SetParseError(this,0x10,uVar4);
bVar2 = HasParseError(this);
if ((bVar2 & 1) != 0) {
return;
}
}
SkipWhitespaceAndComments<0u,rapidjson::GenericStringStream<rapidjson::UTF8<char>>>(this,param_1);
bVar2 = HasParseError(this);
if ((bVar2 & 1) == 0) {
bVar3 = Consume<rapidjson::GenericStringStream<rapidjson::UTF8<char>>>(param_1);
if (bVar3) {
bVar2 = GenericDocument<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>,rapidjson::CrtAllocator>
::EndArray((GenericDocument<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>,rapidjson::CrtAllocator>
*)param_2,0);
if (((bVar2 ^ 0xff) & 1) != 0) {
bVar2 = HasParseError(this);
if (((bVar2 ^ 0xff) & 1) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("!HasParseError()",
"/workspace/llm4binary/github2025/mnn-tts/MNN/3rd_party/rapidjson/reader.h",
0x332,
"void rapidjson::GenericReader<rapidjson::UTF8<>, rapidjson::UTF8<>>::ParseArray(InputStream &, Handler &) [SourceEncoding = rapidjson::UTF8<>, TargetEncoding = rapidjson::UTF8<>, StackAllocator = rapidjson::CrtAllocator, parseFlags = 0U, InputStream = rapidjson::GenericStringStream<rapidjson::UTF8<>>, Handler = rapidjson::GenericDocument<rapidjson::UTF8<>>]"
);
}
uVar4 = GenericStringStream<rapidjson::UTF8<char>>::Tell
((GenericStringStream<rapidjson::UTF8<char>> *)param_1);
SetParseError(this,0x10,uVar4);
HasParseError(this);
}
}
else {
local_1c = 0;
do {
while( true ) {
ParseValue<0u,rapidjson::GenericStringStream<rapidjson::UTF8<char>>,rapidjson::GenericDocument<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>,rapidjson::CrtAllocator>>
(this,param_1,param_2);
bVar2 = HasParseError(this);
if ((bVar2 & 1) != 0) {
return;
}
local_1c = local_1c + 1;
SkipWhitespaceAndComments<0u,rapidjson::GenericStringStream<rapidjson::UTF8<char>>>
(this,param_1);
bVar2 = HasParseError(this);
if ((bVar2 & 1) != 0) {
return;
}
bVar3 = Consume<rapidjson::GenericStringStream<rapidjson::UTF8<char>>>(param_1,0x2c);
if (bVar3) break;
bVar3 = Consume<rapidjson::GenericStringStream<rapidjson::UTF8<char>>>(param_1,0x5d);
if (bVar3) {
bVar2 = GenericDocument<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>,rapidjson::CrtAllocator>
::EndArray((GenericDocument<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>,rapidjson::CrtAllocator>
*)param_2,local_1c);
if (((bVar2 ^ 0xff) & 1) == 0) {
return;
}
bVar2 = HasParseError(this);
if (((bVar2 ^ 0xff) & 1) != 0) {
uVar4 = GenericStringStream<rapidjson::UTF8<char>>::Tell
((GenericStringStream<rapidjson::UTF8<char>> *)param_1);
SetParseError(this,0x10,uVar4);
HasParseError(this);
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("!HasParseError()",
"/workspace/llm4binary/github2025/mnn-tts/MNN/3rd_party/rapidjson/reader.h"
,0x344,
"void rapidjson::GenericReader<rapidjson::UTF8<>, rapidjson::UTF8<>>::ParseArray(InputStream &, Handler &) [SourceEncoding = rapidjson::UTF8<>, TargetEncoding = rapidjson::UTF8<>, StackAllocator = rapidjson::CrtAllocator, parseFlags = 0U, InputStream = rapidjson::GenericStringStream<rapidjson::UTF8<>>, Handler = rapidjson::GenericDocument<rapidjson::UTF8<>>]"
);
}
bVar2 = HasParseError(this);
if (((bVar2 ^ 0xff) & 1) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("!HasParseError()",
"/workspace/llm4binary/github2025/mnn-tts/MNN/3rd_party/rapidjson/reader.h"
,0x348,
"void rapidjson::GenericReader<rapidjson::UTF8<>, rapidjson::UTF8<>>::ParseArray(InputStream &, Handler &) [SourceEncoding = rapidjson::UTF8<>, TargetEncoding = rapidjson::UTF8<>, StackAllocator = rapidjson::CrtAllocator, parseFlags = 0U, InputStream = rapidjson::GenericStringStream<rapidjson::UTF8<>>, Handler = rapidjson::GenericDocument<rapidjson::UTF8<>>]"
);
}
uVar4 = GenericStringStream<rapidjson::UTF8<char>>::Tell
((GenericStringStream<rapidjson::UTF8<char>> *)param_1);
SetParseError(this,7,uVar4);
bVar2 = HasParseError(this);
if ((bVar2 & 1) != 0) {
return;
}
}
SkipWhitespaceAndComments<0u,rapidjson::GenericStringStream<rapidjson::UTF8<char>>>
(this,param_1);
bVar2 = HasParseError(this);
} while ((bVar2 & 1) == 0);
}
}
return;
}
| |
24,861 | JS_ToInt32SatFree | bluesky950520[P]quickjs/quickjs.c | static int JS_ToInt32SatFree(JSContext *ctx, int *pres, JSValue val)
{
uint32_t tag;
int ret;
redo:
tag = JS_VALUE_GET_NORM_TAG(val);
switch(tag) {
case JS_TAG_INT:
case JS_TAG_BOOL:
case JS_TAG_NULL:
case JS_TAG_UNDEFINED:
ret = JS_VALUE_GET_INT(val);
break;
case JS_TAG_EXCEPTION:
*pres = 0;
return -1;
case JS_TAG_FLOAT64:
{
double d = JS_VALUE_GET_FLOAT64(val);
if (isnan(d)) {
ret = 0;
} else {
if (d < INT32_MIN)
ret = INT32_MIN;
else if (d > INT32_MAX)
ret = INT32_MAX;
else
ret = (int)d;
}
}
break;
default:
val = JS_ToNumberFree(ctx, val);
if (JS_IsException(val)) {
*pres = 0;
return -1;
}
goto redo;
}
*pres = ret;
return 0;
} | O2 | c | JS_ToInt32SatFree:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $-0x1
popq %rbp
xorl %r15d, %r15d
cmpl $0x4, %ecx
jb 0x21383
cmpl $0x6, %ecx
je 0x21388
cmpl $0x7, %ecx
je 0x21398
movq %r14, %rdi
movq %rax, %rsi
movq %rcx, %rdx
callq 0x2e216
movq %rdx, %rcx
cmpl $0x6, %ecx
jne 0x2135c
jmp 0x21388
xorl %ebp, %ebp
movl %eax, %r15d
movl %r15d, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %xmm0
xorl %ebp, %ebp
ucomisd %xmm0, %xmm0
jp 0x213d0
movl $0x80000000, %r15d # imm = 0x80000000
movsd 0x64425(%rip), %xmm1 # 0x857d8
ucomisd %xmm0, %xmm1
ja 0x21388
movl $0x7fffffff, %r15d # imm = 0x7FFFFFFF
ucomisd 0x64419(%rip), %xmm0 # 0x857e0
ja 0x21388
cvttsd2si %xmm0, %r15d
jmp 0x21388
xorl %r15d, %r15d
jmp 0x21388
| JS_ToInt32SatFree:
push rbp
push r15
push r14
push rbx
push rax
mov rax, rdx
mov rbx, rsi
mov r14, rdi
push 0FFFFFFFFFFFFFFFFh
pop rbp
xor r15d, r15d
loc_2135C:
cmp ecx, 4
jb short loc_21383
cmp ecx, 6
jz short loc_21388
cmp ecx, 7
jz short loc_21398
mov rdi, r14
mov rsi, rax
mov rdx, rcx
call JS_ToNumberFree
mov rcx, rdx
cmp ecx, 6
jnz short loc_2135C
jmp short loc_21388
loc_21383:
xor ebp, ebp
mov r15d, eax
loc_21388:
mov [rbx], r15d
mov eax, ebp
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_21398:
movq xmm0, rax
xor ebp, ebp
ucomisd xmm0, xmm0
jp short loc_213D0
mov r15d, 80000000h
movsd xmm1, cs:qword_857D8
ucomisd xmm1, xmm0
ja short loc_21388
mov r15d, 7FFFFFFFh
ucomisd xmm0, cs:qword_857E0
ja short loc_21388
cvttsd2si r15d, xmm0
jmp short loc_21388
loc_213D0:
xor r15d, r15d
jmp short loc_21388
| long long JS_ToInt32SatFree(long long a1, int *a2, long long a3, long long a4)
{
unsigned int v5; // ebp
int v6; // r15d
long long v7; // rdx
v5 = -1;
v6 = 0;
while ( 1 )
{
if ( (unsigned int)a4 < 4 )
{
v5 = 0;
v6 = a3;
goto LABEL_8;
}
if ( (_DWORD)a4 == 6 )
goto LABEL_8;
if ( (_DWORD)a4 == 7 )
break;
*(double *)&a3 = COERCE_DOUBLE(JS_ToNumberFree(a1, a3, a4));
a4 = v7;
if ( (_DWORD)v7 == 6 )
goto LABEL_8;
}
v5 = 0;
v6 = 0x80000000;
if ( *(double *)&a3 >= -2147483648.0 )
{
v6 = 0x7FFFFFFF;
if ( *(double *)&a3 <= 2147483647.0 )
v6 = (int)*(double *)&a3;
}
LABEL_8:
*a2 = v6;
return v5;
}
| JS_ToInt32SatFree:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RAX,RDX
MOV RBX,RSI
MOV R14,RDI
PUSH -0x1
POP RBP
XOR R15D,R15D
LAB_0012135c:
CMP ECX,0x4
JC 0x00121383
CMP ECX,0x6
JZ 0x00121388
CMP ECX,0x7
JZ 0x00121398
MOV RDI,R14
MOV RSI,RAX
MOV RDX,RCX
CALL 0x0012e216
MOV RCX,RDX
CMP ECX,0x6
JNZ 0x0012135c
JMP 0x00121388
LAB_00121383:
XOR EBP,EBP
MOV R15D,EAX
LAB_00121388:
MOV dword ptr [RBX],R15D
MOV EAX,EBP
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00121398:
MOVQ XMM0,RAX
XOR EBP,EBP
UCOMISD XMM0,XMM0
JP 0x001213d0
MOV R15D,0x80000000
MOVSD XMM1,qword ptr [0x001857d8]
UCOMISD XMM1,XMM0
JA 0x00121388
MOV R15D,0x7fffffff
UCOMISD XMM0,qword ptr [0x001857e0]
JA 0x00121388
CVTTSD2SI R15D,XMM0
JMP 0x00121388
LAB_001213d0:
XOR R15D,R15D
JMP 0x00121388
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int4 JS_ToInt32SatFree(int8 param_1,int *param_2,int8 param_3,int8 param_4)
{
double dVar1;
uint uVar2;
int4 uVar3;
int iVar4;
int1 auVar5 [16];
auVar5._8_8_ = param_4;
auVar5._0_8_ = param_3;
uVar3 = 0xffffffff;
iVar4 = 0;
while( true ) {
dVar1 = auVar5._0_8_;
uVar2 = auVar5._8_4_;
if (uVar2 < 4) {
uVar3 = 0;
iVar4 = auVar5._0_4_;
goto LAB_00121388;
}
if (uVar2 == 6) goto LAB_00121388;
if (uVar2 == 7) break;
auVar5 = JS_ToNumberFree(param_1,dVar1,auVar5._8_8_);
if (auVar5._8_4_ == 6) {
LAB_00121388:
*param_2 = iVar4;
return uVar3;
}
}
if (NAN(dVar1)) {
iVar4 = 0;
uVar3 = 0;
}
else {
iVar4 = -0x80000000;
uVar3 = 0;
if ((DAT_001857d8 <= dVar1) && (iVar4 = 0x7fffffff, dVar1 <= _DAT_001857e0)) {
iVar4 = (int)dVar1;
uVar3 = 0;
}
}
goto LAB_00121388;
}
| |
24,862 | bf_can_round | bluesky950520[P]quickjs/libbf.c | int bf_can_round(const bf_t *a, slimb_t prec, bf_rnd_t rnd_mode, slimb_t k)
{
BOOL is_rndn;
slimb_t bit_pos, n;
limb_t bit;
if (a->expn == BF_EXP_INF || a->expn == BF_EXP_NAN)
return FALSE;
if (rnd_mode == BF_RNDF) {
return (k >= (prec + 1));
}
if (a->expn == BF_EXP_ZERO)
return FALSE;
is_rndn = (rnd_mode == BF_RNDN || rnd_mode == BF_RNDNA);
if (k < (prec + 2))
return FALSE;
bit_pos = a->len * LIMB_BITS - 1 - prec;
n = k - prec;
/* bit pattern for RNDN or RNDNA: 0111.. or 1000...
for other rounding modes: 000... or 111...
*/
bit = get_bit(a->tab, a->len, bit_pos);
bit_pos--;
n--;
bit ^= is_rndn;
/* XXX: slow, but a few iterations on average */
while (n != 0) {
if (get_bit(a->tab, a->len, bit_pos) != bit)
return TRUE;
bit_pos--;
n--;
}
return FALSE;
} | O1 | c | bf_can_round:
movabsq $0x7ffffffffffffffd, %r8 # imm = 0x7FFFFFFFFFFFFFFD
movq 0x10(%rdi), %r9
xorl %eax, %eax
cmpq %r8, %r9
jg 0x85209
cmpl $0x6, %edx
jne 0x8520a
xorl %eax, %eax
cmpq %rcx, %rsi
setl %al
retq
addq $0x3, %r8
cmpq %r8, %r9
sete %r8b
leaq 0x2(%rsi), %r9
cmpq %rcx, %r9
setg %r9b
orb %r8b, %r9b
jne 0x85209
pushq %rbp
pushq %rbx
movq 0x18(%rdi), %r8
movq 0x20(%rdi), %rdi
movq %r8, %r9
shlq $0x6, %r9
movq %rsi, %r11
notq %r11
leaq (%r9,%r11), %r10
sarq $0x6, %r10
sets %bl
cmpq %r8, %r10
setae %bpl
xorl %eax, %eax
orb %bl, %bpl
jne 0x85266
movq (%rdi,%r10,8), %rbx
xorl %r10d, %r10d
btq %r11, %rbx
setb %r10b
jmp 0x85269
xorl %r10d, %r10d
xorl %ebx, %ebx
testl $0xfffffffb, %edx # imm = 0xFFFFFFFB
sete %dl
addq %rcx, %r11
je 0x852c6
movb %dl, %bl
xorq %rbx, %r10
subq %rsi, %r9
addq $-0x2, %r9
subq %rcx, %rsi
incq %rsi
movq %r9, %rax
sarq $0x6, %rax
sets %cl
cmpq %r8, %rax
setae %dl
orb %cl, %dl
jne 0x852ae
movq (%rdi,%rax,8), %rcx
xorl %eax, %eax
btq %r9, %rcx
setb %al
jmp 0x852b0
xorl %eax, %eax
cmpl %r10d, %eax
jne 0x852c1
decq %r9
incq %rsi
jne 0x8528b
xorl %eax, %eax
jmp 0x852c6
movl $0x1, %eax
popq %rbx
popq %rbp
retq
| bf_can_round:
mov r8, 7FFFFFFFFFFFFFFDh
mov r9, [rdi+10h]
xor eax, eax
cmp r9, r8
jg short locret_85209
cmp edx, 6
jnz short loc_8520A
xor eax, eax
cmp rsi, rcx
setl al
locret_85209:
retn
loc_8520A:
add r8, 3
cmp r9, r8
setz r8b
lea r9, [rsi+2]
cmp r9, rcx
setnle r9b
or r9b, r8b
jnz short locret_85209
push rbp
push rbx
mov r8, [rdi+18h]
mov rdi, [rdi+20h]
mov r9, r8
shl r9, 6
mov r11, rsi
not r11
lea r10, [r9+r11]
sar r10, 6
sets bl
cmp r10, r8
setnb bpl
xor eax, eax
or bpl, bl
jnz short loc_85266
mov rbx, [rdi+r10*8]
xor r10d, r10d
bt rbx, r11
setb r10b
jmp short loc_85269
loc_85266:
xor r10d, r10d
loc_85269:
xor ebx, ebx
test edx, 0FFFFFFFBh
setz dl
add r11, rcx
jz short loc_852C6
mov bl, dl
xor r10, rbx
sub r9, rsi
add r9, 0FFFFFFFFFFFFFFFEh
sub rsi, rcx
inc rsi
loc_8528B:
mov rax, r9
sar rax, 6
sets cl
cmp rax, r8
setnb dl
or dl, cl
jnz short loc_852AE
mov rcx, [rdi+rax*8]
xor eax, eax
bt rcx, r9
setb al
jmp short loc_852B0
loc_852AE:
xor eax, eax
loc_852B0:
cmp eax, r10d
jnz short loc_852C1
dec r9
inc rsi
jnz short loc_8528B
xor eax, eax
jmp short loc_852C6
loc_852C1:
mov eax, 1
loc_852C6:
pop rbx
pop rbp
retn
| _BOOL8 bf_can_round(_QWORD *a1, long long a2, int a3, long long a4)
{
long long v4; // r9
_BOOL8 result; // rax
unsigned long long v6; // r8
long long v7; // rdi
unsigned long long v8; // r11
long long v9; // r10
long long v10; // rbx
int v11; // r10d
int v12; // ebx
bool v13; // dl
int v14; // r10d
signed long long v15; // r9
long long v16; // rsi
long long v17; // rcx
int v18; // eax
v4 = a1[2];
result = 0LL;
if ( v4 <= 0x7FFFFFFFFFFFFFFDLL )
{
if ( a3 == 6 )
{
return a2 < a4;
}
else if ( v4 != 0x8000000000000000LL && a2 + 2 <= a4 )
{
v6 = a1[3];
v7 = a1[4];
v8 = ~a2;
v9 = (long long)((v6 << 6) + ~a2) >> 6;
result = 0LL;
if ( v9 < 0 || v9 >= v6 )
{
v11 = 0;
}
else
{
v10 = *(_QWORD *)(v7 + 8 * v9);
v11 = _bittest64(&v10, v8);
}
v12 = 0;
v13 = (a3 & 0xFFFFFFFB) == 0;
if ( a4 + v8 )
{
LOBYTE(v12) = v13;
v14 = v12 ^ v11;
v15 = (v6 << 6) - a2 - 2;
v16 = a2 - a4 + 1;
while ( 1 )
{
if ( v15 >> 6 < 0 || v15 >> 6 >= v6 )
{
v18 = 0;
}
else
{
v17 = *(_QWORD *)(v7 + 8 * (v15 >> 6));
v18 = _bittest64(&v17, v15);
}
if ( v18 != v14 )
break;
--v15;
if ( !++v16 )
return 0LL;
}
return 1LL;
}
}
}
return result;
}
| bf_can_round:
MOV R8,0x7ffffffffffffffd
MOV R9,qword ptr [RDI + 0x10]
XOR EAX,EAX
CMP R9,R8
JG 0x00185209
CMP EDX,0x6
JNZ 0x0018520a
XOR EAX,EAX
CMP RSI,RCX
SETL AL
LAB_00185209:
RET
LAB_0018520a:
ADD R8,0x3
CMP R9,R8
SETZ R8B
LEA R9,[RSI + 0x2]
CMP R9,RCX
SETG R9B
OR R9B,R8B
JNZ 0x00185209
PUSH RBP
PUSH RBX
MOV R8,qword ptr [RDI + 0x18]
MOV RDI,qword ptr [RDI + 0x20]
MOV R9,R8
SHL R9,0x6
MOV R11,RSI
NOT R11
LEA R10,[R9 + R11*0x1]
SAR R10,0x6
SETS BL
CMP R10,R8
SETNC BPL
XOR EAX,EAX
OR BPL,BL
JNZ 0x00185266
MOV RBX,qword ptr [RDI + R10*0x8]
XOR R10D,R10D
BT RBX,R11
SETC R10B
JMP 0x00185269
LAB_00185266:
XOR R10D,R10D
LAB_00185269:
XOR EBX,EBX
TEST EDX,0xfffffffb
SETZ DL
ADD R11,RCX
JZ 0x001852c6
MOV BL,DL
XOR R10,RBX
SUB R9,RSI
ADD R9,-0x2
SUB RSI,RCX
INC RSI
LAB_0018528b:
MOV RAX,R9
SAR RAX,0x6
SETS CL
CMP RAX,R8
SETNC DL
OR DL,CL
JNZ 0x001852ae
MOV RCX,qword ptr [RDI + RAX*0x8]
XOR EAX,EAX
BT RCX,R9
SETC AL
JMP 0x001852b0
LAB_001852ae:
XOR EAX,EAX
LAB_001852b0:
CMP EAX,R10D
JNZ 0x001852c1
DEC R9
INC RSI
JNZ 0x0018528b
XOR EAX,EAX
JMP 0x001852c6
LAB_001852c1:
MOV EAX,0x1
LAB_001852c6:
POP RBX
POP RBP
RET
|
bool bf_can_round(long param_1,ulong param_2,uint param_3,long param_4)
{
ulong uVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
bool bVar5;
bool bVar6;
bVar5 = false;
if (*(long *)(param_1 + 0x10) < 0x7ffffffffffffffe) {
if (param_3 == 6) {
bVar5 = (long)param_2 < param_4;
}
else if ((long)(param_2 + 2) <= param_4 && *(long *)(param_1 + 0x10) != -0x8000000000000000) {
uVar1 = *(ulong *)(param_1 + 0x18);
uVar4 = ~param_2;
uVar3 = (long)(uVar1 * 0x40 + uVar4) >> 6;
if (uVar3 < uVar1 && -1 < (long)uVar3) {
bVar5 = (*(ulong *)(*(long *)(param_1 + 0x20) + uVar3 * 8) >> (uVar4 & 0x3f) & 1) != 0;
}
else {
bVar5 = false;
}
if (uVar4 + param_4 != 0) {
uVar3 = (uVar1 * 0x40 - param_2) - 2;
lVar2 = (param_2 - param_4) + 1;
do {
uVar4 = (long)uVar3 >> 6;
if (uVar4 < uVar1 && -1 < (long)uVar4) {
bVar6 = (*(ulong *)(*(long *)(param_1 + 0x20) + uVar4 * 8) >> (uVar3 & 0x3f) & 1) != 0;
}
else {
bVar6 = false;
}
if (bVar6 != (bool)(bVar5 ^ (param_3 & 0xfffffffb) == 0)) {
return true;
}
uVar3 = uVar3 - 1;
lVar2 = lVar2 + 1;
} while (lVar2 != 0);
}
return false;
}
}
return bVar5;
}
| |
24,863 | add_compiled_extra_collation | eloqsql/mysys/charset.c | void add_compiled_extra_collation(struct charset_info_st *cs)
{
DBUG_ASSERT(cs->number < array_elements(all_charsets));
all_charsets[cs->number]= cs;
cs->state|= MY_CS_AVAILABLE;
if ((my_hash_insert(&charset_name_hash, (uchar*) cs)))
{
CHARSET_INFO *org= (CHARSET_INFO*) my_hash_search(&charset_name_hash,
(uchar*) cs->cs_name.str,
cs->cs_name.length);
cs->cs_name= org->cs_name;
}
} | O3 | c | add_compiled_extra_collation:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
leaq 0x3a9990(%rip), %rcx # 0x403270
movq %rdi, (%rcx,%rax,8)
orb $0x2, 0xd(%rdi)
leaq 0x3ad981(%rip), %rdi # 0x407270
movq %rbx, %rsi
callq 0x5beda
testb %al, %al
je 0x59917
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
leaq 0x3ad966(%rip), %rdi # 0x407270
callq 0x5bc7a
movups 0x10(%rax), %xmm0
movups %xmm0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| add_compiled_extra_collation:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
mov eax, [rdi]
lea rcx, all_charsets
mov [rcx+rax*8], rdi
or byte ptr [rdi+0Dh], 2
lea rdi, charset_name_hash
mov rsi, rbx
call my_hash_insert
test al, al
jz short loc_59917
mov rsi, [rbx+10h]
mov rdx, [rbx+18h]
lea rdi, charset_name_hash
call my_hash_search
movups xmm0, xmmword ptr [rax+10h]
movups xmmword ptr [rbx+10h], xmm0
loc_59917:
add rsp, 8
pop rbx
pop rbp
retn
| long long add_compiled_extra_collation(unsigned int *a1)
{
long long result; // rax
all_charsets[*a1] = a1;
*((_BYTE *)a1 + 13) |= 2u;
result = my_hash_insert(&charset_name_hash, a1);
if ( (_BYTE)result )
{
result = my_hash_search(&charset_name_hash, *((_QWORD *)a1 + 2), *((_QWORD *)a1 + 3));
*((_OWORD *)a1 + 1) = *(_OWORD *)(result + 16);
}
return result;
}
| add_compiled_extra_collation:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV EAX,dword ptr [RDI]
LEA RCX,[0x503270]
MOV qword ptr [RCX + RAX*0x8],RDI
OR byte ptr [RDI + 0xd],0x2
LEA RDI,[0x507270]
MOV RSI,RBX
CALL 0x0015beda
TEST AL,AL
JZ 0x00159917
MOV RSI,qword ptr [RBX + 0x10]
MOV RDX,qword ptr [RBX + 0x18]
LEA RDI,[0x507270]
CALL 0x0015bc7a
MOVUPS XMM0,xmmword ptr [RAX + 0x10]
MOVUPS xmmword ptr [RBX + 0x10],XMM0
LAB_00159917:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void add_compiled_extra_collation(uint *param_1)
{
int8 uVar1;
char cVar2;
long lVar3;
(&all_charsets)[*param_1] = param_1;
*(byte *)((long)param_1 + 0xd) = *(byte *)((long)param_1 + 0xd) | 2;
cVar2 = my_hash_insert(charset_name_hash,param_1);
if (cVar2 != '\0') {
lVar3 = my_hash_search(charset_name_hash,*(int8 *)(param_1 + 4),
*(int8 *)(param_1 + 6));
uVar1 = *(int8 *)(lVar3 + 0x18);
*(int8 *)(param_1 + 4) = *(int8 *)(lVar3 + 0x10);
*(int8 *)(param_1 + 6) = uVar1;
}
return;
}
| |
24,864 | pfs_start_transaction_v1 | eloqsql/storage/perfschema/pfs.cc | void pfs_start_transaction_v1(PSI_transaction_locker *locker,
const char *src_file, uint src_line)
{
PSI_transaction_locker_state *state= reinterpret_cast<PSI_transaction_locker_state*> (locker);
assert(state != NULL);
uint flags= state->m_flags;
ulonglong timer_start= 0;
if (flags & STATE_FLAG_TIMED)
{
timer_start= get_timer_raw_value_and_function(transaction_timer, &state->m_timer);
state->m_timer_start= timer_start;
}
if (flags & STATE_FLAG_EVENT)
{
PFS_events_transactions *pfs= reinterpret_cast<PFS_events_transactions*> (state->m_transaction);
assert(pfs != NULL);
pfs->m_timer_start= timer_start;
pfs->m_source_file= src_file;
pfs->m_source_line= src_line;
pfs->m_state= TRANS_STATE_ACTIVE;
//pfs->m_sid.clear();
bzero(&pfs->m_gtid_spec, sizeof(pfs->m_gtid_spec));
}
} | O0 | cpp | pfs_start_transaction_v1:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movl -0x24(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x5003d
leaq 0x1c6152(%rip), %rax # 0x216170
movl (%rax), %edi
movq -0x20(%rbp), %rsi
addq $0x20, %rsi
callq 0x34850
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0x24(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x50095
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x48(%rax)
movl -0x14(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x50(%rax)
movq -0x38(%rbp), %rax
movl $0x1, 0x60(%rax)
movq -0x38(%rbp), %rdi
addq $0x68, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x261c0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| pfs_start_transaction_v1:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov eax, [rax]
mov [rbp+var_24], eax
mov [rbp+var_30], 0
mov eax, [rbp+var_24]
and eax, 1
cmp eax, 0
jz short loc_5003D
lea rax, transaction_timer
mov edi, [rax]
mov rsi, [rbp+var_20]
add rsi, 20h ; ' '
call _Z32get_timer_raw_value_and_function15enum_timer_namePPFyvE; get_timer_raw_value_and_function(enum_timer_name,ulong long (**)(void))
mov [rbp+var_30], rax
mov rcx, [rbp+var_30]
mov rax, [rbp+var_20]
mov [rax+18h], rcx
loc_5003D:
mov eax, [rbp+var_24]
and eax, 4
cmp eax, 0
jz short loc_50095
mov rax, [rbp+var_20]
mov rax, [rax+28h]
mov [rbp+var_38], rax
mov rcx, [rbp+var_30]
mov rax, [rbp+var_38]
mov [rax+38h], rcx
mov rcx, [rbp+var_10]
mov rax, [rbp+var_38]
mov [rax+48h], rcx
mov ecx, [rbp+var_14]
mov rax, [rbp+var_38]
mov [rax+50h], ecx
mov rax, [rbp+var_38]
mov dword ptr [rax+60h], 1
mov rdi, [rbp+var_38]
add rdi, 68h ; 'h'
xor esi, esi
mov edx, 10h
call _memset
loc_50095:
add rsp, 40h
pop rbp
retn
| long long pfs_start_transaction_v1(int *a1, long long a2, int a3)
{
long long result; // rax
long long v4; // [rsp+8h] [rbp-38h]
unsigned long long timer_raw_value_and_function; // [rsp+10h] [rbp-30h]
int v6; // [rsp+1Ch] [rbp-24h]
v6 = *a1;
timer_raw_value_and_function = 0LL;
if ( (*a1 & 1) != 0 )
{
timer_raw_value_and_function = get_timer_raw_value_and_function(
(unsigned int)transaction_timer,
(unsigned long long (**)(void))a1 + 4);
*((_QWORD *)a1 + 3) = timer_raw_value_and_function;
}
result = v6 & 4;
if ( (v6 & 4) != 0 )
{
v4 = *((_QWORD *)a1 + 5);
*(_QWORD *)(v4 + 56) = timer_raw_value_and_function;
*(_QWORD *)(v4 + 72) = a2;
*(_DWORD *)(v4 + 80) = a3;
*(_DWORD *)(v4 + 96) = 1;
return memset(v4 + 104, 0LL, 16LL);
}
return result;
}
| pfs_start_transaction_v1:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x24],EAX
MOV qword ptr [RBP + -0x30],0x0
MOV EAX,dword ptr [RBP + -0x24]
AND EAX,0x1
CMP EAX,0x0
JZ 0x0015003d
LEA RAX,[0x316170]
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x20]
ADD RSI,0x20
CALL 0x00134850
MOV qword ptr [RBP + -0x30],RAX
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x18],RCX
LAB_0015003d:
MOV EAX,dword ptr [RBP + -0x24]
AND EAX,0x4
CMP EAX,0x0
JZ 0x00150095
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x38],RAX
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x38],RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x48],RCX
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x50],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x60],0x1
MOV RDI,qword ptr [RBP + -0x38]
ADD RDI,0x68
XOR ESI,ESI
MOV EDX,0x10
CALL 0x001261c0
LAB_00150095:
ADD RSP,0x40
POP RBP
RET
|
void pfs_start_transaction_v1(uint *param_1,int8 param_2,int4 param_3)
{
uint uVar1;
long lVar2;
int8 local_38;
uVar1 = *param_1;
local_38 = 0;
if ((uVar1 & 1) != 0) {
local_38 = get_timer_raw_value_and_function(transaction_timer);
*(int8 *)(param_1 + 6) = local_38;
}
if ((uVar1 & 4) != 0) {
lVar2 = *(long *)(param_1 + 10);
*(int8 *)(lVar2 + 0x38) = local_38;
*(int8 *)(lVar2 + 0x48) = param_2;
*(int4 *)(lVar2 + 0x50) = param_3;
*(int4 *)(lVar2 + 0x60) = 1;
memset((void *)(lVar2 + 0x68),0,0x10);
}
return;
}
| |
24,865 | pfs_start_transaction_v1 | eloqsql/storage/perfschema/pfs.cc | void pfs_start_transaction_v1(PSI_transaction_locker *locker,
const char *src_file, uint src_line)
{
PSI_transaction_locker_state *state= reinterpret_cast<PSI_transaction_locker_state*> (locker);
assert(state != NULL);
uint flags= state->m_flags;
ulonglong timer_start= 0;
if (flags & STATE_FLAG_TIMED)
{
timer_start= get_timer_raw_value_and_function(transaction_timer, &state->m_timer);
state->m_timer_start= timer_start;
}
if (flags & STATE_FLAG_EVENT)
{
PFS_events_transactions *pfs= reinterpret_cast<PFS_events_transactions*> (state->m_transaction);
assert(pfs != NULL);
pfs->m_timer_start= timer_start;
pfs->m_source_file= src_file;
pfs->m_source_line= src_line;
pfs->m_state= TRANS_STATE_ACTIVE;
//pfs->m_sid.clear();
bzero(&pfs->m_gtid_spec, sizeof(pfs->m_gtid_spec));
}
} | O3 | cpp | pfs_start_transaction_v1:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl (%rdi), %r12d
testb $0x1, %r12b
jne 0x4033b
xorl %eax, %eax
jmp 0x40351
leaq 0x2d9d76(%rip), %rax # 0x31a0b8
movl (%rax), %edi
leaq 0x20(%r15), %rsi
callq 0x33edf
movq %rax, 0x18(%r15)
testb $0x4, %r12b
je 0x40374
movq 0x28(%r15), %rcx
movq %rax, 0x38(%rcx)
movq %r14, 0x48(%rcx)
movl %ebx, 0x50(%rcx)
movl $0x1, 0x60(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rcx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| pfs_start_transaction_v1:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov ebx, edx
mov r14, rsi
mov r15, rdi
mov r12d, [rdi]
test r12b, 1
jnz short loc_4033B
xor eax, eax
jmp short loc_40351
loc_4033B:
lea rax, transaction_timer
mov edi, [rax]
lea rsi, [r15+20h]
call _Z32get_timer_raw_value_and_function15enum_timer_namePPFyvE; get_timer_raw_value_and_function(enum_timer_name,ulong long (**)(void))
mov [r15+18h], rax
loc_40351:
test r12b, 4
jz short loc_40374
mov rcx, [r15+28h]
mov [rcx+38h], rax
mov [rcx+48h], r14
mov [rcx+50h], ebx
mov dword ptr [rcx+60h], 1
xorps xmm0, xmm0
movups xmmword ptr [rcx+68h], xmm0
loc_40374:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long pfs_start_transaction_v1(int *a1, long long a2, int a3)
{
int v4; // r12d
long long result; // rax
long long v6; // rcx
v4 = *a1;
if ( (*a1 & 1) != 0 )
{
result = get_timer_raw_value_and_function(transaction_timer, (unsigned long long (**)(void))a1 + 4);
*((_QWORD *)a1 + 3) = result;
}
else
{
result = 0LL;
}
if ( (v4 & 4) != 0 )
{
v6 = *((_QWORD *)a1 + 5);
*(_QWORD *)(v6 + 56) = result;
*(_QWORD *)(v6 + 72) = a2;
*(_DWORD *)(v6 + 80) = a3;
*(_DWORD *)(v6 + 96) = 1;
*(_OWORD *)(v6 + 104) = 0LL;
}
return result;
}
| pfs_start_transaction_v1:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV EBX,EDX
MOV R14,RSI
MOV R15,RDI
MOV R12D,dword ptr [RDI]
TEST R12B,0x1
JNZ 0x0014033b
XOR EAX,EAX
JMP 0x00140351
LAB_0014033b:
LEA RAX,[0x41a0b8]
MOV EDI,dword ptr [RAX]
LEA RSI,[R15 + 0x20]
CALL 0x00133edf
MOV qword ptr [R15 + 0x18],RAX
LAB_00140351:
TEST R12B,0x4
JZ 0x00140374
MOV RCX,qword ptr [R15 + 0x28]
MOV qword ptr [RCX + 0x38],RAX
MOV qword ptr [RCX + 0x48],R14
MOV dword ptr [RCX + 0x50],EBX
MOV dword ptr [RCX + 0x60],0x1
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RCX + 0x68],XMM0
LAB_00140374:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
void pfs_start_transaction_v1(uint *param_1,int8 param_2,int4 param_3)
{
uint uVar1;
long lVar2;
int8 uVar3;
uVar1 = *param_1;
if ((uVar1 & 1) == 0) {
uVar3 = 0;
}
else {
uVar3 = get_timer_raw_value_and_function(transaction_timer,param_1 + 8);
*(int8 *)(param_1 + 6) = uVar3;
}
if ((uVar1 & 4) != 0) {
lVar2 = *(long *)(param_1 + 10);
*(int8 *)(lVar2 + 0x38) = uVar3;
*(int8 *)(lVar2 + 0x48) = param_2;
*(int4 *)(lVar2 + 0x50) = param_3;
*(int4 *)(lVar2 + 0x60) = 1;
*(int8 *)(lVar2 + 0x68) = 0;
*(int8 *)(lVar2 + 0x70) = 0;
}
return;
}
| |
24,866 | Rows_log_event::update_sequence() | eloqsql/sql/log_event_server.cc | int Rows_log_event::update_sequence()
{
TABLE *table= m_table; // pointer to event's table
if (!bitmap_is_set(table->rpl_write_set, MIN_VALUE_FIELD_NO))
{
/* This event come from a setval function executed on the master.
Update the sequence next_number and round, like we do with setval()
*/
MY_BITMAP *old_map= dbug_tmp_use_all_columns(table,
&table->read_set);
longlong nextval= table->field[NEXT_FIELD_NO]->val_int();
longlong round= table->field[ROUND_FIELD_NO]->val_int();
dbug_tmp_restore_column_map(&table->read_set, old_map);
return table->s->sequence->set_value(table, nextval, round, 0) > 0;
}
/*
Update all fields in table and update the active sequence, like with
ALTER SEQUENCE
*/
return table->file->ha_write_row(table->record[0]);
} | O0 | cpp | Rows_log_event::update_sequence():
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x200(%rax), %rdi
movl $0x1, %esi
callq 0x8768a0
cmpl $0x0, %eax
jne 0x87b0ab
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x1f0, %rsi # imm = 0x1F0
callq 0x87b1a0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0xb0(%rax), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0xc8(%rax)
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0xb0(%rax), %rax
movq 0x38(%rax), %rdi
movq (%rdi), %rax
callq *0xc8(%rax)
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
addq $0x1f0, %rdi # imm = 0x1F0
movq -0x20(%rbp), %rsi
callq 0x87b1b0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x418(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
xorl %r8d, %r8d
callq 0xc21560
cmpl $0x0, %eax
setg %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x87b0c3
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rsi
callq 0xd18010
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| _ZN14Rows_log_event15update_sequenceEv:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov rax, [rax+70h]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rdi, [rax+200h]
mov esi, 1
call _ZL13bitmap_is_setPK9st_bitmapj; bitmap_is_set(st_bitmap const*,uint)
cmp eax, 0
jnz loc_87B0AB
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_18]
add rsi, 1F0h
call _ZL24dbug_tmp_use_all_columnsP5TABLEPP9st_bitmap; dbug_tmp_use_all_columns(TABLE *,st_bitmap **)
mov [rbp+var_20], rax
mov rax, [rbp+var_18]
mov rax, [rax+0B0h]
mov rdi, [rax]
mov rax, [rdi]
call qword ptr [rax+0C8h]
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov rax, [rax+0B0h]
mov rdi, [rax+38h]
mov rax, [rdi]
call qword ptr [rax+0C8h]
mov [rbp+var_30], rax
mov rdi, [rbp+var_18]
add rdi, 1F0h
mov rsi, [rbp+var_20]
call _ZL27dbug_tmp_restore_column_mapPP9st_bitmapS0_; dbug_tmp_restore_column_map(st_bitmap **,st_bitmap *)
mov rax, [rbp+var_18]
mov rax, [rax]
mov rdi, [rax+418h]; this
mov rsi, [rbp+var_18]; TABLE *
mov rdx, [rbp+var_28]; __int64
mov rcx, [rbp+var_30]; unsigned __int64
xor r8d, r8d; bool
call _ZN8SEQUENCE9set_valueEP5TABLExyb; SEQUENCE::set_value(TABLE *,long long,ulong long,bool)
cmp eax, 0
setnle al
and al, 1
movzx eax, al
mov [rbp+var_4], eax
jmp short loc_87B0C3
loc_87B0AB:
mov rax, [rbp+var_18]
mov rdi, [rax+8]; this
mov rax, [rbp+var_18]
mov rsi, [rax+50h]; unsigned __int8 *
call _ZN7handler12ha_write_rowEPKh; handler::ha_write_row(uchar const*)
mov [rbp+var_4], eax
loc_87B0C3:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long Rows_log_event::update_sequence(Rows_log_event *this)
{
long long v2; // [rsp+0h] [rbp-30h]
long long v3; // [rsp+8h] [rbp-28h]
long long v4; // [rsp+10h] [rbp-20h]
TABLE *v5; // [rsp+18h] [rbp-18h]
v5 = (TABLE *)*((_QWORD *)this + 14);
if ( bitmap_is_set(*((_QWORD **)v5 + 64), 1u) )
{
return (unsigned int)handler::ha_write_row(*((handler **)v5 + 1), *((const unsigned __int8 **)v5 + 10));
}
else
{
v4 = dbug_tmp_use_all_columns(v5, (char *)v5 + 496);
v3 = (*(long long ( **)(_QWORD))(***((_QWORD ***)v5 + 22) + 200LL))(**((_QWORD **)v5 + 22));
v2 = (*(long long ( **)(_QWORD))(**(_QWORD **)(*((_QWORD *)v5 + 22) + 56LL) + 200LL))(*(_QWORD *)(*((_QWORD *)v5 + 22) + 56LL));
dbug_tmp_restore_column_map((char *)v5 + 496, v4);
return (int)SEQUENCE::set_value(*(SEQUENCE **)(*(_QWORD *)v5 + 1048LL), v5, v3, v2, 0) > 0;
}
}
| __cxx_global_var_init.9:
PUSH RBP
MOV RBP,RSP
LEA RDI,[0x1e4790c]
MOV ESI,0x3800000
CALL 0x008fd530
POP RBP
RET
|
void __cxx_global_var_init_9(void)
{
date_conv_mode_t::date_conv_mode_t((date_conv_mode_t *)&TIME_MODE_FOR_XXX_TO_DATE,0x3800000);
return;
}
| |
24,867 | init_dynamic_string | eloqsql/mysys/string.c | my_bool init_dynamic_string(DYNAMIC_STRING *str, const char *init_str,
size_t init_alloc, size_t alloc_increment)
{
size_t length;
DBUG_ENTER("init_dynamic_string");
if (!alloc_increment)
alloc_increment=128;
length=1;
if (init_str && (length= strlen(init_str)+1) < init_alloc)
init_alloc=((length+alloc_increment-1)/alloc_increment)*alloc_increment;
if (!init_alloc)
init_alloc=alloc_increment;
if (!(str->str=(char*) my_malloc(key_memory_DYNAMIC_STRING,
init_alloc, MYF(MY_WME))))
DBUG_RETURN(TRUE);
str->length=length-1;
if (init_str)
memcpy(str->str,init_str,length);
str->max_length=init_alloc;
str->alloc_increment=alloc_increment;
DBUG_RETURN(FALSE);
} | O0 | c | init_dynamic_string:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x39c07
movq $0x80, -0x28(%rbp)
movq $0x1, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x39c4a
movq -0x18(%rbp), %rdi
callq 0x29150
addq $0x1, %rax
movq %rax, -0x30(%rbp)
cmpq -0x20(%rbp), %rax
jae 0x39c4a
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
subq $0x1, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x28(%rbp)
imulq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x39c59
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x3c5a70(%rip), %rax # 0x3ff6d0
movl (%rax), %edi
movq -0x20(%rbp), %rsi
movl $0x10, %edx
callq 0x37090
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x39c85
jmp 0x39c7f
movb $0x1, -0x1(%rbp)
jmp 0x39ccc
movq -0x30(%rbp), %rcx
subq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x39cb0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x29270
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| init_dynamic_string:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
cmp [rbp+var_28], 0
jnz short loc_39C07
mov [rbp+var_28], 80h
loc_39C07:
mov [rbp+var_30], 1
cmp [rbp+var_18], 0
jz short loc_39C4A
mov rdi, [rbp+var_18]
call _strlen
add rax, 1
mov [rbp+var_30], rax
cmp rax, [rbp+var_20]
jnb short loc_39C4A
mov rax, [rbp+var_30]
add rax, [rbp+var_28]
sub rax, 1
xor ecx, ecx
mov edx, ecx
div [rbp+var_28]
imul rax, [rbp+var_28]
mov [rbp+var_20], rax
loc_39C4A:
cmp [rbp+var_20], 0
jnz short loc_39C59
mov rax, [rbp+var_28]
mov [rbp+var_20], rax
loc_39C59:
lea rax, key_memory_DYNAMIC_STRING
mov edi, [rax]
mov rsi, [rbp+var_20]
mov edx, 10h
call my_malloc
mov rcx, [rbp+var_10]
mov [rcx], rax
cmp rax, 0
jnz short loc_39C85
jmp short $+2
loc_39C7F:
mov [rbp+var_1], 1
jmp short loc_39CCC
loc_39C85:
mov rcx, [rbp+var_30]
sub rcx, 1
mov rax, [rbp+var_10]
mov [rax+8], rcx
cmp [rbp+var_18], 0
jz short loc_39CB0
mov rax, [rbp+var_10]
mov rdi, [rax]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_30]
call _memcpy
loc_39CB0:
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax+10h], rcx
mov rcx, [rbp+var_28]
mov rax, [rbp+var_10]
mov [rax+18h], rcx
mov [rbp+var_1], 0
loc_39CCC:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
| char init_dynamic_string(long long *a1, long long a2, unsigned long long a3, unsigned long long a4, double a5)
{
long long v5; // rax
unsigned long long v7; // [rsp+0h] [rbp-30h]
unsigned long long v8; // [rsp+8h] [rbp-28h]
v8 = a4;
if ( !a4 )
v8 = 128LL;
v7 = 1LL;
if ( a2 )
{
v7 = strlen(a2) + 1;
if ( v7 < a3 )
a3 = v8 * ((v8 + v7 - 1) / v8);
}
if ( !a3 )
a3 = v8;
v5 = my_malloc(key_memory_DYNAMIC_STRING, a3, 16, a5);
*a1 = v5;
if ( !v5 )
return 1;
a1[1] = v7 - 1;
if ( a2 )
memcpy(*a1, a2, v7);
a1[2] = a3;
a1[3] = v8;
return 0;
}
| init_dynamic_string:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
CMP qword ptr [RBP + -0x28],0x0
JNZ 0x00139c07
MOV qword ptr [RBP + -0x28],0x80
LAB_00139c07:
MOV qword ptr [RBP + -0x30],0x1
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00139c4a
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00129150
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x00139c4a
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,qword ptr [RBP + -0x28]
SUB RAX,0x1
XOR ECX,ECX
MOV EDX,ECX
DIV qword ptr [RBP + -0x28]
IMUL RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x20],RAX
LAB_00139c4a:
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x00139c59
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x20],RAX
LAB_00139c59:
LEA RAX,[0x4ff6d0]
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x20]
MOV EDX,0x10
CALL 0x00137090
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JNZ 0x00139c85
JMP 0x00139c7f
LAB_00139c7f:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00139ccc
LAB_00139c85:
MOV RCX,qword ptr [RBP + -0x30]
SUB RCX,0x1
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00139cb0
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x30]
CALL 0x00129270
LAB_00139cb0:
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],RCX
MOV byte ptr [RBP + -0x1],0x0
LAB_00139ccc:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 init_dynamic_string(long *param_1,char *param_2,ulong param_3,ulong param_4)
{
size_t sVar1;
long lVar2;
size_t local_38;
ulong local_30;
ulong local_28;
int1 local_9;
local_30 = param_4;
if (param_4 == 0) {
local_30 = 0x80;
}
local_38 = 1;
local_28 = param_3;
if (param_2 != (char *)0x0) {
sVar1 = strlen(param_2);
local_38 = sVar1 + 1;
if (local_38 < param_3) {
local_28 = (((local_38 + local_30) - 1) / local_30) * local_30;
}
}
if (local_28 == 0) {
local_28 = local_30;
}
lVar2 = my_malloc(key_memory_DYNAMIC_STRING,local_28,0x10);
*param_1 = lVar2;
if (lVar2 == 0) {
local_9 = 1;
}
else {
param_1[1] = local_38 - 1;
if (param_2 != (char *)0x0) {
memcpy((void *)*param_1,param_2,local_38);
}
param_1[2] = local_28;
param_1[3] = local_30;
local_9 = 0;
}
return local_9;
}
| |
24,868 | crypto_sign_open | eloqsql/plugin/auth_ed25519/ref10/open.c | int crypto_sign_open(
unsigned char *sm, unsigned long long smlen,
const unsigned char *pk
)
{
unsigned char scopy[32];
unsigned char h[64];
unsigned char rcheck[32];
ge_p3 A;
ge_p2 R;
if (smlen < 64) goto badsig;
if (sm[63] & 224) goto badsig;
if (ge_frombytes_negate_vartime(&A,pk) != 0) goto badsig;
memmove(scopy,sm + 32,32);
memmove(sm + 32,pk,32);
crypto_hash_sha512(h,sm,smlen);
sc_reduce(h);
ge_double_scalarmult_vartime(&R,h,&A,scopy);
ge_tobytes(rcheck,&R);
if (crypto_verify_32(rcheck,sm) == 0)
return 0;
badsig:
return -1;
} | O0 | c | crypto_sign_open:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp # imm = 0x1D0
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0xa0(%rbp)
movq %rsi, -0xa8(%rbp)
movq %rdx, -0xb0(%rbp)
cmpq $0x40, -0xa8(%rbp)
jae 0x227c
jmp 0x2364
movq -0xa0(%rbp), %rax
movzbl 0x3f(%rax), %eax
andl $0xe0, %eax
cmpl $0x0, %eax
je 0x2296
jmp 0x2364
movq -0xb0(%rbp), %rsi
leaq -0x150(%rbp), %rdi
callq 0x4650
cmpl $0x0, %eax
je 0x22b3
jmp 0x2364
leaq -0x30(%rbp), %rax
movq -0xa0(%rbp), %rcx
addq $0x20, %rcx
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movq -0xa0(%rbp), %rax
addq $0x20, %rax
movq -0xb0(%rbp), %rcx
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0x70(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
callq 0xc680
leaq -0x70(%rbp), %rdi
callq 0x23a0
leaq -0x70(%rbp), %rsi
leaq -0x30(%rbp), %rcx
leaq -0x1c8(%rbp), %rdi
leaq -0x150(%rbp), %rdx
callq 0x3f50
leaq -0x90(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x5650
leaq -0x90(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x3c20
cmpl $0x0, %eax
jne 0x2362
movl $0x0, -0x94(%rbp)
jmp 0x236e
jmp 0x2364
movl $0xffffffff, -0x94(%rbp) # imm = 0xFFFFFFFF
movl -0x94(%rbp), %eax
movl %eax, -0x1cc(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x239b
movl -0x1cc(%rbp), %eax
addq $0x1d0, %rsp # imm = 0x1D0
popq %rbp
retq
callq 0x10a0
| crypto_sign_open:
push rbp
mov rbp, rsp
sub rsp, 1D0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_A0], rdi
mov [rbp+var_A8], rsi
mov [rbp+var_B0], rdx
cmp [rbp+var_A8], 40h ; '@'
jnb short loc_227C
jmp loc_2364
loc_227C:
mov rax, [rbp+var_A0]
movzx eax, byte ptr [rax+3Fh]
and eax, 0E0h
cmp eax, 0
jz short loc_2296
jmp loc_2364
loc_2296:
mov rsi, [rbp+var_B0]
lea rdi, [rbp+var_150]
call crypto_sign_ed25519_ref10_ge_frombytes_negate_vartime
cmp eax, 0
jz short loc_22B3
jmp loc_2364
loc_22B3:
lea rax, [rbp+var_30]
mov rcx, [rbp+var_A0]
add rcx, 20h ; ' '
movups xmm0, xmmword ptr [rcx]
movups xmm1, xmmword ptr [rcx+10h]
movups xmmword ptr [rax+10h], xmm1
movups xmmword ptr [rax], xmm0
mov rax, [rbp+var_A0]
add rax, 20h ; ' '
mov rcx, [rbp+var_B0]
movups xmm0, xmmword ptr [rcx]
movups xmm1, xmmword ptr [rcx+10h]
movups xmmword ptr [rax+10h], xmm1
movups xmmword ptr [rax], xmm0
lea rdi, [rbp+var_70]
mov rsi, [rbp+var_A0]
mov rdx, [rbp+var_A8]
call my_sha512
lea rdi, [rbp+var_70]
call crypto_sign_ed25519_ref10_sc_reduce
lea rsi, [rbp+var_70]
lea rcx, [rbp+var_30]
lea rdi, [rbp+var_1C8]
lea rdx, [rbp+var_150]
call crypto_sign_ed25519_ref10_ge_double_scalarmult_vartime
lea rdi, [rbp+var_90]
lea rsi, [rbp+var_1C8]
call crypto_sign_ed25519_ref10_ge_tobytes
lea rdi, [rbp+var_90]
mov rsi, [rbp+var_A0]
call crypto_verify
cmp eax, 0
jnz short loc_2362
mov [rbp+var_94], 0
jmp short loc_236E
loc_2362:
jmp short $+2
loc_2364:
mov [rbp+var_94], 0FFFFFFFFh
loc_236E:
mov eax, [rbp+var_94]
mov [rbp+var_1CC], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_239B
mov eax, [rbp+var_1CC]
add rsp, 1D0h
pop rbp
retn
loc_239B:
call ___stack_chk_fail
| long long crypto_sign_open(long long a1, unsigned long long a2, __int128 *a3)
{
__int128 v3; // xmm0
_OWORD *v4; // rax
__int128 v5; // xmm0
_BYTE v7[120]; // [rsp+8h] [rbp-1C8h] BYREF
_BYTE v8[160]; // [rsp+80h] [rbp-150h] BYREF
__int128 *v9; // [rsp+120h] [rbp-B0h]
unsigned long long v10; // [rsp+128h] [rbp-A8h]
long long v11; // [rsp+130h] [rbp-A0h]
_BYTE v13[32]; // [rsp+140h] [rbp-90h] BYREF
_BYTE v14[64]; // [rsp+160h] [rbp-70h] BYREF
_OWORD v15[2]; // [rsp+1A0h] [rbp-30h] BYREF
unsigned long long v16; // [rsp+1C8h] [rbp-8h]
v16 = __readfsqword(0x28u);
v11 = a1;
v10 = a2;
v9 = a3;
if ( a2 < 0x40 )
return (unsigned int)-1;
if ( (*(_BYTE *)(v11 + 63) & 0xE0) != 0 )
return (unsigned int)-1;
if ( (unsigned int)crypto_sign_ed25519_ref10_ge_frombytes_negate_vartime(v8, v9) )
return (unsigned int)-1;
v3 = *(_OWORD *)(v11 + 32);
v15[1] = *(_OWORD *)(v11 + 48);
v15[0] = v3;
v4 = (_OWORD *)(v11 + 32);
v5 = *v9;
*(_OWORD *)(v11 + 48) = v9[1];
*v4 = v5;
my_sha512(v14, v11, v10);
crypto_sign_ed25519_ref10_sc_reduce(v14);
crypto_sign_ed25519_ref10_ge_double_scalarmult_vartime(v7, v14, v8, v15);
crypto_sign_ed25519_ref10_ge_tobytes(v13, v7);
if ( (unsigned int)crypto_verify(v13, v11) )
return (unsigned int)-1;
else
return 0;
}
| crypto_sign_open:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x1d0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0xa0],RDI
MOV qword ptr [RBP + -0xa8],RSI
MOV qword ptr [RBP + -0xb0],RDX
CMP qword ptr [RBP + -0xa8],0x40
JNC 0x0010227c
JMP 0x00102364
LAB_0010227c:
MOV RAX,qword ptr [RBP + -0xa0]
MOVZX EAX,byte ptr [RAX + 0x3f]
AND EAX,0xe0
CMP EAX,0x0
JZ 0x00102296
JMP 0x00102364
LAB_00102296:
MOV RSI,qword ptr [RBP + -0xb0]
LEA RDI,[RBP + -0x150]
CALL 0x00104650
CMP EAX,0x0
JZ 0x001022b3
JMP 0x00102364
LAB_001022b3:
LEA RAX,[RBP + -0x30]
MOV RCX,qword ptr [RBP + -0xa0]
ADD RCX,0x20
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS XMM1,xmmword ptr [RCX + 0x10]
MOVUPS xmmword ptr [RAX + 0x10],XMM1
MOVUPS xmmword ptr [RAX],XMM0
MOV RAX,qword ptr [RBP + -0xa0]
ADD RAX,0x20
MOV RCX,qword ptr [RBP + -0xb0]
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS XMM1,xmmword ptr [RCX + 0x10]
MOVUPS xmmword ptr [RAX + 0x10],XMM1
MOVUPS xmmword ptr [RAX],XMM0
LEA RDI,[RBP + -0x70]
MOV RSI,qword ptr [RBP + -0xa0]
MOV RDX,qword ptr [RBP + -0xa8]
CALL 0x0010c680
LEA RDI,[RBP + -0x70]
CALL 0x001023a0
LEA RSI,[RBP + -0x70]
LEA RCX,[RBP + -0x30]
LEA RDI,[RBP + -0x1c8]
LEA RDX,[RBP + -0x150]
CALL 0x00103f50
LEA RDI,[RBP + -0x90]
LEA RSI,[RBP + -0x1c8]
CALL 0x00105650
LEA RDI,[RBP + -0x90]
MOV RSI,qword ptr [RBP + -0xa0]
CALL 0x00103c20
CMP EAX,0x0
JNZ 0x00102362
MOV dword ptr [RBP + -0x94],0x0
JMP 0x0010236e
LAB_00102362:
JMP 0x00102364
LAB_00102364:
MOV dword ptr [RBP + -0x94],0xffffffff
LAB_0010236e:
MOV EAX,dword ptr [RBP + -0x94]
MOV dword ptr [RBP + -0x1cc],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0010239b
MOV EAX,dword ptr [RBP + -0x1cc]
ADD RSP,0x1d0
POP RBP
RET
LAB_0010239b:
CALL 0x001010a0
|
int4 crypto_sign_open(long param_1,ulong param_2,int4 *param_3)
{
int4 uVar1;
int4 uVar2;
int4 uVar3;
int4 uVar4;
int4 uVar5;
int4 uVar6;
int4 uVar7;
int iVar8;
long in_FS_OFFSET;
int1 local_1d0 [120];
int1 local_158 [160];
int4 *local_b8;
ulong local_b0;
long local_a8;
int4 local_9c;
int1 local_98 [32];
int1 local_78 [64];
int8 local_38;
int8 uStack_30;
int8 local_28;
int8 uStack_20;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_b8 = param_3;
local_b0 = param_2;
local_a8 = param_1;
if (((0x3f < param_2) && ((*(byte *)(param_1 + 0x3f) & 0xe0) == 0)) &&
(iVar8 = crypto_sign_ed25519_ref10_ge_frombytes_negate_vartime(local_158,param_3), iVar8 == 0))
{
local_38 = *(int8 *)(local_a8 + 0x20);
uStack_30 = *(int8 *)(local_a8 + 0x28);
local_28 = *(int8 *)(local_a8 + 0x30);
uStack_20 = *(int8 *)(local_a8 + 0x38);
uVar1 = *local_b8;
uVar2 = local_b8[1];
uVar3 = local_b8[2];
uVar4 = local_b8[3];
uVar5 = local_b8[5];
uVar6 = local_b8[6];
uVar7 = local_b8[7];
*(int4 *)(local_a8 + 0x30) = local_b8[4];
*(int4 *)(local_a8 + 0x34) = uVar5;
*(int4 *)(local_a8 + 0x38) = uVar6;
*(int4 *)(local_a8 + 0x3c) = uVar7;
*(int4 *)(local_a8 + 0x20) = uVar1;
*(int4 *)(local_a8 + 0x24) = uVar2;
*(int4 *)(local_a8 + 0x28) = uVar3;
*(int4 *)(local_a8 + 0x2c) = uVar4;
my_sha512(local_78,local_a8,local_b0);
crypto_sign_ed25519_ref10_sc_reduce(local_78);
crypto_sign_ed25519_ref10_ge_double_scalarmult_vartime(local_1d0,local_78,local_158,&local_38);
crypto_sign_ed25519_ref10_ge_tobytes(local_98,local_1d0);
iVar8 = crypto_verify(local_98,local_a8);
if (iVar8 == 0) {
local_9c = 0;
goto LAB_0010236e;
}
}
local_9c = 0xffffffff;
LAB_0010236e:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_9c;
}
| |
24,869 | translog_get_next_chunk | eloqsql/storage/maria/ma_loghandler.c | static my_bool
translog_get_next_chunk(TRANSLOG_SCANNER_DATA *scanner)
{
uint16 len;
DBUG_ENTER("translog_get_next_chunk");
if (translog_scanner_eop(scanner))
len= TRANSLOG_PAGE_SIZE - scanner->page_offset;
else if ((len= translog_get_total_chunk_length(scanner->page,
scanner->page_offset)) == 0)
DBUG_RETURN(1);
scanner->page_offset+= len;
if (translog_scanner_eol(scanner))
{
scanner->page= END_OF_LOG;
scanner->page_offset= 0;
DBUG_RETURN(0);
}
if (translog_scanner_eop(scanner))
{
/* before reading next page we should unpin current one if it was pinned */
translog_free_link(scanner->direct_link);
if (translog_scanner_eof(scanner))
{
DBUG_PRINT("info", ("horizon: " LSN_FMT " pageaddr: " LSN_FMT,
LSN_IN_PARTS(scanner->horizon),
LSN_IN_PARTS(scanner->page_addr)));
/* if it is log end it have to be caught before */
DBUG_ASSERT(LSN_FILE_NO(scanner->horizon) >
LSN_FILE_NO(scanner->page_addr));
scanner->page_addr+= LSN_ONE_FILE;
scanner->page_addr= LSN_REPLACE_OFFSET(scanner->page_addr,
TRANSLOG_PAGE_SIZE);
if (translog_scanner_set_last_page(scanner))
DBUG_RETURN(1);
}
else
{
scanner->page_addr+= TRANSLOG_PAGE_SIZE; /* offset increased */
}
if (translog_scanner_get_page(scanner))
DBUG_RETURN(1);
scanner->page_offset= translog_get_first_chunk_offset(scanner->page);
if (translog_scanner_eol(scanner))
{
scanner->page= END_OF_LOG;
scanner->page_offset= 0;
DBUG_RETURN(0);
}
DBUG_ASSERT(scanner->page[scanner->page_offset] != TRANSLOG_FILLER);
}
DBUG_RETURN(0);
} | O0 | c | translog_get_next_chunk:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x93ec0
cmpb $0x0, %al
je 0x8faae
movq -0x10(%rbp), %rcx
movl $0x2000, %eax # imm = 0x2000
subl 0x2028(%rcx), %eax
movw %ax, -0x12(%rbp)
jmp 0x8fae4
movq -0x10(%rbp), %rax
movq 0x2018(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x2028(%rax), %eax
movzwl %ax, %esi
callq 0x8f370
movw %ax, -0x12(%rbp)
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0x8fae2
jmp 0x8fad9
movb $0x1, -0x1(%rbp)
jmp 0x8fc4b
jmp 0x8fae4
movzwl -0x12(%rbp), %ecx
movq -0x10(%rbp), %rax
addl 0x2028(%rax), %ecx
movl %ecx, 0x2028(%rax)
movq -0x10(%rbp), %rdi
callq 0x98fb0
cmpb $0x0, %al
je 0x8fb2e
movq -0x10(%rbp), %rax
leaq 0xbf5960(%rip), %rcx # 0xc85470
movq %rcx, 0x2018(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x2028(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x8fc4b
movq -0x10(%rbp), %rdi
callq 0x93ec0
cmpb $0x0, %al
je 0x8fc45
movq -0x10(%rbp), %rax
movq 0x2020(%rax), %rdi
callq 0x91990
movq -0x10(%rbp), %rdi
callq 0x99060
cmpb $0x0, %al
je 0x8fbc1
jmp 0x8fb5e
jmp 0x8fb60
jmp 0x8fb62
jmp 0x8fb64
movq -0x10(%rbp), %rax
movabsq $0x100000000, %rcx # imm = 0x100000000
addq 0x2000(%rax), %rcx
movq %rcx, 0x2000(%rax)
movq -0x10(%rbp), %rax
movabsq $0xffffff00000000, %rcx # imm = 0xFFFFFF00000000
andq 0x2000(%rax), %rcx
orq $0x2000, %rcx # imm = 0x2000
movq -0x10(%rbp), %rax
movq %rcx, 0x2000(%rax)
movq -0x10(%rbp), %rdi
callq 0x91830
cmpb $0x0, %al
je 0x8fbbf
jmp 0x8fbb6
movb $0x1, -0x1(%rbp)
jmp 0x8fc4b
jmp 0x8fbda
movq -0x10(%rbp), %rax
movq 0x2000(%rax), %rcx
addq $0x2000, %rcx # imm = 0x2000
movq %rcx, 0x2000(%rax)
movq -0x10(%rbp), %rdi
callq 0x91900
cmpb $0x0, %al
je 0x8fbef
jmp 0x8fbe9
movb $0x1, -0x1(%rbp)
jmp 0x8fc4b
movq -0x10(%rbp), %rax
movq 0x2018(%rax), %rdi
callq 0x8f340
movsbl %al, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x2028(%rax)
movq -0x10(%rbp), %rdi
callq 0x98fb0
cmpb $0x0, %al
je 0x8fc3f
movq -0x10(%rbp), %rax
leaq 0xbf584c(%rip), %rcx # 0xc85470
movq %rcx, 0x2018(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x2028(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x8fc4b
jmp 0x8fc41
jmp 0x8fc43
jmp 0x8fc45
jmp 0x8fc47
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| translog_get_next_chunk:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov rdi, [rbp+var_10]
call translog_scanner_eop
cmp al, 0
jz short loc_8FAAE
mov rcx, [rbp+var_10]
mov eax, 2000h
sub eax, [rcx+2028h]
mov [rbp+var_12], ax
jmp short loc_8FAE4
loc_8FAAE:
mov rax, [rbp+var_10]
mov rdi, [rax+2018h]
mov rax, [rbp+var_10]
mov eax, [rax+2028h]
movzx esi, ax
call translog_get_total_chunk_length
mov [rbp+var_12], ax
movzx eax, ax
cmp eax, 0
jnz short loc_8FAE2
jmp short $+2
loc_8FAD9:
mov [rbp+var_1], 1
jmp loc_8FC4B
loc_8FAE2:
jmp short $+2
loc_8FAE4:
movzx ecx, [rbp+var_12]
mov rax, [rbp+var_10]
add ecx, [rax+2028h]
mov [rax+2028h], ecx
mov rdi, [rbp+var_10]
call translog_scanner_eol
cmp al, 0
jz short loc_8FB2E
mov rax, [rbp+var_10]
lea rcx, end_of_log
mov [rax+2018h], rcx
mov rax, [rbp+var_10]
mov dword ptr [rax+2028h], 0
mov [rbp+var_1], 0
jmp loc_8FC4B
loc_8FB2E:
mov rdi, [rbp+var_10]
call translog_scanner_eop
cmp al, 0
jz loc_8FC45
mov rax, [rbp+var_10]
mov rdi, [rax+2020h]
call translog_free_link
mov rdi, [rbp+var_10]
call translog_scanner_eof
cmp al, 0
jz short loc_8FBC1
jmp short $+2
loc_8FB5E:
jmp short $+2
loc_8FB60:
jmp short $+2
loc_8FB62:
jmp short $+2
loc_8FB64:
mov rax, [rbp+var_10]
mov rcx, 100000000h
add rcx, [rax+2000h]
mov [rax+2000h], rcx
mov rax, [rbp+var_10]
mov rcx, 0FFFFFF00000000h
and rcx, [rax+2000h]
or rcx, 2000h
mov rax, [rbp+var_10]
mov [rax+2000h], rcx
mov rdi, [rbp+var_10]
call translog_scanner_set_last_page
cmp al, 0
jz short loc_8FBBF
jmp short $+2
loc_8FBB6:
mov [rbp+var_1], 1
jmp loc_8FC4B
loc_8FBBF:
jmp short loc_8FBDA
loc_8FBC1:
mov rax, [rbp+var_10]
mov rcx, [rax+2000h]
add rcx, 2000h
mov [rax+2000h], rcx
loc_8FBDA:
mov rdi, [rbp+var_10]
call translog_scanner_get_page
cmp al, 0
jz short loc_8FBEF
jmp short $+2
loc_8FBE9:
mov [rbp+var_1], 1
jmp short loc_8FC4B
loc_8FBEF:
mov rax, [rbp+var_10]
mov rdi, [rax+2018h]
call translog_get_first_chunk_offset
movsx ecx, al
mov rax, [rbp+var_10]
mov [rax+2028h], ecx
mov rdi, [rbp+var_10]
call translog_scanner_eol
cmp al, 0
jz short loc_8FC3F
mov rax, [rbp+var_10]
lea rcx, end_of_log
mov [rax+2018h], rcx
mov rax, [rbp+var_10]
mov dword ptr [rax+2028h], 0
mov [rbp+var_1], 0
jmp short loc_8FC4B
loc_8FC3F:
jmp short $+2
loc_8FC41:
jmp short $+2
loc_8FC43:
jmp short $+2
loc_8FC45:
jmp short $+2
loc_8FC47:
mov [rbp+var_1], 0
loc_8FC4B:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
| char translog_get_next_chunk(long long a1)
{
unsigned __int16 total_chunk_length; // [rsp+Eh] [rbp-12h]
if ( (unsigned __int8)translog_scanner_eop(a1) )
{
total_chunk_length = 0x2000 - *(_WORD *)(a1 + 8232);
}
else
{
total_chunk_length = translog_get_total_chunk_length(*(_QWORD *)(a1 + 8216), *(_DWORD *)(a1 + 8232));
if ( !total_chunk_length )
return 1;
}
*(_DWORD *)(a1 + 8232) += total_chunk_length;
if ( !(unsigned __int8)translog_scanner_eol(a1) )
{
if ( (unsigned __int8)translog_scanner_eop(a1) )
{
translog_free_link(*(_QWORD *)(a1 + 8224));
if ( (unsigned __int8)translog_scanner_eof(a1) )
{
*(_QWORD *)(a1 + 0x2000) += 0x100000000LL;
*(_QWORD *)(a1 + 0x2000) = *(_QWORD *)(a1 + 0x2000) & 0xFFFFFF00000000LL | 0x2000;
if ( (unsigned __int8)translog_scanner_set_last_page(a1) )
return 1;
}
else
{
*(_QWORD *)(a1 + 0x2000) += 0x2000LL;
}
if ( (unsigned __int8)translog_scanner_get_page(a1) )
return 1;
*(_DWORD *)(a1 + 8232) = translog_get_first_chunk_offset(*(_QWORD *)(a1 + 8216));
if ( (unsigned __int8)translog_scanner_eol(a1) )
{
*(_QWORD *)(a1 + 8216) = &end_of_log;
*(_DWORD *)(a1 + 8232) = 0;
return 0;
}
}
return 0;
}
*(_QWORD *)(a1 + 8216) = &end_of_log;
*(_DWORD *)(a1 + 8232) = 0;
return 0;
}
| translog_get_next_chunk:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00193ec0
CMP AL,0x0
JZ 0x0018faae
MOV RCX,qword ptr [RBP + -0x10]
MOV EAX,0x2000
SUB EAX,dword ptr [RCX + 0x2028]
MOV word ptr [RBP + -0x12],AX
JMP 0x0018fae4
LAB_0018faae:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x2018]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x2028]
MOVZX ESI,AX
CALL 0x0018f370
MOV word ptr [RBP + -0x12],AX
MOVZX EAX,AX
CMP EAX,0x0
JNZ 0x0018fae2
JMP 0x0018fad9
LAB_0018fad9:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0018fc4b
LAB_0018fae2:
JMP 0x0018fae4
LAB_0018fae4:
MOVZX ECX,word ptr [RBP + -0x12]
MOV RAX,qword ptr [RBP + -0x10]
ADD ECX,dword ptr [RAX + 0x2028]
MOV dword ptr [RAX + 0x2028],ECX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00198fb0
CMP AL,0x0
JZ 0x0018fb2e
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0xd85470]
MOV qword ptr [RAX + 0x2018],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x2028],0x0
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0018fc4b
LAB_0018fb2e:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00193ec0
CMP AL,0x0
JZ 0x0018fc45
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x2020]
CALL 0x00191990
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00199060
CMP AL,0x0
JZ 0x0018fbc1
JMP 0x0018fb5e
LAB_0018fb5e:
JMP 0x0018fb60
LAB_0018fb60:
JMP 0x0018fb62
LAB_0018fb62:
JMP 0x0018fb64
LAB_0018fb64:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,0x100000000
ADD RCX,qword ptr [RAX + 0x2000]
MOV qword ptr [RAX + 0x2000],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,0xffffff00000000
AND RCX,qword ptr [RAX + 0x2000]
OR RCX,0x2000
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x2000],RCX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00191830
CMP AL,0x0
JZ 0x0018fbbf
JMP 0x0018fbb6
LAB_0018fbb6:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0018fc4b
LAB_0018fbbf:
JMP 0x0018fbda
LAB_0018fbc1:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x2000]
ADD RCX,0x2000
MOV qword ptr [RAX + 0x2000],RCX
LAB_0018fbda:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00191900
CMP AL,0x0
JZ 0x0018fbef
JMP 0x0018fbe9
LAB_0018fbe9:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0018fc4b
LAB_0018fbef:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x2018]
CALL 0x0018f340
MOVSX ECX,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x2028],ECX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00198fb0
CMP AL,0x0
JZ 0x0018fc3f
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0xd85470]
MOV qword ptr [RAX + 0x2018],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x2028],0x0
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0018fc4b
LAB_0018fc3f:
JMP 0x0018fc41
LAB_0018fc41:
JMP 0x0018fc43
LAB_0018fc43:
JMP 0x0018fc45
LAB_0018fc45:
JMP 0x0018fc47
LAB_0018fc47:
MOV byte ptr [RBP + -0x1],0x0
LAB_0018fc4b:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 translog_get_next_chunk(long param_1)
{
char cVar1;
ushort local_1a;
cVar1 = translog_scanner_eop(param_1);
if (cVar1 == '\0') {
local_1a = translog_get_total_chunk_length
(*(int8 *)(param_1 + 0x2018),*(uint *)(param_1 + 0x2028) & 0xffff);
if (local_1a == 0) {
return 1;
}
}
else {
local_1a = 0x2000 - (short)*(int4 *)(param_1 + 0x2028);
}
*(uint *)(param_1 + 0x2028) = (uint)local_1a + *(int *)(param_1 + 0x2028);
cVar1 = translog_scanner_eol(param_1);
if (cVar1 != '\0') {
*(int1 **)(param_1 + 0x2018) = &end_of_log;
*(int4 *)(param_1 + 0x2028) = 0;
return 0;
}
cVar1 = translog_scanner_eop(param_1);
if (cVar1 != '\0') {
translog_free_link(*(int8 *)(param_1 + 0x2020));
cVar1 = translog_scanner_eof(param_1);
if (cVar1 == '\0') {
*(long *)(param_1 + 0x2000) = *(long *)(param_1 + 0x2000) + 0x2000;
}
else {
*(long *)(param_1 + 0x2000) = *(long *)(param_1 + 0x2000) + 0x100000000;
*(ulong *)(param_1 + 0x2000) = *(ulong *)(param_1 + 0x2000) & 0xffffff00000000 | 0x2000;
cVar1 = translog_scanner_set_last_page(param_1);
if (cVar1 != '\0') {
return 1;
}
}
cVar1 = translog_scanner_get_page(param_1);
if (cVar1 != '\0') {
return 1;
}
cVar1 = translog_get_first_chunk_offset(*(int8 *)(param_1 + 0x2018));
*(int *)(param_1 + 0x2028) = (int)cVar1;
cVar1 = translog_scanner_eol(param_1);
if (cVar1 != '\0') {
*(int1 **)(param_1 + 0x2018) = &end_of_log;
*(int4 *)(param_1 + 0x2028) = 0;
return 0;
}
}
return 0;
}
| |
24,870 | translog_get_next_chunk | eloqsql/storage/maria/ma_loghandler.c | static my_bool
translog_get_next_chunk(TRANSLOG_SCANNER_DATA *scanner)
{
uint16 len;
DBUG_ENTER("translog_get_next_chunk");
if (translog_scanner_eop(scanner))
len= TRANSLOG_PAGE_SIZE - scanner->page_offset;
else if ((len= translog_get_total_chunk_length(scanner->page,
scanner->page_offset)) == 0)
DBUG_RETURN(1);
scanner->page_offset+= len;
if (translog_scanner_eol(scanner))
{
scanner->page= END_OF_LOG;
scanner->page_offset= 0;
DBUG_RETURN(0);
}
if (translog_scanner_eop(scanner))
{
/* before reading next page we should unpin current one if it was pinned */
translog_free_link(scanner->direct_link);
if (translog_scanner_eof(scanner))
{
DBUG_PRINT("info", ("horizon: " LSN_FMT " pageaddr: " LSN_FMT,
LSN_IN_PARTS(scanner->horizon),
LSN_IN_PARTS(scanner->page_addr)));
/* if it is log end it have to be caught before */
DBUG_ASSERT(LSN_FILE_NO(scanner->horizon) >
LSN_FILE_NO(scanner->page_addr));
scanner->page_addr+= LSN_ONE_FILE;
scanner->page_addr= LSN_REPLACE_OFFSET(scanner->page_addr,
TRANSLOG_PAGE_SIZE);
if (translog_scanner_set_last_page(scanner))
DBUG_RETURN(1);
}
else
{
scanner->page_addr+= TRANSLOG_PAGE_SIZE; /* offset increased */
}
if (translog_scanner_get_page(scanner))
DBUG_RETURN(1);
scanner->page_offset= translog_get_first_chunk_offset(scanner->page);
if (translog_scanner_eol(scanner))
{
scanner->page= END_OF_LOG;
scanner->page_offset= 0;
DBUG_RETURN(0);
}
DBUG_ASSERT(scanner->page[scanner->page_offset] != TRANSLOG_FILLER);
}
DBUG_RETURN(0);
} | O3 | c | translog_get_next_chunk:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x2028(%rdi), %r14d
cmpq $0x1fff, %r14 # imm = 0x1FFF
ja 0x6ac9d
movq 0x2018(%rbx), %rdi
cmpb $-0x1, (%rdi,%r14)
je 0x6ac9d
movzwl %r14w, %esi
callq 0x6a888
testw %ax, %ax
jne 0x6aca5
jmp 0x6adbe
movl $0x2000, %eax # imm = 0x2000
subl %r14d, %eax
movzwl %ax, %eax
addl %r14d, %eax
movl %eax, 0x2028(%rbx)
movq %rbx, %rdi
callq 0x7002f
testb %al, %al
je 0x6ace0
leaq 0xb9ec9c(%rip), %rax # 0xc09960
movq %rax, 0x2018(%rbx)
movl $0x0, 0x2028(%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl 0x2028(%rbx), %eax
cmpq $0x1fff, %rax # imm = 0x1FFF
ja 0x6acfb
movq 0x2018(%rbx), %rcx
cmpb $-0x1, (%rcx,%rax)
jne 0x6acd5
movq 0x2020(%rbx), %rdi
callq 0x6bf6a
leaq 0x2000(%rbx), %r14
movq 0x2000(%rbx), %rax
cmpq 0x2010(%rbx), %rax
jne 0x6ad58
movabsq $0x100000000, %rcx # imm = 0x100000000
addq %rcx, %rax
movabsq $0xffffff00000000, %rcx # imm = 0xFFFFFF00000000
andq %rax, %rcx
orq $0x2000, %rcx # imm = 0x2000
movq %rcx, 0x2000(%rbx)
movq %rbx, %rdi
callq 0x6bf0c
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x6acd7
jmp 0x6ad61
addq $0x2000, %rax # imm = 0x2000
movq %rax, (%r14)
leaq 0x2020(%rbx), %rax
leaq -0x20(%rbp), %rdi
movq %r14, (%rdi)
movb $0x0, 0x8(%rdi)
xorl %edx, %edx
cmpb $0x0, 0x202d(%rbx)
cmovneq %rax, %rdx
movq %rbx, %rsi
callq 0x6a4a8
movq %rax, 0x2018(%rbx)
testq %rax, %rax
je 0x6adbe
movzbl 0x6(%rax), %eax
leaq 0xb9eb91(%rip), %rcx # 0xc09930
movsbl (%rcx,%rax,4), %eax
movl %eax, 0x2028(%rbx)
movq %rbx, %rdi
callq 0x7002f
testb %al, %al
jne 0x6acbd
jmp 0x6acd5
movb $0x1, %al
jmp 0x6acd7
| translog_get_next_chunk:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 10h
mov rbx, rdi
mov r14d, [rdi+2028h]
cmp r14, 1FFFh
ja short loc_6AC9D
mov rdi, [rbx+2018h]
cmp byte ptr [rdi+r14], 0FFh
jz short loc_6AC9D
movzx esi, r14w
call translog_get_total_chunk_length
test ax, ax
jnz short loc_6ACA5
jmp loc_6ADBE
loc_6AC9D:
mov eax, 2000h
sub eax, r14d
loc_6ACA5:
movzx eax, ax
add eax, r14d
mov [rbx+2028h], eax
mov rdi, rbx
call translog_scanner_eol
test al, al
jz short loc_6ACE0
loc_6ACBD:
lea rax, end_of_log
mov [rbx+2018h], rax
mov dword ptr [rbx+2028h], 0
loc_6ACD5:
xor eax, eax
loc_6ACD7:
add rsp, 10h
pop rbx
pop r14
pop rbp
retn
loc_6ACE0:
mov eax, [rbx+2028h]
cmp rax, 1FFFh
ja short loc_6ACFB
mov rcx, [rbx+2018h]
cmp byte ptr [rcx+rax], 0FFh
jnz short loc_6ACD5
loc_6ACFB:
mov rdi, [rbx+2020h]
call translog_free_link
lea r14, [rbx+2000h]
mov rax, [rbx+2000h]
cmp rax, [rbx+2010h]
jnz short loc_6AD58
mov rcx, 100000000h
add rax, rcx
mov rcx, 0FFFFFF00000000h
and rcx, rax
or rcx, 2000h
mov [rbx+2000h], rcx
mov rdi, rbx
call translog_scanner_set_last_page
mov ecx, eax
mov al, 1
test cl, cl
jnz short loc_6ACD7
jmp short loc_6AD61
loc_6AD58:
add rax, 2000h
mov [r14], rax
loc_6AD61:
lea rax, [rbx+2020h]
lea rdi, [rbp+var_20]
mov [rdi], r14
mov byte ptr [rdi+8], 0
xor edx, edx
cmp byte ptr [rbx+202Dh], 0
cmovnz rdx, rax
mov rsi, rbx
call translog_get_page
mov [rbx+2018h], rax
test rax, rax
jz short loc_6ADBE
movzx eax, byte ptr [rax+6]
lea rcx, page_overhead
movsx eax, byte ptr [rcx+rax*4]
mov [rbx+2028h], eax
mov rdi, rbx
call translog_scanner_eol
test al, al
jnz loc_6ACBD
jmp loc_6ACD5
loc_6ADBE:
mov al, 1
jmp loc_6ACD7
| char translog_get_next_chunk(long long a1)
{
unsigned long long v2; // r14
long long v3; // rdi
unsigned __int16 total_chunk_length; // ax
char result; // al
unsigned long long v6; // rax
long long v7; // rax
char page; // cl
_QWORD *v9; // rdx
long long v10; // rax
long long *v11; // [rsp+0h] [rbp-20h] BYREF
char v12; // [rsp+8h] [rbp-18h]
v2 = *(unsigned int *)(a1 + 8232);
if ( v2 > 0x1FFF || (v3 = *(_QWORD *)(a1 + 8216), *(_BYTE *)(v3 + v2) == 0xFF) )
{
total_chunk_length = 0x2000 - v2;
}
else
{
total_chunk_length = translog_get_total_chunk_length(v3, (unsigned __int16)v2);
if ( !total_chunk_length )
return 1;
}
*(_DWORD *)(a1 + 8232) = v2 + total_chunk_length;
if ( (unsigned __int8)translog_scanner_eol(a1) )
{
LABEL_7:
*(_QWORD *)(a1 + 8216) = &end_of_log;
*(_DWORD *)(a1 + 8232) = 0;
return 0;
}
v6 = *(unsigned int *)(a1 + 8232);
if ( v6 <= 0x1FFF && *(_BYTE *)(*(_QWORD *)(a1 + 8216) + v6) != 0xFF )
return 0;
translog_free_link(*(_QWORD *)(a1 + 8224));
v7 = *(_QWORD *)(a1 + 0x2000);
if ( v7 != *(_QWORD *)(a1 + 8208) )
{
*(_QWORD *)(a1 + 0x2000) = v7 + 0x2000;
goto LABEL_16;
}
*(_QWORD *)(a1 + 0x2000) = (v7 + 0x100000000LL) & 0xFFFFFF00000000LL | 0x2000;
page = translog_scanner_set_last_page(a1);
result = 1;
if ( !page )
{
LABEL_16:
v11 = (long long *)(a1 + 0x2000);
v12 = 0;
v9 = 0LL;
if ( *(_BYTE *)(a1 + 8237) )
v9 = (_QWORD *)(a1 + 8224);
v10 = translog_get_page(&v11, a1, v9);
*(_QWORD *)(a1 + 8216) = v10;
if ( !v10 )
return 1;
*(_DWORD *)(a1 + 8232) = *((char *)&page_overhead + 4 * *(unsigned __int8 *)(v10 + 6));
if ( !(unsigned __int8)translog_scanner_eol(a1) )
return 0;
goto LABEL_7;
}
return result;
}
| translog_get_next_chunk:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
MOV R14D,dword ptr [RDI + 0x2028]
CMP R14,0x1fff
JA 0x0016ac9d
MOV RDI,qword ptr [RBX + 0x2018]
CMP byte ptr [RDI + R14*0x1],0xff
JZ 0x0016ac9d
MOVZX ESI,R14W
CALL 0x0016a888
TEST AX,AX
JNZ 0x0016aca5
JMP 0x0016adbe
LAB_0016ac9d:
MOV EAX,0x2000
SUB EAX,R14D
LAB_0016aca5:
MOVZX EAX,AX
ADD EAX,R14D
MOV dword ptr [RBX + 0x2028],EAX
MOV RDI,RBX
CALL 0x0017002f
TEST AL,AL
JZ 0x0016ace0
LAB_0016acbd:
LEA RAX,[0xd09960]
MOV qword ptr [RBX + 0x2018],RAX
MOV dword ptr [RBX + 0x2028],0x0
LAB_0016acd5:
XOR EAX,EAX
LAB_0016acd7:
ADD RSP,0x10
POP RBX
POP R14
POP RBP
RET
LAB_0016ace0:
MOV EAX,dword ptr [RBX + 0x2028]
CMP RAX,0x1fff
JA 0x0016acfb
MOV RCX,qword ptr [RBX + 0x2018]
CMP byte ptr [RCX + RAX*0x1],0xff
JNZ 0x0016acd5
LAB_0016acfb:
MOV RDI,qword ptr [RBX + 0x2020]
CALL 0x0016bf6a
LEA R14,[RBX + 0x2000]
MOV RAX,qword ptr [RBX + 0x2000]
CMP RAX,qword ptr [RBX + 0x2010]
JNZ 0x0016ad58
MOV RCX,0x100000000
ADD RAX,RCX
MOV RCX,0xffffff00000000
AND RCX,RAX
OR RCX,0x2000
MOV qword ptr [RBX + 0x2000],RCX
MOV RDI,RBX
CALL 0x0016bf0c
MOV ECX,EAX
MOV AL,0x1
TEST CL,CL
JNZ 0x0016acd7
JMP 0x0016ad61
LAB_0016ad58:
ADD RAX,0x2000
MOV qword ptr [R14],RAX
LAB_0016ad61:
LEA RAX,[RBX + 0x2020]
LEA RDI,[RBP + -0x20]
MOV qword ptr [RDI],R14
MOV byte ptr [RDI + 0x8],0x0
XOR EDX,EDX
CMP byte ptr [RBX + 0x202d],0x0
CMOVNZ RDX,RAX
MOV RSI,RBX
CALL 0x0016a4a8
MOV qword ptr [RBX + 0x2018],RAX
TEST RAX,RAX
JZ 0x0016adbe
MOVZX EAX,byte ptr [RAX + 0x6]
LEA RCX,[0xd09930]
MOVSX EAX,byte ptr [RCX + RAX*0x4]
MOV dword ptr [RBX + 0x2028],EAX
MOV RDI,RBX
CALL 0x0017002f
TEST AL,AL
JNZ 0x0016acbd
JMP 0x0016acd5
LAB_0016adbe:
MOV AL,0x1
JMP 0x0016acd7
|
int8 translog_get_next_chunk(long param_1)
{
uint uVar1;
char cVar2;
uint uVar3;
long lVar4;
int8 uVar5;
ulong uVar6;
long *local_28;
int1 local_20;
uVar1 = *(uint *)(param_1 + 0x2028);
uVar6 = (ulong)uVar1;
if ((uVar6 < 0x2000) && (*(char *)(*(long *)(param_1 + 0x2018) + uVar6) != -1)) {
uVar3 = translog_get_total_chunk_length(*(long *)(param_1 + 0x2018),uVar6 & 0xffff);
if ((short)uVar3 != 0) goto LAB_0016aca5;
LAB_0016adbe:
uVar5 = 1;
}
else {
uVar3 = 0x2000 - uVar1;
LAB_0016aca5:
*(uint *)(param_1 + 0x2028) = (uVar3 & 0xffff) + uVar1;
cVar2 = translog_scanner_eol(param_1);
if (cVar2 == '\0') {
if ((0x1fff < (ulong)*(uint *)(param_1 + 0x2028)) ||
(*(char *)(*(long *)(param_1 + 0x2018) + (ulong)*(uint *)(param_1 + 0x2028)) == -1)) {
translog_free_link(*(int8 *)(param_1 + 0x2020));
local_28 = (long *)(param_1 + 0x2000);
lVar4 = *(long *)(param_1 + 0x2000);
if (lVar4 == *(long *)(param_1 + 0x2010)) {
*(ulong *)(param_1 + 0x2000) = lVar4 + 0x100000000U & 0xffffff00000000 | 0x2000;
cVar2 = translog_scanner_set_last_page(param_1);
if (cVar2 != '\0') {
return 1;
}
}
else {
*local_28 = lVar4 + 0x2000;
}
local_20 = 0;
lVar4 = 0;
if (*(char *)(param_1 + 0x202d) != '\0') {
lVar4 = param_1 + 0x2020;
}
lVar4 = translog_get_page(&local_28,param_1,lVar4);
*(long *)(param_1 + 0x2018) = lVar4;
if (lVar4 == 0) goto LAB_0016adbe;
*(int *)(param_1 + 0x2028) = (int)(char)page_overhead[(ulong)*(byte *)(lVar4 + 6) * 4];
cVar2 = translog_scanner_eol(param_1);
if (cVar2 != '\0') goto LAB_0016acbd;
}
}
else {
LAB_0016acbd:
*(int1 **)(param_1 + 0x2018) = &end_of_log;
*(int4 *)(param_1 + 0x2028) = 0;
}
uVar5 = 0;
}
return uVar5;
}
| |
24,871 | hexlo | eloqsql/strings/ctype-utf8.c | static int hexlo(int x)
{
static const char hex_lo_digit[256]=
{
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* ................ */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* ................ */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* !"#$%&'()*+,-./ */
0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1,-1,-1,-1,-1, /* 0123456789:;<=>? */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* @ABCDEFGHIJKLMNO */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* PQRSTUVWXYZ[\]^_ */
-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* `abcdefghijklmno */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* pqrstuvwxyz{|}~. */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* ................ */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* ................ */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* ................ */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* ................ */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* ................ */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* ................ */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* ................ */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* ................ */
};
return hex_lo_digit[(unsigned int) x];
} | O0 | c | hexlo:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x14b93d(%rip), %rax # 0x1b7450
movsbl (%rax,%rcx), %eax
popq %rbp
retq
nopl (%rax)
| hexlo:
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
mov ecx, eax
lea rax, hexlo_hex_lo_digit
movsx eax, byte ptr [rax+rcx]
pop rbp
retn
| long long hexlo(int a1)
{
return (unsigned int)hexlo_hex_lo_digit[a1];
}
| hexlo:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
MOV ECX,EAX
LEA RAX,[0x2b7450]
MOVSX EAX,byte ptr [RAX + RCX*0x1]
POP RBP
RET
|
int hexlo(uint param_1)
{
return (int)(char)hexlo_hex_lo_digit[param_1];
}
| |
24,872 | minja::Value::to_bool() const | monkey531[P]llama/common/minja.hpp | bool to_bool() const {
if (is_null()) return false;
if (is_boolean()) return get<bool>();
if (is_number()) return get<double>() != 0;
if (is_string()) return !get<std::string>().empty();
if (is_array()) return !empty();
return true;
} | O2 | cpp | minja::Value::to_bool() const:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x6390a
testb %al, %al
je 0x63097
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movb 0x40(%rbx), %al
cmpb $0x4, %al
jne 0x630ad
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x63c9e
leal -0x5(%rax), %ecx
cmpb $0x2, %cl
ja 0x630d0
movq %rbx, %rdi
callq 0x6323c
xorpd %xmm1, %xmm1
cmpneqsd %xmm0, %xmm1
movq %xmm1, %rbx
andl $0x1, %ebx
jmp 0x6308d
cmpb $0x3, %al
jne 0x630f6
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x63d54
cmpq $0x0, 0x8(%r14)
setne %bl
movq %r14, %rdi
callq 0x251b8
jmp 0x6308d
cmpq $0x0, 0x10(%rbx)
je 0x6310c
movq %rbx, %rdi
callq 0x63e18
movl %eax, %ebx
xorb $0x1, %bl
jmp 0x6308d
movb $0x1, %bl
jmp 0x6308d
nop
| _ZNK5minja5Value7to_boolEv:
push r14
push rbx
sub rsp, 28h
mov rbx, rdi
call _ZNK5minja5Value7is_nullEv; minja::Value::is_null(void)
test al, al
jz short loc_63097
xor ebx, ebx
loc_6308D:
mov eax, ebx
add rsp, 28h
pop rbx
pop r14
retn
loc_63097:
mov al, [rbx+40h]
cmp al, 4
jnz short loc_630AD
mov rdi, rbx
add rsp, 28h
pop rbx
pop r14
jmp _ZNK5minja5Value3getIbEET_v; minja::Value::get<bool>(void)
loc_630AD:
lea ecx, [rax-5]
cmp cl, 2
ja short loc_630D0
mov rdi, rbx
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
xorpd xmm1, xmm1
cmpneqsd xmm1, xmm0
movq rbx, xmm1
and ebx, 1
jmp short loc_6308D
loc_630D0:
cmp al, 3
jnz short loc_630F6
lea r14, [rsp+38h+var_30]
mov rdi, r14
mov rsi, rbx
call _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v; minja::Value::get<std::string>(void)
cmp qword ptr [r14+8], 0
setnz bl
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_6308D
loc_630F6:
cmp qword ptr [rbx+10h], 0
jz short loc_6310C
mov rdi, rbx; this
call _ZNK5minja5Value5emptyEv; minja::Value::empty(void)
mov ebx, eax
xor bl, 1
jmp short loc_6308D
loc_6310C:
mov bl, 1
jmp loc_6308D
| long long minja::Value::to_bool(minja::Value *this)
{
unsigned int v1; // ebx
char v3; // al
__m128d v4; // xmm0
_BYTE v5[8]; // [rsp+8h] [rbp-30h] BYREF
long long v6; // [rsp+10h] [rbp-28h]
v1 = (unsigned int)this;
if ( (unsigned __int8)minja::Value::is_null(this) )
return 0;
v3 = *((_BYTE *)this + 64);
if ( v3 != 4 )
{
if ( (unsigned __int8)(v3 - 5) > 2u )
{
if ( v3 == 3 )
{
minja::Value::get<std::string>(v5, this);
LOBYTE(v1) = v6 != 0;
std::string::~string(v5);
}
else if ( *((_QWORD *)this + 2) )
{
v1 = minja::Value::empty(this);
LOBYTE(v1) = v1 ^ 1;
}
else
{
LOBYTE(v1) = 1;
}
}
else
{
v4.m128d_f64[0] = minja::Value::get<double>(this);
return *(_OWORD *)&_mm_cmpneq_sd((__m128d)0LL, v4) & 1;
}
return v1;
}
return minja::Value::get<bool>(this);
}
| to_bool:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
CALL 0x0016390a
TEST AL,AL
JZ 0x00163097
XOR EBX,EBX
LAB_0016308d:
MOV EAX,EBX
ADD RSP,0x28
POP RBX
POP R14
RET
LAB_00163097:
MOV AL,byte ptr [RBX + 0x40]
CMP AL,0x4
JNZ 0x001630ad
MOV RDI,RBX
ADD RSP,0x28
POP RBX
POP R14
JMP 0x00163c9e
LAB_001630ad:
LEA ECX,[RAX + -0x5]
CMP CL,0x2
JA 0x001630d0
MOV RDI,RBX
CALL 0x0016323c
XORPD XMM1,XMM1
CMPNEQSD XMM1,XMM0
MOVQ RBX,XMM1
AND EBX,0x1
JMP 0x0016308d
LAB_001630d0:
CMP AL,0x3
JNZ 0x001630f6
LEA R14,[RSP + 0x8]
MOV RDI,R14
MOV RSI,RBX
CALL 0x00163d54
CMP qword ptr [R14 + 0x8],0x0
SETNZ BL
MOV RDI,R14
CALL 0x001251b8
JMP 0x0016308d
LAB_001630f6:
CMP qword ptr [RBX + 0x10],0x0
JZ 0x0016310c
MOV RDI,RBX
CALL 0x00163e18
MOV EBX,EAX
XOR BL,0x1
JMP 0x0016308d
LAB_0016310c:
MOV BL,0x1
JMP 0x0016308d
|
/* minja::Value::to_bool() const */
byte __thiscall minja::Value::to_bool(Value *this)
{
Value VVar1;
char cVar2;
bool bVar3;
byte bVar4;
double dVar5;
string local_30 [8];
long local_28;
cVar2 = is_null(this);
if (cVar2 == '\0') {
VVar1 = this[0x40];
if (VVar1 == (Value)0x4) {
bVar3 = get<bool>(this);
return bVar3;
}
if ((byte)((char)VVar1 - 5U) < 3) {
dVar5 = get<double>(this);
bVar4 = -(dVar5 != 0.0) & 1;
}
else if (VVar1 == (Value)0x3) {
get<std::__cxx11::string>();
bVar4 = local_28 != 0;
std::__cxx11::string::~string(local_30);
}
else if (*(long *)(this + 0x10) == 0) {
bVar4 = 1;
}
else {
bVar4 = empty(this);
bVar4 = bVar4 ^ 1;
}
}
else {
bVar4 = 0;
}
return bVar4;
}
| |
24,873 | Utils::getCurrentTimestamp[abi:cxx11]() | shubhamoy[P]dir2txt/src/Utils.cpp | std::string getCurrentTimestamp() {
auto now = std::chrono::system_clock::now();
std::time_t now_time = std::chrono::system_clock::to_time_t(now);
std::tm local_tm = *std::localtime(&now_time);
std::ostringstream oss;
oss << std::put_time(&local_tm, "%d%m%y%H%M%S");
return oss.str();
} | O0 | cpp | Utils::getCurrentTimestamp[abi:cxx11]():
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x208(%rbp)
movq %rdi, %rax
movq %rax, -0x200(%rbp)
movq %rdi, -0x8(%rbp)
callq 0xa060
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x8a930
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xa360
movq 0x30(%rax), %rcx
movq %rcx, -0x20(%rbp)
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movaps %xmm2, -0x30(%rbp)
movaps %xmm1, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0xa540
leaq 0xe4a7(%rip), %rsi # 0x98b18
leaq -0x50(%rbp), %rdi
callq 0x8ac70
movq %rdx, -0x1f8(%rbp)
movq %rax, -0x1f0(%rbp)
jmp 0x8a68a
movq -0x1f8(%rbp), %rax
movq -0x1f0(%rbp), %rcx
movq %rcx, -0x1d8(%rbp)
movq %rax, -0x1d0(%rbp)
movq -0x1d8(%rbp), %rsi
movq -0x1d0(%rbp), %rdx
leaq -0x1c8(%rbp), %rdi
callq 0x8a990
jmp 0x8a6c2
movq -0x208(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0xa6b0
jmp 0x8a6d7
leaq -0x1c8(%rbp), %rdi
callq 0xa0d0
movq -0x200(%rbp), %rax
addq $0x210, %rsp # imm = 0x210
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1e0(%rbp)
movl %eax, -0x1e4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0xa0d0
movq -0x1e0(%rbp), %rdi
callq 0xa6c0
nopl (%rax)
| _ZN5Utils19getCurrentTimestampB5cxx11Ev:
push rbp
mov rbp, rsp
sub rsp, 210h
mov [rbp+var_208], rdi
mov rax, rdi
mov [rbp+var_200], rax
mov [rbp+var_8], rdi
call __ZNSt6chrono3_V212system_clock3nowEv; std::chrono::_V2::system_clock::now(void)
mov [rbp+var_10], rax
lea rdi, [rbp+var_10]
call _ZNSt6chrono3_V212system_clock9to_time_tERKNS_10time_pointIS1_NS_8durationIlSt5ratioILl1ELl1000000000EEEEEE; std::chrono::_V2::system_clock::to_time_t(std::chrono::time_point<std::chrono::_V2::system_clock,std::chrono::duration<long,std::ratio<1l,1000000000l>>> const&)
mov [rbp+var_18], rax
lea rdi, [rbp+var_18]
call _localtime
mov rcx, [rax+30h]
mov [rbp+var_20], rcx
movups xmm0, xmmword ptr [rax]
movups xmm1, xmmword ptr [rax+10h]
movups xmm2, xmmword ptr [rax+20h]
movaps [rbp+var_30], xmm2
movaps [rbp+var_40], xmm1
movaps [rbp+var_50], xmm0
lea rdi, [rbp+var_1C8]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
lea rsi, aDMYHMS; "%d%m%y%H%M%S"
lea rdi, [rbp+var_50]
call _ZSt8put_timeIcESt9_Put_timeIT_EPK2tmPKS1_; std::put_time<char>(tm const*,char const*)
mov [rbp+var_1F8], rdx
mov [rbp+var_1F0], rax
jmp short $+2
loc_8A68A:
mov rax, [rbp+var_1F8]
mov rcx, [rbp+var_1F0]
mov [rbp+var_1D8], rcx
mov [rbp+var_1D0], rax
mov rsi, [rbp+var_1D8]
mov rdx, [rbp+var_1D0]
lea rdi, [rbp+var_1C8]
call _ZStlsIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_St9_Put_timeIS3_E; std::operator<<<char,std::char_traits<char>>(std::ostream &,std::_Put_time<char>)
jmp short $+2
loc_8A6C2:
mov rdi, [rbp+var_208]
lea rsi, [rbp+var_1C8]
call __ZNKRSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEE3strEv; std::ostringstream::str(void)
jmp short $+2
loc_8A6D7:
lea rdi, [rbp+var_1C8]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
mov rax, [rbp+var_200]
add rsp, 210h
pop rbp
retn
mov rcx, rax
mov eax, edx
mov [rbp+var_1E0], rcx
mov [rbp+var_1E4], eax
lea rdi, [rbp+var_1C8]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
mov rdi, [rbp+var_1E0]
call __Unwind_Resume
| std::chrono::_V2::system_clock * Utils::getCurrentTimestamp[abi:cxx11](std::chrono::_V2::system_clock *a1)
{
long long v1; // rax
__int128 v2; // xmm0
__int128 v3; // xmm1
long long v4; // rax
long long v5; // rdx
_BYTE v7[376]; // [rsp+48h] [rbp-1C8h] BYREF
_OWORD v8[3]; // [rsp+1C0h] [rbp-50h] BYREF
long long v9; // [rsp+1F0h] [rbp-20h]
long long v10; // [rsp+1F8h] [rbp-18h] BYREF
_QWORD v11[2]; // [rsp+200h] [rbp-10h] BYREF
v11[1] = a1;
v11[0] = std::chrono::_V2::system_clock::now(a1);
v10 = std::chrono::_V2::system_clock::to_time_t(v11);
v1 = localtime(&v10);
v9 = *(_QWORD *)(v1 + 48);
v2 = *(_OWORD *)v1;
v3 = *(_OWORD *)(v1 + 16);
v8[2] = *(_OWORD *)(v1 + 32);
v8[1] = v3;
v8[0] = v2;
std::ostringstream::basic_ostringstream(v7);
v4 = std::put_time<char>(v8, "%d%m%y%H%M%S");
std::operator<<<char,std::char_traits<char>>(v7, v4, v5);
std::ostringstream::str(a1, v7);
std::ostringstream::~ostringstream(v7);
return a1;
}
| getCurrentTimestamp[abi:cxx11]:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x210
MOV qword ptr [RBP + -0x208],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0x200],RAX
MOV qword ptr [RBP + -0x8],RDI
CALL 0x0010a060
MOV qword ptr [RBP + -0x10],RAX
LEA RDI,[RBP + -0x10]
CALL 0x0018a930
MOV qword ptr [RBP + -0x18],RAX
LEA RDI,[RBP + -0x18]
CALL 0x0010a360
MOV RCX,qword ptr [RAX + 0x30]
MOV qword ptr [RBP + -0x20],RCX
MOVUPS XMM0,xmmword ptr [RAX]
MOVUPS XMM1,xmmword ptr [RAX + 0x10]
MOVUPS XMM2,xmmword ptr [RAX + 0x20]
MOVAPS xmmword ptr [RBP + -0x30],XMM2
MOVAPS xmmword ptr [RBP + -0x40],XMM1
MOVAPS xmmword ptr [RBP + -0x50],XMM0
LEA RDI,[RBP + -0x1c8]
CALL 0x0010a540
LAB_0018a66a:
LEA RSI,[0x198b18]
LEA RDI,[RBP + -0x50]
CALL 0x0018ac70
MOV qword ptr [RBP + -0x1f8],RDX
MOV qword ptr [RBP + -0x1f0],RAX
JMP 0x0018a68a
LAB_0018a68a:
MOV RAX,qword ptr [RBP + -0x1f8]
MOV RCX,qword ptr [RBP + -0x1f0]
MOV qword ptr [RBP + -0x1d8],RCX
MOV qword ptr [RBP + -0x1d0],RAX
MOV RSI,qword ptr [RBP + -0x1d8]
MOV RDX,qword ptr [RBP + -0x1d0]
LEA RDI,[RBP + -0x1c8]
CALL 0x0018a990
JMP 0x0018a6c2
LAB_0018a6c2:
MOV RDI,qword ptr [RBP + -0x208]
LEA RSI,[RBP + -0x1c8]
CALL 0x0010a6b0
LAB_0018a6d5:
JMP 0x0018a6d7
LAB_0018a6d7:
LEA RDI,[RBP + -0x1c8]
CALL 0x0010a0d0
MOV RAX,qword ptr [RBP + -0x200]
ADD RSP,0x210
POP RBP
RET
|
/* Utils::getCurrentTimestamp[abi:cxx11]() */
Utils * __thiscall Utils::getCurrentTimestamp_abi_cxx11_(Utils *this)
{
tm *ptVar1;
int1 auVar2 [16];
ostringstream local_1d0 [376];
tm local_58;
time_t local_20;
int8 local_18;
Utils *local_10;
local_10 = this;
local_18 = std::chrono::_V2::system_clock::now();
local_20 = std::chrono::_V2::system_clock::to_time_t((time_point *)&local_18);
ptVar1 = localtime(&local_20);
local_58.tm_zone = ptVar1->tm_zone;
local_58.tm_sec = ptVar1->tm_sec;
local_58.tm_min = ptVar1->tm_min;
local_58.tm_hour = ptVar1->tm_hour;
local_58.tm_mday = ptVar1->tm_mday;
local_58.tm_mon = ptVar1->tm_mon;
local_58.tm_year = ptVar1->tm_year;
local_58.tm_wday = ptVar1->tm_wday;
local_58.tm_yday = ptVar1->tm_yday;
local_58.tm_isdst = ptVar1->tm_isdst;
local_58._36_4_ = *(int4 *)&ptVar1->field_0x24;
local_58.tm_gmtoff = ptVar1->tm_gmtoff;
std::__cxx11::ostringstream::ostringstream(local_1d0);
/* try { // try from 0018a66a to 0018a6d4 has its CatchHandler @ 0018a6f3 */
auVar2 = std::put_time<char>(&local_58,"%d%m%y%H%M%S");
std::operator<<(local_1d0,auVar2._0_8_,auVar2._8_8_);
std::__cxx11::ostringstream::str();
std::__cxx11::ostringstream::~ostringstream(local_1d0);
return this;
}
| |
24,874 | Utils::getCurrentTimestamp[abi:cxx11]() | shubhamoy[P]dir2txt/src/Utils.cpp | std::string getCurrentTimestamp() {
auto now = std::chrono::system_clock::now();
std::time_t now_time = std::chrono::system_clock::to_time_t(now);
std::tm local_tm = *std::localtime(&now_time);
std::ostringstream oss;
oss << std::put_time(&local_tm, "%d%m%y%H%M%S");
return oss.str();
} | O3 | cpp | Utils::getCurrentTimestamp[abi:cxx11]():
pushq %r15
pushq %r14
pushq %rbx
subq $0x1c0, %rsp # imm = 0x1C0
movq %rdi, %rbx
callq 0x8050
movabsq $0x112e0be826d694b3, %rcx # imm = 0x112E0BE826D694B3
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x1a, %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %rdi
movq %rdx, (%rdi)
callq 0x82c0
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
leaq 0x10(%rsp), %r14
movaps %xmm0, (%r14)
movaps %xmm1, 0x10(%r14)
movaps %xmm2, 0x20(%r14)
movq 0x30(%rax), %rax
movq %rax, 0x30(%r14)
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x8490
leaq 0x7266(%rip), %rdx # 0x39648
movq %r15, %rdi
movq %r14, %rsi
callq 0x327ca
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0x82b0
movq 0x1bb8f(%rip), %rsi # 0x4df90
leaq 0x48(%rsp), %rdi
callq 0x8200
leaq 0xb8(%rsp), %rdi
callq 0x80f0
movq %rbx, %rax
addq $0x1c0, %rsp # imm = 0x1C0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x1bb5e(%rip), %rsi # 0x4df90
leaq 0x48(%rsp), %rdi
callq 0x8200
leaq 0xb8(%rsp), %rdi
callq 0x80f0
movq %rbx, %rdi
callq 0x85d0
| _ZN5Utils19getCurrentTimestampB5cxx11Ev:
push r15
push r14
push rbx
sub rsp, 1C0h
mov rbx, rdi
call __ZNSt6chrono3_V212system_clock3nowEv; std::chrono::_V2::system_clock::now(void)
mov rcx, 112E0BE826D694B3h
imul rcx
mov rax, rdx
shr rax, 3Fh
sar rdx, 1Ah
add rdx, rax
lea rdi, [rsp+1D8h+var_1D0]
mov [rdi], rdx
call _localtime
movups xmm0, xmmword ptr [rax]
movups xmm1, xmmword ptr [rax+10h]
movups xmm2, xmmword ptr [rax+20h]
lea r14, [rsp+1D8h+var_1C8]
movaps xmmword ptr [r14], xmm0
movaps xmmword ptr [r14+10h], xmm1
movaps xmmword ptr [r14+20h], xmm2
mov rax, [rax+30h]
mov [r14+30h], rax
lea r15, [rsp+1D8h+var_190]
mov rdi, r15
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
lea rdx, aDMYHMS; "%d%m%y%H%M%S"
mov rdi, r15; std::ostream *
mov rsi, r14
call _ZStlsIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_St9_Put_timeIS3_E; std::operator<<<char,std::char_traits<char>>(std::ostream &,std::_Put_time<char>)
lea rsi, [rsp+1D8h+var_188]
mov rdi, rbx
call __ZNKRSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
mov rsi, cs:_ZTTNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+1D8h+var_190]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED2Ev; std::ostringstream::~ostringstream()
lea rdi, [rsp+1D8h+var_120]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rax, rbx
add rsp, 1C0h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov rsi, cs:_ZTTNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+arg_40]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED2Ev; std::ostringstream::~ostringstream()
lea rdi, [rsp+arg_B0]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rdi, rbx
call __Unwind_Resume
| std::chrono::_V2::system_clock * Utils::getCurrentTimestamp[abi:cxx11](std::chrono::_V2::system_clock *a1)
{
_BYTE v2[8]; // [rsp+48h] [rbp-190h] BYREF
_BYTE v3[104]; // [rsp+50h] [rbp-188h] BYREF
_BYTE v4[288]; // [rsp+B8h] [rbp-120h] BYREF
std::chrono::_V2::system_clock::now(a1);
localtime();
std::ostringstream::basic_ostringstream(v2);
std::operator<<<char,std::char_traits<char>>((std::ostream *)v2);
std::stringbuf::str(a1, v3);
std::ostringstream::~ostringstream(v2, &`VTT for'std::ostringstream);
std::ios_base::~ios_base((std::ios_base *)v4);
return a1;
}
| getCurrentTimestamp[abi:cxx11]:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x1c0
MOV RBX,RDI
CALL 0x00108050
MOV RCX,0x112e0be826d694b3
IMUL RCX
MOV RAX,RDX
SHR RAX,0x3f
SAR RDX,0x1a
ADD RDX,RAX
LEA RDI,[RSP + 0x8]
MOV qword ptr [RDI],RDX
CALL 0x001082c0
MOVUPS XMM0,xmmword ptr [RAX]
MOVUPS XMM1,xmmword ptr [RAX + 0x10]
MOVUPS XMM2,xmmword ptr [RAX + 0x20]
LEA R14,[RSP + 0x10]
MOVAPS xmmword ptr [R14],XMM0
MOVAPS xmmword ptr [R14 + 0x10],XMM1
MOVAPS xmmword ptr [R14 + 0x20],XMM2
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [R14 + 0x30],RAX
LEA R15,[RSP + 0x48]
MOV RDI,R15
CALL 0x00108490
LAB_001323db:
LEA RDX,[0x139648]
MOV RDI,R15
MOV RSI,R14
CALL 0x001327ca
LEA RSI,[RSP + 0x50]
MOV RDI,RBX
CALL 0x001082b0
LAB_001323fa:
MOV RSI,qword ptr [0x0014df90]
LEA RDI,[RSP + 0x48]
CALL 0x00108200
LEA RDI,[RSP + 0xb8]
CALL 0x001080f0
MOV RAX,RBX
ADD RSP,0x1c0
POP RBX
POP R14
POP R15
RET
|
/* Utils::getCurrentTimestamp[abi:cxx11]() */
Utils * __thiscall Utils::getCurrentTimestamp_abi_cxx11_(Utils *this)
{
tm *ptVar1;
long local_1d0;
int8 local_1c8;
int8 uStack_1c0;
int8 local_1b8;
int8 uStack_1b0;
int8 local_1a8;
long lStack_1a0;
char *local_198;
ostringstream local_190 [112];
ios_base local_120 [264];
local_1d0 = std::chrono::_V2::system_clock::now();
local_1d0 = local_1d0 / 1000000000;
ptVar1 = localtime(&local_1d0);
local_1c8._0_4_ = ptVar1->tm_sec;
local_1c8._4_4_ = ptVar1->tm_min;
uStack_1c0._0_4_ = ptVar1->tm_hour;
uStack_1c0._4_4_ = ptVar1->tm_mday;
local_1b8._0_4_ = ptVar1->tm_mon;
local_1b8._4_4_ = ptVar1->tm_year;
uStack_1b0._0_4_ = ptVar1->tm_wday;
uStack_1b0._4_4_ = ptVar1->tm_yday;
local_1a8 = *(int8 *)&ptVar1->tm_isdst;
lStack_1a0 = ptVar1->tm_gmtoff;
local_198 = ptVar1->tm_zone;
std::__cxx11::ostringstream::ostringstream(local_190);
/* try { // try from 001323db to 001323f9 has its CatchHandler @ 00132428 */
std::operator<<(local_190,&local_1c8,"%d%m%y%H%M%S");
std::__cxx11::stringbuf::str();
std::__cxx11::ostringstream::~ostringstream(local_190);
std::ios_base::~ios_base(local_120);
return this;
}
| |
24,875 | my_wildcmp_8bit_impl | eloqsql/strings/ctype-simple.c | static
int my_wildcmp_8bit_impl(CHARSET_INFO *cs,
const char *str,const char *str_end,
const char *wildstr,const char *wildend,
int escape, int w_one, int w_many, int recurse_level)
{
int result= -1; /* Not found, using wildcards */
if (my_string_stack_guard && my_string_stack_guard(recurse_level))
return 1;
while (wildstr != wildend)
{
while (*wildstr != w_many && *wildstr != w_one)
{
if (*wildstr == escape && wildstr+1 != wildend)
wildstr++;
if (str == str_end || likeconv(cs,*wildstr++) != likeconv(cs,*str++))
return(1); /* No match */
if (wildstr == wildend)
return(str != str_end); /* Match if both are at end */
result=1; /* Found an anchor char */
}
if (*wildstr == w_one)
{
do
{
if (str == str_end) /* Skip one char if possible */
return(result);
INC_PTR(cs,str,str_end);
} while (++wildstr < wildend && *wildstr == w_one);
if (wildstr == wildend)
break;
}
if (*wildstr == w_many)
{ /* Found w_many */
uchar cmp;
wildstr++;
/* Remove any '%' and '_' from the wild search string */
for (; wildstr != wildend ; wildstr++)
{
if (*wildstr == w_many)
continue;
if (*wildstr == w_one)
{
if (str == str_end)
return(-1);
INC_PTR(cs,str,str_end);
continue;
}
break; /* Not a wild character */
}
if (wildstr == wildend)
return(0); /* Ok if w_many is last */
if (str == str_end)
return(-1);
if ((cmp= *wildstr) == escape && wildstr+1 != wildend)
cmp= *++wildstr;
INC_PTR(cs,wildstr,wildend); /* This is compared trough cmp */
cmp=likeconv(cs,cmp);
do
{
/*
Find the next character in the subject string equal to 'cmp', then
check recursively my_wildcmp_8bit_impl() for the pattern remainder.
*/
while (str != str_end && (uchar) likeconv(cs,*str) != cmp)
str++;
if (str++ == str_end)
return(-1); /* 'cmp' was not found in the subject string */
{
int tmp=my_wildcmp_8bit_impl(cs,str,str_end,
wildstr,wildend,escape,w_one,
w_many, recurse_level+1);
if (tmp <= 0)
return(tmp);
}
/*
The recursion call did not match. But it returned 1, which means
the pattern remainder has some non-special characters.
Continue, there is a chance that we'll find another 'cmp'
at a different position in the subject string.
*/
} while (str != str_end);
return(-1);
}
}
return(str != str_end ? 1 : 0);
} | O0 | c | my_wildcmp_8bit_impl:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movl $0xffffffff, -0x38(%rbp) # imm = 0xFFFFFFFF
leaq 0x34d301(%rip), %rax # 0x39a5e8
cmpq $0x0, (%rax)
je 0x4d30d
leaq 0x34d2f4(%rip), %rax # 0x39a5e8
movq (%rax), %rax
movl 0x20(%rbp), %edi
callq *%rax
cmpl $0x0, %eax
je 0x4d30d
movl $0x1, -0x4(%rbp)
jmp 0x4d63a
jmp 0x4d30f
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x4d622
jmp 0x4d31f
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl 0x18(%rbp), %ecx
movb %al, -0x41(%rbp)
je 0x4d340
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl 0x10(%rbp), %eax
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x4d34c
jmp 0x4d3f6
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl -0x34(%rbp), %eax
jne 0x4d372
movq -0x28(%rbp), %rax
addq $0x1, %rax
cmpq -0x30(%rbp), %rax
je 0x4d372
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x4d3bc
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movzbl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movq 0x58(%rcx), %rcx
movq -0x18(%rbp), %rdx
movq %rdx, %rsi
addq $0x1, %rsi
movq %rsi, -0x18(%rbp)
movzbl (%rdx), %edx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x4d3c8
movl $0x1, -0x4(%rbp)
jmp 0x4d63a
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0x4d3ea
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x4d63a
movl $0x1, -0x38(%rbp)
jmp 0x4d31f
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl 0x10(%rbp), %eax
jne 0x4d464
jmp 0x4d404
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x4d419
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4d63a
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x30(%rbp), %rcx
movb %al, -0x42(%rbp)
jae 0x4d44c
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl 0x10(%rbp), %eax
sete %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
testb $0x1, %al
jne 0x4d404
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0x4d462
jmp 0x4d622
jmp 0x4d464
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl 0x18(%rbp), %eax
jne 0x4d61d
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x4d4d8
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl 0x18(%rbp), %eax
jne 0x4d498
jmp 0x4d4ca
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl 0x10(%rbp), %eax
jne 0x4d4c8
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x4d4ba
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4d63a
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4d4ca
jmp 0x4d4d8
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4d480
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0x4d4ee
movl $0x0, -0x4(%rbp)
jmp 0x4d63a
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x4d504
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4d63a
movq -0x28(%rbp), %rax
movb (%rax), %al
movb %al, -0x39(%rbp)
movzbl %al, %eax
cmpl -0x34(%rbp), %eax
jne 0x4d538
movq -0x28(%rbp), %rax
addq $0x1, %rax
cmpq -0x30(%rbp), %rax
je 0x4d538
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb 0x1(%rax), %al
movb %al, -0x39(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movzbl -0x39(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0x39(%rbp)
jmp 0x4d558
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x43(%rbp)
je 0x4d586
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
movzbl -0x39(%rbp), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x43(%rbp)
movb -0x43(%rbp), %al
testb $0x1, %al
jne 0x4d58f
jmp 0x4d59d
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4d558
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x4d5bb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4d63a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movl -0x34(%rbp), %r9d
movl 0x10(%rbp), %r11d
movl 0x18(%rbp), %r10d
movl 0x20(%rbp), %eax
addl $0x1, %eax
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
callq 0x4d2b0
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
jg 0x4d604
movl -0x40(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4d63a
jmp 0x4d606
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x4d556
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4d63a
jmp 0x4d30f
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl $0x1, %ecx
cmpq %rsi, %rdx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_wildcmp_8bit_impl:
push rbp
mov rbp, rsp
sub rsp, 60h
mov eax, [rbp+arg_10]
mov eax, [rbp+arg_8]
mov eax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_34], r9d
mov [rbp+var_38], 0FFFFFFFFh
lea rax, my_string_stack_guard
cmp qword ptr [rax], 0
jz short loc_4D30D
lea rax, my_string_stack_guard
mov rax, [rax]
mov edi, [rbp+arg_10]
call rax
cmp eax, 0
jz short loc_4D30D
mov [rbp+var_4], 1
jmp loc_4D63A
loc_4D30D:
jmp short $+2
loc_4D30F:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jz loc_4D622
jmp short $+2
loc_4D31F:
mov rax, [rbp+var_28]
movsx ecx, byte ptr [rax]
xor eax, eax
cmp ecx, [rbp+arg_8]
mov [rbp+var_41], al
jz short loc_4D340
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax]
cmp eax, [rbp+arg_0]
setnz al
mov [rbp+var_41], al
loc_4D340:
mov al, [rbp+var_41]
test al, 1
jnz short loc_4D34C
jmp loc_4D3F6
loc_4D34C:
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax]
cmp eax, [rbp+var_34]
jnz short loc_4D372
mov rax, [rbp+var_28]
add rax, 1
cmp rax, [rbp+var_30]
jz short loc_4D372
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
loc_4D372:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jz short loc_4D3BC
mov rax, [rbp+var_10]
mov rax, [rax+58h]
mov rcx, [rbp+var_28]
mov rdx, rcx
add rdx, 1
mov [rbp+var_28], rdx
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx]
mov rcx, [rbp+var_10]
mov rcx, [rcx+58h]
mov rdx, [rbp+var_18]
mov rsi, rdx
add rsi, 1
mov [rbp+var_18], rsi
movzx edx, byte ptr [rdx]
movzx ecx, byte ptr [rcx+rdx]
cmp eax, ecx
jz short loc_4D3C8
loc_4D3BC:
mov [rbp+var_4], 1
jmp loc_4D63A
loc_4D3C8:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jnz short loc_4D3EA
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
setnz al
and al, 1
movzx eax, al
mov [rbp+var_4], eax
jmp loc_4D63A
loc_4D3EA:
mov [rbp+var_38], 1
jmp loc_4D31F
loc_4D3F6:
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax]
cmp eax, [rbp+arg_0]
jnz short loc_4D464
jmp short $+2
loc_4D404:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnz short loc_4D419
mov eax, [rbp+var_38]
mov [rbp+var_4], eax
jmp loc_4D63A
loc_4D419:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
mov rcx, [rbp+var_28]
add rcx, 1
mov [rbp+var_28], rcx
xor eax, eax
cmp rcx, [rbp+var_30]
mov [rbp+var_42], al
jnb short loc_4D44C
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax]
cmp eax, [rbp+arg_0]
setz al
mov [rbp+var_42], al
loc_4D44C:
mov al, [rbp+var_42]
test al, 1
jnz short loc_4D404
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jnz short loc_4D462
jmp loc_4D622
loc_4D462:
jmp short $+2
loc_4D464:
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax]
cmp eax, [rbp+arg_8]
jnz loc_4D61D
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
loc_4D480:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jz short loc_4D4D8
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax]
cmp eax, [rbp+arg_8]
jnz short loc_4D498
jmp short loc_4D4CA
loc_4D498:
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax]
cmp eax, [rbp+arg_0]
jnz short loc_4D4C8
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnz short loc_4D4BA
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_4D63A
loc_4D4BA:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_4D4CA
loc_4D4C8:
jmp short loc_4D4D8
loc_4D4CA:
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
jmp short loc_4D480
loc_4D4D8:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jnz short loc_4D4EE
mov [rbp+var_4], 0
jmp loc_4D63A
loc_4D4EE:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnz short loc_4D504
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_4D63A
loc_4D504:
mov rax, [rbp+var_28]
mov al, [rax]
mov [rbp+var_39], al
movzx eax, al
cmp eax, [rbp+var_34]
jnz short loc_4D538
mov rax, [rbp+var_28]
add rax, 1
cmp rax, [rbp+var_30]
jz short loc_4D538
mov rax, [rbp+var_28]
mov rcx, rax
add rcx, 1
mov [rbp+var_28], rcx
mov al, [rax+1]
mov [rbp+var_39], al
loc_4D538:
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
mov rax, [rax+58h]
movzx ecx, [rbp+var_39]
mov al, [rax+rcx]
mov [rbp+var_39], al
loc_4D556:
jmp short $+2
loc_4D558:
mov rcx, [rbp+var_18]
xor eax, eax
cmp rcx, [rbp+var_20]
mov [rbp+var_43], al
jz short loc_4D586
mov rax, [rbp+var_10]
mov rax, [rax+58h]
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx]
movzx ecx, [rbp+var_39]
cmp eax, ecx
setnz al
mov [rbp+var_43], al
loc_4D586:
mov al, [rbp+var_43]
test al, 1
jnz short loc_4D58F
jmp short loc_4D59D
loc_4D58F:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_4D558
loc_4D59D:
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
cmp rax, [rbp+var_20]
jnz short loc_4D5BB
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_4D63A
loc_4D5BB:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
mov r8, [rbp+var_30]
mov r9d, [rbp+var_34]
mov r11d, [rbp+arg_0]
mov r10d, [rbp+arg_8]
mov eax, [rbp+arg_10]
add eax, 1
mov [rsp+60h+var_60], r11d
mov [rsp+60h+var_58], r10d
mov [rsp+60h+var_50], eax
call my_wildcmp_8bit_impl
mov [rbp+var_40], eax
cmp [rbp+var_40], 0
jg short loc_4D604
mov eax, [rbp+var_40]
mov [rbp+var_4], eax
jmp short loc_4D63A
loc_4D604:
jmp short $+2
loc_4D606:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnz loc_4D556
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_4D63A
loc_4D61D:
jmp loc_4D30F
loc_4D622:
mov rdx, [rbp+var_18]
mov rsi, [rbp+var_20]
xor eax, eax
mov ecx, 1
cmp rdx, rsi
cmovnz eax, ecx
mov [rbp+var_4], eax
loc_4D63A:
mov eax, [rbp+var_4]
add rsp, 60h
pop rbp
retn
| long long my_wildcmp_8bit_impl(
long long a1,
unsigned __int8 *a2,
unsigned __int8 *a3,
char *a4,
char *a5,
int a6,
int a7,
int a8,
unsigned int a9)
{
char *v9; // rcx
unsigned __int8 *v10; // rdx
char *v11; // rax
unsigned __int8 *v12; // rax
bool v14; // [rsp+1Dh] [rbp-43h]
bool v15; // [rsp+1Eh] [rbp-42h]
bool v16; // [rsp+1Fh] [rbp-41h]
int v17; // [rsp+20h] [rbp-40h]
unsigned __int8 v18; // [rsp+27h] [rbp-39h]
unsigned __int8 v19; // [rsp+27h] [rbp-39h]
unsigned int v20; // [rsp+28h] [rbp-38h]
char *i; // [rsp+38h] [rbp-28h]
int v25; // [rsp+38h] [rbp-28h]
v20 = -1;
if ( my_string_stack_guard && (unsigned int)my_string_stack_guard(a9) )
{
return 1;
}
else
{
do
{
if ( a4 != a5 )
{
while ( 1 )
{
v16 = 0;
if ( *a4 != a8 )
v16 = *a4 != a7;
if ( !v16 )
break;
if ( *a4 == a6 && a4 + 1 != a5 )
++a4;
if ( a2 == a3 )
return 1;
v9 = a4++;
v10 = a2++;
if ( *(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + (unsigned __int8)*v9) != *(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + *v10) )
return 1;
if ( a4 == a5 )
return a2 != a3;
v20 = 1;
}
if ( *a4 != a7 )
continue;
do
{
if ( a2 == a3 )
return v20;
++a2;
++a4;
v15 = 0;
if ( a4 < a5 )
v15 = *a4 == a7;
}
while ( v15 );
if ( a4 != a5 )
continue;
}
return a2 != a3;
}
while ( *a4 != a8 );
for ( i = a4 + 1; i != a5; ++i )
{
if ( *i != a8 )
{
if ( *i != a7 )
break;
if ( a2 == a3 )
return (unsigned int)-1;
++a2;
}
}
if ( i == a5 )
{
return 0;
}
else if ( a2 == a3 )
{
return (unsigned int)-1;
}
else
{
v18 = *i;
if ( (unsigned __int8)*i == a6 && i + 1 != a5 )
{
v11 = i;
LODWORD(i) = (_DWORD)i + 1;
v18 = v11[1];
}
v25 = (_DWORD)i + 1;
v19 = *(_BYTE *)(*(_QWORD *)(a1 + 88) + v18);
do
{
while ( 1 )
{
v14 = 0;
if ( a2 != a3 )
v14 = *(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + *a2) != v19;
if ( !v14 )
break;
++a2;
}
v12 = a2++;
if ( v12 == a3 )
return (unsigned int)-1;
v17 = my_wildcmp_8bit_impl(a1, (_DWORD)a2, (_DWORD)a3, v25, (_DWORD)a5, a6, a7, a8, a9 + 1);
if ( v17 <= 0 )
return (unsigned int)v17;
}
while ( a2 != a3 );
return (unsigned int)-1;
}
}
}
| my_wildcmp_8bit_impl:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV EAX,dword ptr [RBP + 0x20]
MOV EAX,dword ptr [RBP + 0x18]
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV dword ptr [RBP + -0x34],R9D
MOV dword ptr [RBP + -0x38],0xffffffff
LEA RAX,[0x49a5e8]
CMP qword ptr [RAX],0x0
JZ 0x0014d30d
LEA RAX,[0x49a5e8]
MOV RAX,qword ptr [RAX]
MOV EDI,dword ptr [RBP + 0x20]
CALL RAX
CMP EAX,0x0
JZ 0x0014d30d
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0014d63a
LAB_0014d30d:
JMP 0x0014d30f
LAB_0014d30f:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JZ 0x0014d622
JMP 0x0014d31f
LAB_0014d31f:
MOV RAX,qword ptr [RBP + -0x28]
MOVSX ECX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,dword ptr [RBP + 0x18]
MOV byte ptr [RBP + -0x41],AL
JZ 0x0014d340
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RBP + 0x10]
SETNZ AL
MOV byte ptr [RBP + -0x41],AL
LAB_0014d340:
MOV AL,byte ptr [RBP + -0x41]
TEST AL,0x1
JNZ 0x0014d34c
JMP 0x0014d3f6
LAB_0014d34c:
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RBP + -0x34]
JNZ 0x0014d372
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
CMP RAX,qword ptr [RBP + -0x30]
JZ 0x0014d372
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
LAB_0014d372:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JZ 0x0014d3bc
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x58]
MOV RCX,qword ptr [RBP + -0x28]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x28],RDX
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x58]
MOV RDX,qword ptr [RBP + -0x18]
MOV RSI,RDX
ADD RSI,0x1
MOV qword ptr [RBP + -0x18],RSI
MOVZX EDX,byte ptr [RDX]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
CMP EAX,ECX
JZ 0x0014d3c8
LAB_0014d3bc:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0014d63a
LAB_0014d3c8:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0014d3ea
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0014d63a
LAB_0014d3ea:
MOV dword ptr [RBP + -0x38],0x1
JMP 0x0014d31f
LAB_0014d3f6:
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RBP + 0x10]
JNZ 0x0014d464
JMP 0x0014d404
LAB_0014d404:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x0014d419
MOV EAX,dword ptr [RBP + -0x38]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0014d63a
LAB_0014d419:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
MOV RCX,qword ptr [RBP + -0x28]
ADD RCX,0x1
MOV qword ptr [RBP + -0x28],RCX
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x30]
MOV byte ptr [RBP + -0x42],AL
JNC 0x0014d44c
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RBP + 0x10]
SETZ AL
MOV byte ptr [RBP + -0x42],AL
LAB_0014d44c:
MOV AL,byte ptr [RBP + -0x42]
TEST AL,0x1
JNZ 0x0014d404
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0014d462
JMP 0x0014d622
LAB_0014d462:
JMP 0x0014d464
LAB_0014d464:
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RBP + 0x18]
JNZ 0x0014d61d
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
LAB_0014d480:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JZ 0x0014d4d8
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RBP + 0x18]
JNZ 0x0014d498
JMP 0x0014d4ca
LAB_0014d498:
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RBP + 0x10]
JNZ 0x0014d4c8
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x0014d4ba
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0014d63a
LAB_0014d4ba:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0014d4ca
LAB_0014d4c8:
JMP 0x0014d4d8
LAB_0014d4ca:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0014d480
LAB_0014d4d8:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0014d4ee
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0014d63a
LAB_0014d4ee:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x0014d504
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0014d63a
LAB_0014d504:
MOV RAX,qword ptr [RBP + -0x28]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x39],AL
MOVZX EAX,AL
CMP EAX,dword ptr [RBP + -0x34]
JNZ 0x0014d538
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
CMP RAX,qword ptr [RBP + -0x30]
JZ 0x0014d538
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x28],RCX
MOV AL,byte ptr [RAX + 0x1]
MOV byte ptr [RBP + -0x39],AL
LAB_0014d538:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x58]
MOVZX ECX,byte ptr [RBP + -0x39]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RBP + -0x39],AL
LAB_0014d556:
JMP 0x0014d558
LAB_0014d558:
MOV RCX,qword ptr [RBP + -0x18]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x20]
MOV byte ptr [RBP + -0x43],AL
JZ 0x0014d586
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x58]
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOVZX ECX,byte ptr [RBP + -0x39]
CMP EAX,ECX
SETNZ AL
MOV byte ptr [RBP + -0x43],AL
LAB_0014d586:
MOV AL,byte ptr [RBP + -0x43]
TEST AL,0x1
JNZ 0x0014d58f
JMP 0x0014d59d
LAB_0014d58f:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0014d558
LAB_0014d59d:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x0014d5bb
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0014d63a
LAB_0014d5bb:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8,qword ptr [RBP + -0x30]
MOV R9D,dword ptr [RBP + -0x34]
MOV R11D,dword ptr [RBP + 0x10]
MOV R10D,dword ptr [RBP + 0x18]
MOV EAX,dword ptr [RBP + 0x20]
ADD EAX,0x1
MOV dword ptr [RSP],R11D
MOV dword ptr [RSP + 0x8],R10D
MOV dword ptr [RSP + 0x10],EAX
CALL 0x0014d2b0
MOV dword ptr [RBP + -0x40],EAX
CMP dword ptr [RBP + -0x40],0x0
JG 0x0014d604
MOV EAX,dword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0014d63a
LAB_0014d604:
JMP 0x0014d606
LAB_0014d606:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x0014d556
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0014d63a
LAB_0014d61d:
JMP 0x0014d30f
LAB_0014d622:
MOV RDX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
XOR EAX,EAX
MOV ECX,0x1
CMP RDX,RSI
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
LAB_0014d63a:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x60
POP RBP
RET
|
uint my_wildcmp_8bit_impl
(long param_1,byte *param_2,byte *param_3,byte *param_4,byte *param_5,uint param_6,
int param_7,int param_8,int param_9)
{
char cVar1;
int iVar2;
uint uVar3;
byte *pbVar4;
bool bVar5;
byte local_41;
uint local_40;
byte *local_30;
byte *local_20;
uint local_c;
local_40 = 0xffffffff;
local_30 = param_4;
local_20 = param_2;
if ((my_string_stack_guard == (code *)0x0) ||
(iVar2 = (*my_string_stack_guard)(param_9), iVar2 == 0)) {
do {
if (local_30 == param_5) {
LAB_0014d622:
return (uint)(local_20 != param_3);
}
while( true ) {
bVar5 = false;
if ((char)*local_30 != param_8) {
bVar5 = (char)*local_30 != param_7;
}
if (!bVar5) break;
if (((int)(char)*local_30 == param_6) && (local_30 + 1 != param_5)) {
local_30 = local_30 + 1;
}
if (local_20 == param_3) {
return 1;
}
if (*(char *)(*(long *)(param_1 + 0x58) + (ulong)*local_30) !=
*(char *)(*(long *)(param_1 + 0x58) + (ulong)*local_20)) {
return 1;
}
if (local_30 + 1 == param_5) {
return (uint)(local_20 + 1 != param_3);
}
local_40 = 1;
local_30 = local_30 + 1;
local_20 = local_20 + 1;
}
if ((char)*local_30 == param_7) {
do {
if (local_20 == param_3) {
return local_40;
}
local_20 = local_20 + 1;
local_30 = local_30 + 1;
bVar5 = false;
if (local_30 < param_5) {
bVar5 = (char)*local_30 == param_7;
}
} while (bVar5);
if (local_30 == param_5) goto LAB_0014d622;
}
} while ((char)*local_30 != param_8);
while (pbVar4 = local_30, local_30 = pbVar4 + 1, local_30 != param_5) {
if ((char)*local_30 != param_8) {
if ((char)*local_30 != param_7) break;
if (local_20 == param_3) {
return 0xffffffff;
}
local_20 = local_20 + 1;
}
}
if (local_30 == param_5) {
local_c = 0;
}
else if (local_20 == param_3) {
local_c = 0xffffffff;
}
else {
local_41 = *local_30;
if ((local_41 == param_6) && (pbVar4 + 2 != param_5)) {
local_30 = pbVar4 + 2;
local_41 = pbVar4[2];
}
cVar1 = *(char *)(*(long *)(param_1 + 0x58) + (ulong)local_41);
do {
while( true ) {
bVar5 = false;
if (local_20 != param_3) {
bVar5 = *(char *)(*(long *)(param_1 + 0x58) + (ulong)*local_20) != cVar1;
}
if (!bVar5) break;
local_20 = local_20 + 1;
}
pbVar4 = local_20 + 1;
if (local_20 == param_3) {
return 0xffffffff;
}
uVar3 = my_wildcmp_8bit_impl
(param_1,pbVar4,param_3,local_30 + 1,param_5,param_6,param_7,param_8,
param_9 + 1);
if ((int)uVar3 < 1) {
return uVar3;
}
local_20 = pbVar4;
} while (pbVar4 != param_3);
local_c = 0xffffffff;
}
}
else {
local_c = 1;
}
return local_c;
}
| |
24,876 | my_wildcmp_8bit_impl | eloqsql/strings/ctype-simple.c | static
int my_wildcmp_8bit_impl(CHARSET_INFO *cs,
const char *str,const char *str_end,
const char *wildstr,const char *wildend,
int escape, int w_one, int w_many, int recurse_level)
{
int result= -1; /* Not found, using wildcards */
if (my_string_stack_guard && my_string_stack_guard(recurse_level))
return 1;
while (wildstr != wildend)
{
while (*wildstr != w_many && *wildstr != w_one)
{
if (*wildstr == escape && wildstr+1 != wildend)
wildstr++;
if (str == str_end || likeconv(cs,*wildstr++) != likeconv(cs,*str++))
return(1); /* No match */
if (wildstr == wildend)
return(str != str_end); /* Match if both are at end */
result=1; /* Found an anchor char */
}
if (*wildstr == w_one)
{
do
{
if (str == str_end) /* Skip one char if possible */
return(result);
INC_PTR(cs,str,str_end);
} while (++wildstr < wildend && *wildstr == w_one);
if (wildstr == wildend)
break;
}
if (*wildstr == w_many)
{ /* Found w_many */
uchar cmp;
wildstr++;
/* Remove any '%' and '_' from the wild search string */
for (; wildstr != wildend ; wildstr++)
{
if (*wildstr == w_many)
continue;
if (*wildstr == w_one)
{
if (str == str_end)
return(-1);
INC_PTR(cs,str,str_end);
continue;
}
break; /* Not a wild character */
}
if (wildstr == wildend)
return(0); /* Ok if w_many is last */
if (str == str_end)
return(-1);
if ((cmp= *wildstr) == escape && wildstr+1 != wildend)
cmp= *++wildstr;
INC_PTR(cs,wildstr,wildend); /* This is compared trough cmp */
cmp=likeconv(cs,cmp);
do
{
/*
Find the next character in the subject string equal to 'cmp', then
check recursively my_wildcmp_8bit_impl() for the pattern remainder.
*/
while (str != str_end && (uchar) likeconv(cs,*str) != cmp)
str++;
if (str++ == str_end)
return(-1); /* 'cmp' was not found in the subject string */
{
int tmp=my_wildcmp_8bit_impl(cs,str,str_end,
wildstr,wildend,escape,w_one,
w_many, recurse_level+1);
if (tmp <= 0)
return(tmp);
}
/*
The recursion call did not match. But it returned 1, which means
the pattern remainder has some non-special characters.
Continue, there is a chance that we'll find another 'cmp'
at a different position in the subject string.
*/
} while (str != str_end);
return(-1);
}
}
return(str != str_end ? 1 : 0);
} | O3 | c | my_wildcmp_8bit_impl:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r14
movl 0x20(%rbp), %r10d
leaq 0x338ca9(%rip), %rax # 0x376988
movq (%rax), %rax
testq %rax, %rax
je 0x3dd12
movq %rbx, -0x30(%rbp)
movq %rdi, %rbx
movl %r10d, %edi
movl %r9d, %r15d
callq *%rax
movl 0x20(%rbp), %r10d
movq %rbx, %rdi
movq -0x30(%rbp), %rbx
movl %r15d, %r9d
movl $0x1, %r15d
testl %eax, %eax
jne 0x3de38
movl 0x18(%rbp), %r11d
movl 0x10(%rbp), %r8d
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
cmpq %r12, %r13
je 0x3de2e
movb (%r13), %al
movsbl %al, %ecx
cmpl %r11d, %ecx
sete %sil
cmpl %r8d, %ecx
sete %dl
orb %dl, %sil
je 0x3dd8f
testb %dl, %dl
je 0x3dd85
incq %r13
movq %r13, %rax
cmpq %rbx, %r14
je 0x3de38
movq %r14, %rcx
movq %rax, %r13
cmpq %r12, %rax
jae 0x3dd72
leaq 0x1(%rcx), %r14
movsbl (%r13), %edx
leaq 0x1(%r13), %rax
cmpl %r8d, %edx
je 0x3dd4c
incq %rcx
cmpq %r12, %r13
je 0x3de2b
movb (%r13), %al
movq %rcx, %r14
movsbl %al, %eax
cmpl %r11d, %eax
jne 0x3dd20
jmp 0x3ddf0
movl $0x1, %r15d
cmpq %rbx, %r14
je 0x3de38
leaq 0x1(%r13), %rax
cmpq %r12, %rax
cmoveq %r13, %rax
cmpl %r9d, %ecx
cmoveq %rax, %r13
movq 0x58(%rdi), %rax
movzbl (%r13), %ecx
movb (%rax,%rcx), %cl
movzbl (%r14), %edx
cmpb (%rax,%rdx), %cl
jne 0x3de38
incq %r14
incq %r13
cmpq %r12, %r13
je 0x3de2e
movb (%r13), %al
movsbl %al, %ecx
cmpl %r8d, %ecx
sete %dl
cmpl %r11d, %ecx
je 0x3dd42
cmpl %r8d, %ecx
jne 0x3dd8f
jmp 0x3dd42
leaq 0x1(%r13), %rax
xorl %r15d, %r15d
cmpq %r12, %rax
je 0x3de38
addq $0x2, %r13
movb -0x1(%r13), %al
movsbl %al, %ecx
cmpl %r11d, %ecx
je 0x3de1d
cmpl %r8d, %ecx
jne 0x3de4a
cmpq %rbx, %r14
je 0x3def5
incq %r14
leaq 0x1(%r13), %rax
cmpq %r12, %r13
movq %rax, %r13
jne 0x3de00
jmp 0x3de38
movq %rcx, %r14
xorl %r15d, %r15d
cmpq %rbx, %r14
setne %r15b
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
cmpq %rbx, %r14
je 0x3de38
movzbl %al, %ecx
leaq -0x1(%r13), %rdx
cmpl %r9d, %ecx
jne 0x3de6d
cmpq %r12, %r13
je 0x3de6d
movb (%r13), %al
movq %r13, %rdx
incq %rdx
movq 0x58(%rdi), %rcx
movzbl %al, %eax
movb (%rcx,%rax), %r13b
incl %r10d
cmpq %rbx, %r14
je 0x3de38
movq 0x58(%rdi), %rax
movzbl (%r14), %ecx
cmpb %r13b, (%rax,%rcx)
je 0x3de9b
incq %r14
cmpq %rbx, %r14
jne 0x3de87
jmp 0x3de38
incq %r14
subq $0x8, %rsp
movq %rdi, -0x48(%rbp)
movq %r14, %rsi
movq %rdx, %rcx
movq %rbx, %rdx
movq %rcx, -0x38(%rbp)
movq %r8, %rax
movq %r12, %r8
movl %r9d, -0x30(%rbp)
movq %r10, -0x40(%rbp)
pushq %r10
pushq %r11
pushq %rax
callq 0x3dcb7
addq $0x20, %rsp
testl %eax, %eax
jle 0x3df00
cmpq %rbx, %r14
movl -0x30(%rbp), %r9d
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %r10
movl 0x18(%rbp), %r11d
movl 0x10(%rbp), %r8d
movq -0x38(%rbp), %rdx
jne 0x3de7e
jmp 0x3de38
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
jmp 0x3de38
movl %eax, %r15d
jmp 0x3de38
| my_wildcmp_8bit_impl:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r12, r8
mov r13, rcx
mov rbx, rdx
mov r14, rsi
mov r10d, [rbp+arg_10]
lea rax, my_string_stack_guard
mov rax, [rax]
test rax, rax
jz short loc_3DD12
mov [rbp+var_30], rbx
mov rbx, rdi
mov edi, r10d
mov r15d, r9d
call rax
mov r10d, [rbp+arg_10]
mov rdi, rbx
mov rbx, [rbp+var_30]
mov r9d, r15d
mov r15d, 1
test eax, eax
jnz loc_3DE38
loc_3DD12:
mov r11d, [rbp+arg_8]
mov r8d, [rbp+arg_0]
mov r15d, 0FFFFFFFFh
loc_3DD20:
cmp r13, r12
jz loc_3DE2E
mov al, [r13+0]
movsx ecx, al
cmp ecx, r11d
setz sil
cmp ecx, r8d
setz dl
or sil, dl
jz short loc_3DD8F
loc_3DD42:
test dl, dl
jz short loc_3DD85
inc r13
mov rax, r13
loc_3DD4C:
cmp r14, rbx
jz loc_3DE38
mov rcx, r14
mov r13, rax
cmp rax, r12
jnb short loc_3DD72
lea r14, [rcx+1]
movsx edx, byte ptr [r13+0]
lea rax, [r13+1]
cmp edx, r8d
jz short loc_3DD4C
loc_3DD72:
inc rcx
cmp r13, r12
jz loc_3DE2B
mov al, [r13+0]
mov r14, rcx
loc_3DD85:
movsx eax, al
cmp eax, r11d
jnz short loc_3DD20
jmp short loc_3DDF0
loc_3DD8F:
mov r15d, 1
cmp r14, rbx
jz loc_3DE38
lea rax, [r13+1]
cmp rax, r12
cmovz rax, r13
cmp ecx, r9d
cmovz r13, rax
mov rax, [rdi+58h]
movzx ecx, byte ptr [r13+0]
mov cl, [rax+rcx]
movzx edx, byte ptr [r14]
cmp cl, [rax+rdx]
jnz short loc_3DE38
inc r14
inc r13
cmp r13, r12
jz short loc_3DE2E
mov al, [r13+0]
movsx ecx, al
cmp ecx, r8d
setz dl
cmp ecx, r11d
jz loc_3DD42
cmp ecx, r8d
jnz short loc_3DD8F
jmp loc_3DD42
loc_3DDF0:
lea rax, [r13+1]
xor r15d, r15d
cmp rax, r12
jz short loc_3DE38
add r13, 2
loc_3DE00:
mov al, [r13-1]
movsx ecx, al
cmp ecx, r11d
jz short loc_3DE1D
cmp ecx, r8d
jnz short loc_3DE4A
cmp r14, rbx
jz loc_3DEF5
inc r14
loc_3DE1D:
lea rax, [r13+1]
cmp r13, r12
mov r13, rax
jnz short loc_3DE00
jmp short loc_3DE38
loc_3DE2B:
mov r14, rcx
loc_3DE2E:
xor r15d, r15d
cmp r14, rbx
setnz r15b
loc_3DE38:
mov eax, r15d
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3DE4A:
mov r15d, 0FFFFFFFFh
cmp r14, rbx
jz short loc_3DE38
movzx ecx, al
lea rdx, [r13-1]
cmp ecx, r9d
jnz short loc_3DE6D
cmp r13, r12
jz short loc_3DE6D
mov al, [r13+0]
mov rdx, r13
loc_3DE6D:
inc rdx
mov rcx, [rdi+58h]
movzx eax, al
mov r13b, [rcx+rax]
inc r10d
loc_3DE7E:
cmp r14, rbx
jz short loc_3DE38
mov rax, [rdi+58h]
loc_3DE87:
movzx ecx, byte ptr [r14]
cmp [rax+rcx], r13b
jz short loc_3DE9B
inc r14
cmp r14, rbx
jnz short loc_3DE87
jmp short loc_3DE38
loc_3DE9B:
inc r14
sub rsp, 8
mov [rbp+var_48], rdi
mov rsi, r14
mov rcx, rdx
mov rdx, rbx
mov [rbp+var_38], rcx
mov rax, r8
mov r8, r12
mov dword ptr [rbp+var_30], r9d
mov [rbp+var_40], r10
push r10
push r11
push rax
call my_wildcmp_8bit_impl
add rsp, 20h
test eax, eax
jle short loc_3DF00
cmp r14, rbx
mov r9d, dword ptr [rbp+var_30]
mov rdi, [rbp+var_48]
mov r10, [rbp+var_40]
mov r11d, [rbp+arg_8]
mov r8d, [rbp+arg_0]
mov rdx, [rbp+var_38]
jnz short loc_3DE7E
jmp loc_3DE38
loc_3DEF5:
mov r15d, 0FFFFFFFFh
jmp loc_3DE38
loc_3DF00:
mov r15d, eax
jmp loc_3DE38
| long long my_wildcmp_8bit_impl(
long long a1,
unsigned __int8 *a2,
unsigned __int8 *a3,
char *a4,
char *a5,
int a6,
int a7,
int a8,
unsigned int a9)
{
unsigned __int8 *v11; // rbx
unsigned int v13; // r10d
int v14; // r15d
int v15; // eax
unsigned int v16; // r15d
int v17; // r11d
int v18; // r8d
signed __int8 v19; // al
int v20; // ecx
bool v21; // dl
char *v22; // rax
unsigned __int8 *v23; // rcx
int v24; // edx
unsigned __int8 *v25; // rcx
char *v26; // rax
char *v27; // r13
unsigned __int8 v28; // al
char *v31; // rdx
_BYTE *v32; // rdx
char v33; // r13
long long v34; // r10
int v35; // eax
long long v36; // [rsp+10h] [rbp-40h]
_BYTE *v37; // [rsp+18h] [rbp-38h]
int v39; // [rsp+20h] [rbp-30h]
v11 = a3;
v13 = a9;
if ( my_string_stack_guard )
{
v14 = a6;
v15 = my_string_stack_guard(a9);
v13 = a9;
v11 = a3;
a6 = v14;
v16 = 1;
if ( v15 )
return v16;
}
v17 = a8;
v18 = a7;
v16 = -1;
do
{
if ( a4 == a5 )
return a2 != v11;
v19 = *a4;
v20 = *a4;
v21 = v20 == a7;
if ( v20 != a7 && v20 != a8 )
{
do
{
v16 = 1;
if ( a2 == v11 )
return v16;
v26 = a4 + 1;
if ( a4 + 1 == a5 )
v26 = a4;
if ( v20 == a6 )
a4 = v26;
if ( *(_BYTE *)(*(_QWORD *)(a1 + 88) + (unsigned __int8)*a4) != *(_BYTE *)(*(_QWORD *)(a1 + 88) + *a2) )
return v16;
++a2;
if ( ++a4 == a5 )
return a2 != v11;
v19 = *a4;
v20 = *a4;
v21 = v20 == a7;
}
while ( v20 != a8 && v20 != a7 );
}
if ( v21 )
{
v22 = a4 + 1;
do
{
if ( a2 == v11 )
return v16;
v23 = a2;
a4 = v22;
if ( v22 >= a5 )
break;
++a2;
v24 = *v22++;
}
while ( v24 == a7 );
v25 = v23 + 1;
if ( a4 == a5 )
{
a2 = v25;
return a2 != v11;
}
v19 = *a4;
a2 = v25;
}
}
while ( v19 != a8 );
v16 = 0;
if ( a4 + 1 == a5 )
return v16;
v27 = a4 + 2;
while ( 1 )
{
v28 = *(v27 - 1);
if ( (char)v28 == a8 )
goto LABEL_31;
if ( (char)v28 != a7 )
break;
if ( a2 == v11 )
return (unsigned int)-1;
++a2;
LABEL_31:
if ( v27++ == a5 )
return v16;
}
v16 = -1;
if ( a2 != v11 )
{
v31 = v27 - 1;
if ( v28 == a6 && v27 != a5 )
{
v28 = *v27;
v31 = v27;
}
v32 = v31 + 1;
v33 = *(_BYTE *)(*(_QWORD *)(a1 + 88) + v28);
v34 = v13 + 1;
while ( a2 != v11 )
{
while ( *(_BYTE *)(*(_QWORD *)(a1 + 88) + *a2) != v33 )
{
if ( ++a2 == v11 )
return v16;
}
++a2;
v37 = v32;
v39 = a6;
v36 = v34;
v35 = my_wildcmp_8bit_impl(a1, (_DWORD)a2, (_DWORD)v11, (_DWORD)v32, (_DWORD)a5, a6, v18, v17, v34);
if ( v35 <= 0 )
return (unsigned int)v35;
a6 = v39;
v34 = v36;
v17 = a8;
v18 = a7;
v32 = v37;
if ( a2 == v11 )
return v16;
}
}
return v16;
}
| my_wildcmp_8bit_impl:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R12,R8
MOV R13,RCX
MOV RBX,RDX
MOV R14,RSI
MOV R10D,dword ptr [RBP + 0x20]
LEA RAX,[0x476988]
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x0013dd12
MOV qword ptr [RBP + -0x30],RBX
MOV RBX,RDI
MOV EDI,R10D
MOV R15D,R9D
CALL RAX
MOV R10D,dword ptr [RBP + 0x20]
MOV RDI,RBX
MOV RBX,qword ptr [RBP + -0x30]
MOV R9D,R15D
MOV R15D,0x1
TEST EAX,EAX
JNZ 0x0013de38
LAB_0013dd12:
MOV R11D,dword ptr [RBP + 0x18]
MOV R8D,dword ptr [RBP + 0x10]
MOV R15D,0xffffffff
LAB_0013dd20:
CMP R13,R12
JZ 0x0013de2e
MOV AL,byte ptr [R13]
MOVSX ECX,AL
CMP ECX,R11D
SETZ SIL
CMP ECX,R8D
SETZ DL
OR SIL,DL
JZ 0x0013dd8f
LAB_0013dd42:
TEST DL,DL
JZ 0x0013dd85
INC R13
MOV RAX,R13
LAB_0013dd4c:
CMP R14,RBX
JZ 0x0013de38
MOV RCX,R14
MOV R13,RAX
CMP RAX,R12
JNC 0x0013dd72
LEA R14,[RCX + 0x1]
MOVSX EDX,byte ptr [R13]
LEA RAX,[R13 + 0x1]
CMP EDX,R8D
JZ 0x0013dd4c
LAB_0013dd72:
INC RCX
CMP R13,R12
JZ 0x0013de2b
MOV AL,byte ptr [R13]
MOV R14,RCX
LAB_0013dd85:
MOVSX EAX,AL
CMP EAX,R11D
JNZ 0x0013dd20
JMP 0x0013ddf0
LAB_0013dd8f:
MOV R15D,0x1
CMP R14,RBX
JZ 0x0013de38
LEA RAX,[R13 + 0x1]
CMP RAX,R12
CMOVZ RAX,R13
CMP ECX,R9D
CMOVZ R13,RAX
MOV RAX,qword ptr [RDI + 0x58]
MOVZX ECX,byte ptr [R13]
MOV CL,byte ptr [RAX + RCX*0x1]
MOVZX EDX,byte ptr [R14]
CMP CL,byte ptr [RAX + RDX*0x1]
JNZ 0x0013de38
INC R14
INC R13
CMP R13,R12
JZ 0x0013de2e
MOV AL,byte ptr [R13]
MOVSX ECX,AL
CMP ECX,R8D
SETZ DL
CMP ECX,R11D
JZ 0x0013dd42
CMP ECX,R8D
JNZ 0x0013dd8f
JMP 0x0013dd42
LAB_0013ddf0:
LEA RAX,[R13 + 0x1]
XOR R15D,R15D
CMP RAX,R12
JZ 0x0013de38
ADD R13,0x2
LAB_0013de00:
MOV AL,byte ptr [R13 + -0x1]
MOVSX ECX,AL
CMP ECX,R11D
JZ 0x0013de1d
CMP ECX,R8D
JNZ 0x0013de4a
CMP R14,RBX
JZ 0x0013def5
INC R14
LAB_0013de1d:
LEA RAX,[R13 + 0x1]
CMP R13,R12
MOV R13,RAX
JNZ 0x0013de00
JMP 0x0013de38
LAB_0013de2b:
MOV R14,RCX
LAB_0013de2e:
XOR R15D,R15D
CMP R14,RBX
SETNZ R15B
LAB_0013de38:
MOV EAX,R15D
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013de4a:
MOV R15D,0xffffffff
CMP R14,RBX
JZ 0x0013de38
MOVZX ECX,AL
LEA RDX,[R13 + -0x1]
CMP ECX,R9D
JNZ 0x0013de6d
CMP R13,R12
JZ 0x0013de6d
MOV AL,byte ptr [R13]
MOV RDX,R13
LAB_0013de6d:
INC RDX
MOV RCX,qword ptr [RDI + 0x58]
MOVZX EAX,AL
MOV R13B,byte ptr [RCX + RAX*0x1]
INC R10D
LAB_0013de7e:
CMP R14,RBX
JZ 0x0013de38
MOV RAX,qword ptr [RDI + 0x58]
LAB_0013de87:
MOVZX ECX,byte ptr [R14]
CMP byte ptr [RAX + RCX*0x1],R13B
JZ 0x0013de9b
INC R14
CMP R14,RBX
JNZ 0x0013de87
JMP 0x0013de38
LAB_0013de9b:
INC R14
SUB RSP,0x8
MOV qword ptr [RBP + -0x48],RDI
MOV RSI,R14
MOV RCX,RDX
MOV RDX,RBX
MOV qword ptr [RBP + -0x38],RCX
MOV RAX,R8
MOV R8,R12
MOV dword ptr [RBP + -0x30],R9D
MOV qword ptr [RBP + -0x40],R10
PUSH R10
PUSH R11
PUSH RAX
CALL 0x0013dcb7
ADD RSP,0x20
TEST EAX,EAX
JLE 0x0013df00
CMP R14,RBX
MOV R9D,dword ptr [RBP + -0x30]
MOV RDI,qword ptr [RBP + -0x48]
MOV R10,qword ptr [RBP + -0x40]
MOV R11D,dword ptr [RBP + 0x18]
MOV R8D,dword ptr [RBP + 0x10]
MOV RDX,qword ptr [RBP + -0x38]
JNZ 0x0013de7e
JMP 0x0013de38
LAB_0013def5:
MOV R15D,0xffffffff
JMP 0x0013de38
LAB_0013df00:
MOV R15D,EAX
JMP 0x0013de38
|
uint my_wildcmp_8bit_impl
(long param_1,byte *param_2,byte *param_3,byte *param_4,byte *param_5,ulong param_6,
uint param_7,uint param_8,int param_9)
{
char cVar1;
byte bVar2;
int iVar3;
uint uVar4;
byte *pbVar5;
uint uVar6;
byte *pbVar7;
bool bVar8;
if (my_string_stack_guard != (code *)0x0) {
param_6 = param_6 & 0xffffffff;
iVar3 = (*my_string_stack_guard)(param_9);
if (iVar3 != 0) {
return 1;
}
}
uVar4 = 0xffffffff;
while (param_4 != param_5) {
bVar2 = *param_4;
uVar6 = (uint)(char)bVar2;
bVar8 = uVar6 == param_7;
if (uVar6 != param_8 && !bVar8) {
do {
uVar4 = 1;
if (param_2 == param_3) {
return 1;
}
pbVar5 = param_4 + 1;
if (param_4 + 1 == param_5) {
pbVar5 = param_4;
}
if (uVar6 == (uint)param_6) {
param_4 = pbVar5;
}
if (*(char *)(*(long *)(param_1 + 0x58) + (ulong)*param_4) !=
*(char *)(*(long *)(param_1 + 0x58) + (ulong)*param_2)) {
return 1;
}
param_2 = param_2 + 1;
param_4 = param_4 + 1;
if (param_4 == param_5) goto LAB_0013de2e;
bVar2 = *param_4;
uVar6 = (uint)(char)bVar2;
bVar8 = uVar6 == param_7;
} while ((uVar6 != param_8) && (uVar6 != param_7));
}
if (bVar8) {
do {
pbVar5 = param_2;
param_4 = param_4 + 1;
if (pbVar5 == param_3) {
return uVar4;
}
} while ((param_4 < param_5) && (param_2 = pbVar5 + 1, (int)(char)*param_4 == param_7));
param_2 = pbVar5 + 1;
if (param_4 == param_5) break;
bVar2 = *param_4;
}
if ((int)(char)bVar2 == param_8) {
if (param_4 + 1 != param_5) {
pbVar5 = param_4 + 2;
do {
bVar2 = pbVar5[-1];
if ((int)(char)bVar2 != param_8) {
if ((int)(char)bVar2 != param_7) {
if (param_2 == param_3) {
return 0xffffffff;
}
pbVar7 = pbVar5 + -1;
if (((uint)bVar2 == (uint)param_6) && (pbVar5 != param_5)) {
bVar2 = *pbVar5;
pbVar7 = pbVar5;
}
cVar1 = *(char *)(*(long *)(param_1 + 0x58) + (ulong)bVar2);
while( true ) {
if (param_2 == param_3) {
return 0xffffffff;
}
while (*(char *)(*(long *)(param_1 + 0x58) + (ulong)*param_2) != cVar1) {
param_2 = param_2 + 1;
if (param_2 == param_3) {
return 0xffffffff;
}
}
param_2 = param_2 + 1;
uVar4 = my_wildcmp_8bit_impl
(param_1,param_2,param_3,pbVar7 + 1,param_5,param_6,param_7,
param_8,param_9 + 1);
if ((int)uVar4 < 1) break;
param_6 = param_6 & 0xffffffff;
if (param_2 == param_3) {
return 0xffffffff;
}
}
return uVar4;
}
if (param_2 == param_3) {
return 0xffffffff;
}
param_2 = param_2 + 1;
}
bVar8 = pbVar5 != param_5;
pbVar5 = pbVar5 + 1;
} while (bVar8);
}
return 0;
}
}
LAB_0013de2e:
return (uint)(param_2 != param_3);
}
| |
24,877 | find_export_entry | bluesky950520[P]quickjs/quickjs.c | static JSExportEntry *find_export_entry(JSContext *ctx, const JSModuleDef *m,
JSAtom export_name)
{
JSExportEntry *me;
int i;
for(i = 0; i < m->export_entries_count; i++) {
me = &m->export_entries[i];
if (me->export_name == export_name)
return me;
}
return NULL;
} | O0 | c | find_export_entry:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl %edx, -0x1c(%rsp)
movl $0x0, -0x2c(%rsp)
movl -0x2c(%rsp), %eax
movq -0x18(%rsp), %rcx
cmpl 0x30(%rcx), %eax
jge 0x48827
movq -0x18(%rsp), %rax
movq 0x28(%rax), %rax
movslq -0x2c(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movl 0x18(%rax), %eax
cmpl -0x1c(%rsp), %eax
jne 0x48818
movq -0x28(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x48830
jmp 0x4881a
movl -0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rsp)
jmp 0x487d6
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
| find_export_entry:
mov [rsp+var_10], rdi
mov [rsp+var_18], rsi
mov [rsp+var_1C], edx
mov [rsp+var_2C], 0
loc_487D6:
mov eax, [rsp+var_2C]
mov rcx, [rsp+var_18]
cmp eax, [rcx+30h]
jge short loc_48827
mov rax, [rsp+var_18]
mov rax, [rax+28h]
movsxd rcx, [rsp+var_2C]
shl rcx, 5
add rax, rcx
mov [rsp+var_28], rax
mov rax, [rsp+var_28]
mov eax, [rax+18h]
cmp eax, [rsp+var_1C]
jnz short loc_48818
mov rax, [rsp+var_28]
mov [rsp+var_8], rax
jmp short loc_48830
loc_48818:
jmp short $+2
loc_4881A:
mov eax, [rsp+var_2C]
add eax, 1
mov [rsp+var_2C], eax
jmp short loc_487D6
loc_48827:
mov [rsp+var_8], 0
loc_48830:
mov rax, [rsp+var_8]
retn
| long long find_export_entry(long long a1, long long a2, int a3)
{
int i; // [rsp+0h] [rbp-2Ch]
for ( i = 0; i < *(_DWORD *)(a2 + 48); ++i )
{
if ( *(_DWORD *)(32LL * i + *(_QWORD *)(a2 + 40) + 24) == a3 )
return 32LL * i + *(_QWORD *)(a2 + 40);
}
return 0LL;
}
| find_export_entry:
MOV qword ptr [RSP + -0x10],RDI
MOV qword ptr [RSP + -0x18],RSI
MOV dword ptr [RSP + -0x1c],EDX
MOV dword ptr [RSP + -0x2c],0x0
LAB_001487d6:
MOV EAX,dword ptr [RSP + -0x2c]
MOV RCX,qword ptr [RSP + -0x18]
CMP EAX,dword ptr [RCX + 0x30]
JGE 0x00148827
MOV RAX,qword ptr [RSP + -0x18]
MOV RAX,qword ptr [RAX + 0x28]
MOVSXD RCX,dword ptr [RSP + -0x2c]
SHL RCX,0x5
ADD RAX,RCX
MOV qword ptr [RSP + -0x28],RAX
MOV RAX,qword ptr [RSP + -0x28]
MOV EAX,dword ptr [RAX + 0x18]
CMP EAX,dword ptr [RSP + -0x1c]
JNZ 0x00148818
MOV RAX,qword ptr [RSP + -0x28]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x00148830
LAB_00148818:
JMP 0x0014881a
LAB_0014881a:
MOV EAX,dword ptr [RSP + -0x2c]
ADD EAX,0x1
MOV dword ptr [RSP + -0x2c],EAX
JMP 0x001487d6
LAB_00148827:
MOV qword ptr [RSP + -0x8],0x0
LAB_00148830:
MOV RAX,qword ptr [RSP + -0x8]
RET
|
long find_export_entry(int8 param_1,long param_2,int param_3)
{
long lVar1;
int local_2c;
local_2c = 0;
while( true ) {
if (*(int *)(param_2 + 0x30) <= local_2c) {
return 0;
}
lVar1 = *(long *)(param_2 + 0x28) + (long)local_2c * 0x20;
if (*(int *)(lVar1 + 0x18) == param_3) break;
local_2c = local_2c + 1;
}
return lVar1;
}
| |
24,878 | match | eshkol/src/frontend/lexer/lexer.c | static bool match(Lexer* lexer, char expected) {
if (is_at_end(lexer)) {
return false;
}
if (*lexer->current != expected) {
return false;
}
lexer->current++;
lexer->column++;
return true;
} | O0 | c | match:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5910
testb $0x1, %al
jne 0x5bd1
jmp 0x5bd7
movb $0x0, -0x1(%rbp)
jmp 0x5c14
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movsbl (%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
je 0x5bf0
movb $0x0, -0x1(%rbp)
jmp 0x5c14
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x38(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
| match:
push rbp
mov rbp, rsp
sub rsp, 20h
mov al, sil
mov [rbp+var_10], rdi
mov [rbp+var_11], al
mov rdi, [rbp+var_10]
call is_at_end
test al, 1
jnz short loc_5BD1
jmp short loc_5BD7
loc_5BD1:
mov [rbp+var_1], 0
jmp short loc_5C14
loc_5BD7:
mov rax, [rbp+var_10]
mov rax, [rax+28h]
movsx eax, byte ptr [rax]
movsx ecx, [rbp+var_11]
cmp eax, ecx
jz short loc_5BF0
mov [rbp+var_1], 0
jmp short loc_5C14
loc_5BF0:
mov rax, [rbp+var_10]
mov rcx, [rax+28h]
add rcx, 1
mov [rax+28h], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+38h]
add rcx, 1
mov [rax+38h], rcx
mov [rbp+var_1], 1
loc_5C14:
mov al, [rbp+var_1]
and al, 1
add rsp, 20h
pop rbp
retn
| char match(long long a1, char a2)
{
if ( is_at_end(a1) )
return 0;
if ( **(char **)(a1 + 40) != a2 )
return 0;
++*(_QWORD *)(a1 + 40);
++*(_QWORD *)(a1 + 56);
return 1;
}
| match:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV AL,SIL
MOV qword ptr [RBP + -0x10],RDI
MOV byte ptr [RBP + -0x11],AL
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00105910
TEST AL,0x1
JNZ 0x00105bd1
JMP 0x00105bd7
LAB_00105bd1:
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00105c14
LAB_00105bd7:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x28]
MOVSX EAX,byte ptr [RAX]
MOVSX ECX,byte ptr [RBP + -0x11]
CMP EAX,ECX
JZ 0x00105bf0
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00105c14
LAB_00105bf0:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x28]
ADD RCX,0x1
MOV qword ptr [RAX + 0x28],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x38]
ADD RCX,0x1
MOV qword ptr [RAX + 0x38],RCX
MOV byte ptr [RBP + -0x1],0x1
LAB_00105c14:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0x20
POP RBP
RET
|
int1 match(long param_1,char param_2)
{
ulong uVar1;
int1 local_9;
uVar1 = is_at_end(param_1);
if ((uVar1 & 1) == 0) {
if (**(char **)(param_1 + 0x28) == param_2) {
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + 1;
*(long *)(param_1 + 0x38) = *(long *)(param_1 + 0x38) + 1;
local_9 = 1;
}
else {
local_9 = 0;
}
}
else {
local_9 = 0;
}
return local_9;
}
| |
24,879 | mi_munmap_file | eloqsql/storage/myisam/mi_dynrec.c | int mi_munmap_file(MI_INFO *info)
{
int ret;
DBUG_ENTER("mi_unmap_file");
if ((ret= my_munmap((void*) info->s->file_map, info->s->mmaped_length)))
DBUG_RETURN(ret);
info->s->file_read= mi_nommap_pread;
info->s->file_write= mi_nommap_pwrite;
info->s->file_map= 0;
info->s->mmaped_length= 0;
DBUG_RETURN(0);
} | O0 | c | mi_munmap_file:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x270(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x4d0(%rax), %rsi
callq 0x2a490
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0xa710f
jmp 0xa7107
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa7164
movq -0x10(%rbp), %rax
movq (%rax), %rax
leaq 0x53(%rip), %rcx # 0xa7170
movq %rcx, 0x2e0(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
leaq 0x9e(%rip), %rcx # 0xa71d0
movq %rcx, 0x2e8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x270(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x4d0(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| mi_munmap_file:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov rax, [rax]
mov rdi, [rax+270h]
mov rax, [rbp+var_10]
mov rax, [rax]
mov rsi, [rax+4D0h]
call _munmap
mov [rbp+var_14], eax
cmp eax, 0
jz short loc_A710F
jmp short $+2
loc_A7107:
mov eax, [rbp+var_14]
mov [rbp+var_4], eax
jmp short loc_A7164
loc_A710F:
mov rax, [rbp+var_10]
mov rax, [rax]
lea rcx, mi_nommap_pread
mov [rax+2E0h], rcx
mov rax, [rbp+var_10]
mov rax, [rax]
lea rcx, mi_nommap_pwrite
mov [rax+2E8h], rcx
mov rax, [rbp+var_10]
mov rax, [rax]
mov qword ptr [rax+270h], 0
mov rax, [rbp+var_10]
mov rax, [rax]
mov qword ptr [rax+4D0h], 0
mov [rbp+var_4], 0
loc_A7164:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long mi_munmap_file(long long a1)
{
unsigned int v2; // [rsp+Ch] [rbp-14h]
v2 = munmap(*(_QWORD *)(*(_QWORD *)a1 + 624LL), *(_QWORD *)(*(_QWORD *)a1 + 1232LL));
if ( v2 )
{
return v2;
}
else
{
*(_QWORD *)(*(_QWORD *)a1 + 736LL) = mi_nommap_pread;
*(_QWORD *)(*(_QWORD *)a1 + 744LL) = mi_nommap_pwrite;
*(_QWORD *)(*(_QWORD *)a1 + 624LL) = 0LL;
*(_QWORD *)(*(_QWORD *)a1 + 1232LL) = 0LL;
return 0;
}
}
| mi_munmap_file:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + 0x270]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x4d0]
CALL 0x0012a490
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JZ 0x001a710f
JMP 0x001a7107
LAB_001a7107:
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001a7164
LAB_001a710f:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
LEA RCX,[0x1a7170]
MOV qword ptr [RAX + 0x2e0],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
LEA RCX,[0x1a71d0]
MOV qword ptr [RAX + 0x2e8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0x270],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0x4d0],0x0
MOV dword ptr [RBP + -0x4],0x0
LAB_001a7164:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int mi_munmap_file(long *param_1)
{
int local_c;
local_c = munmap(*(void **)(*param_1 + 0x270),*(size_t *)(*param_1 + 0x4d0));
if (local_c == 0) {
*(code **)(*param_1 + 0x2e0) = mi_nommap_pread;
*(code **)(*param_1 + 0x2e8) = mi_nommap_pwrite;
*(int8 *)(*param_1 + 0x270) = 0;
*(int8 *)(*param_1 + 0x4d0) = 0;
local_c = 0;
}
return local_c;
}
| |
24,880 | nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::decode(unsigned char&, unsigned int&, unsigned char) | monkey531[P]llama/common/./json.hpp | static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept
{
static const std::array<std::uint8_t, 400> utf8d =
{
{
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 00..1F
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20..3F
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 40..5F
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 60..7F
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // 80..9F
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // A0..BF
8, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // C0..DF
0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // E0..EF
0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // F0..FF
0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, // s1..s2
1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, // s3..s4
1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, // s5..s6
1, 3, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // s7..s8
}
};
JSON_ASSERT(byte < utf8d.size());
const std::uint8_t type = utf8d[byte];
codep = (state != UTF8_ACCEPT)
? (byte & 0x3fu) | (codep << 6u)
: (0xFFu >> type) & (byte);
const std::size_t index = 256u + static_cast<size_t>(state) * 16u + static_cast<size_t>(type);
JSON_ASSERT(index < utf8d.size());
state = utf8d[index];
return state;
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::decode(unsigned char&, unsigned int&, unsigned char):
movl %edx, %ecx
leaq 0x581df(%rip), %rax # 0xbf192
movzbl (%rcx,%rax), %ecx
cmpb $0x0, (%rdi)
je 0x66fcd
andb $0x3f, %dl
movzbl %dl, %r8d
movl (%rsi), %edx
shll $0x6, %edx
orl %r8d, %edx
jmp 0x66fdc
movl $0xff, %r8d
shrl %cl, %r8d
movzbl %dl, %edx
andl %r8d, %edx
movl %edx, (%rsi)
movzbl (%rdi), %edx
shll $0x4, %edx
movl %ecx, %ecx
addq %rdx, %rcx
addq $0x100, %rcx # imm = 0x100
cmpq $0x190, %rcx # imm = 0x190
jae 0x66fff
movb (%rcx,%rax), %al
movb %al, (%rdi)
retq
pushq %rax
leaq 0x54dd0(%rip), %rdi # 0xbbdd7
leaq 0x4fc98(%rip), %rsi # 0xb6ca6
leaq 0x54ce9(%rip), %rcx # 0xbbcfe
movl $0x49fb, %edx # imm = 0x49FB
callq 0x18470
| _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE6decodeERhRjh:
mov ecx, edx
lea rax, _ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE6decodeERhRjhE5utf8d; nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::decode(uchar &,uint &,uchar)::utf8d
movzx ecx, byte ptr [rcx+rax]
cmp byte ptr [rdi], 0
jz short loc_66FCD
and dl, 3Fh
movzx r8d, dl
mov edx, [rsi]
shl edx, 6
or edx, r8d
jmp short loc_66FDC
loc_66FCD:
mov r8d, 0FFh
shr r8d, cl
movzx edx, dl
and edx, r8d
loc_66FDC:
mov [rsi], edx
movzx edx, byte ptr [rdi]
shl edx, 4
mov ecx, ecx
add rcx, rdx
add rcx, 100h
cmp rcx, 190h
jnb short loc_66FFF
mov al, [rcx+rax]
mov [rdi], al
retn
loc_66FFF:
push rax
lea rdi, aIndexUtf8dSize; "index < utf8d.size()"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStaticStdUint8; "static std::uint8_t nlohmann::detail::s"...
mov edx, 49FBh
call ___assert_fail
| unsigned __int8 nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::decode(
unsigned __int8 *a1,
unsigned int *a2,
int a3)
{
unsigned int v3; // ecx
unsigned int v4; // edx
unsigned long long v5; // rcx
unsigned __int8 result; // al
v3 = nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::decode(unsigned char &,unsigned int &,unsigned char)::utf8d[a3];
if ( *a1 )
v4 = a3 & 0x3F | (*a2 << 6);
else
v4 = (0xFFu >> v3) & (unsigned __int8)a3;
*a2 = v4;
v5 = 16 * (unsigned int)*a1 + (unsigned long long)v3 + 256;
if ( v5 >= 0x190 )
__assert_fail(
"index < utf8d.size()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
"__gmon_start__",
"static std::uint8_t nlohmann::detail::serializer<nlohmann::basic_json<nlohmann::ordered_map>>::decode(std::uint8_t"
" &, std::uint32_t &, const std::uint8_t) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered_map>]");
result = nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::decode(unsigned char &,unsigned int &,unsigned char)::utf8d[v5];
*a1 = result;
return result;
}
| decode:
MOV ECX,EDX
LEA RAX,[0x1bf192]
MOVZX ECX,byte ptr [RCX + RAX*0x1]
CMP byte ptr [RDI],0x0
JZ 0x00166fcd
AND DL,0x3f
MOVZX R8D,DL
MOV EDX,dword ptr [RSI]
SHL EDX,0x6
OR EDX,R8D
JMP 0x00166fdc
LAB_00166fcd:
MOV R8D,0xff
SHR R8D,CL
MOVZX EDX,DL
AND EDX,R8D
LAB_00166fdc:
MOV dword ptr [RSI],EDX
MOVZX EDX,byte ptr [RDI]
SHL EDX,0x4
MOV ECX,ECX
ADD RCX,RDX
ADD RCX,0x100
CMP RCX,0x190
JNC 0x00166fff
MOV AL,byte ptr [RCX + RAX*0x1]
MOV byte ptr [RDI],AL
RET
LAB_00166fff:
PUSH RAX
LEA RDI,[0x1bbdd7]
LEA RSI,[0x1b6ca6]
LEA RCX,[0x1bbcfe]
MOV EDX,0x49fb
CALL 0x00118470
|
/* nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::decode(unsigned char&, unsigned int&, unsigned char) */
void nlohmann::json_abi_v3_11_3::detail::
serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::decode(uchar *param_1,uint *param_2,uchar param_3)
{
byte bVar1;
long lVar2;
uint uVar3;
int7 in_register_00000011;
bVar1 = decode(unsigned_char&,unsigned_int&,unsigned_char)::utf8d
[CONCAT71(in_register_00000011,param_3) & 0xffffffff];
if (*param_1 == '\0') {
uVar3 = (uint)param_3 & 0xffU >> (bVar1 & 0x1f);
}
else {
uVar3 = *param_2 << 6 | (uint)(param_3 & 0x3f);
}
*param_2 = uVar3;
lVar2 = (ulong)bVar1 + (ulong)*param_1 * 0x10;
if (lVar2 + 0x100U < 400) {
*param_1 = decode(unsigned_char&,unsigned_int&,unsigned_char)::utf8d[lVar2 + 0x100];
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("index < utf8d.size()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",0x49fb
,
"static std::uint8_t nlohmann::detail::serializer<nlohmann::basic_json<nlohmann::ordered_map>>::decode(std::uint8_t &, std::uint32_t &, const std::uint8_t) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered_map>]"
);
}
| |
24,881 | get_leb128 | bluesky950520[P]quickjs/quickjs.c | static int get_leb128(uint32_t *pval, const uint8_t *buf,
const uint8_t *buf_end)
{
const uint8_t *ptr = buf;
uint32_t v, a, i;
v = 0;
for(i = 0; i < 5; i++) {
if (unlikely(ptr >= buf_end))
break;
a = *ptr++;
v |= (a & 0x7f) << (i * 7);
if (!(a & 0x80)) {
*pval = v;
return ptr - buf;
}
}
*pval = 0;
return -1;
} | O2 | c | get_leb128:
xorl %ecx, %ecx
xorl %eax, %eax
xorl %r8d, %r8d
leaq (%rsi,%rax), %r9
cmpl $0x5, %eax
setb %r10b
cmpq %rdx, %r9
setb %r11b
andb %r10b, %r11b
cmpb $0x1, %r11b
jne 0x3ec64
movzbl (%r9), %r9d
movl %r9d, %r10d
andl $0x7f, %r10d
shll %cl, %r10d
orl %r10d, %r8d
incq %rax
addl $0x7, %ecx
testb %r9b, %r9b
js 0x3ec29
movl %r8d, (%rdi)
retq
andl $0x0, (%rdi)
pushq $-0x1
popq %rax
retq
| get_leb128:
xor ecx, ecx
xor eax, eax
xor r8d, r8d
loc_3EC29:
lea r9, [rsi+rax]
cmp eax, 5
setb r10b
cmp r9, rdx
setb r11b
and r11b, r10b
cmp r11b, 1
jnz short loc_3EC64
movzx r9d, byte ptr [r9]
mov r10d, r9d
and r10d, 7Fh
shl r10d, cl
or r8d, r10d
inc rax
add ecx, 7
test r9b, r9b
js short loc_3EC29
mov [rdi], r8d
retn
loc_3EC64:
and dword ptr [rdi], 0
push 0FFFFFFFFFFFFFFFFh
pop rax
retn
| long long get_leb128(_DWORD *a1, long long a2, unsigned long long a3)
{
int v3; // ecx
long long result; // rax
int v5; // r8d
char v6; // r9
v3 = 0;
result = 0LL;
v5 = 0;
while ( (unsigned int)result < 5 && a2 + result < a3 )
{
v6 = *(_BYTE *)(a2 + result);
v5 |= (v6 & 0x7F) << v3;
++result;
v3 += 7;
if ( v6 >= 0 )
{
*a1 = v5;
return result;
}
}
*a1 = 0;
return -1LL;
}
| get_leb128:
XOR ECX,ECX
XOR EAX,EAX
XOR R8D,R8D
LAB_0013ec29:
LEA R9,[RSI + RAX*0x1]
CMP EAX,0x5
SETC R10B
CMP R9,RDX
SETC R11B
AND R11B,R10B
CMP R11B,0x1
JNZ 0x0013ec64
MOVZX R9D,byte ptr [R9]
MOV R10D,R9D
AND R10D,0x7f
SHL R10D,CL
OR R8D,R10D
INC RAX
ADD ECX,0x7
TEST R9B,R9B
JS 0x0013ec29
MOV dword ptr [RDI],R8D
RET
LAB_0013ec64:
AND dword ptr [RDI],0x0
PUSH -0x1
POP RAX
RET
|
long get_leb128(uint *param_1,long param_2,byte *param_3)
{
byte bVar1;
long lVar2;
byte bVar3;
uint uVar4;
bVar3 = 0;
lVar2 = 0;
uVar4 = 0;
do {
if (param_3 <= (byte *)(param_2 + lVar2) || 4 < (uint)lVar2) {
*param_1 = 0;
return -1;
}
bVar1 = *(byte *)(param_2 + lVar2);
uVar4 = uVar4 | (bVar1 & 0x7f) << (bVar3 & 0x1f);
lVar2 = lVar2 + 1;
bVar3 = bVar3 + 7;
} while ((char)bVar1 < '\0');
*param_1 = uVar4;
return lVar2;
}
| |
24,882 | expand_tilde | eloqsql/mysys/mf_pack.c | static char * expand_tilde(char **path)
{
if (path[0][0] == FN_LIBCHAR)
return home_dir; /* ~/ expanded to home */
#ifdef HAVE_GETPWNAM
{
char *str,save;
struct passwd *user_entry;
if (!(str=strchr(*path,FN_LIBCHAR)))
str=strend(*path);
save= *str; *str= '\0';
user_entry=getpwnam(*path);
*str=save;
endpwent();
if (user_entry)
{
*path=str;
return user_entry->pw_dir;
}
}
#endif
return (char *) 0;
} | O0 | c | expand_tilde:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x3033e
leaq 0x357756(%rip), %rax # 0x387a88
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x303bf
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x2f, %esi
callq 0x24110
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x30369
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x79370
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x24220
movq %rax, -0x28(%rbp)
movb -0x19(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
callq 0x24310
cmpq $0x0, -0x28(%rbp)
je 0x303b7
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x303bf
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| expand_tilde:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov rax, [rax]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jnz short loc_3033E
lea rax, home_dir
mov rax, [rax]
mov [rbp+var_8], rax
jmp loc_303BF
loc_3033E:
mov rax, [rbp+var_10]
mov rdi, [rax]
mov esi, 2Fh ; '/'
call _strchr
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_30369
mov rax, [rbp+var_10]
mov rdi, [rax]
call strend
mov [rbp+var_18], rax
loc_30369:
mov rax, [rbp+var_18]
mov al, [rax]
mov [rbp+var_19], al
mov rax, [rbp+var_18]
mov byte ptr [rax], 0
mov rax, [rbp+var_10]
mov rdi, [rax]
call _getpwnam
mov [rbp+var_28], rax
mov cl, [rbp+var_19]
mov rax, [rbp+var_18]
mov [rax], cl
call _endpwent
cmp [rbp+var_28], 0
jz short loc_303B7
mov rcx, [rbp+var_18]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rax, [rbp+var_28]
mov rax, [rax+20h]
mov [rbp+var_8], rax
jmp short loc_303BF
loc_303B7:
mov [rbp+var_8], 0
loc_303BF:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| long long expand_tilde(char **a1)
{
long long v2; // [rsp+8h] [rbp-28h]
char v3; // [rsp+17h] [rbp-19h]
char *v4; // [rsp+18h] [rbp-18h]
if ( **a1 == 47 )
return home_dir;
v4 = (char *)strchr(*a1, 47LL);
if ( !v4 )
v4 = (char *)strend(*a1);
v3 = *v4;
*v4 = 0;
v2 = getpwnam(*a1);
*v4 = v3;
endpwent();
if ( !v2 )
return 0LL;
*a1 = v4;
return *(_QWORD *)(v2 + 32);
}
| expand_tilde:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JNZ 0x0013033e
LEA RAX,[0x487a88]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001303bf
LAB_0013033e:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV ESI,0x2f
CALL 0x00124110
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x00130369
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
CALL 0x00179370
MOV qword ptr [RBP + -0x18],RAX
LAB_00130369:
MOV RAX,qword ptr [RBP + -0x18]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x19],AL
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
CALL 0x00124220
MOV qword ptr [RBP + -0x28],RAX
MOV CL,byte ptr [RBP + -0x19]
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],CL
CALL 0x00124310
CMP qword ptr [RBP + -0x28],0x0
JZ 0x001303b7
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001303bf
LAB_001303b7:
MOV qword ptr [RBP + -0x8],0x0
LAB_001303bf:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
char * expand_tilde(int8 *param_1)
{
char cVar1;
passwd *ppVar2;
char *local_20;
char *local_10;
if (*(char *)*param_1 == '/') {
local_10 = home_dir;
}
else {
local_20 = strchr((char *)*param_1,0x2f);
if (local_20 == (char *)0x0) {
local_20 = (char *)strend(*param_1);
}
cVar1 = *local_20;
*local_20 = '\0';
ppVar2 = getpwnam((char *)*param_1);
*local_20 = cVar1;
endpwent();
if (ppVar2 == (passwd *)0x0) {
local_10 = (char *)0x0;
}
else {
*param_1 = local_20;
local_10 = ppVar2->pw_dir;
}
}
return local_10;
}
| |
24,883 | rb_insert | eloqsql/mysys/tree.c | static void rb_insert(TREE *tree, TREE_ELEMENT ***parent, TREE_ELEMENT *leaf)
{
TREE_ELEMENT *y,*par,*par2;
leaf->colour=RED;
while (leaf != tree->root && (par=parent[-1][0])->colour == RED)
{
if (par == (par2=parent[-2][0])->left)
{
y= par2->right;
if (y->colour == RED)
{
par->colour=BLACK;
y->colour=BLACK;
leaf=par2;
parent-=2;
leaf->colour=RED; /* And the loop continues */
}
else
{
if (leaf == par->right)
{
left_rotate(parent[-1],par);
par=leaf; /* leaf is now parent to old leaf */
}
par->colour=BLACK;
par2->colour=RED;
right_rotate(parent[-2],par2);
break;
}
}
else
{
y= par2->left;
if (y->colour == RED)
{
par->colour=BLACK;
y->colour=BLACK;
leaf=par2;
parent-=2;
leaf->colour=RED; /* And the loop continues */
}
else
{
if (leaf == par->left)
{
right_rotate(parent[-1],par);
par=leaf;
}
par->colour=BLACK;
par2->colour=RED;
left_rotate(parent[-2],par2);
break;
}
}
}
tree->root->colour=BLACK;
} | O0 | c | rb_insert:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x0, %ecx
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rdx
xorl %eax, %eax
cmpq (%rdx), %rcx
movb %al, -0x31(%rbp)
je 0xfad07
movq -0x10(%rbp), %rax
movq -0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl 0x10(%rax), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xfad13
jmp 0xfaee2
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq -0x10(%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, -0x30(%rbp)
cmpq (%rcx), %rax
jne 0xfae0a
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
jne 0xfad9f
movq -0x28(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $-0x10, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x0, %ecx
movl %ecx, 0x10(%rax)
jmp 0xfae05
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0xfadc6
movq -0x10(%rbp), %rax
movq -0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0xfc250
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
movq -0x30(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x0, %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq -0x10(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0xfc290
jmp 0xfaee2
jmp 0xfaedd
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
jne 0xfae79
movq -0x28(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $-0x10, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x0, %ecx
movl %ecx, 0x10(%rax)
jmp 0xfaedb
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xfae9f
movq -0x10(%rbp), %rax
movq -0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0xfc290
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
movq -0x30(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x0, %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq -0x10(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0xfc250
jmp 0xfaee2
jmp 0xfaedd
jmp 0xfacd7
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| rb_insert:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_18]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 0
mov [rax+10h], ecx
loc_FACD7:
mov rcx, [rbp+var_18]
mov rdx, [rbp+var_8]
xor eax, eax
cmp rcx, [rdx]
mov [rbp+var_31], al
jz short loc_FAD07
mov rax, [rbp+var_10]
mov rax, [rax-8]
mov rax, [rax]
mov [rbp+var_28], rax
mov eax, [rax+10h]
shr eax, 1Fh
cmp eax, 0
setz al
mov [rbp+var_31], al
loc_FAD07:
mov al, [rbp+var_31]
test al, 1
jnz short loc_FAD13
jmp loc_FAEE2
loc_FAD13:
mov rax, [rbp+var_28]
mov rcx, [rbp+var_10]
mov rcx, [rcx-10h]
mov rcx, [rcx]
mov [rbp+var_30], rcx
cmp rax, [rcx]
jnz loc_FAE0A
mov rax, [rbp+var_30]
mov rax, [rax+8]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov eax, [rax+10h]
shr eax, 1Fh
cmp eax, 0
jnz short loc_FAD9F
mov rax, [rbp+var_28]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
mov rax, [rbp+var_20]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
mov rax, [rbp+var_30]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
add rax, 0FFFFFFFFFFFFFFF0h
mov [rbp+var_10], rax
mov rax, [rbp+var_18]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 0
mov [rax+10h], ecx
jmp short loc_FAE05
loc_FAD9F:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_28]
cmp rax, [rcx+8]
jnz short loc_FADC6
mov rax, [rbp+var_10]
mov rdi, [rax-8]
mov rsi, [rbp+var_28]
call left_rotate
mov rax, [rbp+var_18]
mov [rbp+var_28], rax
loc_FADC6:
mov rax, [rbp+var_28]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
mov rax, [rbp+var_30]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 0
mov [rax+10h], ecx
mov rax, [rbp+var_10]
mov rdi, [rax-10h]
mov rsi, [rbp+var_30]
call right_rotate
jmp loc_FAEE2
loc_FAE05:
jmp loc_FAEDD
loc_FAE0A:
mov rax, [rbp+var_30]
mov rax, [rax]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov eax, [rax+10h]
shr eax, 1Fh
cmp eax, 0
jnz short loc_FAE79
mov rax, [rbp+var_28]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
mov rax, [rbp+var_20]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
mov rax, [rbp+var_30]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
add rax, 0FFFFFFFFFFFFFFF0h
mov [rbp+var_10], rax
mov rax, [rbp+var_18]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 0
mov [rax+10h], ecx
jmp short loc_FAEDB
loc_FAE79:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_28]
cmp rax, [rcx]
jnz short loc_FAE9F
mov rax, [rbp+var_10]
mov rdi, [rax-8]
mov rsi, [rbp+var_28]
call right_rotate
mov rax, [rbp+var_18]
mov [rbp+var_28], rax
loc_FAE9F:
mov rax, [rbp+var_28]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
mov rax, [rbp+var_30]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 0
mov [rax+10h], ecx
mov rax, [rbp+var_10]
mov rdi, [rax-10h]
mov rsi, [rbp+var_30]
call left_rotate
jmp short loc_FAEE2
loc_FAEDB:
jmp short $+2
loc_FAEDD:
jmp loc_FACD7
loc_FAEE2:
mov rax, [rbp+var_8]
mov rax, [rax]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
add rsp, 40h
pop rbp
retn
| long long * rb_insert(long long **a1, long long a2, long long *a3)
{
long long *result; // rax
bool v4; // [rsp+Fh] [rbp-31h]
long long *v5; // [rsp+10h] [rbp-30h]
long long *v6; // [rsp+18h] [rbp-28h]
long long v7; // [rsp+20h] [rbp-20h]
long long *v8; // [rsp+28h] [rbp-18h]
v8 = a3;
*((_DWORD *)a3 + 4) &= ~0x80000000;
while ( 1 )
{
v4 = 0;
if ( v8 != *a1 )
{
v6 = **(long long ***)(a2 - 8);
v4 = *((_DWORD *)v6 + 4) >> 31 == 0;
}
if ( !v4 )
break;
v5 = **(long long ***)(a2 - 16);
if ( v6 == (long long *)*v5 )
{
v7 = v5[1];
if ( *(int *)(v7 + 16) < 0 )
{
if ( v8 == (long long *)v6[1] )
{
left_rotate(*(_QWORD *)(a2 - 8), v6);
v6 = v8;
}
*((_DWORD *)v6 + 4) = v6[2] & 0x7FFFFFFF | 0x80000000;
*((_DWORD *)v5 + 4) &= ~0x80000000;
right_rotate(*(_QWORD *)(a2 - 16), v5);
break;
}
}
else
{
v7 = *v5;
if ( *(int *)(*v5 + 16) < 0 )
{
if ( v8 == (long long *)*v6 )
{
right_rotate(*(_QWORD *)(a2 - 8), v6);
v6 = v8;
}
*((_DWORD *)v6 + 4) = v6[2] & 0x7FFFFFFF | 0x80000000;
*((_DWORD *)v5 + 4) &= ~0x80000000;
left_rotate(*(_QWORD *)(a2 - 16), v5);
break;
}
}
*((_DWORD *)v6 + 4) = v6[2] & 0x7FFFFFFF | 0x80000000;
*(_DWORD *)(v7 + 16) = *(_DWORD *)(v7 + 16) & 0x7FFFFFFF | 0x80000000;
v8 = v5;
a2 -= 16LL;
*((_DWORD *)v5 + 4) &= ~0x80000000;
}
result = *a1;
*((_DWORD *)*a1 + 4) = (*a1)[2] & 0x7FFFFFFF | 0x80000000;
return result;
}
| rb_insert:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x0
MOV dword ptr [RAX + 0x10],ECX
LAB_001facd7:
MOV RCX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x8]
XOR EAX,EAX
CMP RCX,qword ptr [RDX]
MOV byte ptr [RBP + -0x31],AL
JZ 0x001fad07
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV EAX,dword ptr [RAX + 0x10]
SHR EAX,0x1f
CMP EAX,0x0
SETZ AL
MOV byte ptr [RBP + -0x31],AL
LAB_001fad07:
MOV AL,byte ptr [RBP + -0x31]
TEST AL,0x1
JNZ 0x001fad13
JMP 0x001faee2
LAB_001fad13:
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + -0x10]
MOV RCX,qword ptr [RCX]
MOV qword ptr [RBP + -0x30],RCX
CMP RAX,qword ptr [RCX]
JNZ 0x001fae0a
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x10]
SHR EAX,0x1f
CMP EAX,0x0
JNZ 0x001fad9f
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,-0x10
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x0
MOV dword ptr [RAX + 0x10],ECX
JMP 0x001fae05
LAB_001fad9f:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RCX + 0x8]
JNZ 0x001fadc6
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + -0x8]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x001fc250
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x28],RAX
LAB_001fadc6:
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x0
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
CALL 0x001fc290
JMP 0x001faee2
LAB_001fae05:
JMP 0x001faedd
LAB_001fae0a:
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x10]
SHR EAX,0x1f
CMP EAX,0x0
JNZ 0x001fae79
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,-0x10
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x0
MOV dword ptr [RAX + 0x10],ECX
JMP 0x001faedb
LAB_001fae79:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RCX]
JNZ 0x001fae9f
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + -0x8]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x001fc290
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x28],RAX
LAB_001fae9f:
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x0
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
CALL 0x001fc250
JMP 0x001faee2
LAB_001faedb:
JMP 0x001faedd
LAB_001faedd:
JMP 0x001facd7
LAB_001faee2:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
ADD RSP,0x40
POP RBP
RET
|
void rb_insert(long *param_1,long param_2,long *param_3)
{
long *plVar1;
long lVar2;
bool bVar3;
long *local_30;
long *local_20;
long local_18;
*(uint *)(param_3 + 2) = *(uint *)(param_3 + 2) & 0x7fffffff;
local_20 = param_3;
local_18 = param_2;
do {
bVar3 = false;
if (local_20 != (long *)*param_1) {
local_30 = (long *)**(long **)(local_18 + -8);
bVar3 = -1 < (int)local_30[2];
}
if (!bVar3) goto LAB_001faee2;
plVar1 = (long *)**(long **)(local_18 + -0x10);
if (local_30 == (long *)*plVar1) {
lVar2 = plVar1[1];
if (*(int *)(lVar2 + 0x10) < 0) {
if (local_20 == (long *)local_30[1]) {
left_rotate(*(int8 *)(local_18 + -8),local_30);
local_30 = local_20;
}
*(uint *)(local_30 + 2) = *(uint *)(local_30 + 2) & 0x7fffffff | 0x80000000;
*(uint *)(plVar1 + 2) = *(uint *)(plVar1 + 2) & 0x7fffffff;
right_rotate(*(int8 *)(local_18 + -0x10),plVar1);
LAB_001faee2:
*(uint *)(*param_1 + 0x10) = *(uint *)(*param_1 + 0x10) & 0x7fffffff | 0x80000000;
return;
}
*(uint *)(local_30 + 2) = *(uint *)(local_30 + 2) & 0x7fffffff | 0x80000000;
*(uint *)(lVar2 + 0x10) = *(uint *)(lVar2 + 0x10) & 0x7fffffff | 0x80000000;
*(uint *)(plVar1 + 2) = *(uint *)(plVar1 + 2) & 0x7fffffff;
}
else {
lVar2 = *plVar1;
if (*(int *)(lVar2 + 0x10) < 0) {
if (local_20 == (long *)*local_30) {
right_rotate(*(int8 *)(local_18 + -8),local_30);
local_30 = local_20;
}
*(uint *)(local_30 + 2) = *(uint *)(local_30 + 2) & 0x7fffffff | 0x80000000;
*(uint *)(plVar1 + 2) = *(uint *)(plVar1 + 2) & 0x7fffffff;
left_rotate(*(int8 *)(local_18 + -0x10),plVar1);
goto LAB_001faee2;
}
*(uint *)(local_30 + 2) = *(uint *)(local_30 + 2) & 0x7fffffff | 0x80000000;
*(uint *)(lVar2 + 0x10) = *(uint *)(lVar2 + 0x10) & 0x7fffffff | 0x80000000;
*(uint *)(plVar1 + 2) = *(uint *)(plVar1 + 2) & 0x7fffffff;
}
local_18 = local_18 + -0x10;
local_20 = plVar1;
} while( true );
}
| |
24,884 | end_server | eloqsql/libmariadb/libmariadb/mariadb_lib.c | static void
end_server(MYSQL *mysql)
{
/* if net->error 2 and reconnect is activated, we need to inform
connection handler */
if (mysql->net.pvio != 0)
{
ma_pvio_close(mysql->net.pvio);
mysql->net.pvio= 0; /* Marker */
}
ma_net_end(&mysql->net);
free_old_query(mysql);
return;
} | O3 | c | end_server:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x19157
callq 0x21027
movq $0x0, (%rbx)
movq %rbx, %rdi
callq 0x34b4f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1de2a
| end_server:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
mov rdi, [rdi]
test rdi, rdi
jz short loc_19157
call ma_pvio_close
mov qword ptr [rbx], 0
loc_19157:
mov rdi, rbx
call ma_net_end
mov rdi, rbx
add rsp, 8
pop rbx
pop rbp
jmp free_old_query
| long long end_server(long long *a1)
{
long long v2; // rdi
v2 = *a1;
if ( v2 )
{
ma_pvio_close(v2);
*a1 = 0LL;
}
ma_net_end(a1);
return free_old_query(a1);
}
| end_server:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RDI,qword ptr [RDI]
TEST RDI,RDI
JZ 0x00119157
CALL 0x00121027
MOV qword ptr [RBX],0x0
LAB_00119157:
MOV RDI,RBX
CALL 0x00134b4f
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x0011de2a
|
void end_server(long *param_1)
{
if (*param_1 != 0) {
ma_pvio_close();
*param_1 = 0;
}
ma_net_end(param_1);
free_old_query(param_1);
return;
}
| |
24,885 | ma_flush_table_files | eloqsql/storage/maria/ma_extra.c | int _ma_flush_table_files(MARIA_HA *info, uint flush_data_or_index,
enum flush_type flush_type_for_data,
enum flush_type flush_type_for_index)
{
int error= 0;
MARIA_SHARE *share= info->s;
DBUG_ENTER("_ma_flush_table_files");
/* flush data file first because it's more critical */
if (flush_data_or_index & MARIA_FLUSH_DATA)
{
if ((info->opt_flag & WRITE_CACHE_USED) &&
flush_type_for_data != FLUSH_IGNORE_CHANGED &&
flush_io_cache(&info->rec_cache))
error= 1;
if (share->data_file_type == BLOCK_RECORD)
{
if (flush_type_for_data != FLUSH_IGNORE_CHANGED)
{
if (_ma_bitmap_flush(share))
error= 1;
}
else
{
mysql_mutex_lock(&share->bitmap.bitmap_lock);
share->bitmap.changed= 0;
share->bitmap.changed_not_flushed= 0;
mysql_mutex_unlock(&share->bitmap.bitmap_lock);
}
if (flush_pagecache_blocks(share->pagecache, &info->dfile,
flush_type_for_data))
error= 1;
}
}
if ((flush_data_or_index & MARIA_FLUSH_INDEX) &&
flush_pagecache_blocks(share->pagecache, &share->kfile,
flush_type_for_index))
error= 1;
if (!error)
DBUG_RETURN(0);
_ma_set_fatal_error(info, HA_ERR_CRASHED);
DBUG_RETURN(1);
} | O0 | c | ma_flush_table_files:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x38fe2
movq -0x10(%rbp), %rax
movl 0x61c(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x38f2f
cmpl $0x2, -0x18(%rbp)
je 0x38f2f
movq -0x10(%rbp), %rdi
addq $0x4b8, %rdi # imm = 0x4B8
movl $0x1, %esi
callq 0xe8710
cmpl $0x0, %eax
je 0x38f2f
movl $0x1, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x3, 0x7d0(%rax)
jne 0x38fe0
cmpl $0x2, -0x18(%rbp)
je 0x38f5c
movq -0x28(%rbp), %rdi
callq 0x610a0
cmpb $0x0, %al
je 0x38f5a
movl $0x1, -0x20(%rbp)
jmp 0x38fac
movq -0x28(%rbp), %rdi
addq $0xa10, %rdi # imm = 0xA10
addq $0x88, %rdi
leaq 0x120154(%rip), %rsi # 0x1590c9
movl $0x28c, %edx # imm = 0x28C
callq 0x38df0
movq -0x28(%rbp), %rax
movb $0x0, 0xa30(%rax)
movq -0x28(%rbp), %rax
movb $0x0, 0xa31(%rax)
movq -0x28(%rbp), %rdi
addq $0xa10, %rdi # imm = 0xA10
addq $0x88, %rdi
callq 0x38e60
movq -0x28(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x470, %rsi # imm = 0x470
movl -0x18(%rbp), %edx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x9dc00
cmpl $0x0, %eax
je 0x38fde
movl $0x1, -0x20(%rbp)
jmp 0x38fe0
jmp 0x38fe2
movl -0x14(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x3901f
movq -0x28(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x28(%rbp), %rsi
addq $0x750, %rsi # imm = 0x750
movl -0x1c(%rbp), %edx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x9dc00
cmpl $0x0, %eax
je 0x3901f
movl $0x1, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x39030
jmp 0x39027
movl $0x0, -0x4(%rbp)
jmp 0x39045
movq -0x10(%rbp), %rdi
movl $0x7e, %esi
callq 0x39b70
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
| _ma_flush_table_files:
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
mov [rbp+var_20], 0
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_28], rax
mov eax, [rbp+var_14]
and eax, 1
cmp eax, 0
jz loc_38FE2
mov rax, [rbp+var_10]
mov eax, [rax+61Ch]
and eax, 10h
cmp eax, 0
jz short loc_38F2F
cmp [rbp+var_18], 2
jz short loc_38F2F
mov rdi, [rbp+var_10]
add rdi, 4B8h
mov esi, 1
call my_b_flush_io_cache
cmp eax, 0
jz short loc_38F2F
mov [rbp+var_20], 1
loc_38F2F:
mov rax, [rbp+var_28]
cmp dword ptr [rax+7D0h], 3
jnz loc_38FE0
cmp [rbp+var_18], 2
jz short loc_38F5C
mov rdi, [rbp+var_28]
call _ma_bitmap_flush
cmp al, 0
jz short loc_38F5A
mov [rbp+var_20], 1
loc_38F5A:
jmp short loc_38FAC
loc_38F5C:
mov rdi, [rbp+var_28]
add rdi, 0A10h
add rdi, 88h
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 28Ch
call inline_mysql_mutex_lock_0
mov rax, [rbp+var_28]
mov byte ptr [rax+0A30h], 0
mov rax, [rbp+var_28]
mov byte ptr [rax+0A31h], 0
mov rdi, [rbp+var_28]
add rdi, 0A10h
add rdi, 88h
call inline_mysql_mutex_unlock_0
loc_38FAC:
mov rax, [rbp+var_28]
mov rdi, [rax+600h]
mov rsi, [rbp+var_10]
add rsi, 470h
mov edx, [rbp+var_18]
xor eax, eax
mov r8d, eax
mov rcx, r8
call flush_pagecache_blocks_with_filter
cmp eax, 0
jz short loc_38FDE
mov [rbp+var_20], 1
loc_38FDE:
jmp short $+2
loc_38FE0:
jmp short $+2
loc_38FE2:
mov eax, [rbp+var_14]
and eax, 2
cmp eax, 0
jz short loc_3901F
mov rax, [rbp+var_28]
mov rdi, [rax+600h]
mov rsi, [rbp+var_28]
add rsi, 750h
mov edx, [rbp+var_1C]
xor eax, eax
mov r8d, eax
mov rcx, r8
call flush_pagecache_blocks_with_filter
cmp eax, 0
jz short loc_3901F
mov [rbp+var_20], 1
loc_3901F:
cmp [rbp+var_20], 0
jnz short loc_39030
jmp short $+2
loc_39027:
mov [rbp+var_4], 0
jmp short loc_39045
loc_39030:
mov rdi, [rbp+var_10]
mov esi, 7Eh ; '~'
call _ma_set_fatal_error
mov [rbp+var_4], 1
loc_39045:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long ma_flush_table_files(long long *a1, char a2, unsigned int a3, unsigned int a4)
{
long long v5; // [rsp+8h] [rbp-28h]
BOOL v6; // [rsp+10h] [rbp-20h]
v6 = 0;
v5 = *a1;
if ( (a2 & 1) != 0 )
{
if ( (*((_DWORD *)a1 + 391) & 0x10) != 0 && a3 != 2 )
v6 = my_b_flush_io_cache(a1 + 151, 1LL) != 0;
if ( *(_DWORD *)(v5 + 2000) == 3 )
{
if ( a3 == 2 )
{
inline_mysql_mutex_lock_0(
v5 + 2712,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_extra.c",
0x28Cu);
*(_BYTE *)(v5 + 2608) = 0;
*(_BYTE *)(v5 + 2609) = 0;
inline_mysql_mutex_unlock_0(v5 + 2712);
}
else if ( (unsigned __int8)ma_bitmap_flush(v5) )
{
v6 = 1;
}
if ( (unsigned int)flush_pagecache_blocks_with_filter(*(_QWORD *)(v5 + 1536), a1 + 142, a3, 0LL) )
v6 = 1;
}
}
if ( (a2 & 2) != 0 && (unsigned int)flush_pagecache_blocks_with_filter(*(_QWORD *)(v5 + 1536), v5 + 1872, a4, 0LL) )
v6 = 1;
if ( v6 )
{
ma_set_fatal_error(a1, 126LL);
return 1;
}
else
{
return 0;
}
}
| _ma_flush_table_files:
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
MOV dword ptr [RBP + -0x20],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x1
CMP EAX,0x0
JZ 0x00138fe2
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x61c]
AND EAX,0x10
CMP EAX,0x0
JZ 0x00138f2f
CMP dword ptr [RBP + -0x18],0x2
JZ 0x00138f2f
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x4b8
MOV ESI,0x1
CALL 0x001e8710
CMP EAX,0x0
JZ 0x00138f2f
MOV dword ptr [RBP + -0x20],0x1
LAB_00138f2f:
MOV RAX,qword ptr [RBP + -0x28]
CMP dword ptr [RAX + 0x7d0],0x3
JNZ 0x00138fe0
CMP dword ptr [RBP + -0x18],0x2
JZ 0x00138f5c
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x001610a0
CMP AL,0x0
JZ 0x00138f5a
MOV dword ptr [RBP + -0x20],0x1
LAB_00138f5a:
JMP 0x00138fac
LAB_00138f5c:
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0xa10
ADD RDI,0x88
LEA RSI,[0x2590c9]
MOV EDX,0x28c
CALL 0x00138df0
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0xa30],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0xa31],0x0
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0xa10
ADD RDI,0x88
CALL 0x00138e60
LAB_00138fac:
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x470
MOV EDX,dword ptr [RBP + -0x18]
XOR EAX,EAX
MOV R8D,EAX
MOV RCX,R8
CALL 0x0019dc00
CMP EAX,0x0
JZ 0x00138fde
MOV dword ptr [RBP + -0x20],0x1
LAB_00138fde:
JMP 0x00138fe0
LAB_00138fe0:
JMP 0x00138fe2
LAB_00138fe2:
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x2
CMP EAX,0x0
JZ 0x0013901f
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x28]
ADD RSI,0x750
MOV EDX,dword ptr [RBP + -0x1c]
XOR EAX,EAX
MOV R8D,EAX
MOV RCX,R8
CALL 0x0019dc00
CMP EAX,0x0
JZ 0x0013901f
MOV dword ptr [RBP + -0x20],0x1
LAB_0013901f:
CMP dword ptr [RBP + -0x20],0x0
JNZ 0x00139030
JMP 0x00139027
LAB_00139027:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00139045
LAB_00139030:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x7e
CALL 0x00139b70
MOV dword ptr [RBP + -0x4],0x1
LAB_00139045:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
bool _ma_flush_table_files(long *param_1,uint param_2,int param_3,int4 param_4)
{
long lVar1;
bool bVar2;
char cVar3;
int iVar4;
bVar2 = false;
lVar1 = *param_1;
if ((param_2 & 1) != 0) {
if ((((*(uint *)((long)param_1 + 0x61c) & 0x10) != 0) && (param_3 != 2)) &&
(iVar4 = my_b_flush_io_cache(param_1 + 0x97,1), iVar4 != 0)) {
bVar2 = true;
}
if (*(int *)(lVar1 + 2000) == 3) {
if (param_3 == 2) {
inline_mysql_mutex_lock
(lVar1 + 0xa98,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_extra.c"
,0x28c);
*(int1 *)(lVar1 + 0xa30) = 0;
*(int1 *)(lVar1 + 0xa31) = 0;
inline_mysql_mutex_unlock(lVar1 + 0xa98);
}
else {
cVar3 = _ma_bitmap_flush(lVar1);
if (cVar3 != '\0') {
bVar2 = true;
}
}
iVar4 = flush_pagecache_blocks_with_filter
(*(int8 *)(lVar1 + 0x600),param_1 + 0x8e,param_3,0);
if (iVar4 != 0) {
bVar2 = true;
}
}
}
if (((param_2 & 2) != 0) &&
(iVar4 = flush_pagecache_blocks_with_filter
(*(int8 *)(lVar1 + 0x600),lVar1 + 0x750,param_4,0), iVar4 != 0)) {
bVar2 = true;
}
if (bVar2) {
_ma_set_fatal_error(param_1,0x7e);
}
return bVar2;
}
| |
24,886 | nglog::base::GetLogger(nglog::LogSeverity) | ng-log[P]ng-log/src/logging.cc | base::Logger* base::GetLogger(LogSeverity severity) {
std::lock_guard<std::mutex> l{log_mutex};
return LogDestination::log_destination(severity)->GetLoggerImpl();
} | O1 | cpp | nglog::base::GetLogger(nglog::LogSeverity):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebp
leaq 0x34e2c(%rip), %rdi # 0x40cd8
callq 0x7820
testl %eax, %eax
jne 0xbf22
movl %ebp, %eax
leaq 0x25d62(%rip), %rcx # 0x31c20
leaq (%rcx,%rax,8), %rbx
cmpq $0x0, (%rbx)
jne 0xbefe
movl $0xd0, %edi
callq 0x7530
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0xa584
movq %rsp, %r15
movq $0x0, (%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12a74
movq %r15, %rdi
callq 0x115b4
movq (%rbx), %rax
movq 0xc8(%rax), %rbx
leaq 0x34dc9(%rip), %rdi # 0x40cd8
callq 0x73e0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x7350
movq %rax, %rbx
movl $0xd0, %esi
movq %r14, %rdi
callq 0x7540
jmp 0xbf3e
movq %rax, %rbx
leaq 0x34d93(%rip), %rdi # 0x40cd8
callq 0x73e0
movq %rbx, %rdi
callq 0x7990
| _ZN5nglog4base9GetLoggerENS_11LogSeverityE:
push rbp
push r15
push r14
push rbx
push rax
mov ebp, edi
lea rdi, _ZN5nglogL9log_mutexE; nglog::log_mutex
call _pthread_mutex_lock
test eax, eax
jnz short loc_BF22
mov eax, ebp
lea rcx, _ZN5nglog14LogDestination17log_destinations_E; nglog::LogDestination::log_destinations_
lea rbx, [rcx+rax*8]
cmp qword ptr [rbx], 0
jnz short loc_BEFE
mov edi, 0D0h; unsigned __int64
call __Znwm; operator new(ulong)
mov r14, rax
mov rdi, rax
mov esi, ebp
xor edx, edx
call _ZN5nglog14LogDestinationC2ENS_11LogSeverityEPKc; nglog::LogDestination::LogDestination(nglog::LogSeverity,char const*)
mov r15, rsp
mov qword ptr [r15], 0
mov rdi, rbx
mov rsi, r14
call _ZNSt15__uniq_ptr_implIN5nglog14LogDestinationESt14default_deleteIS1_EE5resetEPS1_; std::__uniq_ptr_impl<nglog::LogDestination,std::default_delete<nglog::LogDestination>>::reset(nglog::LogDestination*)
mov rdi, r15
call _ZNSt10unique_ptrIN5nglog14LogDestinationESt14default_deleteIS1_EED2Ev; std::unique_ptr<nglog::LogDestination>::~unique_ptr()
loc_BEFE:
mov rax, [rbx]
mov rbx, [rax+0C8h]
lea rdi, _ZN5nglogL9log_mutexE; nglog::log_mutex
call _pthread_mutex_unlock
mov rax, rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_BF22:
mov edi, eax; int
call __ZSt20__throw_system_errori; std::__throw_system_error(int)
mov rbx, rax
mov esi, 0D0h; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_BF3E
mov rbx, rax
loc_BF3E:
lea rdi, _ZN5nglogL9log_mutexE; nglog::log_mutex
call _pthread_mutex_unlock
mov rdi, rbx
call __Unwind_Resume
| long long nglog::base::GetLogger(unsigned int a1)
{
long long v1; // rax
int v2; // eax
char *v3; // rbx
long long v4; // r14
long long v5; // rbx
long long v7; // [rsp-8h] [rbp-28h] BYREF
v7 = v1;
v2 = pthread_mutex_lock(&nglog::log_mutex);
if ( v2 )
std::__throw_system_error(v2);
v3 = (char *)&nglog::LogDestination::log_destinations_ + 8 * a1;
if ( !*(_QWORD *)v3 )
{
v4 = operator new(0xD0uLL);
nglog::LogDestination::LogDestination(v4, a1, 0LL);
v7 = 0LL;
std::__uniq_ptr_impl<nglog::LogDestination,std::default_delete<nglog::LogDestination>>::reset(
(char *)&nglog::LogDestination::log_destinations_ + 8 * a1,
v4);
std::unique_ptr<nglog::LogDestination>::~unique_ptr(&v7);
}
v5 = *(_QWORD *)(*(_QWORD *)v3 + 200LL);
pthread_mutex_unlock(&nglog::log_mutex);
return v5;
}
| GetLogger:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EBP,EDI
LEA RDI,[0x140cd8]
CALL 0x00107820
TEST EAX,EAX
JNZ 0x0010bf22
MOV EAX,EBP
LEA RCX,[0x131c20]
LEA RBX,[RCX + RAX*0x8]
CMP qword ptr [RBX],0x0
JNZ 0x0010befe
LAB_0010bec8:
MOV EDI,0xd0
CALL 0x00107530
LAB_0010bed2:
MOV R14,RAX
MOV RDI,RAX
MOV ESI,EBP
XOR EDX,EDX
CALL 0x0010a584
LAB_0010bee1:
MOV R15,RSP
MOV qword ptr [R15],0x0
MOV RDI,RBX
MOV RSI,R14
CALL 0x00112a74
MOV RDI,R15
CALL 0x001115b4
LAB_0010befe:
MOV RAX,qword ptr [RBX]
MOV RBX,qword ptr [RAX + 0xc8]
LEA RDI,[0x140cd8]
CALL 0x001073e0
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0010bf22:
MOV EDI,EAX
CALL 0x00107350
|
/* nglog::base::GetLogger(nglog::LogSeverity) */
int8 nglog::base::GetLogger(uint param_1)
{
__uniq_ptr_impl<nglog::LogDestination,std::default_delete<nglog::LogDestination>> *this;
int8 uVar1;
int iVar2;
int8 in_RAX;
LogDestination *pLVar3;
int8 local_28;
local_28 = in_RAX;
iVar2 = pthread_mutex_lock((pthread_mutex_t *)log_mutex);
if (iVar2 == 0) {
this = (__uniq_ptr_impl<nglog::LogDestination,std::default_delete<nglog::LogDestination>> *)
(&LogDestination::log_destinations_ + param_1);
if (*(long *)this == 0) {
/* try { // try from 0010bec8 to 0010bed1 has its CatchHandler @ 0010bf3b */
pLVar3 = (LogDestination *)operator_new(0xd0);
/* try { // try from 0010bed2 to 0010bee0 has its CatchHandler @ 0010bf29 */
LogDestination::LogDestination(pLVar3,param_1,0);
local_28 = 0;
std::__uniq_ptr_impl<nglog::LogDestination,std::default_delete<nglog::LogDestination>>::reset
(this,pLVar3);
std::unique_ptr<nglog::LogDestination,std::default_delete<nglog::LogDestination>>::~unique_ptr
((unique_ptr<nglog::LogDestination,std::default_delete<nglog::LogDestination>> *)
&local_28);
}
uVar1 = *(int8 *)(*(long *)this + 200);
pthread_mutex_unlock((pthread_mutex_t *)log_mutex);
return uVar1;
}
/* WARNING: Subroutine does not return */
std::__throw_system_error(iVar2);
}
| |
24,887 | has_path | eloqsql/mysys/my_getwd.c | my_bool has_path(const char *name)
{
return MY_TEST(strchr(name, FN_LIBCHAR))
#if FN_LIBCHAR != '/'
|| MY_TEST(strchr(name, '/'))
#endif
#ifdef FN_DEVCHAR
|| MY_TEST(strchr(name, FN_DEVCHAR))
#endif
;
} | O0 | c | has_path:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2f, %esi
callq 0x2a410
movq %rax, %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| has_path:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]
mov esi, 2Fh ; '/'
call _strchr
mov rdx, rax
xor eax, eax
mov ecx, 1
cmp rdx, 0
cmovnz eax, ecx
add rsp, 10h
pop rbp
retn
| _BOOL8 has_path(long long a1)
{
return strchr(a1, 47LL) != 0;
}
| has_path:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,0x2f
CALL 0x0012a410
MOV RDX,RAX
XOR EAX,EAX
MOV ECX,0x1
CMP RDX,0x0
CMOVNZ EAX,ECX
ADD RSP,0x10
POP RBP
RET
|
bool has_path(char *param_1)
{
char *pcVar1;
pcVar1 = strchr(param_1,0x2f);
return pcVar1 != (char *)0x0;
}
| |
24,888 | ma_tls_async_check_result | eloqsql/libmariadb/libmariadb/secure/openssl.c | static my_bool
ma_tls_async_check_result(int res, struct mysql_async_context *b, SSL *ssl)
{
int ssl_err;
b->events_to_wait_for= 0;
if (res >= 0)
return 1;
ssl_err= SSL_get_error(ssl, res);
if (ssl_err == SSL_ERROR_WANT_READ)
b->events_to_wait_for|= MYSQL_WAIT_READ;
else if (ssl_err == SSL_ERROR_WANT_WRITE)
b->events_to_wait_for|= MYSQL_WAIT_WRITE;
else
return 1;
if (b->suspend_resume_hook)
(*b->suspend_resume_hook)(TRUE, b->suspend_resume_hook_user_data);
my_context_yield(&b->async_context);
if (b->suspend_resume_hook)
(*b->suspend_resume_hook)(FALSE, b->suspend_resume_hook_user_data);
return 0;
} | O3 | c | ma_tls_async_check_result:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl $0x0, (%rsi)
movb $0x1, %r14b
testl %edi, %edi
js 0x29f95
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl %edi, %esi
movq %rdx, %rdi
callq 0x13050
cmpl $0x2, %eax
je 0x29fb0
cmpl $0x3, %eax
jne 0x29f8d
movl $0x2, %eax
jmp 0x29fb5
movl $0x1, %eax
orl %eax, (%rbx)
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x29fcb
movq 0x28(%rbx), %rsi
movl $0x1, %edi
callq *%rax
leaq 0x38(%rbx), %rdi
callq 0x2f3bd
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x29fea
movq 0x28(%rbx), %rsi
xorl %r14d, %r14d
xorl %edi, %edi
callq *%rax
jmp 0x29f8d
xorl %r14d, %r14d
jmp 0x29f8d
| ma_tls_async_check_result:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rsi
mov dword ptr [rsi], 0
mov r14b, 1
test edi, edi
js short loc_29F95
loc_29F8D:
mov eax, r14d
pop rbx
pop r14
pop rbp
retn
loc_29F95:
mov esi, edi
mov rdi, rdx
call _SSL_get_error
cmp eax, 2
jz short loc_29FB0
cmp eax, 3
jnz short loc_29F8D
mov eax, 2
jmp short loc_29FB5
loc_29FB0:
mov eax, 1
loc_29FB5:
or [rbx], eax
mov rax, [rbx+20h]
test rax, rax
jz short loc_29FCB
mov rsi, [rbx+28h]
mov edi, 1
call rax
loc_29FCB:
lea rdi, [rbx+38h]
call my_context_yield
mov rax, [rbx+20h]
test rax, rax
jz short loc_29FEA
mov rsi, [rbx+28h]
xor r14d, r14d
xor edi, edi
call rax
jmp short loc_29F8D
loc_29FEA:
xor r14d, r14d
jmp short loc_29F8D
| long long ma_tls_async_check_result(int a1, long long a2, long long a3)
{
unsigned int v3; // r14d
int error; // eax
int v6; // eax
void ( *v7)(long long, _QWORD); // rax
void ( *v8)(_QWORD, _QWORD); // rax
*(_DWORD *)a2 = 0;
LOBYTE(v3) = 1;
if ( a1 < 0 )
{
error = SSL_get_error(a3, (unsigned int)a1);
if ( error == 2 )
{
v6 = 1;
}
else
{
if ( error != 3 )
return v3;
v6 = 2;
}
*(_DWORD *)a2 |= v6;
v7 = *(void ( **)(long long, _QWORD))(a2 + 32);
if ( v7 )
v7(1LL, *(_QWORD *)(a2 + 40));
my_context_yield(a2 + 56);
v8 = *(void ( **)(_QWORD, _QWORD))(a2 + 32);
v3 = 0;
if ( v8 )
v8(0LL, *(_QWORD *)(a2 + 40));
}
return v3;
}
| ma_tls_async_check_result:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV dword ptr [RSI],0x0
MOV R14B,0x1
TEST EDI,EDI
JS 0x00129f95
LAB_00129f8d:
MOV EAX,R14D
POP RBX
POP R14
POP RBP
RET
LAB_00129f95:
MOV ESI,EDI
MOV RDI,RDX
CALL 0x00113050
CMP EAX,0x2
JZ 0x00129fb0
CMP EAX,0x3
JNZ 0x00129f8d
MOV EAX,0x2
JMP 0x00129fb5
LAB_00129fb0:
MOV EAX,0x1
LAB_00129fb5:
OR dword ptr [RBX],EAX
MOV RAX,qword ptr [RBX + 0x20]
TEST RAX,RAX
JZ 0x00129fcb
MOV RSI,qword ptr [RBX + 0x28]
MOV EDI,0x1
CALL RAX
LAB_00129fcb:
LEA RDI,[RBX + 0x38]
CALL 0x0012f3bd
MOV RAX,qword ptr [RBX + 0x20]
TEST RAX,RAX
JZ 0x00129fea
MOV RSI,qword ptr [RBX + 0x28]
XOR R14D,R14D
XOR EDI,EDI
CALL RAX
JMP 0x00129f8d
LAB_00129fea:
XOR R14D,R14D
JMP 0x00129f8d
|
ulong ma_tls_async_check_result(int param_1,uint *param_2,SSL *param_3)
{
int iVar1;
uint uVar2;
int8 unaff_R14;
ulong uVar3;
*param_2 = 0;
uVar3 = CONCAT71((int7)((ulong)unaff_R14 >> 8),1);
if (param_1 < 0) {
iVar1 = SSL_get_error(param_3,param_1);
if (iVar1 == 2) {
uVar2 = 1;
}
else {
if (iVar1 != 3) goto LAB_00129f8d;
uVar2 = 2;
}
*param_2 = *param_2 | uVar2;
if (*(code **)(param_2 + 8) != (code *)0x0) {
(**(code **)(param_2 + 8))(1,*(int8 *)(param_2 + 10));
}
my_context_yield(param_2 + 0xe);
if (*(code **)(param_2 + 8) == (code *)0x0) {
uVar3 = 0;
}
else {
uVar3 = 0;
(**(code **)(param_2 + 8))(0,*(int8 *)(param_2 + 10));
}
}
LAB_00129f8d:
return uVar3 & 0xffffffff;
}
| |
24,889 | read_array | eloqsql/strings/json_lib.c | static int read_array(json_engine_t *j)
{
j->state= JST_ARRAY_START;
j->value_type= JSON_VALUE_ARRAY;
j->value= j->value_begin;
if (++j->stack_p < JSON_DEPTH_LIMIT)
{
j->stack[j->stack_p]= JST_ARRAY_CONT;
return 0;
}
j->s.error= JE_DEPTH;
return 1;
} | O0 | c | read_array:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x4, 0x34(%rax)
movq -0x10(%rbp), %rax
movl $0x2, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rcx
movl 0xe4(%rcx), %eax
addl $0x1, %eax
movl %eax, 0xe4(%rcx)
cmpl $0x20, %eax
jge 0x133d126
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0xe4(%rcx), %rcx
movl $0x8, 0x64(%rax,%rcx,4)
movl $0x0, -0x4(%rbp)
jmp 0x133d138
movq -0x10(%rbp), %rax
movl $0xfffffff9, 0x18(%rax) # imm = 0xFFFFFFF9
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
| read_array:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov dword ptr [rax+34h], 4
mov rax, [rbp+var_10]
mov dword ptr [rax+38h], 2
mov rax, [rbp+var_10]
mov rcx, [rax+48h]
mov rax, [rbp+var_10]
mov [rax+40h], rcx
mov rcx, [rbp+var_10]
mov eax, [rcx+0E4h]
add eax, 1
mov [rcx+0E4h], eax
cmp eax, 20h ; ' '
jge short loc_133D126
mov rax, [rbp+var_10]
mov rcx, [rbp+var_10]
movsxd rcx, dword ptr [rcx+0E4h]
mov dword ptr [rax+rcx*4+64h], 8
mov [rbp+var_4], 0
jmp short loc_133D138
loc_133D126:
mov rax, [rbp+var_10]
mov dword ptr [rax+18h], 0FFFFFFF9h
mov [rbp+var_4], 1
loc_133D138:
mov eax, [rbp+var_4]
pop rbp
retn
| long long read_array(long long a1)
{
int v1; // eax
*(_DWORD *)(a1 + 52) = 4;
*(_DWORD *)(a1 + 56) = 2;
*(_QWORD *)(a1 + 64) = *(_QWORD *)(a1 + 72);
v1 = *(_DWORD *)(a1 + 228) + 1;
*(_DWORD *)(a1 + 228) = v1;
if ( v1 >= 32 )
{
*(_DWORD *)(a1 + 24) = -7;
return 1;
}
else
{
*(_DWORD *)(a1 + 4LL * *(int *)(a1 + 228) + 100) = 8;
return 0;
}
}
| fts0tget_column:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x28],0x0
JZ 0x0133d0f5
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x28]
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX + 0x18]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0133d0fd
LAB_0133d0f5:
XOR EAX,EAX
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0133d0fd
LAB_0133d0fd:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,0x0
JNZ 0x0133d110
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0133d12a
LAB_0133d110:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x28]
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX + 0x18]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV EAX,dword ptr [RAX + 0x30]
MOV dword ptr [RBP + -0x4],EAX
LAB_0133d12a:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
/* fts0tget_column(void*) */
int4 fts0tget_column(void *param_1)
{
int8 local_28;
int4 local_c;
if (*(long *)((long)param_1 + 0x28) == 0) {
local_28 = 0;
}
else {
local_28 = *(long *)(*(long *)((long)param_1 + 0x28) + *(long *)((long)param_1 + 0x18) * 8);
}
if (local_28 == 0) {
local_c = 0;
}
else {
local_c = *(int4 *)
(*(long *)(*(long *)((long)param_1 + 0x28) + *(long *)((long)param_1 + 0x18) * 8) +
0x30);
}
return local_c;
}
| |
24,890 | Test_CleanImmediately_logging::Test_CleanImmediately_logging() | ng-log[P]ng-log/src/cleanup_immediately_unittest.cc | TEST(CleanImmediately, logging) {
using namespace std::chrono_literals;
nglog::SetLogFilenameExtension(".foobar");
nglog::EnableLogCleaner(0h);
for (unsigned i = 0; i < 1000; ++i) {
LOG(INFO) << "cleanup test";
}
nglog::DisableLogCleaner();
} | O2 | cpp | Test_CleanImmediately_logging::Test_CleanImmediately_logging():
pushq %rax
leaq 0x238(%rip), %rax # 0xa49a
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x277e9(%rip), %rdi # 0x31a58
callq 0xa4ce
popq %rax
retq
| _ZN29Test_CleanImmediately_loggingC2Ev:
push rax
lea rax, _ZN29Test_CleanImmediately_logging3RunEv; Test_CleanImmediately_logging::Run(void)
mov rsi, rsp
mov [rsi], rax
lea rdi, _ZN5nglog10g_testlistE; nglog::g_testlist
call _ZNSt6vectorIPFvvESaIS1_EE12emplace_backIJS1_EEERS1_DpOT_; std::vector<void (*)(void)>::emplace_back<void (*)(void)>(void (*)(void) &&)
pop rax
retn
| void Test_CleanImmediately_logging::Test_CleanImmediately_logging(Test_CleanImmediately_logging *this)
{
std::vector<void (*)(void)>::emplace_back<void (*)(void)>(&nglog::g_testlist);
}
| Test_CleanImmediately_logging:
PUSH RAX
LEA RAX,[0x10a49a]
MOV RSI,RSP
MOV qword ptr [RSI],RAX
LEA RDI,[0x131a58]
CALL 0x0010a4ce
POP RAX
RET
|
/* Test_CleanImmediately_logging::Test_CleanImmediately_logging() */
code * __thiscall
Test_CleanImmediately_logging::Test_CleanImmediately_logging(Test_CleanImmediately_logging *this)
{
___std__vector<void(*)(),std::allocator<void(*)()>>__emplace_back<void(*)()>_void_________();
return Run;
}
| |
24,891 | thr_print_locks | eloqsql/mysys/thr_lock.c | void thr_print_locks(void)
{
LIST *list;
uint count=0;
mysql_mutex_lock(&THR_LOCK_lock);
puts("Current active THR (table level locks):");
for (list= thr_lock_thread_list; list && count++ < MAX_THREADS;
list= list_rest(list))
{
THR_LOCK *lock=(THR_LOCK*) list->data;
mysql_mutex_lock(&lock->mutex);
if ((lock->write.data || lock->read.data ||
lock->write_wait.data || lock->read_wait.data))
{
printf("lock: %p:", lock);
if ((lock->write_wait.data || lock->read_wait.data) &&
(! lock->read.data && ! lock->write.data))
printf(" WARNING: ");
if (lock->write.data)
printf(" write");
if (lock->write_wait.data)
printf(" write_wait");
if (lock->read.data)
printf(" read");
if (lock->read_wait.data)
printf(" read_wait");
puts("");
thr_print_lock("write",&lock->write);
thr_print_lock("write_wait",&lock->write_wait);
thr_print_lock("read",&lock->read);
thr_print_lock("read_wait",&lock->read_wait);
puts("");
}
mysql_mutex_unlock(&lock->mutex);
}
fflush(stdout);
mysql_mutex_unlock(&THR_LOCK_lock);
} | O3 | c | thr_print_locks:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x3543d9(%rip), %rax # 0x3b8cf8
cmpq $0x0, 0x40(%rax)
jne 0x64b5c
leaq 0x3543c7(%rip), %rdi # 0x3b8cf8
callq 0x285e0
leaq 0x36c6e(%rip), %rdi # 0x9b5ab
callq 0x28690
leaq 0x35465f(%rip), %rax # 0x3b8fa8
movq (%rax), %r15
testq %r15, %r15
je 0x64b23
movl $0x3e9, %ebx # imm = 0x3E9
decl %ebx
je 0x64b23
movq 0x10(%r15), %r14
leaq 0x18(%r14), %r12
cmpq $0x0, 0x58(%r14)
jne 0x64af8
movq %r12, %rdi
callq 0x285e0
cmpq $0x0, 0x90(%r14)
jne 0x649a3
cmpq $0x0, 0x70(%r14)
jne 0x649a3
cmpq $0x0, 0x80(%r14)
jne 0x649a3
cmpq $0x0, 0x60(%r14)
je 0x64ac0
movq %r15, -0x38(%rbp)
leaq 0x90(%r14), %r15
movl $0x1, %edi
leaq 0x36c19(%rip), %rsi # 0x9b5d3
movq %r14, %rdx
xorl %eax, %eax
callq 0x28030
cmpq $0x0, 0x80(%r14)
jne 0x649d5
cmpq $0x0, 0x60(%r14)
je 0x649dc
cmpq $0x0, 0x70(%r14)
je 0x649e4
cmpq $0x0, (%r15)
jne 0x649ee
jmp 0x64a01
cmpq $0x0, (%r15)
je 0x64ae0
movl $0x1, %edi
leaq 0x36bee(%rip), %rsi # 0x9b5e8
xorl %eax, %eax
callq 0x28030
movq %r12, -0x40(%rbp)
leaq 0x80(%r14), %r12
cmpq $0x0, (%r12)
je 0x64a26
movl $0x1, %edi
leaq 0x36bd0(%rip), %rsi # 0x9b5ef
xorl %eax, %eax
callq 0x28030
cmpq $0x0, 0x70(%r14)
je 0x64a40
movl $0x1, %edi
leaq 0x3a9b9(%rip), %rsi # 0x9f3f2
xorl %eax, %eax
callq 0x28030
movl %ebx, -0x2c(%rbp)
cmpq $0x0, 0x60(%r14)
je 0x64a5d
movl $0x1, %edi
leaq 0x36ba5(%rip), %rsi # 0x9b5fb
xorl %eax, %eax
callq 0x28030
leaq 0x70(%r14), %r13
leaq 0x60(%r14), %rbx
movl $0xa, %edi
callq 0x28590
leaq 0x36b73(%rip), %rdi # 0x9b5e9
movq %r15, %rsi
callq 0x64b78
leaq 0x36b6b(%rip), %rdi # 0x9b5f0
movq %r12, %rsi
callq 0x64b78
leaq 0x3a95f(%rip), %rdi # 0x9f3f3
movq %r13, %rsi
callq 0x64b78
leaq 0x36b59(%rip), %rdi # 0x9b5fc
movq %rbx, %rsi
callq 0x64b78
movl $0xa, %edi
callq 0x28590
movl -0x2c(%rbp), %ebx
movq -0x40(%rbp), %r12
movq -0x38(%rbp), %r15
movq 0x58(%r14), %rdi
testq %rdi, %rdi
jne 0x64b11
movq %r12, %rdi
callq 0x282b0
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x6495a
jmp 0x64b23
movl $0x1, %edi
leaq 0x36af1(%rip), %rsi # 0x9b5dd
xorl %eax, %eax
callq 0x28030
jmp 0x649dc
movq %r12, %rdi
leaq 0x36a6f(%rip), %rsi # 0x9b571
movl $0x621, %edx # imm = 0x621
callq 0x2a970
jmp 0x6497d
leaq 0x2d4960(%rip), %rax # 0x339478
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x64ac9
movq 0x2d2466(%rip), %rax # 0x336f90
movq (%rax), %rdi
callq 0x284c0
leaq 0x3541bf(%rip), %rax # 0x3b8cf8
movq 0x40(%rax), %rdi
testq %rdi, %rdi
jne 0x64b66
leaq 0x3541af(%rip), %rdi # 0x3b8cf8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x282b0
callq 0x2afe9
jmp 0x64936
leaq 0x2d490b(%rip), %rax # 0x339478
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x64b42
| thr_print_locks:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
lea rax, THR_LOCK_lock
cmp qword ptr [rax+40h], 0
jnz loc_64B5C
lea rdi, THR_LOCK_lock
call _pthread_mutex_lock
loc_64936:
lea rdi, aCurrentActiveT; "Current active THR (table level locks):"
call _puts
lea rax, thr_lock_thread_list
mov r15, [rax]
test r15, r15
jz loc_64B23
mov ebx, 3E9h
loc_6495A:
dec ebx
jz loc_64B23
mov r14, [r15+10h]
lea r12, [r14+18h]
cmp qword ptr [r14+58h], 0
jnz loc_64AF8
mov rdi, r12
call _pthread_mutex_lock
loc_6497D:
cmp qword ptr [r14+90h], 0
jnz short loc_649A3
cmp qword ptr [r14+70h], 0
jnz short loc_649A3
cmp qword ptr [r14+80h], 0
jnz short loc_649A3
cmp qword ptr [r14+60h], 0
jz loc_64AC0
loc_649A3:
mov [rbp+var_38], r15
lea r15, [r14+90h]
mov edi, 1
lea rsi, aLockP; "lock: %p:"
mov rdx, r14
xor eax, eax
call ___printf_chk
cmp qword ptr [r14+80h], 0
jnz short loc_649D5
cmp qword ptr [r14+60h], 0
jz short loc_649DC
loc_649D5:
cmp qword ptr [r14+70h], 0
jz short loc_649E4
loc_649DC:
cmp qword ptr [r15], 0
jnz short loc_649EE
jmp short loc_64A01
loc_649E4:
cmp qword ptr [r15], 0
jz loc_64AE0
loc_649EE:
mov edi, 1
lea rsi, aWrite; " write"
xor eax, eax
call ___printf_chk
loc_64A01:
mov [rbp+var_40], r12
lea r12, [r14+80h]
cmp qword ptr [r12], 0
jz short loc_64A26
mov edi, 1
lea rsi, aWriteWait; " write_wait"
xor eax, eax
call ___printf_chk
loc_64A26:
cmp qword ptr [r14+70h], 0
jz short loc_64A40
mov edi, 1
lea rsi, aTheEventWasCor+34h; " read"
xor eax, eax
call ___printf_chk
loc_64A40:
mov [rbp+var_2C], ebx
cmp qword ptr [r14+60h], 0
jz short loc_64A5D
mov edi, 1
lea rsi, aReadWait; " read_wait"
xor eax, eax
call ___printf_chk
loc_64A5D:
lea r13, [r14+70h]
lea rbx, [r14+60h]
mov edi, 0Ah
call _putchar
lea rdi, aWrite+1; "write"
mov rsi, r15
call thr_print_lock
lea rdi, aWriteWait+1; "write_wait"
mov rsi, r12
call thr_print_lock
lea rdi, aTheEventWasCor+35h; "read"
mov rsi, r13
call thr_print_lock
lea rdi, aReadWait+1; "read_wait"
mov rsi, rbx
call thr_print_lock
mov edi, 0Ah
call _putchar
mov ebx, [rbp+var_2C]
mov r12, [rbp+var_40]
mov r15, [rbp+var_38]
loc_64AC0:
mov rdi, [r14+58h]
test rdi, rdi
jnz short loc_64B11
loc_64AC9:
mov rdi, r12
call _pthread_mutex_unlock
mov r15, [r15+8]
test r15, r15
jnz loc_6495A
jmp short loc_64B23
loc_64AE0:
mov edi, 1
lea rsi, aWarning_1; " WARNING: "
xor eax, eax
call ___printf_chk
jmp loc_649DC
loc_64AF8:
mov rdi, r12
lea rsi, aWorkspaceLlm4b_12; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 621h
call psi_mutex_lock
jmp loc_6497D
loc_64B11:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_64AC9
loc_64B23:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
lea rax, THR_LOCK_lock
mov rdi, [rax+40h]
test rdi, rdi
jnz short loc_64B66
loc_64B42:
lea rdi, THR_LOCK_lock
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _pthread_mutex_unlock
loc_64B5C:
call thr_print_locks_cold_1
jmp loc_64936
loc_64B66:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_64B42
| long long thr_print_locks()
{
long long *v0; // r15
int v1; // ebx
_QWORD *v2; // r14
_QWORD *v3; // r12
_QWORD *v4; // r15
long long *v6; // [rsp+8h] [rbp-38h]
if ( THR_LOCK_lock[8] )
thr_print_locks_cold_1();
else
pthread_mutex_lock(THR_LOCK_lock);
puts("Current active THR (table level locks):");
v0 = thr_lock_thread_list;
if ( thr_lock_thread_list )
{
v1 = 1001;
while ( 1 )
{
if ( !--v1 )
goto LABEL_32;
v2 = (_QWORD *)v0[2];
v3 = v2 + 3;
if ( v2[11] )
psi_mutex_lock((long long)(v2 + 3), (long long)"/workspace/llm4binary/github2025/eloqsql/mysys/thr_lock.c", 0x621u);
else
pthread_mutex_lock(v2 + 3);
if ( v2[18] || v2[14] || v2[16] || v2[12] )
break;
LABEL_26:
if ( v2[11] )
(*((void (**)(void))PSI_server + 44))();
pthread_mutex_unlock(v3);
v0 = (long long *)v0[1];
if ( !v0 )
goto LABEL_32;
}
v6 = v0;
v4 = v2 + 18;
__printf_chk(1LL, "lock: %p:", v2);
if ( (v2[16] || v2[12]) && !v2[14] )
{
if ( *v4 )
{
LABEL_18:
__printf_chk(1LL, " write");
LABEL_19:
if ( v2[16] )
__printf_chk(1LL, " write_wait");
if ( v2[14] )
__printf_chk(1LL, " read");
if ( v2[12] )
__printf_chk(1LL, " read_wait");
putchar(10LL);
thr_print_lock("write", v2 + 18);
thr_print_lock("write_wait", v2 + 16);
thr_print_lock("read", v2 + 14);
thr_print_lock("read_wait", v2 + 12);
putchar(10LL);
v3 = v2 + 3;
v0 = v6;
goto LABEL_26;
}
__printf_chk(1LL, " WARNING: ");
}
if ( !*v4 )
goto LABEL_19;
goto LABEL_18;
}
LABEL_32:
fflush(stdout);
if ( THR_LOCK_lock[8] )
(*((void (**)(void))PSI_server + 44))();
return pthread_mutex_unlock(THR_LOCK_lock);
}
| thr_print_locks:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
LEA RAX,[0x4b8cf8]
CMP qword ptr [RAX + 0x40],0x0
JNZ 0x00164b5c
LEA RDI,[0x4b8cf8]
CALL 0x001285e0
LAB_00164936:
LEA RDI,[0x19b5ab]
CALL 0x00128690
LEA RAX,[0x4b8fa8]
MOV R15,qword ptr [RAX]
TEST R15,R15
JZ 0x00164b23
MOV EBX,0x3e9
LAB_0016495a:
DEC EBX
JZ 0x00164b23
MOV R14,qword ptr [R15 + 0x10]
LEA R12,[R14 + 0x18]
CMP qword ptr [R14 + 0x58],0x0
JNZ 0x00164af8
MOV RDI,R12
CALL 0x001285e0
LAB_0016497d:
CMP qword ptr [R14 + 0x90],0x0
JNZ 0x001649a3
CMP qword ptr [R14 + 0x70],0x0
JNZ 0x001649a3
CMP qword ptr [R14 + 0x80],0x0
JNZ 0x001649a3
CMP qword ptr [R14 + 0x60],0x0
JZ 0x00164ac0
LAB_001649a3:
MOV qword ptr [RBP + -0x38],R15
LEA R15,[R14 + 0x90]
MOV EDI,0x1
LEA RSI,[0x19b5d3]
MOV RDX,R14
XOR EAX,EAX
CALL 0x00128030
CMP qword ptr [R14 + 0x80],0x0
JNZ 0x001649d5
CMP qword ptr [R14 + 0x60],0x0
JZ 0x001649dc
LAB_001649d5:
CMP qword ptr [R14 + 0x70],0x0
JZ 0x001649e4
LAB_001649dc:
CMP qword ptr [R15],0x0
JNZ 0x001649ee
JMP 0x00164a01
LAB_001649e4:
CMP qword ptr [R15],0x0
JZ 0x00164ae0
LAB_001649ee:
MOV EDI,0x1
LEA RSI,[0x19b5e8]
XOR EAX,EAX
CALL 0x00128030
LAB_00164a01:
MOV qword ptr [RBP + -0x40],R12
LEA R12,[R14 + 0x80]
CMP qword ptr [R12],0x0
JZ 0x00164a26
MOV EDI,0x1
LEA RSI,[0x19b5ef]
XOR EAX,EAX
CALL 0x00128030
LAB_00164a26:
CMP qword ptr [R14 + 0x70],0x0
JZ 0x00164a40
MOV EDI,0x1
LEA RSI,[0x19f3f2]
XOR EAX,EAX
CALL 0x00128030
LAB_00164a40:
MOV dword ptr [RBP + -0x2c],EBX
CMP qword ptr [R14 + 0x60],0x0
JZ 0x00164a5d
MOV EDI,0x1
LEA RSI,[0x19b5fb]
XOR EAX,EAX
CALL 0x00128030
LAB_00164a5d:
LEA R13,[R14 + 0x70]
LEA RBX,[R14 + 0x60]
MOV EDI,0xa
CALL 0x00128590
LEA RDI,[0x19b5e9]
MOV RSI,R15
CALL 0x00164b78
LEA RDI,[0x19b5f0]
MOV RSI,R12
CALL 0x00164b78
LEA RDI,[0x19f3f3]
MOV RSI,R13
CALL 0x00164b78
LEA RDI,[0x19b5fc]
MOV RSI,RBX
CALL 0x00164b78
MOV EDI,0xa
CALL 0x00128590
MOV EBX,dword ptr [RBP + -0x2c]
MOV R12,qword ptr [RBP + -0x40]
MOV R15,qword ptr [RBP + -0x38]
LAB_00164ac0:
MOV RDI,qword ptr [R14 + 0x58]
TEST RDI,RDI
JNZ 0x00164b11
LAB_00164ac9:
MOV RDI,R12
CALL 0x001282b0
MOV R15,qword ptr [R15 + 0x8]
TEST R15,R15
JNZ 0x0016495a
JMP 0x00164b23
LAB_00164ae0:
MOV EDI,0x1
LEA RSI,[0x19b5dd]
XOR EAX,EAX
CALL 0x00128030
JMP 0x001649dc
LAB_00164af8:
MOV RDI,R12
LEA RSI,[0x19b571]
MOV EDX,0x621
CALL 0x0012a970
JMP 0x0016497d
LAB_00164b11:
LEA RAX,[0x439478]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00164ac9
LAB_00164b23:
MOV RAX,qword ptr [0x00436f90]
MOV RDI,qword ptr [RAX]
CALL 0x001284c0
LEA RAX,[0x4b8cf8]
MOV RDI,qword ptr [RAX + 0x40]
TEST RDI,RDI
JNZ 0x00164b66
LAB_00164b42:
LEA RDI,[0x4b8cf8]
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001282b0
LAB_00164b5c:
CALL 0x0012afe9
JMP 0x00164936
LAB_00164b66:
LEA RAX,[0x439478]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00164b42
|
void thr_print_locks(void)
{
pthread_mutex_t *__mutex;
long *plVar1;
long lVar2;
int iVar3;
long lVar4;
if (THR_LOCK_lock._64_8_ == 0) {
pthread_mutex_lock((pthread_mutex_t *)THR_LOCK_lock);
}
else {
thr_print_locks_cold_1();
}
puts("Current active THR (table level locks):");
if (thr_lock_thread_list != 0) {
iVar3 = 0x3e9;
lVar4 = thr_lock_thread_list;
do {
iVar3 = iVar3 + -1;
if (iVar3 == 0) break;
lVar2 = *(long *)(lVar4 + 0x10);
__mutex = (pthread_mutex_t *)(lVar2 + 0x18);
if (*(long *)(lVar2 + 0x58) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/mysys/thr_lock.c",0x621);
}
if ((((*(long *)(lVar2 + 0x90) != 0) || (*(long *)(lVar2 + 0x70) != 0)) ||
(*(long *)(lVar2 + 0x80) != 0)) || (*(long *)(lVar2 + 0x60) != 0)) {
plVar1 = (long *)(lVar2 + 0x90);
__printf_chk(1,"lock: %p:",lVar2);
if (((*(long *)(lVar2 + 0x80) == 0) && (*(long *)(lVar2 + 0x60) == 0)) ||
(*(long *)(lVar2 + 0x70) != 0)) {
LAB_001649dc:
if (*plVar1 != 0) goto LAB_001649ee;
}
else {
if (*plVar1 == 0) {
__printf_chk(1," WARNING: ");
goto LAB_001649dc;
}
LAB_001649ee:
__printf_chk(1," write");
}
if (*(long *)(lVar2 + 0x80) != 0) {
__printf_chk(1," write_wait");
}
if (*(long *)(lVar2 + 0x70) != 0) {
__printf_chk(1," read");
}
if (*(long *)(lVar2 + 0x60) != 0) {
__printf_chk(1," read_wait");
}
putchar(10);
thr_print_lock("write",plVar1);
thr_print_lock("write_wait",(long *)(lVar2 + 0x80));
thr_print_lock("read",lVar2 + 0x70);
thr_print_lock("read_wait",lVar2 + 0x60);
putchar(10);
}
if (*(long *)(lVar2 + 0x58) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
lVar4 = *(long *)(lVar4 + 8);
} while (lVar4 != 0);
}
fflush(*(FILE **)PTR_stdout_00436f90);
if (THR_LOCK_lock._64_8_ != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)THR_LOCK_lock);
return;
}
| |
24,892 | alloc_dynamic | eloqsql/mysys/array.c | void *alloc_dynamic(DYNAMIC_ARRAY *array)
{
DBUG_ENTER("alloc_dynamic");
DBUG_ASSERT(array->size_of_element); /* Ensure init() is called */
if (array->elements == array->max_element)
{
char *new_ptr;
if (array->malloc_flags & MY_INIT_BUFFER_USED)
{
/*
In this scenario, the buffer is statically preallocated,
so we have to create an all-new malloc since we overflowed
*/
if (!(new_ptr= (char *) my_malloc(array->m_psi_key,
(array->max_element+
array->alloc_increment) *
array->size_of_element,
MYF(array->malloc_flags | MY_WME))))
DBUG_RETURN(0);
if (array->elements)
memcpy(new_ptr, array->buffer,
array->elements * array->size_of_element);
array->malloc_flags&= ~MY_INIT_BUFFER_USED;
}
else if (!(new_ptr=(char*)
my_realloc(array->m_psi_key, array->buffer,
(array->max_element+ array->alloc_increment) *
array->size_of_element,
MYF(MY_WME | MY_ALLOW_ZERO_PTR |
array->malloc_flags))))
DBUG_RETURN(0);
array->buffer= (uchar*) new_ptr;
array->max_element+=array->alloc_increment;
}
DBUG_RETURN(array->buffer+(array->elements++ * array->size_of_element));
} | O3 | c | alloc_dynamic:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl 0xc(%rdi), %eax
jne 0x91c2f
movq 0x20(%rbx), %rcx
btl $0x8, %ecx
movl 0x18(%rbx), %edi
jb 0x91c34
addl 0x10(%rbx), %eax
movq (%rbx), %rsi
imull 0x14(%rbx), %eax
orq $0x50, %rcx
movq %rax, %rdx
callq 0x9feac
movq %rax, %r14
testq %rax, %rax
jne 0x91c71
jmp 0x91c8f
movq (%rbx), %r14
jmp 0x91c7d
addl 0x10(%rbx), %eax
imull 0x14(%rbx), %eax
orq $0x10, %rcx
movq %rax, %rsi
movq %rcx, %rdx
callq 0x9fd89
testq %rax, %rax
je 0x91c8f
movq %rax, %r14
movl 0x8(%rbx), %edx
testl %edx, %edx
je 0x91c68
movq (%rbx), %rsi
imull 0x14(%rbx), %edx
movq %r14, %rdi
callq 0x29080
movl $0xfffffeff, %eax # imm = 0xFFFFFEFF
andq %rax, 0x20(%rbx)
movq %r14, (%rbx)
movl 0x8(%rbx), %eax
movl 0x10(%rbx), %ecx
addl %ecx, 0xc(%rbx)
leal 0x1(%rax), %ecx
movl %ecx, 0x8(%rbx)
imull 0x14(%rbx), %eax
addq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
jmp 0x91c8a
| alloc_dynamic:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
mov eax, [rdi+8]
cmp eax, [rdi+0Ch]
jnz short loc_91C2F
mov rcx, [rbx+20h]
bt ecx, 8
mov edi, [rbx+18h]
jb short loc_91C34
add eax, [rbx+10h]
mov rsi, [rbx]
imul eax, [rbx+14h]
or rcx, 50h
mov rdx, rax
call my_realloc
mov r14, rax
test rax, rax
jnz short loc_91C71
jmp short loc_91C8F
loc_91C2F:
mov r14, [rbx]
jmp short loc_91C7D
loc_91C34:
add eax, [rbx+10h]
imul eax, [rbx+14h]
or rcx, 10h
mov rsi, rax
mov rdx, rcx
call my_malloc
test rax, rax
jz short loc_91C8F
mov r14, rax
mov edx, [rbx+8]
test edx, edx
jz short loc_91C68
mov rsi, [rbx]
imul edx, [rbx+14h]
mov rdi, r14
call _memcpy
loc_91C68:
mov eax, 0FFFFFEFFh
and [rbx+20h], rax
loc_91C71:
mov [rbx], r14
mov eax, [rbx+8]
mov ecx, [rbx+10h]
add [rbx+0Ch], ecx
loc_91C7D:
lea ecx, [rax+1]
mov [rbx+8], ecx
imul eax, [rbx+14h]
add rax, r14
loc_91C8A:
pop rbx
pop r14
pop rbp
retn
loc_91C8F:
xor eax, eax
jmp short loc_91C8A
| long long alloc_dynamic(long long *a1, long long a2, long long a3, long long a4, long long a5, long long a6)
{
int v7; // eax
long long v8; // rcx
long long v9; // rdi
long long v10; // r14
long long v11; // rax
int v12; // edx
v7 = *((_DWORD *)a1 + 2);
if ( v7 != *((_DWORD *)a1 + 3) )
{
v10 = *a1;
LABEL_11:
*((_DWORD *)a1 + 2) = v7 + 1;
return v10 + (unsigned int)(*((_DWORD *)a1 + 5) * v7);
}
v8 = a1[4];
v9 = *((unsigned int *)a1 + 6);
if ( (v8 & 0x100) == 0 )
{
v10 = my_realloc(v9, *a1, (unsigned int)(*((_DWORD *)a1 + 5) * (*((_DWORD *)a1 + 4) + v7)), v8 | 0x50, a5, a6);
if ( !v10 )
return 0LL;
goto LABEL_10;
}
v11 = my_malloc(v9, (unsigned int)(*((_DWORD *)a1 + 5) * (*((_DWORD *)a1 + 4) + v7)), v8 | 0x10);
if ( v11 )
{
v10 = v11;
v12 = *((_DWORD *)a1 + 2);
if ( v12 )
memcpy(v11, *a1, (unsigned int)(*((_DWORD *)a1 + 5) * v12));
a1[4] &= 0xFFFFFEFFuLL;
LABEL_10:
*a1 = v10;
v7 = *((_DWORD *)a1 + 2);
*((_DWORD *)a1 + 3) += *((_DWORD *)a1 + 4);
goto LABEL_11;
}
return 0LL;
}
| alloc_dynamic:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV EAX,dword ptr [RDI + 0x8]
CMP EAX,dword ptr [RDI + 0xc]
JNZ 0x00191c2f
MOV RCX,qword ptr [RBX + 0x20]
BT ECX,0x8
MOV EDI,dword ptr [RBX + 0x18]
JC 0x00191c34
ADD EAX,dword ptr [RBX + 0x10]
MOV RSI,qword ptr [RBX]
IMUL EAX,dword ptr [RBX + 0x14]
OR RCX,0x50
MOV RDX,RAX
CALL 0x0019feac
MOV R14,RAX
TEST RAX,RAX
JNZ 0x00191c71
JMP 0x00191c8f
LAB_00191c2f:
MOV R14,qword ptr [RBX]
JMP 0x00191c7d
LAB_00191c34:
ADD EAX,dword ptr [RBX + 0x10]
IMUL EAX,dword ptr [RBX + 0x14]
OR RCX,0x10
MOV RSI,RAX
MOV RDX,RCX
CALL 0x0019fd89
TEST RAX,RAX
JZ 0x00191c8f
MOV R14,RAX
MOV EDX,dword ptr [RBX + 0x8]
TEST EDX,EDX
JZ 0x00191c68
MOV RSI,qword ptr [RBX]
IMUL EDX,dword ptr [RBX + 0x14]
MOV RDI,R14
CALL 0x00129080
LAB_00191c68:
MOV EAX,0xfffffeff
AND qword ptr [RBX + 0x20],RAX
LAB_00191c71:
MOV qword ptr [RBX],R14
MOV EAX,dword ptr [RBX + 0x8]
MOV ECX,dword ptr [RBX + 0x10]
ADD dword ptr [RBX + 0xc],ECX
LAB_00191c7d:
LEA ECX,[RAX + 0x1]
MOV dword ptr [RBX + 0x8],ECX
IMUL EAX,dword ptr [RBX + 0x14]
ADD RAX,R14
LAB_00191c8a:
POP RBX
POP R14
POP RBP
RET
LAB_00191c8f:
XOR EAX,EAX
JMP 0x00191c8a
|
long alloc_dynamic(long *param_1)
{
ulong uVar1;
int iVar2;
void *__dest;
long lVar3;
iVar2 = (int)param_1[1];
if (iVar2 == *(int *)((long)param_1 + 0xc)) {
uVar1 = param_1[4];
if (((uint)uVar1 >> 8 & 1) == 0) {
__dest = (void *)my_realloc((int)param_1[3],*param_1,
(iVar2 + (int)param_1[2]) * *(int *)((long)param_1 + 0x14),
uVar1 | 0x50);
if (__dest != (void *)0x0) {
LAB_00191c71:
*param_1 = (long)__dest;
iVar2 = (int)param_1[1];
*(int *)((long)param_1 + 0xc) = *(int *)((long)param_1 + 0xc) + (int)param_1[2];
goto LAB_00191c7d;
}
}
else {
__dest = (void *)my_malloc((int)param_1[3],
(iVar2 + (int)param_1[2]) * *(int *)((long)param_1 + 0x14),
uVar1 | 0x10);
if (__dest != (void *)0x0) {
if ((int)param_1[1] != 0) {
memcpy(__dest,(void *)*param_1,
(ulong)(uint)((int)param_1[1] * *(int *)((long)param_1 + 0x14)));
}
param_1[4] = param_1[4] & 0xfffffeff;
goto LAB_00191c71;
}
}
lVar3 = 0;
}
else {
__dest = (void *)*param_1;
LAB_00191c7d:
*(int *)(param_1 + 1) = iVar2 + 1;
lVar3 = (ulong)(uint)(iVar2 * *(int *)((long)param_1 + 0x14)) + (long)__dest;
}
return lVar3;
}
| |
24,893 | my_utf8mb3_uni_no_range | eloqsql/strings/ctype-utf8.c | static int my_utf8mb3_uni_no_range(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t * pwc, const uchar *s)
{
uchar c;
c= s[0];
if (c < 0x80)
{
*pwc = c;
return 1;
}
if (c < 0xc2)
return MY_CS_ILSEQ;
if (c < 0xe0)
{
if (!((s[1] ^ 0x80) < 0x40))
return MY_CS_ILSEQ;
*pwc= UTF8MB2_CODE(c, s[1]);
return 2;
}
if (c < 0xf0)
{
if (!IS_UTF8MB3_STEP2(c, s[1], s[2]))
return MY_CS_ILSEQ;
*pwc= UTF8MB3_CODE(c, s[1], s[2]);
return 3;
}
return MY_CS_ILSEQ;
} | O0 | c | my_utf8mb3_uni_no_range:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0x80, %eax
jge 0x6e91d
movzbl -0x21(%rbp), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x6ea33
movzbl -0x21(%rbp), %eax
cmpl $0xc2, %eax
jge 0x6e934
movl $0x0, -0x4(%rbp)
jmp 0x6ea33
movzbl -0x21(%rbp), %eax
cmpl $0xe0, %eax
jge 0x6e990
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jl 0x6e95d
movl $0x0, -0x4(%rbp)
jmp 0x6ea33
movzbl -0x21(%rbp), %eax
andl $0x1f, %eax
movslq %eax, %rcx
shlq $0x6, %rcx
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cltq
orq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0x6ea33
movzbl -0x21(%rbp), %eax
cmpl $0xf0, %eax
jge 0x6ea2c
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x6e9dd
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x6e9dd
movzbl -0x21(%rbp), %eax
cmpl $0xe1, %eax
jge 0x6e9e6
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xa0, %eax
jge 0x6e9e6
movl $0x0, -0x4(%rbp)
jmp 0x6ea33
movzbl -0x21(%rbp), %eax
andl $0xf, %eax
movslq %eax, %rcx
shlq $0xc, %rcx
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cltq
shlq $0x6, %rax
orq %rax, %rcx
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %eax
xorl $0x80, %eax
cltq
orq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x3, -0x4(%rbp)
jmp 0x6ea33
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
| my_utf8mb3_uni_no_range:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_20]
mov al, [rax]
mov [rbp+var_21], al
movzx eax, [rbp+var_21]
cmp eax, 80h
jge short loc_6E91D
movzx eax, [rbp+var_21]
mov ecx, eax
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_4], 1
jmp loc_6EA33
loc_6E91D:
movzx eax, [rbp+var_21]
cmp eax, 0C2h
jge short loc_6E934
mov [rbp+var_4], 0
jmp loc_6EA33
loc_6E934:
movzx eax, [rbp+var_21]
cmp eax, 0E0h
jge short loc_6E990
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cmp eax, 40h ; '@'
jl short loc_6E95D
mov [rbp+var_4], 0
jmp loc_6EA33
loc_6E95D:
movzx eax, [rbp+var_21]
and eax, 1Fh
movsxd rcx, eax
shl rcx, 6
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cdqe
or rcx, rax
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_4], 2
jmp loc_6EA33
loc_6E990:
movzx eax, [rbp+var_21]
cmp eax, 0F0h
jge loc_6EA2C
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_6E9DD
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+2]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_6E9DD
movzx eax, [rbp+var_21]
cmp eax, 0E1h
jge short loc_6E9E6
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
cmp eax, 0A0h
jge short loc_6E9E6
loc_6E9DD:
mov [rbp+var_4], 0
jmp short loc_6EA33
loc_6E9E6:
movzx eax, [rbp+var_21]
and eax, 0Fh
movsxd rcx, eax
shl rcx, 0Ch
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cdqe
shl rax, 6
or rcx, rax
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+2]
xor eax, 80h
cdqe
or rcx, rax
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_4], 3
jmp short loc_6EA33
loc_6EA2C:
mov [rbp+var_4], 0
loc_6EA33:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_utf8mb3_uni_no_range(long long a1, unsigned long long *a2, unsigned __int8 *a3)
{
unsigned __int8 v4; // [rsp+1h] [rbp-21h]
v4 = *a3;
if ( *a3 >= 0x80u )
{
if ( v4 >= 0xC2u )
{
if ( v4 >= 0xE0u )
{
if ( v4 >= 0xF0u )
{
return 0;
}
else if ( (a3[1] ^ 0x80) < 64 && (a3[2] ^ 0x80) < 64 && (v4 >= 0xE1u || a3[1] >= 0xA0u) )
{
*a2 = a3[2] ^ 0x80u | ((long long)(a3[1] ^ 0x80u) << 6) | ((unsigned long long)(v4 & 0xF) << 12);
return 3;
}
else
{
return 0;
}
}
else if ( (a3[1] ^ 0x80) < 64 )
{
*a2 = a3[1] ^ 0x80u | ((unsigned long long)(v4 & 0x1F) << 6);
return 2;
}
else
{
return 0;
}
}
else
{
return 0;
}
}
else
{
*a2 = v4;
return 1;
}
}
| my_utf8mb3_uni_no_range:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x20]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x21],AL
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0x80
JGE 0x0016e91d
MOVZX EAX,byte ptr [RBP + -0x21]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0016ea33
LAB_0016e91d:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xc2
JGE 0x0016e934
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0016ea33
LAB_0016e934:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xe0
JGE 0x0016e990
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CMP EAX,0x40
JL 0x0016e95d
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0016ea33
LAB_0016e95d:
MOVZX EAX,byte ptr [RBP + -0x21]
AND EAX,0x1f
MOVSXD RCX,EAX
SHL RCX,0x6
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CDQE
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x2
JMP 0x0016ea33
LAB_0016e990:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xf0
JGE 0x0016ea2c
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x0016e9dd
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x2]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x0016e9dd
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xe1
JGE 0x0016e9e6
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0xa0
JGE 0x0016e9e6
LAB_0016e9dd:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0016ea33
LAB_0016e9e6:
MOVZX EAX,byte ptr [RBP + -0x21]
AND EAX,0xf
MOVSXD RCX,EAX
SHL RCX,0xc
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CDQE
SHL RAX,0x6
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x2]
XOR EAX,0x80
CDQE
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x3
JMP 0x0016ea33
LAB_0016ea2c:
MOV dword ptr [RBP + -0x4],0x0
LAB_0016ea33:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_utf8mb3_uni_no_range(int8 param_1,ulong *param_2,byte *param_3)
{
byte bVar1;
int4 local_c;
bVar1 = *param_3;
if (bVar1 < 0x80) {
*param_2 = (ulong)bVar1;
local_c = 1;
}
else if (bVar1 < 0xc2) {
local_c = 0;
}
else if (bVar1 < 0xe0) {
if ((param_3[1] ^ 0x80) < 0x40) {
*param_2 = (long)(int)(bVar1 & 0x1f) << 6 | (long)(int)(param_3[1] ^ 0x80);
local_c = 2;
}
else {
local_c = 0;
}
}
else if (bVar1 < 0xf0) {
if ((((param_3[1] ^ 0x80) < 0x40) && ((param_3[2] ^ 0x80) < 0x40)) &&
((0xe0 < bVar1 || (0x9f < param_3[1])))) {
*param_2 = (long)(int)(bVar1 & 0xf) << 0xc | (long)(int)(param_3[1] ^ 0x80) << 6 |
(long)(int)(param_3[2] ^ 0x80);
local_c = 3;
}
else {
local_c = 0;
}
}
else {
local_c = 0;
}
return local_c;
}
| |
24,894 | strxnmov | eloqsql/strings/strxnmov.c | char *strxnmov(char *dst, size_t len, const char *src, ...)
{
va_list pvar;
char *end_of_dst=dst+len;
va_start(pvar,src);
while (src != NullS)
{
do
{
if (dst == end_of_dst)
goto end;
}
while ((*dst++ = *src++));
dst--;
src = va_arg(pvar, char *);
}
end:
*dst=0;
va_end(pvar);
return dst;
} | O3 | c | strxnmov:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %eax, %r10d
movq %rdi, %rax
leaq -0xd0(%rbp), %rdi
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %r10b, %r10b
je 0xda12c
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movabsq $0x3000000018, %rcx # imm = 0x3000000018
movq %rcx, -0x20(%rbp)
testq %rdx, %rdx
je 0xda1a5
addq %rax, %rsi
movq -0x10(%rbp), %rcx
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %r8
movq %r8, %r9
cmpq %rsi, %rax
je 0xda1a2
movb (%rdx), %r10b
movb %r10b, (%rax)
testb %r10b, %r10b
jne 0xda19a
cmpl $0x28, %edi
ja 0xda182
movq %r9, %r10
movl %edi, %r9d
addq %rcx, %r9
addl $0x8, %edi
movl %edi, -0x20(%rbp)
jmp 0xda18d
leaq 0x8(%r9), %r8
movq %r8, -0x18(%rbp)
movq %r8, %r10
movq (%r9), %rdx
movq %r10, %r9
testq %rdx, %rdx
jne 0xda15c
jmp 0xda1a5
incq %rax
incq %rdx
jmp 0xda159
movq %rsi, %rax
movb $0x0, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nop
| strxnmov:
push rbp
mov rbp, rsp
sub rsp, 50h
mov r10d, eax
mov rax, rdi
lea rdi, [rbp+var_D0]
mov [rdi+18h], rcx
mov [rdi+20h], r8
mov [rdi+28h], r9
test r10b, r10b
jz short loc_DA12C
movaps [rbp+var_A0], xmm0
movaps [rbp+var_90], xmm1
movaps [rbp+var_80], xmm2
movaps [rbp+var_70], xmm3
movaps [rbp+var_60], xmm4
movaps [rbp+var_50], xmm5
movaps [rbp+var_40], xmm6
movaps [rbp+var_30], xmm7
loc_DA12C:
mov [rbp+var_10], rdi
lea rcx, [rbp+arg_0]
mov [rbp+var_18], rcx
mov rcx, 3000000018h
mov [rbp+var_20], rcx
test rdx, rdx
jz short loc_DA1A5
add rsi, rax
mov rcx, [rbp+var_10]
mov edi, dword ptr [rbp+var_20]
mov r8, [rbp+var_18]
loc_DA159:
mov r9, r8
loc_DA15C:
cmp rax, rsi
jz short loc_DA1A2
mov r10b, [rdx]
mov [rax], r10b
test r10b, r10b
jnz short loc_DA19A
cmp edi, 28h ; '('
ja short loc_DA182
mov r10, r9
mov r9d, edi
add r9, rcx
add edi, 8
mov dword ptr [rbp+var_20], edi
jmp short loc_DA18D
loc_DA182:
lea r8, [r9+8]
mov [rbp+var_18], r8
mov r10, r8
loc_DA18D:
mov rdx, [r9]
mov r9, r10
test rdx, rdx
jnz short loc_DA15C
jmp short loc_DA1A5
loc_DA19A:
inc rax
inc rdx
jmp short loc_DA159
loc_DA1A2:
mov rax, rsi
loc_DA1A5:
mov byte ptr [rax], 0
add rsp, 50h
pop rbp
retn
| char *strxnmov(char *a1, long long a2, char *a3, ...)
{
char *result; // rax
char *v4; // rsi
char *reg_save_area; // rcx
unsigned int gp_offset; // edi
char *overflow_arg_area; // r8
char *v8; // r9
char v9; // r10
char *v10; // r10
va_list va; // [rsp+B0h] [rbp-20h] BYREF
result = a1;
va_start(va, a3);
if ( a3 )
{
v4 = &a1[a2];
reg_save_area = (char *)va[0].reg_save_area;
gp_offset = va[0].gp_offset;
overflow_arg_area = (char *)va[0].overflow_arg_area;
LABEL_3:
v8 = overflow_arg_area;
while ( result != v4 )
{
v9 = *a3;
*result = *a3;
if ( v9 )
{
++result;
++a3;
goto LABEL_3;
}
if ( gp_offset > 0x28 )
{
overflow_arg_area = v8 + 8;
va[0].overflow_arg_area = v8 + 8;
v10 = v8 + 8;
}
else
{
v10 = v8;
v8 = ®_save_area[gp_offset];
gp_offset += 8;
va[0].gp_offset = gp_offset;
}
a3 = *(char **)v8;
v8 = v10;
if ( !a3 )
goto LABEL_13;
}
result = v4;
}
LABEL_13:
*result = 0;
return result;
}
| strxnmov:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV R10D,EAX
MOV RAX,RDI
LEA RDI,[RBP + -0xd0]
MOV qword ptr [RDI + 0x18],RCX
MOV qword ptr [RDI + 0x20],R8
MOV qword ptr [RDI + 0x28],R9
TEST R10B,R10B
JZ 0x001da12c
MOVAPS xmmword ptr [RBP + -0xa0],XMM0
MOVAPS xmmword ptr [RBP + -0x90],XMM1
MOVAPS xmmword ptr [RBP + -0x80],XMM2
MOVAPS xmmword ptr [RBP + -0x70],XMM3
MOVAPS xmmword ptr [RBP + -0x60],XMM4
MOVAPS xmmword ptr [RBP + -0x50],XMM5
MOVAPS xmmword ptr [RBP + -0x40],XMM6
MOVAPS xmmword ptr [RBP + -0x30],XMM7
LAB_001da12c:
MOV qword ptr [RBP + -0x10],RDI
LEA RCX,[RBP + 0x10]
MOV qword ptr [RBP + -0x18],RCX
MOV RCX,0x3000000018
MOV qword ptr [RBP + -0x20],RCX
TEST RDX,RDX
JZ 0x001da1a5
ADD RSI,RAX
MOV RCX,qword ptr [RBP + -0x10]
MOV EDI,dword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + -0x18]
LAB_001da159:
MOV R9,R8
LAB_001da15c:
CMP RAX,RSI
JZ 0x001da1a2
MOV R10B,byte ptr [RDX]
MOV byte ptr [RAX],R10B
TEST R10B,R10B
JNZ 0x001da19a
CMP EDI,0x28
JA 0x001da182
MOV R10,R9
MOV R9D,EDI
ADD R9,RCX
ADD EDI,0x8
MOV dword ptr [RBP + -0x20],EDI
JMP 0x001da18d
LAB_001da182:
LEA R8,[R9 + 0x8]
MOV qword ptr [RBP + -0x18],R8
MOV R10,R8
LAB_001da18d:
MOV RDX,qword ptr [R9]
MOV R9,R10
TEST RDX,RDX
JNZ 0x001da15c
JMP 0x001da1a5
LAB_001da19a:
INC RAX
INC RDX
JMP 0x001da159
LAB_001da1a2:
MOV RAX,RSI
LAB_001da1a5:
MOV byte ptr [RAX],0x0
ADD RSP,0x50
POP RBP
RET
|
void strxnmov(char *param_1,long param_2,char *param_3)
{
char cVar1;
char *pcVar2;
char *pcVar3;
int8 *puVar4;
int8 *puVar5;
ulong uVar6;
int8 *puVar7;
int8 local_d8 [22];
uint local_28;
puVar4 = (int8 *)&stack0x00000008;
pcVar2 = param_1;
if (param_3 != (char *)0x0) {
pcVar3 = param_1 + param_2;
local_28 = 0x18;
puVar5 = puVar4;
do {
while( true ) {
pcVar2 = pcVar3;
if (param_1 == pcVar3) goto LAB_001da1a5;
cVar1 = *param_3;
*param_1 = cVar1;
if (cVar1 == '\0') break;
param_1 = param_1 + 1;
param_3 = param_3 + 1;
puVar5 = puVar4;
}
if (local_28 < 0x29) {
uVar6 = (ulong)local_28;
local_28 = local_28 + 8;
puVar7 = (int8 *)((long)local_d8 + uVar6);
}
else {
puVar4 = puVar5 + 1;
puVar7 = puVar5;
puVar5 = puVar4;
}
param_3 = (char *)*puVar7;
pcVar2 = param_1;
} while (param_3 != (char *)0x0);
}
LAB_001da1a5:
*pcVar2 = '\0';
return;
}
| |
24,895 | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::scan_string() | llama.cpp/common/json.hpp | token_type scan_string()
{
// reset token_buffer (ignore opening quote)
reset();
// we entered the function by reading an open quote
JSON_ASSERT(current == '\"');
while (true)
{
// get next character
switch (get())
{
// end of file while parsing string
case char_traits<char_type>::eof():
{
error_message = "invalid string: missing closing quote";
return token_type::parse_error;
}
// closing quote
case '\"':
{
return token_type::value_string;
}
// escapes
case '\\':
{
switch (get())
{
// quotation mark
case '\"':
add('\"');
break;
// reverse solidus
case '\\':
add('\\');
break;
// solidus
case '/':
add('/');
break;
// backspace
case 'b':
add('\b');
break;
// form feed
case 'f':
add('\f');
break;
// line feed
case 'n':
add('\n');
break;
// carriage return
case 'r':
add('\r');
break;
// tab
case 't':
add('\t');
break;
// unicode escapes
case 'u':
{
const int codepoint1 = get_codepoint();
int codepoint = codepoint1; // start with codepoint1
if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
{
error_message = "invalid string: '\\u' must be followed by 4 hex digits";
return token_type::parse_error;
}
// check if code point is a high surrogate
if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
{
// expect next \uxxxx entry
if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u'))
{
const int codepoint2 = get_codepoint();
if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
{
error_message = "invalid string: '\\u' must be followed by 4 hex digits";
return token_type::parse_error;
}
// check if codepoint2 is a low surrogate
if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF))
{
// overwrite codepoint
codepoint = static_cast<int>(
// high surrogate occupies the most significant 22 bits
(static_cast<unsigned int>(codepoint1) << 10u)
// low surrogate occupies the least significant 15 bits
+ static_cast<unsigned int>(codepoint2)
// there is still the 0xD800, 0xDC00 and 0x10000 noise
// in the result, so we have to subtract with:
// (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
- 0x35FDC00u);
}
else
{
error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
return token_type::parse_error;
}
}
else
{
error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
return token_type::parse_error;
}
}
else
{
if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))
{
error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
return token_type::parse_error;
}
}
// result of the above calculation yields a proper codepoint
JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
// translate codepoint into bytes
if (codepoint < 0x80)
{
// 1-byte characters: 0xxxxxxx (ASCII)
add(static_cast<char_int_type>(codepoint));
}
else if (codepoint <= 0x7FF)
{
// 2-byte characters: 110xxxxx 10xxxxxx
add(static_cast<char_int_type>(0xC0u | (static_cast<unsigned int>(codepoint) >> 6u)));
add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
}
else if (codepoint <= 0xFFFF)
{
// 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
add(static_cast<char_int_type>(0xE0u | (static_cast<unsigned int>(codepoint) >> 12u)));
add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
}
else
{
// 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
add(static_cast<char_int_type>(0xF0u | (static_cast<unsigned int>(codepoint) >> 18u)));
add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));
add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
}
break;
}
// other characters after escape
default:
error_message = "invalid string: forbidden character after backslash";
return token_type::parse_error;
}
break;
}
// invalid control characters
case 0x00:
{
error_message = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
return token_type::parse_error;
}
case 0x01:
{
error_message = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
return token_type::parse_error;
}
case 0x02:
{
error_message = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
return token_type::parse_error;
}
case 0x03:
{
error_message = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
return token_type::parse_error;
}
case 0x04:
{
error_message = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
return token_type::parse_error;
}
case 0x05:
{
error_message = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
return token_type::parse_error;
}
case 0x06:
{
error_message = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
return token_type::parse_error;
}
case 0x07:
{
error_message = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
return token_type::parse_error;
}
case 0x08:
{
error_message = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
return token_type::parse_error;
}
case 0x09:
{
error_message = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
return token_type::parse_error;
}
case 0x0A:
{
error_message = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
return token_type::parse_error;
}
case 0x0B:
{
error_message = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
return token_type::parse_error;
}
case 0x0C:
{
error_message = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
return token_type::parse_error;
}
case 0x0D:
{
error_message = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
return token_type::parse_error;
}
case 0x0E:
{
error_message = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
return token_type::parse_error;
}
case 0x0F:
{
error_message = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
return token_type::parse_error;
}
case 0x10:
{
error_message = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
return token_type::parse_error;
}
case 0x11:
{
error_message = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
return token_type::parse_error;
}
case 0x12:
{
error_message = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
return token_type::parse_error;
}
case 0x13:
{
error_message = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
return token_type::parse_error;
}
case 0x14:
{
error_message = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
return token_type::parse_error;
}
case 0x15:
{
error_message = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
return token_type::parse_error;
}
case 0x16:
{
error_message = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
return token_type::parse_error;
}
case 0x17:
{
error_message = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
return token_type::parse_error;
}
case 0x18:
{
error_message = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
return token_type::parse_error;
}
case 0x19:
{
error_message = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
return token_type::parse_error;
}
case 0x1A:
{
error_message = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
return token_type::parse_error;
}
case 0x1B:
{
error_message = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
return token_type::parse_error;
}
case 0x1C:
{
error_message = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
return token_type::parse_error;
}
case 0x1D:
{
error_message = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
return token_type::parse_error;
}
case 0x1E:
{
error_message = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
return token_type::parse_error;
}
case 0x1F:
{
error_message = "invalid string: control character U+001F (US) must be escaped to \\u001F";
return token_type::parse_error;
}
// U+0020..U+007F (except U+0022 (quote) and U+005C (backspace))
case 0x20:
case 0x21:
case 0x23:
case 0x24:
case 0x25:
case 0x26:
case 0x27:
case 0x28:
case 0x29:
case 0x2A:
case 0x2B:
case 0x2C:
case 0x2D:
case 0x2E:
case 0x2F:
case 0x30:
case 0x31:
case 0x32:
case 0x33:
case 0x34:
case 0x35:
case 0x36:
case 0x37:
case 0x38:
case 0x39:
case 0x3A:
case 0x3B:
case 0x3C:
case 0x3D:
case 0x3E:
case 0x3F:
case 0x40:
case 0x41:
case 0x42:
case 0x43:
case 0x44:
case 0x45:
case 0x46:
case 0x47:
case 0x48:
case 0x49:
case 0x4A:
case 0x4B:
case 0x4C:
case 0x4D:
case 0x4E:
case 0x4F:
case 0x50:
case 0x51:
case 0x52:
case 0x53:
case 0x54:
case 0x55:
case 0x56:
case 0x57:
case 0x58:
case 0x59:
case 0x5A:
case 0x5B:
case 0x5D:
case 0x5E:
case 0x5F:
case 0x60:
case 0x61:
case 0x62:
case 0x63:
case 0x64:
case 0x65:
case 0x66:
case 0x67:
case 0x68:
case 0x69:
case 0x6A:
case 0x6B:
case 0x6C:
case 0x6D:
case 0x6E:
case 0x6F:
case 0x70:
case 0x71:
case 0x72:
case 0x73:
case 0x74:
case 0x75:
case 0x76:
case 0x77:
case 0x78:
case 0x79:
case 0x7A:
case 0x7B:
case 0x7C:
case 0x7D:
case 0x7E:
case 0x7F:
{
add(current);
break;
}
// U+0080..U+07FF: bytes C2..DF 80..BF
case 0xC2:
case 0xC3:
case 0xC4:
case 0xC5:
case 0xC6:
case 0xC7:
case 0xC8:
case 0xC9:
case 0xCA:
case 0xCB:
case 0xCC:
case 0xCD:
case 0xCE:
case 0xCF:
case 0xD0:
case 0xD1:
case 0xD2:
case 0xD3:
case 0xD4:
case 0xD5:
case 0xD6:
case 0xD7:
case 0xD8:
case 0xD9:
case 0xDA:
case 0xDB:
case 0xDC:
case 0xDD:
case 0xDE:
case 0xDF:
{
if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF})))
{
return token_type::parse_error;
}
break;
}
// U+0800..U+0FFF: bytes E0 A0..BF 80..BF
case 0xE0:
{
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
break;
}
// U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF
// U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF
case 0xE1:
case 0xE2:
case 0xE3:
case 0xE4:
case 0xE5:
case 0xE6:
case 0xE7:
case 0xE8:
case 0xE9:
case 0xEA:
case 0xEB:
case 0xEC:
case 0xEE:
case 0xEF:
{
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
break;
}
// U+D000..U+D7FF: bytes ED 80..9F 80..BF
case 0xED:
{
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
break;
}
// U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
case 0xF0:
{
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
break;
}
// U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
case 0xF1:
case 0xF2:
case 0xF3:
{
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
break;
}
// U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
case 0xF4:
{
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
break;
}
// remaining bytes (80..C1 and F5..FF) are ill-formed
default:
{
error_message = "invalid string: ill-formed UTF-8 byte";
return token_type::parse_error;
}
}
}
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::scan_string():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x74090
cmpl $0x22, 0x14(%rbx)
jne 0x73c89
leaq 0x50(%rbx), %r14
leaq 0xa52b5(%rip), %r12 # 0x118b34
leaq 0x9ddc2(%rip), %r13 # 0x111648
movq %rbx, %rdi
callq 0x2154c
incl %eax
cmpl $0xf5, %eax
ja 0x73c58
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movabsq $0xbf00000080, %rax # imm = 0xBF00000080
movq %rsp, %rsi
movq %rax, (%rsi)
movl $0x2, %edx
jmp 0x73926
movaps 0x9dbfd(%rip), %xmm0 # 0x1114c0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movl $0x4, %edx
jmp 0x73926
movb 0x14(%rbx), %r15b
movsbl %r15b, %esi
movq %r14, %rdi
callq 0x213a0
jmp 0x73886
movups 0xa7aef(%rip), %xmm0 # 0x11b3d8
jmp 0x7390d
movaps 0x9dbbe(%rip), %xmm0 # 0x1114b0
jmp 0x738c3
movaps 0x9dbd5(%rip), %xmm0 # 0x1114d0
jmp 0x738c3
movups 0xa7aec(%rip), %xmm0 # 0x11b3f0
jmp 0x7390d
movups 0xa7ab3(%rip), %xmm0 # 0x11b3c0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movabsq $0xbf00000080, %rax # imm = 0xBF00000080
movq %rax, 0x10(%rsi)
movl $0x6, %edx
movq %rbx, %rdi
callq 0x74114
testb %al, %al
jne 0x73886
jmp 0x73c63
movq %rbx, %rdi
callq 0x2154c
leaq 0xa516d(%rip), %rbp # 0x118ab7
cmpl $0x61, %eax
jle 0x73a75
leal -0x6e(%rax), %ecx
cmpl $0x7, %ecx
ja 0x73a90
leaq 0x9e0ba(%rip), %rax # 0x111a20
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %rbx, %rdi
callq 0x740ce
leaq 0xa5048(%rip), %rbp # 0x1189c6
cmpl $-0x1, %eax
je 0x73c5f
movl %eax, %r15d
andl $0xfffffc00, %eax # imm = 0xFFFFFC00
cmpl $0xd800, %eax # imm = 0xD800
jne 0x73a40
movq %rbx, %rdi
callq 0x2154c
cmpl $0x5c, %eax
jne 0x73c77
movq %rbx, %rdi
callq 0x2154c
cmpl $0x75, %eax
jne 0x73c77
movq %rbx, %rdi
callq 0x740ce
cmpl $-0x1, %eax
je 0x73c5f
movl %eax, %ecx
andl $0xfffffc00, %ecx # imm = 0xFFFFFC00
leaq 0xa5020(%rip), %rbp # 0x1189fc
cmpl $0xdc00, %ecx # imm = 0xDC00
jne 0x73c5f
shll $0xa, %r15d
addl %eax, %r15d
addl $0xfca02400, %r15d # imm = 0xFCA02400
movl %r15d, %eax
shrl $0x12, %eax
orb $-0x10, %al
movsbl %al, %esi
movq %r14, %rdi
callq 0x213a0
movl %r15d, %eax
shrl $0xc, %eax
andb $0x3f, %al
orb $-0x80, %al
movsbl %al, %esi
movq %r14, %rdi
callq 0x213a0
movl %r15d, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movsbl %al, %esi
movq %r14, %rdi
callq 0x213a0
andb $0x3f, %r15b
orb $-0x80, %r15b
jmp 0x738d4
cmpl $0xdc00, %eax # imm = 0xDC00
je 0x73c80
cmpl $0x110000, %r15d # imm = 0x110000
jae 0x73ca5
cmpl $0x7f, %r15d
jbe 0x738d4
cmpl $0x7ff, %r15d # imm = 0x7FF
ja 0x73aa6
movl %r15d, %eax
shrl $0x6, %eax
orb $-0x40, %al
jmp 0x73a28
cmpl $0x22, %eax
je 0x73ac8
cmpl $0x2f, %eax
je 0x73ac0
cmpl $0x5c, %eax
jne 0x73c5f
movb $0x5c, %r15b
jmp 0x738d4
cmpl $0x62, %eax
je 0x73ae8
cmpl $0x66, %eax
jne 0x73c5f
movb $0xc, %r15b
jmp 0x738d4
cmpl $0xffff, %r15d # imm = 0xFFFF
ja 0x739f6
movl %r15d, %eax
shrl $0xc, %eax
orb $-0x20, %al
jmp 0x73a13
movb $0x2f, %r15b
jmp 0x738d4
movb $0x22, %r15b
jmp 0x738d4
movb $0x9, %r15b
jmp 0x738d4
movb $0xa, %r15b
jmp 0x738d4
movb $0xd, %r15b
jmp 0x738d4
movb $0x8, %r15b
jmp 0x738d4
movl $0x4, %eax
jmp 0x73c68
leaq 0xa58d3(%rip), %rbp # 0x1193d4
jmp 0x73c5f
leaq 0xa5715(%rip), %rbp # 0x119222
jmp 0x73c5f
leaq 0xa5873(%rip), %rbp # 0x11938c
jmp 0x73c5f
leaq 0xa5340(%rip), %rbp # 0x118e65
jmp 0x73c5f
leaq 0xa57cb(%rip), %rbp # 0x1192fc
jmp 0x73c5f
leaq 0xa569c(%rip), %rbp # 0x1191d9
jmp 0x73c5f
leaq 0xa50c6(%rip), %rbp # 0x118c0f
jmp 0x73c5f
leaq 0xa51de(%rip), %rbp # 0x118d33
jmp 0x73c5f
leaq 0xa5065(%rip), %rbp # 0x118bc6
jmp 0x73c5f
leaq 0xa5134(%rip), %rbp # 0x118ca1
jmp 0x73c5f
leaq 0xa5171(%rip), %rbp # 0x118cea
jmp 0x73c5f
movq %r12, %rbp
jmp 0x73c5f
leaq 0xa5404(%rip), %rbp # 0x118f91
jmp 0x73c5f
leaq 0xa5368(%rip), %rbp # 0x118f01
jmp 0x73c5f
leaq 0xa4dfb(%rip), %rbp # 0x1189a0
jmp 0x73c5f
leaq 0xa50a7(%rip), %rbp # 0x118c58
jmp 0x73c5f
leaq 0xa541d(%rip), %rbp # 0x118fda
jmp 0x73c5f
leaq 0xa4f22(%rip), %rbp # 0x118aeb
jmp 0x73c5f
leaq 0xa4fa8(%rip), %rbp # 0x118b7d
jmp 0x73c5f
leaq 0xa548b(%rip), %rbp # 0x11906c
jmp 0x73c5f
leaq 0xa54cb(%rip), %rbp # 0x1190b5
jmp 0x73c5f
leaq 0xa56c0(%rip), %rbp # 0x1192b3
jmp 0x73c5f
leaq 0xa5185(%rip), %rbp # 0x118d81
jmp 0x73c5f
leaq 0xa54f9(%rip), %rbp # 0x1190fe
jmp 0x73c5f
leaq 0xa52a5(%rip), %rbp # 0x118eb3
jmp 0x73c5f
leaq 0xa5653(%rip), %rbp # 0x11926a
jmp 0x73c5f
leaq 0xa51af(%rip), %rbp # 0x118dcf
jmp 0x73c5f
leaq 0xa51f4(%rip), %rbp # 0x118e1d
jmp 0x73c5f
leaq 0xa53f1(%rip), %rbp # 0x119023
jmp 0x73c5f
leaq 0xa530e(%rip), %rbp # 0x118f49
jmp 0x73c5f
leaq 0xa5700(%rip), %rbp # 0x119344
jmp 0x73c5f
leaq 0xa54fa(%rip), %rbp # 0x119147
jmp 0x73c5f
leaq 0xa553a(%rip), %rbp # 0x119190
jmp 0x73c5f
leaq 0xa57bd(%rip), %rbp # 0x11941c
movq %rbp, 0x70(%rbx)
movl $0xe, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa4d7e(%rip), %rbp # 0x1189fc
jmp 0x73c5f
leaq 0xa4dc1(%rip), %rbp # 0x118a48
jmp 0x73c5f
leaq 0xa4a92(%rip), %rdi # 0x118722
leaq 0xa4ac6(%rip), %rdx # 0x11875d
leaq 0xa4cf2(%rip), %rcx # 0x118990
movl $0x1dd1, %esi # imm = 0x1DD1
jmp 0x73cbf
leaq 0xa4a76(%rip), %rdi # 0x118722
leaq 0xa4aaa(%rip), %rdx # 0x11875d
leaq 0xa4dd2(%rip), %rcx # 0x118a8c
movl $0x1e49, %esi # imm = 0x1E49
xorl %eax, %eax
callq 0x20e70
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE11scan_stringEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE5resetEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::reset(void)
cmp dword ptr [rbx+14h], 22h ; '"'
jnz loc_73C89
lea r14, [rbx+50h]
lea r12, aInvalidStringC; "invalid string: control character U+000"...
lea r13, jpt_738A3
loc_73886:
mov rdi, rbx; this
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::get(void)
inc eax; switch 246 cases
cmp eax, 0F5h
ja def_738A3; jumptable 00000000000738A3 default case, cases 128-193
movsxd rax, ds:(jpt_738A3 - 111648h)[r13+rax*4]
add rax, r13
jmp rax; switch jump
loc_738A5:
mov rax, 0BF00000080h; jumptable 00000000000738A3 cases 194-223
mov rsi, rsp
mov [rsi], rax
mov edx, 2
jmp short loc_73926
loc_738BC:
movaps xmm0, cs:xmmword_1114C0; jumptable 00000000000738A3 cases 225-236,238,239
loc_738C3:
mov rsi, rsp
movaps xmmword ptr [rsi], xmm0
mov edx, 4
jmp short loc_73926
loc_738D0:
mov r15b, [rbx+14h]; jumptable 00000000000738A3 cases 32,33,35-91,93-127
loc_738D4:
movsx esi, r15b
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
jmp short loc_73886
loc_738E2:
movups xmm0, cs:xmmword_11B3D8; jumptable 00000000000738A3 cases 241-243
jmp short loc_7390D
loc_738EB:
movaps xmm0, cs:xmmword_1114B0; jumptable 00000000000738A3 case 237
jmp short loc_738C3
loc_738F4:
movaps xmm0, cs:xmmword_1114D0; jumptable 00000000000738A3 case 224
jmp short loc_738C3
loc_738FD:
movups xmm0, cs:xmmword_11B3F0; jumptable 00000000000738A3 case 244
jmp short loc_7390D
loc_73906:
movups xmm0, cs:xmmword_11B3C0; jumptable 00000000000738A3 case 240
loc_7390D:
mov rsi, rsp
movaps xmmword ptr [rsi], xmm0
mov rax, 0BF00000080h
mov [rsi+10h], rax
mov edx, 6
loc_73926:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE18next_byte_in_rangeESt16initializer_listIiE; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::next_byte_in_range(std::initializer_list<int>)
test al, al
jnz loc_73886
jmp loc_73C63
loc_7393B:
mov rdi, rbx; jumptable 00000000000738A3 case 92
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::get(void)
lea rbp, aInvalidStringF; "invalid string: forbidden character aft"...
cmp eax, 61h ; 'a'
jle loc_73A75
lea ecx, [rax-6Eh]; switch 8 cases
cmp ecx, 7
ja def_7396D; jumptable 000000000007396D default case
lea rax, jpt_7396D
movsxd rcx, ds:(jpt_7396D - 111A20h)[rax+rcx*4]
add rcx, rax
jmp rcx; switch jump
loc_7396F:
mov rdi, rbx; jumptable 000000000007396D case 117
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE13get_codepointEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::get_codepoint(void)
lea rbp, aInvalidStringU; "invalid string: '\\u' must be followed "...
cmp eax, 0FFFFFFFFh
jz loc_73C5F; jumptable 000000000007396D cases 111-113,115
mov r15d, eax
and eax, 0FFFFFC00h
cmp eax, 0D800h
jnz loc_73A40
mov rdi, rbx; this
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::get(void)
cmp eax, 5Ch ; '\'
jnz loc_73C77
mov rdi, rbx; this
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::get(void)
cmp eax, 75h ; 'u'
jnz loc_73C77
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE13get_codepointEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::get_codepoint(void)
cmp eax, 0FFFFFFFFh
jz loc_73C5F; jumptable 000000000007396D cases 111-113,115
mov ecx, eax
and ecx, 0FFFFFC00h
lea rbp, aInvalidStringS; "invalid string: surrogate U+D800..U+DBF"...
cmp ecx, 0DC00h
jnz loc_73C5F; jumptable 000000000007396D cases 111-113,115
shl r15d, 0Ah
add r15d, eax
add r15d, 0FCA02400h
loc_739F6:
mov eax, r15d
shr eax, 12h
or al, 0F0h
movsx esi, al
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov eax, r15d
shr eax, 0Ch
and al, 3Fh
or al, 80h
loc_73A13:
movsx esi, al
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov eax, r15d
shr eax, 6
and al, 3Fh
or al, 80h
loc_73A28:
movsx esi, al
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
and r15b, 3Fh
or r15b, 80h
jmp loc_738D4
loc_73A40:
cmp eax, 0DC00h
jz loc_73C80
cmp r15d, offset _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_19common_sampler_typeESaIS9_ENSt8__detail10_Select1stESt8equal_toIS5_ESt4hashIS5_ENSB_18_Mod_range_hashingENSB_20_Default_ranged_hashENSB_20_Prime_rehash_policyENSB_17_Hashtable_traitsILb1ELb0ELb1EEEE13_M_rehash_auxEmSt17integral_constantIbLb1EE; std::_Hashtable<std::string,std::pair<std::string const,common_sampler_type>,std::allocator<std::pair<std::string const,common_sampler_type>>,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>>::_M_rehash_aux(ulong,std::integral_constant<bool,true>)
jnb loc_73CA5
cmp r15d, 7Fh
jbe loc_738D4
cmp r15d, 7FFh
ja short loc_73AA6
mov eax, r15d
shr eax, 6
or al, 0C0h
jmp short loc_73A28
loc_73A75:
cmp eax, 22h ; '"'
jz short loc_73AC8
cmp eax, 2Fh ; '/'
jz short loc_73AC0
cmp eax, 5Ch ; '\'
jnz loc_73C5F; jumptable 000000000007396D cases 111-113,115
mov r15b, 5Ch ; '\'
jmp loc_738D4
def_7396D:
cmp eax, 62h ; 'b'; jumptable 000000000007396D default case
jz short loc_73AE8
cmp eax, 66h ; 'f'
jnz loc_73C5F; jumptable 000000000007396D cases 111-113,115
mov r15b, 0Ch
jmp loc_738D4
loc_73AA6:
cmp r15d, 0FFFFh
ja loc_739F6
mov eax, r15d
shr eax, 0Ch
or al, 0E0h
jmp loc_73A13
loc_73AC0:
mov r15b, 2Fh ; '/'
jmp loc_738D4
loc_73AC8:
mov r15b, 22h ; '"'
jmp loc_738D4
loc_73AD0:
mov r15b, 9; jumptable 000000000007396D case 116
jmp loc_738D4
loc_73AD8:
mov r15b, 0Ah; jumptable 000000000007396D case 110
jmp loc_738D4
loc_73AE0:
mov r15b, 0Dh; jumptable 000000000007396D case 114
jmp loc_738D4
loc_73AE8:
mov r15b, 8
jmp loc_738D4
loc_73AF0:
mov eax, 4; jumptable 00000000000738A3 case 34
jmp loc_73C68
loc_73AFA:
lea rbp, aInvalidStringC_0; jumptable 00000000000738A3 case 31
jmp loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73B06:
lea rbp, aInvalidStringC_1; jumptable 00000000000738A3 case 25
jmp loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73B12:
lea rbp, aInvalidStringC_2; jumptable 00000000000738A3 case 30
jmp loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73B1E:
lea rbp, aInvalidStringC_3; jumptable 00000000000738A3 case 12
jmp loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73B2A:
lea rbp, aInvalidStringC_4; jumptable 00000000000738A3 case 28
jmp loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73B36:
lea rbp, aInvalidStringC_5; jumptable 00000000000738A3 case 24
jmp loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73B42:
lea rbp, aInvalidStringC_6; jumptable 00000000000738A3 case 4
jmp loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73B4E:
lea rbp, aInvalidStringC_7; jumptable 00000000000738A3 case 8
jmp loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73B5A:
lea rbp, aInvalidStringC_8; jumptable 00000000000738A3 case 3
jmp loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73B66:
lea rbp, aInvalidStringC_9; jumptable 00000000000738A3 case 6
jmp loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73B72:
lea rbp, aInvalidStringC_10; jumptable 00000000000738A3 case 7
jmp loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73B7E:
mov rbp, r12; jumptable 00000000000738A3 case 1
jmp loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73B86:
lea rbp, aInvalidStringC_11; jumptable 00000000000738A3 case 16
jmp loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73B92:
lea rbp, aInvalidStringC_12; jumptable 00000000000738A3 case 14
jmp loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73B9E:
lea rbp, aInvalidStringM; jumptable 00000000000738A3 case -1
jmp loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73BAA:
lea rbp, aInvalidStringC_13; jumptable 00000000000738A3 case 5
jmp loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73BB6:
lea rbp, aInvalidStringC_14; jumptable 00000000000738A3 case 17
jmp loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73BC2:
lea rbp, aInvalidStringC_15; jumptable 00000000000738A3 case 0
jmp loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73BCE:
lea rbp, aInvalidStringC_16; jumptable 00000000000738A3 case 2
jmp loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73BDA:
lea rbp, aInvalidStringC_17; jumptable 00000000000738A3 case 19
jmp short loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73BE3:
lea rbp, aInvalidStringC_18; jumptable 00000000000738A3 case 20
jmp short loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73BEC:
lea rbp, aInvalidStringC_19; jumptable 00000000000738A3 case 27
jmp short loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73BF5:
lea rbp, aInvalidStringC_20; jumptable 00000000000738A3 case 9
jmp short loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73BFE:
lea rbp, aInvalidStringC_21; jumptable 00000000000738A3 case 21
jmp short loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73C07:
lea rbp, aInvalidStringC_22; jumptable 00000000000738A3 case 13
jmp short loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73C10:
lea rbp, aInvalidStringC_23; jumptable 00000000000738A3 case 26
jmp short loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73C19:
lea rbp, aInvalidStringC_24; jumptable 00000000000738A3 case 10
jmp short loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73C22:
lea rbp, aInvalidStringC_25; jumptable 00000000000738A3 case 11
jmp short loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73C2B:
lea rbp, aInvalidStringC_26; jumptable 00000000000738A3 case 18
jmp short loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73C34:
lea rbp, aInvalidStringC_27; jumptable 00000000000738A3 case 15
jmp short loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73C3D:
lea rbp, aInvalidStringC_28; jumptable 00000000000738A3 case 29
jmp short loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73C46:
lea rbp, aInvalidStringC_29; jumptable 00000000000738A3 case 22
jmp short loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73C4F:
lea rbp, aInvalidStringC_30; jumptable 00000000000738A3 case 23
jmp short loc_73C5F; jumptable 000000000007396D cases 111-113,115
def_738A3:
lea rbp, aInvalidStringI; jumptable 00000000000738A3 default case, cases 128-193
loc_73C5F:
mov [rbx+70h], rbp; jumptable 000000000007396D cases 111-113,115
loc_73C63:
mov eax, 0Eh
loc_73C68:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_73C77:
lea rbp, aInvalidStringS; "invalid string: surrogate U+D800..U+DBF"...
jmp short loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73C80:
lea rbp, aInvalidStringS_0; "invalid string: surrogate U+DC00..U+DFF"...
jmp short loc_73C5F; jumptable 000000000007396D cases 111-113,115
loc_73C89:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCurrent; "current == '\\\"'"
mov esi, 1DD1h
jmp short loc_73CBF
loc_73CA5:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, a0x00CodepointC; "0x00 <= codepoint && codepoint <= 0x10F"...
mov esi, 1E49h
loc_73CBF:
xor eax, eax
call _ggml_abort
| long long nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::scan_string(
__m128i *this)
{
long long v1; // rcx
long long v2; // r8
long long v3; // r9
long long v4; // rdx
__int128 v5; // xmm0
unsigned int v6; // r15d
__int128 v7; // xmm0
int v8; // eax
const char *v9; // rbp
unsigned int codepoint; // eax
unsigned int v11; // eax
int v12; // eax
char v13; // al
char v14; // al
__int128 v16; // [rsp+0h] [rbp-48h] BYREF
long long v17; // [rsp+10h] [rbp-38h]
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::reset();
if ( this[1].m128i_i32[1] != 34 )
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
7633LL,
"GGML_ASSERT(%s) failed",
"current == '\\\"'");
return nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::scan_number((nlohmann::json_abi_v3_11_3::detail::input_stream_adapter *)"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp");
}
while ( 2 )
{
while ( 2 )
{
switch ( (unsigned int)nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::get(this) )
{
case 0xFFFFFFFF:
v9 = "invalid string: missing closing quote";
goto LABEL_83;
case 0u:
v9 = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
goto LABEL_83;
case 1u:
v9 = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
goto LABEL_83;
case 2u:
v9 = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
goto LABEL_83;
case 3u:
v9 = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
goto LABEL_83;
case 4u:
v9 = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
goto LABEL_83;
case 5u:
v9 = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
goto LABEL_83;
case 6u:
v9 = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
goto LABEL_83;
case 7u:
v9 = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
goto LABEL_83;
case 8u:
v9 = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
goto LABEL_83;
case 9u:
v9 = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
goto LABEL_83;
case 0xAu:
v9 = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
goto LABEL_83;
case 0xBu:
v9 = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
goto LABEL_83;
case 0xCu:
v9 = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
goto LABEL_83;
case 0xDu:
v9 = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
goto LABEL_83;
case 0xEu:
v9 = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
goto LABEL_83;
case 0xFu:
v9 = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
goto LABEL_83;
case 0x10u:
v9 = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
goto LABEL_83;
case 0x11u:
v9 = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
goto LABEL_83;
case 0x12u:
v9 = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
goto LABEL_83;
case 0x13u:
v9 = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
goto LABEL_83;
case 0x14u:
v9 = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
goto LABEL_83;
case 0x15u:
v9 = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
goto LABEL_83;
case 0x16u:
v9 = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
goto LABEL_83;
case 0x17u:
v9 = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
goto LABEL_83;
case 0x18u:
v9 = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
goto LABEL_83;
case 0x19u:
v9 = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
goto LABEL_83;
case 0x1Au:
v9 = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
goto LABEL_83;
case 0x1Bu:
v9 = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
goto LABEL_83;
case 0x1Cu:
v9 = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
goto LABEL_83;
case 0x1Du:
v9 = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
goto LABEL_83;
case 0x1Eu:
v9 = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
goto LABEL_83;
case 0x1Fu:
v9 = "invalid string: control character U+001F (US) must be escaped to \\u001F";
goto LABEL_83;
case 0x20u:
case 0x21u:
case 0x23u:
case 0x24u:
case 0x25u:
case 0x26u:
case 0x27u:
case 0x28u:
case 0x29u:
case 0x2Au:
case 0x2Bu:
case 0x2Cu:
case 0x2Du:
case 0x2Eu:
case 0x2Fu:
case 0x30u:
case 0x31u:
case 0x32u:
case 0x33u:
case 0x34u:
case 0x35u:
case 0x36u:
case 0x37u:
case 0x38u:
case 0x39u:
case 0x3Au:
case 0x3Bu:
case 0x3Cu:
case 0x3Du:
case 0x3Eu:
case 0x3Fu:
case 0x40u:
case 0x41u:
case 0x42u:
case 0x43u:
case 0x44u:
case 0x45u:
case 0x46u:
case 0x47u:
case 0x48u:
case 0x49u:
case 0x4Au:
case 0x4Bu:
case 0x4Cu:
case 0x4Du:
case 0x4Eu:
case 0x4Fu:
case 0x50u:
case 0x51u:
case 0x52u:
case 0x53u:
case 0x54u:
case 0x55u:
case 0x56u:
case 0x57u:
case 0x58u:
case 0x59u:
case 0x5Au:
case 0x5Bu:
case 0x5Du:
case 0x5Eu:
case 0x5Fu:
case 0x60u:
case 0x61u:
case 0x62u:
case 0x63u:
case 0x64u:
case 0x65u:
case 0x66u:
case 0x67u:
case 0x68u:
case 0x69u:
case 0x6Au:
case 0x6Bu:
case 0x6Cu:
case 0x6Du:
case 0x6Eu:
case 0x6Fu:
case 0x70u:
case 0x71u:
case 0x72u:
case 0x73u:
case 0x74u:
case 0x75u:
case 0x76u:
case 0x77u:
case 0x78u:
case 0x79u:
case 0x7Au:
case 0x7Bu:
case 0x7Cu:
case 0x7Du:
case 0x7Eu:
case 0x7Fu:
LOBYTE(v6) = this[1].m128i_i8[4];
goto LABEL_7;
case 0x22u:
return 4LL;
case 0x5Cu:
v8 = nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::get(this);
v9 = "invalid string: forbidden character after backslash";
if ( v8 <= 97 )
{
switch ( v8 )
{
case '"':
LOBYTE(v6) = 34;
break;
case '/':
LOBYTE(v6) = 47;
break;
case '\\':
LOBYTE(v6) = 92;
break;
default:
goto LABEL_83;
}
goto LABEL_7;
}
break;
case 0xC2u:
case 0xC3u:
case 0xC4u:
case 0xC5u:
case 0xC6u:
case 0xC7u:
case 0xC8u:
case 0xC9u:
case 0xCAu:
case 0xCBu:
case 0xCCu:
case 0xCDu:
case 0xCEu:
case 0xCFu:
case 0xD0u:
case 0xD1u:
case 0xD2u:
case 0xD3u:
case 0xD4u:
case 0xD5u:
case 0xD6u:
case 0xD7u:
case 0xD8u:
case 0xD9u:
case 0xDAu:
case 0xDBu:
case 0xDCu:
case 0xDDu:
case 0xDEu:
case 0xDFu:
*(_QWORD *)&v16 = 0xBF00000080LL;
v4 = 2LL;
goto LABEL_14;
case 0xE0u:
v5 = xmmword_1114D0;
goto LABEL_5;
case 0xE1u:
case 0xE2u:
case 0xE3u:
case 0xE4u:
case 0xE5u:
case 0xE6u:
case 0xE7u:
case 0xE8u:
case 0xE9u:
case 0xEAu:
case 0xEBu:
case 0xECu:
case 0xEEu:
case 0xEFu:
v5 = xmmword_1114C0;
goto LABEL_5;
case 0xEDu:
v5 = xmmword_1114B0;
LABEL_5:
v16 = v5;
v4 = 4LL;
goto LABEL_14;
case 0xF0u:
v7 = xmmword_11B3C0;
goto LABEL_13;
case 0xF1u:
case 0xF2u:
case 0xF3u:
v7 = xmmword_11B3D8;
goto LABEL_13;
case 0xF4u:
v7 = xmmword_11B3F0;
LABEL_13:
v16 = v7;
v17 = 0xBF00000080LL;
v4 = 6LL;
LABEL_14:
if ( !(unsigned __int8)nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::next_byte_in_range(
this,
&v16,
v4,
v1,
v2,
v3,
v16,
*((_QWORD *)&v16 + 1),
v17) )
return 14LL;
continue;
default:
v9 = "invalid string: ill-formed UTF-8 byte";
goto LABEL_83;
}
break;
}
switch ( v8 )
{
case 'n':
LOBYTE(v6) = 10;
goto LABEL_7;
case 'o':
case 'p':
case 'q':
case 's':
goto LABEL_83;
case 'r':
LOBYTE(v6) = 13;
goto LABEL_7;
case 't':
LOBYTE(v6) = 9;
goto LABEL_7;
case 'u':
codepoint = nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::get_codepoint(this);
v9 = "invalid string: '\\u' must be followed by 4 hex digits";
if ( codepoint == -1 )
goto LABEL_83;
v6 = codepoint;
v11 = codepoint & 0xFFFFFC00;
if ( v11 == 55296 )
{
if ( (unsigned int)nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::get(this) != 92
|| (unsigned int)nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::get(this) != 117 )
{
v9 = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
LABEL_83:
this[7].m128i_i64[0] = (long long)v9;
return 14LL;
}
v12 = nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::get_codepoint(this);
if ( v12 == -1 )
goto LABEL_83;
v9 = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
if ( (v12 & 0xFFFFFC00) != 0xDC00 )
goto LABEL_83;
v6 = v12 + (v6 << 10) - 56613888;
goto LABEL_25;
}
if ( v11 == 56320 )
{
v9 = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
goto LABEL_83;
}
if ( v6 < (unsigned int)std::_Hashtable<std::string,std::pair<std::string const,common_sampler_type>,std::allocator<std::pair<std::string const,common_sampler_type>>,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>>::_M_rehash_aux )
{
if ( v6 > 0x7F )
{
if ( v6 <= 0x7FF )
{
v14 = (v6 >> 6) | 0xC0;
goto LABEL_27;
}
if ( v6 <= 0xFFFF )
{
v13 = (v6 >> 12) | 0xE0;
goto LABEL_26;
}
LABEL_25:
std::string::push_back(&this[5], (unsigned int)(char)((v6 >> 18) | 0xF0));
v13 = (v6 >> 12) & 0x3F | 0x80;
LABEL_26:
std::string::push_back(&this[5], (unsigned int)v13);
v14 = (v6 >> 6) & 0x3F | 0x80;
LABEL_27:
std::string::push_back(&this[5], (unsigned int)v14);
LOBYTE(v6) = v6 & 0x3F | 0x80;
}
LABEL_7:
std::string::push_back(&this[5], (unsigned int)(char)v6);
continue;
}
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
7753LL,
"GGML_ASSERT(%s) failed",
"0x00 <= codepoint && codepoint <= 0x10FFFF");
return nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::scan_number((nlohmann::json_abi_v3_11_3::detail::input_stream_adapter *)"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp");
default:
if ( v8 == 98 )
{
LOBYTE(v6) = 8;
}
else
{
if ( v8 != 102 )
goto LABEL_83;
LOBYTE(v6) = 12;
}
goto LABEL_7;
}
}
}
| scan_string:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
CALL 0x00174090
CMP dword ptr [RBX + 0x14],0x22
JNZ 0x00173c89
LEA R14,[RBX + 0x50]
LEA R12,[0x218b34]
LEA R13,[0x211648]
LAB_00173886:
MOV RDI,RBX
CALL 0x0012154c
INC EAX
CMP EAX,0xf5
JA 0x00173c58
MOVSXD RAX,dword ptr [R13 + RAX*0x4]
ADD RAX,R13
switchD:
JMP RAX
caseD_c2:
MOV RAX,0xbf00000080
MOV RSI,RSP
MOV qword ptr [RSI],RAX
MOV EDX,0x2
JMP 0x00173926
caseD_e1:
MOVAPS XMM0,xmmword ptr [0x002114c0]
LAB_001738c3:
MOV RSI,RSP
MOVAPS xmmword ptr [RSI],XMM0
MOV EDX,0x4
JMP 0x00173926
caseD_20:
MOV R15B,byte ptr [RBX + 0x14]
LAB_001738d4:
MOVSX ESI,R15B
MOV RDI,R14
CALL 0x001213a0
JMP 0x00173886
caseD_f1:
MOVUPS XMM0,xmmword ptr [0x0021b3d8]
JMP 0x0017390d
caseD_ed:
MOVAPS XMM0,xmmword ptr [0x002114b0]
JMP 0x001738c3
caseD_e0:
MOVAPS XMM0,xmmword ptr [0x002114d0]
JMP 0x001738c3
caseD_f4:
MOVUPS XMM0,xmmword ptr [0x0021b3f0]
JMP 0x0017390d
caseD_f0:
MOVUPS XMM0,xmmword ptr [0x0021b3c0]
LAB_0017390d:
MOV RSI,RSP
MOVAPS xmmword ptr [RSI],XMM0
MOV RAX,0xbf00000080
MOV qword ptr [RSI + 0x10],RAX
MOV EDX,0x6
LAB_00173926:
MOV RDI,RBX
CALL 0x00174114
TEST AL,AL
JNZ 0x00173886
JMP 0x00173c63
caseD_5c:
MOV RDI,RBX
CALL 0x0012154c
LEA RBP,[0x218ab7]
CMP EAX,0x61
JLE 0x00173a75
LEA ECX,[RAX + -0x6e]
CMP ECX,0x7
JA 0x00173a90
LEA RAX,[0x211a20]
MOVSXD RCX,dword ptr [RAX + RCX*0x4]
ADD RCX,RAX
switchD:
JMP RCX
caseD_75:
MOV RDI,RBX
CALL 0x001740ce
LEA RBP,[0x2189c6]
CMP EAX,-0x1
JZ 0x00173c5f
MOV R15D,EAX
AND EAX,0xfffffc00
CMP EAX,0xd800
JNZ 0x00173a40
MOV RDI,RBX
CALL 0x0012154c
CMP EAX,0x5c
JNZ 0x00173c77
MOV RDI,RBX
CALL 0x0012154c
CMP EAX,0x75
JNZ 0x00173c77
MOV RDI,RBX
CALL 0x001740ce
CMP EAX,-0x1
JZ 0x00173c5f
MOV ECX,EAX
AND ECX,0xfffffc00
LEA RBP,[0x2189fc]
CMP ECX,0xdc00
JNZ 0x00173c5f
SHL R15D,0xa
ADD R15D,EAX
ADD R15D,0xfca02400
LAB_001739f6:
MOV EAX,R15D
SHR EAX,0x12
OR AL,0xf0
MOVSX ESI,AL
MOV RDI,R14
CALL 0x001213a0
MOV EAX,R15D
SHR EAX,0xc
AND AL,0x3f
OR AL,0x80
LAB_00173a13:
MOVSX ESI,AL
MOV RDI,R14
CALL 0x001213a0
MOV EAX,R15D
SHR EAX,0x6
AND AL,0x3f
OR AL,0x80
LAB_00173a28:
MOVSX ESI,AL
MOV RDI,R14
CALL 0x001213a0
AND R15B,0x3f
OR R15B,0x80
JMP 0x001738d4
LAB_00173a40:
CMP EAX,0xdc00
JZ 0x00173c80
CMP R15D,0x110000
JNC 0x00173ca5
CMP R15D,0x7f
JBE 0x001738d4
CMP R15D,0x7ff
JA 0x00173aa6
MOV EAX,R15D
SHR EAX,0x6
OR AL,0xc0
JMP 0x00173a28
LAB_00173a75:
CMP EAX,0x22
JZ 0x00173ac8
CMP EAX,0x2f
JZ 0x00173ac0
CMP EAX,0x5c
JNZ 0x00173c5f
MOV R15B,0x5c
JMP 0x001738d4
default:
CMP EAX,0x62
JZ 0x00173ae8
CMP EAX,0x66
JNZ 0x00173c5f
MOV R15B,0xc
JMP 0x001738d4
LAB_00173aa6:
CMP R15D,0xffff
JA 0x001739f6
MOV EAX,R15D
SHR EAX,0xc
OR AL,0xe0
JMP 0x00173a13
LAB_00173ac0:
MOV R15B,0x2f
JMP 0x001738d4
LAB_00173ac8:
MOV R15B,0x22
JMP 0x001738d4
caseD_74:
MOV R15B,0x9
JMP 0x001738d4
caseD_6e:
MOV R15B,0xa
JMP 0x001738d4
caseD_72:
MOV R15B,0xd
JMP 0x001738d4
LAB_00173ae8:
MOV R15B,0x8
JMP 0x001738d4
caseD_22:
MOV EAX,0x4
JMP 0x00173c68
caseD_1f:
LEA RBP,[0x2193d4]
JMP 0x00173c5f
caseD_19:
LEA RBP,[0x219222]
JMP 0x00173c5f
caseD_1e:
LEA RBP,[0x21938c]
JMP 0x00173c5f
caseD_c:
LEA RBP,[0x218e65]
JMP 0x00173c5f
caseD_1c:
LEA RBP,[0x2192fc]
JMP 0x00173c5f
caseD_18:
LEA RBP,[0x2191d9]
JMP 0x00173c5f
caseD_4:
LEA RBP,[0x218c0f]
JMP 0x00173c5f
caseD_8:
LEA RBP,[0x218d33]
JMP 0x00173c5f
caseD_3:
LEA RBP,[0x218bc6]
JMP 0x00173c5f
caseD_6:
LEA RBP,[0x218ca1]
JMP 0x00173c5f
caseD_7:
LEA RBP,[0x218cea]
JMP 0x00173c5f
caseD_1:
MOV RBP,R12
JMP 0x00173c5f
caseD_10:
LEA RBP,[0x218f91]
JMP 0x00173c5f
caseD_e:
LEA RBP,[0x218f01]
JMP 0x00173c5f
caseD_ffffffff:
LEA RBP,[0x2189a0]
JMP 0x00173c5f
caseD_5:
LEA RBP,[0x218c58]
JMP 0x00173c5f
caseD_11:
LEA RBP,[0x218fda]
JMP 0x00173c5f
caseD_0:
LEA RBP,[0x218aeb]
JMP 0x00173c5f
caseD_2:
LEA RBP,[0x218b7d]
JMP 0x00173c5f
caseD_13:
LEA RBP,[0x21906c]
JMP 0x00173c5f
caseD_14:
LEA RBP,[0x2190b5]
JMP 0x00173c5f
caseD_1b:
LEA RBP,[0x2192b3]
JMP 0x00173c5f
caseD_9:
LEA RBP,[0x218d81]
JMP 0x00173c5f
caseD_15:
LEA RBP,[0x2190fe]
JMP 0x00173c5f
caseD_d:
LEA RBP,[0x218eb3]
JMP 0x00173c5f
caseD_1a:
LEA RBP,[0x21926a]
JMP 0x00173c5f
caseD_a:
LEA RBP,[0x218dcf]
JMP 0x00173c5f
caseD_b:
LEA RBP,[0x218e1d]
JMP 0x00173c5f
caseD_12:
LEA RBP,[0x219023]
JMP 0x00173c5f
caseD_f:
LEA RBP,[0x218f49]
JMP 0x00173c5f
caseD_1d:
LEA RBP,[0x219344]
JMP 0x00173c5f
caseD_16:
LEA RBP,[0x219147]
JMP 0x00173c5f
caseD_17:
LEA RBP,[0x219190]
JMP 0x00173c5f
caseD_80:
LEA RBP,[0x21941c]
caseD_6f:
MOV qword ptr [RBX + 0x70],RBP
LAB_00173c63:
MOV EAX,0xe
LAB_00173c68:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00173c77:
LEA RBP,[0x2189fc]
JMP 0x00173c5f
LAB_00173c80:
LEA RBP,[0x218a48]
JMP 0x00173c5f
LAB_00173c89:
LEA RDI,[0x218722]
LEA RDX,[0x21875d]
LEA RCX,[0x218990]
MOV ESI,0x1dd1
JMP 0x00173cbf
LAB_00173ca5:
LEA RDI,[0x218722]
LEA RDX,[0x21875d]
LEA RCX,[0x218a8c]
MOV ESI,0x1e49
LAB_00173cbf:
XOR EAX,EAX
CALL 0x00120e70
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>, nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::scan_string() */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
::scan_string(lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
*this)
{
char cVar1;
int4 uVar2;
int iVar3;
uint uVar4;
char *pcVar5;
int8 uVar6;
char cVar7;
int4 uVar8;
int8 local_48;
int4 uStack_40;
int4 uStack_3c;
int8 local_38;
reset(this);
if (*(int *)(this + 0x14) != 0x22) {
pcVar5 = "current == \'\\\"\'";
uVar6 = 0x1dd1;
LAB_00173cbf:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",uVar6,
"GGML_ASSERT(%s) failed",pcVar5);
}
cVar7 = (char)this + 'P';
LAB_00173886:
uVar2 = get(this);
switch(uVar2) {
case 0:
pcVar5 = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
break;
case 1:
pcVar5 = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
break;
case 2:
pcVar5 = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
break;
case 3:
pcVar5 = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
break;
case 4:
pcVar5 = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
break;
case 5:
pcVar5 = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
break;
case 6:
pcVar5 = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
break;
case 7:
pcVar5 = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
break;
case 8:
pcVar5 = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
break;
case 9:
pcVar5 = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
break;
case 10:
pcVar5 = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
break;
case 0xb:
pcVar5 = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
break;
case 0xc:
pcVar5 = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
break;
case 0xd:
pcVar5 = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
break;
case 0xe:
pcVar5 = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
break;
case 0xf:
pcVar5 = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
break;
case 0x10:
pcVar5 = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
break;
case 0x11:
pcVar5 = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
break;
case 0x12:
pcVar5 = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
break;
case 0x13:
pcVar5 = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
break;
case 0x14:
pcVar5 = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
break;
case 0x15:
pcVar5 = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
break;
case 0x16:
pcVar5 = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
break;
case 0x17:
pcVar5 = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
break;
case 0x18:
pcVar5 = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
break;
case 0x19:
pcVar5 = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
break;
case 0x1a:
pcVar5 = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
break;
case 0x1b:
pcVar5 = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
break;
case 0x1c:
pcVar5 = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
break;
case 0x1d:
pcVar5 = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
break;
case 0x1e:
pcVar5 = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
break;
case 0x1f:
pcVar5 = "invalid string: control character U+001F (US) must be escaped to \\u001F";
break;
case 0x20:
case 0x21:
case 0x23:
case 0x24:
case 0x25:
case 0x26:
case 0x27:
case 0x28:
case 0x29:
case 0x2a:
case 0x2b:
case 0x2c:
case 0x2d:
case 0x2e:
case 0x2f:
case 0x30:
case 0x31:
case 0x32:
case 0x33:
case 0x34:
case 0x35:
case 0x36:
case 0x37:
case 0x38:
case 0x39:
case 0x3a:
case 0x3b:
case 0x3c:
case 0x3d:
case 0x3e:
case 0x3f:
case 0x40:
case 0x41:
case 0x42:
case 0x43:
case 0x44:
case 0x45:
case 0x46:
case 0x47:
case 0x48:
case 0x49:
case 0x4a:
case 0x4b:
case 0x4c:
case 0x4d:
case 0x4e:
case 0x4f:
case 0x50:
case 0x51:
case 0x52:
case 0x53:
case 0x54:
case 0x55:
case 0x56:
case 0x57:
case 0x58:
case 0x59:
case 0x5a:
case 0x5b:
case 0x5d:
case 0x5e:
case 0x5f:
case 0x60:
case 0x61:
case 0x62:
case 99:
case 100:
case 0x65:
case 0x66:
case 0x67:
case 0x68:
case 0x69:
case 0x6a:
case 0x6b:
case 0x6c:
case 0x6d:
case 0x6e:
case 0x6f:
case 0x70:
case 0x71:
case 0x72:
case 0x73:
case 0x74:
case 0x75:
case 0x76:
case 0x77:
case 0x78:
case 0x79:
case 0x7a:
case 0x7b:
case 0x7c:
case 0x7d:
case 0x7e:
case 0x7f:
goto LAB_001738d4;
case 0x22:
return 4;
case 0x5c:
iVar3 = get(this);
pcVar5 = "invalid string: forbidden character after backslash";
if (iVar3 < 0x62) {
if (((iVar3 != 0x22) && (iVar3 != 0x2f)) && (iVar3 != 0x5c)) break;
}
else {
switch(iVar3) {
case 0x6e:
break;
case 0x6f:
case 0x70:
case 0x71:
case 0x73:
goto switchD_0017396d_caseD_6f;
case 0x72:
break;
case 0x74:
break;
case 0x75:
uVar4 = get_codepoint(this);
pcVar5 = "invalid string: \'\\u\' must be followed by 4 hex digits";
if (uVar4 == 0xffffffff) goto switchD_0017396d_caseD_6f;
if ((uVar4 & 0xfffffc00) == 0xd800) {
iVar3 = get(this);
if ((iVar3 != 0x5c) || (iVar3 = get(this), iVar3 != 0x75)) {
pcVar5 = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
goto switchD_0017396d_caseD_6f;
}
uVar4 = get_codepoint(this);
if ((uVar4 == 0xffffffff) ||
(pcVar5 = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF"
, (uVar4 & 0xfffffc00) != 0xdc00)) goto switchD_0017396d_caseD_6f;
LAB_001739f6:
std::__cxx11::string::push_back(cVar7);
LAB_00173a13:
std::__cxx11::string::push_back(cVar7);
}
else {
if ((uVar4 & 0xfffffc00) == 0xdc00) {
pcVar5 = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
goto switchD_0017396d_caseD_6f;
}
if (0x10ffff < uVar4) {
pcVar5 = "0x00 <= codepoint && codepoint <= 0x10FFFF";
uVar6 = 0x1e49;
goto LAB_00173cbf;
}
if (uVar4 < 0x80) break;
if (0x7ff < uVar4) {
if (0xffff < uVar4) goto LAB_001739f6;
goto LAB_00173a13;
}
}
std::__cxx11::string::push_back(cVar7);
break;
default:
if ((iVar3 != 0x62) && (iVar3 != 0x66)) goto switchD_0017396d_caseD_6f;
}
}
LAB_001738d4:
std::__cxx11::string::push_back(cVar7);
goto LAB_00173886;
default:
pcVar5 = "invalid string: ill-formed UTF-8 byte";
break;
case 0xc2:
case 0xc3:
case 0xc4:
case 0xc5:
case 0xc6:
case 199:
case 200:
case 0xc9:
case 0xca:
case 0xcb:
case 0xcc:
case 0xcd:
case 0xce:
case 0xcf:
case 0xd0:
case 0xd1:
case 0xd2:
case 0xd3:
case 0xd4:
case 0xd5:
case 0xd6:
case 0xd7:
case 0xd8:
case 0xd9:
case 0xda:
case 0xdb:
case 0xdc:
case 0xdd:
case 0xde:
case 0xdf:
local_48 = 0xbf00000080;
uVar6 = 2;
goto LAB_00173926;
case 0xe0:
uVar2 = _DAT_002114d0;
uVar8 = _UNK_002114d4;
uStack_40 = _UNK_002114d8;
uStack_3c = _UNK_002114dc;
goto LAB_001738c3;
case 0xe1:
case 0xe2:
case 0xe3:
case 0xe4:
case 0xe5:
case 0xe6:
case 0xe7:
case 0xe8:
case 0xe9:
case 0xea:
case 0xeb:
case 0xec:
case 0xee:
case 0xef:
uVar2 = _DAT_002114c0;
uVar8 = _UNK_002114c4;
uStack_40 = _UNK_002114c8;
uStack_3c = _UNK_002114cc;
goto LAB_001738c3;
case 0xed:
uVar2 = _DAT_002114b0;
uVar8 = _UNK_002114b4;
uStack_40 = _UNK_002114b8;
uStack_3c = _UNK_002114bc;
LAB_001738c3:
local_48 = CONCAT44(uVar8,uVar2);
uVar6 = 4;
LAB_00173926:
cVar1 = next_byte_in_range(this,&local_48,uVar6);
if (cVar1 == '\0') {
return 0xe;
}
goto LAB_00173886;
case 0xf0:
uVar2 = _DAT_0021b3c0;
uVar8 = _UNK_0021b3c4;
uStack_40 = _UNK_0021b3c8;
uStack_3c = _UNK_0021b3cc;
goto LAB_0017390d;
case 0xf1:
case 0xf2:
case 0xf3:
uVar2 = _DAT_0021b3d8;
uVar8 = _UNK_0021b3dc;
uStack_40 = _UNK_0021b3e0;
uStack_3c = _UNK_0021b3e4;
goto LAB_0017390d;
case 0xf4:
uVar2 = _DAT_0021b3f0;
uVar8 = _UNK_0021b3f4;
uStack_40 = _UNK_0021b3f8;
uStack_3c = _UNK_0021b3fc;
LAB_0017390d:
local_48 = CONCAT44(uVar8,uVar2);
local_38 = 0xbf00000080;
uVar6 = 6;
goto LAB_00173926;
case 0xffffffff:
pcVar5 = "invalid string: missing closing quote";
}
switchD_0017396d_caseD_6f:
*(char **)(this + 0x70) = pcVar5;
return 0xe;
}
| |
24,896 | end_partitioned_key_cache | eloqsql/mysys/mf_keycache.c | static
void end_partitioned_key_cache(PARTITIONED_KEY_CACHE_CB *keycache,
my_bool cleanup)
{
uint i;
uint partitions= keycache->partitions;
DBUG_ENTER("partitioned_end_key_cache");
DBUG_PRINT("enter", ("key_cache: %p", keycache));
for (i= 0; i < partitions; i++)
{
end_simple_key_cache(keycache->partition_array[i], cleanup);
}
if (cleanup)
{
for (i= 0; i < partitions; i++)
my_free(keycache->partition_array[i]);
my_free(keycache->partition_array);
keycache->key_cache_inited= 0;
}
DBUG_VOID_RETURN;
} | O0 | c | end_partitioned_key_cache:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0xed56e
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0xed5a0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x10(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
movsbl -0x9(%rbp), %esi
callq 0xebb30
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xed575
cmpb $0x0, -0x9(%rbp)
je 0xed5e8
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0xed5d4
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x10(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0xfc410
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xed5ad
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xfc410
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
jmp 0xed5ea
jmp 0xed5ec
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| end_partitioned_key_cache:
push rbp
mov rbp, rsp
sub rsp, 20h
mov al, sil
mov [rbp+var_8], rdi
mov [rbp+var_9], al
mov rax, [rbp+var_8]
mov eax, [rax+1Ch]
mov [rbp+var_14], eax
jmp short $+2
loc_ED56E:
mov [rbp+var_10], 0
loc_ED575:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_14]
jnb short loc_ED5A0
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov ecx, [rbp+var_10]
mov rdi, [rax+rcx*8]
movsx esi, [rbp+var_9]
call end_simple_key_cache
mov eax, [rbp+var_10]
add eax, 1
mov [rbp+var_10], eax
jmp short loc_ED575
loc_ED5A0:
cmp [rbp+var_9], 0
jz short loc_ED5E8
mov [rbp+var_10], 0
loc_ED5AD:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_14]
jnb short loc_ED5D4
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov ecx, [rbp+var_10]
mov rdi, [rax+rcx*8]
call my_free
mov eax, [rbp+var_10]
add eax, 1
mov [rbp+var_10], eax
jmp short loc_ED5AD
loc_ED5D4:
mov rax, [rbp+var_8]
mov rdi, [rax+8]
call my_free
mov rax, [rbp+var_8]
mov byte ptr [rax], 0
loc_ED5E8:
jmp short $+2
loc_ED5EA:
jmp short $+2
loc_ED5EC:
add rsp, 20h
pop rbp
retn
| long long end_partitioned_key_cache(long long a1, char a2)
{
long long result; // rax
unsigned int v3; // [rsp+Ch] [rbp-14h]
unsigned int i; // [rsp+10h] [rbp-10h]
unsigned int j; // [rsp+10h] [rbp-10h]
v3 = *(_DWORD *)(a1 + 28);
for ( i = 0; ; ++i )
{
result = i;
if ( i >= v3 )
break;
end_simple_key_cache(*(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL * i), a2);
}
if ( a2 )
{
for ( j = 0; j < v3; ++j )
my_free(*(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL * j));
my_free(*(_QWORD *)(a1 + 8));
result = a1;
*(_BYTE *)a1 = 0;
}
return result;
}
| end_partitioned_key_cache:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV AL,SIL
MOV qword ptr [RBP + -0x8],RDI
MOV byte ptr [RBP + -0x9],AL
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x1c]
MOV dword ptr [RBP + -0x14],EAX
JMP 0x001ed56e
LAB_001ed56e:
MOV dword ptr [RBP + -0x10],0x0
LAB_001ed575:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x14]
JNC 0x001ed5a0
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + RCX*0x8]
MOVSX ESI,byte ptr [RBP + -0x9]
CALL 0x001ebb30
MOV EAX,dword ptr [RBP + -0x10]
ADD EAX,0x1
MOV dword ptr [RBP + -0x10],EAX
JMP 0x001ed575
LAB_001ed5a0:
CMP byte ptr [RBP + -0x9],0x0
JZ 0x001ed5e8
MOV dword ptr [RBP + -0x10],0x0
LAB_001ed5ad:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x14]
JNC 0x001ed5d4
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + RCX*0x8]
CALL 0x001fc410
MOV EAX,dword ptr [RBP + -0x10]
ADD EAX,0x1
MOV dword ptr [RBP + -0x10],EAX
JMP 0x001ed5ad
LAB_001ed5d4:
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x001fc410
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX],0x0
LAB_001ed5e8:
JMP 0x001ed5ea
LAB_001ed5ea:
JMP 0x001ed5ec
LAB_001ed5ec:
ADD RSP,0x20
POP RBP
RET
|
void end_partitioned_key_cache(int1 *param_1,char param_2)
{
uint uVar1;
uint local_18;
uVar1 = *(uint *)(param_1 + 0x1c);
for (local_18 = 0; local_18 < uVar1; local_18 = local_18 + 1) {
end_simple_key_cache(*(int8 *)(*(long *)(param_1 + 8) + (ulong)local_18 * 8),(int)param_2)
;
}
if (param_2 != '\0') {
for (local_18 = 0; local_18 < uVar1; local_18 = local_18 + 1) {
my_free(*(int8 *)(*(long *)(param_1 + 8) + (ulong)local_18 * 8));
}
my_free(*(int8 *)(param_1 + 8));
*param_1 = 0;
}
return;
}
| |
24,897 | void mcp::logger::log_impl<char const (&) [37], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>&, char const (&) [37], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | hkr04[P]cpp-mcp/include/mcp_logger.h | void log_impl(std::stringstream& ss, T&& arg, Args&&... args) {
ss << std::forward<T>(arg);
log_impl(ss, std::forward<Args>(args)...);
} | O3 | c | void mcp::logger::log_impl<char const (&) [37], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>&, char const (&) [37], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
leaq 0x10(%rsi), %r15
movq %rdx, %rdi
callq 0x51c0
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x54d0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x54d0
nop
| _ZN3mcp6logger8log_implIRA37_KcJRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEEvRNS5_18basic_stringstreamIcS8_S9_EEOT_DpOT0_:
push r15
push r14
push rbx
mov rbx, rcx
mov r14, rdx
lea r15, [rsi+10h]
mov rdi, rdx
call _strlen
mov rdi, r15
mov rsi, r14
mov rdx, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rsi, [rbx]
mov rdx, [rbx+8]
mov rdi, r15
pop rbx
pop r14
pop r15
jmp __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
| long long mcp::logger::log_impl<char const(&)[37],std::string const&>(
long long a1,
long long a2,
long long a3,
_QWORD *a4)
{
long long v6; // rax
v6 = strlen(a3);
std::__ostream_insert<char,std::char_traits<char>>(a2 + 16, a3, v6);
return std::__ostream_insert<char,std::char_traits<char>>(a2 + 16, *a4, a4[1]);
}
| log_impl<char_const(&)[37],std::__cxx11::string_const&>:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RCX
MOV R14,RDX
LEA R15,[RSI + 0x10]
MOV RDI,RDX
CALL 0x001051c0
MOV RDI,R15
MOV RSI,R14
MOV RDX,RAX
CALL 0x001054d0
MOV RSI,qword ptr [RBX]
MOV RDX,qword ptr [RBX + 0x8]
MOV RDI,R15
POP RBX
POP R14
POP R15
JMP 0x001054d0
|
/* void mcp::logger::log_impl<char const (&) [37], std::__cxx11::string
const&>(std::__cxx11::stringstream&, char const (&) [37], std::__cxx11::string const&) */
void __thiscall
mcp::logger::log_impl<char_const(&)[37],std::__cxx11::string_const&>
(logger *this,stringstream *param_1,char *param_2,string *param_3)
{
size_t sVar1;
sVar1 = strlen(param_2);
std::__ostream_insert<char,std::char_traits<char>>((ostream *)(param_1 + 0x10),param_2,sVar1);
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)(param_1 + 0x10),*(char **)param_3,*(long *)(param_3 + 8));
return;
}
| |
24,898 | ma_init | eloqsql/libmariadb/libmariadb/ma_init.c | void ma_init(void)
{
if (ma_init_done)
return;
ma_init_done=1;
{
#ifdef _WIN32
my_win_init();
#endif
return;
}
} | O0 | c | ma_init:
pushq %rbp
movq %rsp, %rbp
leaq 0x41846(%rip), %rax # 0x81401
cmpb $0x0, (%rax)
je 0x3fbc2
jmp 0x3fbcc
leaq 0x41838(%rip), %rax # 0x81401
movb $0x1, (%rax)
popq %rbp
retq
nop
| ma_init:
push rbp
mov rbp, rsp
lea rax, ma_init_done
cmp byte ptr [rax], 0
jz short loc_3FBC2
jmp short loc_3FBCC
loc_3FBC2:
lea rax, ma_init_done
mov byte ptr [rax], 1
loc_3FBCC:
pop rbp
retn
| void *ma_init()
{
void *result; // rax
result = &ma_init_done;
if ( !ma_init_done )
{
result = &ma_init_done;
ma_init_done = 1;
}
return result;
}
| ma_init:
PUSH RBP
MOV RBP,RSP
LEA RAX,[0x181401]
CMP byte ptr [RAX],0x0
JZ 0x0013fbc2
JMP 0x0013fbcc
LAB_0013fbc2:
LEA RAX,[0x181401]
MOV byte ptr [RAX],0x1
LAB_0013fbcc:
POP RBP
RET
|
void ma_init(void)
{
if (ma_init_done == '\0') {
ma_init_done = '\x01';
}
return;
}
| |
24,899 | uf_space_endspace_selected | eloqsql/storage/myisam/mi_packrec.c | static void uf_space_endspace_selected(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
uchar *to, uchar *end)
{
uint spaces;
if (get_bit(bit_buff))
bfill((uchar*) to,(end-to),' ');
else
{
if (get_bit(bit_buff))
{
if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
{
bit_buff->error=1;
return;
}
if (to+spaces != end)
decode_bytes(rec,bit_buff,to,end-spaces);
bfill((uchar*) end-spaces,spaces,' ');
}
else
decode_bytes(rec,bit_buff,to,end);
}
} | O3 | c | uf_space_endspace_selected:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
movl 0x4(%rsi), %eax
testl %eax, %eax
je 0x848cd
movl (%r15), %r12d
decl %eax
movl %eax, 0x4(%r15)
btl %eax, %r12d
jb 0x84942
testl %eax, %eax
jne 0x848ea
movq %r15, %rdi
callq 0x83d5d
movl $0x1f, 0x4(%r15)
movl (%r15), %r12d
testl %r12d, %r12d
jns 0x84955
movl $0x1f, %eax
jmp 0x848f6
movq %r15, %rdi
callq 0x83d5d
movl $0x1f, 0x4(%r15)
movl (%r15), %r12d
movl $0x1f, %eax
testl %r12d, %r12d
js 0x84942
decl %eax
movl %eax, 0x4(%r15)
btl %eax, %r12d
jae 0x84955
movq %r13, %rdx
movl 0x1c(%r13), %r13d
movl %eax, %ecx
subl %r13d, %ecx
movq %rdx, -0x30(%rbp)
jae 0x84974
subl %eax, %r13d
movl %eax, %eax
leaq 0x5dffc(%rip), %rcx # 0xe2910
andl (%rcx,%rax,4), %r12d
movl %r13d, %ecx
shll %cl, %r12d
movq %r15, %rdi
callq 0x83d5d
movl $0x20, %eax
subl %r13d, %eax
movl %eax, 0x4(%r15)
movl (%r15), %eax
negl %r13d
movl %r13d, %ecx
shrl %cl, %eax
addl %eax, %r12d
jmp 0x84989
subq %r14, %rbx
movq %r14, %rdi
movl $0x20, %esi
movq %rbx, %rdx
jmp 0x849d8
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8464e
movl %ecx, 0x4(%r15)
shrl %cl, %r12d
movl 0x1c(%rdx), %eax
leaq 0x5df8b(%rip), %rcx # 0xe2910
andl (%rcx,%rax,4), %r12d
movl %r12d, %r13d
leaq (%r14,%r13), %rax
cmpq %rbx, %rax
jbe 0x849ac
movl $0x1, 0x28(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %r12
negq %r12
cmpq %rbx, %rax
je 0x849ca
leaq (%rbx,%r12), %rcx
movq -0x30(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x8464e
addq %r12, %rbx
movq %rbx, %rdi
movl $0x20, %esi
movq %r13, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x29270
| uf_space_endspace_selected_0:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rcx
mov r14, rdx
mov r15, rsi
mov r13, rdi
mov eax, [rsi+4]
test eax, eax
jz short loc_848CD
mov r12d, [r15]
dec eax
mov [r15+4], eax
bt r12d, eax
jb loc_84942
test eax, eax
jnz short loc_848EA
mov rdi, r15
call fill_buffer_0
mov dword ptr [r15+4], 1Fh
mov r12d, [r15]
test r12d, r12d
jns loc_84955
mov eax, 1Fh
jmp short loc_848F6
loc_848CD:
mov rdi, r15
call fill_buffer_0
mov dword ptr [r15+4], 1Fh
mov r12d, [r15]
mov eax, 1Fh
test r12d, r12d
js short loc_84942
loc_848EA:
dec eax
mov [r15+4], eax
bt r12d, eax
jnb short loc_84955
loc_848F6:
mov rdx, r13
mov r13d, [r13+1Ch]
mov ecx, eax
sub ecx, r13d
mov [rbp+var_30], rdx
jnb short loc_84974
sub r13d, eax
mov eax, eax
lea rcx, mask_0
and r12d, [rcx+rax*4]
mov ecx, r13d
shl r12d, cl
mov rdi, r15
call fill_buffer_0
mov eax, 20h ; ' '
sub eax, r13d
mov [r15+4], eax
mov eax, [r15]
neg r13d
mov ecx, r13d
shr eax, cl
add r12d, eax
jmp short loc_84989
loc_84942:
sub rbx, r14
mov rdi, r14
mov esi, 20h ; ' '
mov rdx, rbx
jmp loc_849D8
loc_84955:
mov rdi, r13
mov rsi, r15
mov rdx, r14
mov rcx, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp decode_bytes_0
loc_84974:
mov [r15+4], ecx
shr r12d, cl
mov eax, [rdx+1Ch]
lea rcx, mask_0
and r12d, [rcx+rax*4]
loc_84989:
mov r13d, r12d
lea rax, [r14+r13]
cmp rax, rbx
jbe short loc_849AC
mov dword ptr [r15+28h], 1
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_849AC:
mov r12, r13
neg r12
cmp rax, rbx
jz short loc_849CA
lea rcx, [rbx+r12]
mov rdi, [rbp+var_30]
mov rsi, r15
mov rdx, r14
call decode_bytes_0
loc_849CA:
add rbx, r12
mov rdi, rbx
mov esi, 20h ; ' '
mov rdx, r13
loc_849D8:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _memset
| _BYTE * uf_space_endspace_selected_0(long long a1, unsigned int *a2, _BYTE *a3, _BYTE *a4)
{
unsigned int v6; // eax
unsigned int v7; // r12d
unsigned int v8; // eax
unsigned int v9; // eax
unsigned int v10; // r13d
unsigned int v11; // ecx
int v12; // r13d
int v13; // r12d
unsigned int v14; // r12d
_BYTE *result; // rax
v6 = a2[1];
if ( !v6 )
{
fill_buffer_0((long long)a2);
a2[1] = 31;
v7 = *a2;
v8 = 31;
if ( (*a2 & 0x80000000) == 0 )
{
LABEL_7:
v9 = v8 - 1;
a2[1] = v9;
if ( _bittest((const int *)&v7, v9) )
goto LABEL_8;
return decode_bytes_0(a1, (long long)a2, a3, a4);
}
return (_BYTE *)memset(a3, 32LL, a4 - a3);
}
v7 = *a2;
v8 = v6 - 1;
a2[1] = v8;
if ( _bittest((const int *)&v7, v8) )
return (_BYTE *)memset(a3, 32LL, a4 - a3);
if ( v8 )
goto LABEL_7;
fill_buffer_0((long long)a2);
a2[1] = 31;
v7 = *a2;
if ( (*a2 & 0x80000000) == 0 )
return decode_bytes_0(a1, (long long)a2, a3, a4);
v9 = 31;
LABEL_8:
v10 = *(_DWORD *)(a1 + 28);
v11 = v9 - v10;
if ( v9 >= v10 )
{
a2[1] = v11;
v14 = mask_0[*(unsigned int *)(a1 + 28)] & (v7 >> v11);
}
else
{
v12 = v10 - v9;
v13 = (mask_0[v9] & v7) << v12;
fill_buffer_0((long long)a2);
a2[1] = 32 - v12;
v14 = (*a2 >> -(char)v12) + v13;
}
result = &a3[v14];
if ( result <= a4 )
{
if ( result != a4 )
decode_bytes_0(a1, (long long)a2, a3, &a4[-v14]);
return (_BYTE *)memset(&a4[-v14], 32LL, v14);
}
else
{
a2[10] = 1;
}
return result;
}
| uf_space_endspace_selected:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R14,RDX
MOV R15,RSI
MOV R13,RDI
MOV EAX,dword ptr [RSI + 0x4]
TEST EAX,EAX
JZ 0x001848cd
MOV R12D,dword ptr [R15]
DEC EAX
MOV dword ptr [R15 + 0x4],EAX
BT R12D,EAX
JC 0x00184942
TEST EAX,EAX
JNZ 0x001848ea
MOV RDI,R15
CALL 0x00183d5d
MOV dword ptr [R15 + 0x4],0x1f
MOV R12D,dword ptr [R15]
TEST R12D,R12D
JNS 0x00184955
MOV EAX,0x1f
JMP 0x001848f6
LAB_001848cd:
MOV RDI,R15
CALL 0x00183d5d
MOV dword ptr [R15 + 0x4],0x1f
MOV R12D,dword ptr [R15]
MOV EAX,0x1f
TEST R12D,R12D
JS 0x00184942
LAB_001848ea:
DEC EAX
MOV dword ptr [R15 + 0x4],EAX
BT R12D,EAX
JNC 0x00184955
LAB_001848f6:
MOV RDX,R13
MOV R13D,dword ptr [R13 + 0x1c]
MOV ECX,EAX
SUB ECX,R13D
MOV qword ptr [RBP + -0x30],RDX
JNC 0x00184974
SUB R13D,EAX
MOV EAX,EAX
LEA RCX,[0x1e2910]
AND R12D,dword ptr [RCX + RAX*0x4]
MOV ECX,R13D
SHL R12D,CL
MOV RDI,R15
CALL 0x00183d5d
MOV EAX,0x20
SUB EAX,R13D
MOV dword ptr [R15 + 0x4],EAX
MOV EAX,dword ptr [R15]
NEG R13D
MOV ECX,R13D
SHR EAX,CL
ADD R12D,EAX
JMP 0x00184989
LAB_00184942:
SUB RBX,R14
MOV RDI,R14
MOV ESI,0x20
MOV RDX,RBX
JMP 0x001849d8
LAB_00184955:
MOV RDI,R13
MOV RSI,R15
MOV RDX,R14
MOV RCX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0018464e
LAB_00184974:
MOV dword ptr [R15 + 0x4],ECX
SHR R12D,CL
MOV EAX,dword ptr [RDX + 0x1c]
LEA RCX,[0x1e2910]
AND R12D,dword ptr [RCX + RAX*0x4]
LAB_00184989:
MOV R13D,R12D
LEA RAX,[R14 + R13*0x1]
CMP RAX,RBX
JBE 0x001849ac
MOV dword ptr [R15 + 0x28],0x1
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001849ac:
MOV R12,R13
NEG R12
CMP RAX,RBX
JZ 0x001849ca
LEA RCX,[RBX + R12*0x1]
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,R15
MOV RDX,R14
CALL 0x0018464e
LAB_001849ca:
ADD RBX,R12
MOV RDI,RBX
MOV ESI,0x20
MOV RDX,R13
LAB_001849d8:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00129270
|
void uf_space_endspace_selected(long param_1,uint *param_2,void *param_3,ulong param_4)
{
uint uVar1;
uint uVar2;
uint uVar3;
byte bVar4;
size_t __n;
uint uVar5;
if (param_2[1] == 0) {
fill_buffer(param_2);
param_2[1] = 0x1f;
uVar5 = *param_2;
uVar3 = 0x1f;
if ((int)uVar5 < 0) goto LAB_00184942;
LAB_001848ea:
uVar3 = uVar3 - 1;
param_2[1] = uVar3;
if ((uVar5 >> (uVar3 & 0x1f) & 1) == 0) {
LAB_00184955:
decode_bytes(param_1,param_2,param_3,param_4);
return;
}
}
else {
uVar5 = *param_2;
uVar3 = param_2[1] - 1;
param_2[1] = uVar3;
if ((uVar5 >> (uVar3 & 0x1f) & 1) != 0) {
LAB_00184942:
__n = param_4 - (long)param_3;
goto LAB_001849d8;
}
if (uVar3 != 0) goto LAB_001848ea;
fill_buffer(param_2);
param_2[1] = 0x1f;
uVar5 = *param_2;
if (-1 < (int)uVar5) goto LAB_00184955;
uVar3 = 0x1f;
}
uVar1 = *(uint *)(param_1 + 0x1c);
if (uVar3 < uVar1) {
uVar2 = (&mask)[uVar3];
bVar4 = (byte)(uVar1 - uVar3);
fill_buffer(param_2);
param_2[1] = 0x20 - (uVar1 - uVar3);
uVar5 = ((uVar5 & uVar2) << (bVar4 & 0x1f)) + (*param_2 >> (-bVar4 & 0x1f));
}
else {
param_2[1] = uVar3 - uVar1;
uVar5 = uVar5 >> ((byte)(uVar3 - uVar1) & 0x1f) & (&mask)[*(uint *)(param_1 + 0x1c)];
}
__n = (size_t)uVar5;
if (param_4 < (long)param_3 + __n) {
param_2[10] = 1;
return;
}
if ((long)param_3 + __n != param_4) {
decode_bytes(param_1,param_2,param_3,param_4 + -__n);
}
param_3 = (void *)(param_4 + -__n);
LAB_001849d8:
memset(param_3,0x20,__n);
return;
}
|
Subsets and Splits
C++ Functions Using STL
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++ STL Function Queries
Filters C++ code examples that use standard library containers and algorithms, helping identify common programming patterns and library usage in code generation tasks.
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.