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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
26,400 | ftxui::ComponentBase::Add(std::shared_ptr<ftxui::ComponentBase>) | Andrewchistyakov[P]flashcards_lyc/build_O1/_deps/ftxui-src/src/ftxui/component/component.cpp | void ComponentBase::Add(Component child) {
child->Detach();
child->parent_ = this;
children_.push_back(std::move(child));
} | O1 | cpp | ftxui::ComponentBase::Add(std::shared_ptr<ftxui::ComponentBase>):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
callq 0x273d2
movq (%rbx), %rax
movq %r14, 0x20(%rax)
addq $0x8, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x277e8
nop
| _ZN5ftxui13ComponentBase3AddESt10shared_ptrIS0_E:
push r14
push rbx
push rax
mov rbx, rsi
mov r14, rdi
mov rdi, [rsi]; this
call _ZN5ftxui13ComponentBase6DetachEv; ftxui::ComponentBase::Detach(void)
mov rax, [rbx]
mov [rax+20h], r14
add r14, 8
mov rdi, r14
mov rsi, rbx
add rsp, 8
pop rbx
pop r14
jmp _ZNSt6vectorISt10shared_ptrIN5ftxui13ComponentBaseEESaIS3_EE12emplace_backIJS3_EEERS3_DpOT_; std::vector<std::shared_ptr<ftxui::ComponentBase>>::emplace_back<std::shared_ptr<ftxui::ComponentBase>>(std::shared_ptr<ftxui::ComponentBase> &&)
| long long ftxui::ComponentBase::Add(long long a1, ftxui::ComponentBase **a2)
{
ftxui::ComponentBase::Detach(*a2);
*((_QWORD *)*a2 + 4) = a1;
return std::vector<std::shared_ptr<ftxui::ComponentBase>>::emplace_back<std::shared_ptr<ftxui::ComponentBase>>(
a1 + 8,
a2);
}
| Add:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
MOV RDI,qword ptr [RSI]
CALL 0x001273d2
MOV RAX,qword ptr [RBX]
MOV qword ptr [RAX + 0x20],R14
ADD R14,0x8
MOV RDI,R14
MOV RSI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x001277e8
|
/* ftxui::ComponentBase::Add(std::shared_ptr<ftxui::ComponentBase>) */
void __thiscall ftxui::ComponentBase::Add(ComponentBase *this,shared_ptr *param_2)
{
Detach(*(ComponentBase **)param_2);
*(ComponentBase **)(*(long *)param_2 + 0x20) = this;
std::
vector<std::shared_ptr<ftxui::ComponentBase>,std::allocator<std::shared_ptr<ftxui::ComponentBase>>>
::emplace_back<std::shared_ptr<ftxui::ComponentBase>>
((vector<std::shared_ptr<ftxui::ComponentBase>,std::allocator<std::shared_ptr<ftxui::ComponentBase>>>
*)(this + 8),param_2);
return;
}
| |
26,401 | PFS_buffer_default_allocator<PFS_rwlock>::alloc_array(PFS_buffer_default_array<PFS_rwlock>*) | eloqsql/storage/perfschema/pfs_buffer_container.h | int alloc_array(array_type *array)
{
array->m_ptr= NULL;
array->m_full= true;
array->m_monotonic.m_u32= 0;
if (array->m_max > 0)
{
array->m_ptr= PFS_MALLOC_ARRAY(m_builtin_class,
array->m_max, sizeof(T), T, MYF(MY_ZEROFILL));
if (array->m_ptr == NULL)
return 1;
array->m_full= false;
}
return 0;
} | O0 | c | PFS_buffer_default_allocator<PFS_rwlock>::alloc_array(PFS_buffer_default_array<PFS_rwlock>*):
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jbe 0x46675
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rsi
movl $0x160, %edx # imm = 0x160
movl $0x20, %ecx
callq 0x29b30
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x4666e
movl $0x1, -0x4(%rbp)
jmp 0x4667c
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| _ZN28PFS_buffer_default_allocatorI21PFS_table_share_indexE11alloc_arrayEP24PFS_buffer_default_arrayIS0_E:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov [rbp+var_20], rax
mov rax, [rbp+var_18]
mov qword ptr [rax+48h], 0
mov rax, [rbp+var_18]
mov byte ptr [rax], 1
mov rax, [rbp+var_18]
mov dword ptr [rax+4], 0
mov rax, [rbp+var_18]
cmp qword ptr [rax+50h], 0
jbe short loc_46675
mov rax, [rbp+var_20]
mov rdi, [rax]; PFS_builtin_memory_class *
mov rax, [rbp+var_18]
mov rsi, [rax+50h]; unsigned __int64
mov edx, 160h; unsigned __int64
mov ecx, 20h ; ' '; unsigned __int64
call _Z16pfs_malloc_arrayP24PFS_builtin_memory_classmmm; pfs_malloc_array(PFS_builtin_memory_class *,ulong,ulong,ulong)
mov rcx, rax
mov rax, [rbp+var_18]
mov [rax+48h], rcx
mov rax, [rbp+var_18]
cmp qword ptr [rax+48h], 0
jnz short loc_4666E
mov [rbp+var_4], 1
jmp short loc_4667C
loc_4666E:
mov rax, [rbp+var_18]
mov byte ptr [rax], 0
loc_46675:
mov [rbp+var_4], 0
loc_4667C:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long PFS_buffer_default_allocator<PFS_table_share_index>::alloc_array(
PFS_builtin_memory_class **a1,
long long a2)
{
*(_QWORD *)(a2 + 72) = 0LL;
*(_BYTE *)a2 = 1;
*(_DWORD *)(a2 + 4) = 0;
if ( !*(_QWORD *)(a2 + 80) )
return 0;
*(_QWORD *)(a2 + 72) = pfs_malloc_array(*a1, *(_QWORD *)(a2 + 80), 0x160uLL);
if ( *(_QWORD *)(a2 + 72) )
{
*(_BYTE *)a2 = 0;
return 0;
}
return 1;
}
| alloc_array:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x48],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],0x1
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x4],0x0
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x50],0x0
JBE 0x00146675
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RAX + 0x50]
MOV EDX,0x160
MOV ECX,0x20
CALL 0x00129b30
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x48],RCX
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x48],0x0
JNZ 0x0014666e
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0014667c
LAB_0014666e:
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],0x0
LAB_00146675:
MOV dword ptr [RBP + -0x4],0x0
LAB_0014667c:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
/* PFS_buffer_default_allocator<PFS_table_share_index>::alloc_array(PFS_buffer_default_array<PFS_table_share_index>*)
*/
int4 __thiscall
PFS_buffer_default_allocator<PFS_table_share_index>::alloc_array
(PFS_buffer_default_allocator<PFS_table_share_index> *this,
PFS_buffer_default_array *param_1)
{
int8 uVar1;
*(int8 *)(param_1 + 0x48) = 0;
*param_1 = (PFS_buffer_default_array)0x1;
*(int4 *)(param_1 + 4) = 0;
if (*(long *)(param_1 + 0x50) != 0) {
uVar1 = pfs_malloc_array(*(PFS_builtin_memory_class **)this,*(ulong *)(param_1 + 0x50),0x160,
0x20);
*(int8 *)(param_1 + 0x48) = uVar1;
if (*(long *)(param_1 + 0x48) == 0) {
return 1;
}
*param_1 = (PFS_buffer_default_array)0x0;
}
return 0;
}
| |
26,402 | PFS_buffer_default_allocator<PFS_rwlock>::alloc_array(PFS_buffer_default_array<PFS_rwlock>*) | eloqsql/storage/perfschema/pfs_buffer_container.h | int alloc_array(array_type *array)
{
array->m_ptr= NULL;
array->m_full= true;
array->m_monotonic.m_u32= 0;
if (array->m_max > 0)
{
array->m_ptr= PFS_MALLOC_ARRAY(m_builtin_class,
array->m_max, sizeof(T), T, MYF(MY_ZEROFILL));
if (array->m_ptr == NULL)
return 1;
array->m_full= false;
}
return 0;
} | O3 | c | PFS_buffer_default_allocator<PFS_rwlock>::alloc_array(PFS_buffer_default_array<PFS_rwlock>*):
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq $0x0, 0x48(%rsi)
movb $0x1, (%rsi)
movl $0x0, 0x4(%rsi)
movq 0x50(%rsi), %rsi
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x39e47
movq (%rdi), %rdi
movl $0x2c0, %edx # imm = 0x2C0
movl $0x20, %ecx
callq 0x2ce1c
movq %rax, 0x48(%r14)
testq %rax, %rax
je 0x39e42
movb $0x0, (%r14)
jmp 0x39e47
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
| _ZN28PFS_buffer_default_allocatorI8PFS_fileE11alloc_arrayEP24PFS_buffer_default_arrayIS0_E:
push rbp
mov rbp, rsp
push r14
push rbx
mov r14, rsi
mov qword ptr [rsi+48h], 0
mov byte ptr [rsi], 1
mov dword ptr [rsi+4], 0
mov rsi, [rsi+50h]
xor ebx, ebx
test rsi, rsi
jz short loc_39E47
mov rdi, [rdi]
mov edx, 2C0h
mov ecx, 20h ; ' '
call _Z16pfs_malloc_arrayP24PFS_builtin_memory_classmmm; pfs_malloc_array(PFS_builtin_memory_class *,ulong,ulong,ulong)
mov [r14+48h], rax
test rax, rax
jz short loc_39E42
mov byte ptr [r14], 0
jmp short loc_39E47
loc_39E42:
mov ebx, 1
loc_39E47:
mov eax, ebx
pop rbx
pop r14
pop rbp
retn
| long long PFS_buffer_default_allocator<PFS_file>::alloc_array(long long *a1, long long a2)
{
unsigned long long v3; // rsi
unsigned int v4; // ebx
long long v5; // rax
*(_QWORD *)(a2 + 72) = 0LL;
*(_BYTE *)a2 = 1;
*(_DWORD *)(a2 + 4) = 0;
v3 = *(_QWORD *)(a2 + 80);
v4 = 0;
if ( v3 )
{
v5 = pfs_malloc_array(*a1, v3, 0x2C0uLL);
*(_QWORD *)(a2 + 72) = v5;
if ( v5 )
*(_BYTE *)a2 = 0;
else
return 1;
}
return v4;
}
| alloc_array:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV R14,RSI
MOV qword ptr [RSI + 0x48],0x0
MOV byte ptr [RSI],0x1
MOV dword ptr [RSI + 0x4],0x0
MOV RSI,qword ptr [RSI + 0x50]
XOR EBX,EBX
TEST RSI,RSI
JZ 0x00139e47
MOV RDI,qword ptr [RDI]
MOV EDX,0x2c0
MOV ECX,0x20
CALL 0x0012ce1c
MOV qword ptr [R14 + 0x48],RAX
TEST RAX,RAX
JZ 0x00139e42
MOV byte ptr [R14],0x0
JMP 0x00139e47
LAB_00139e42:
MOV EBX,0x1
LAB_00139e47:
MOV EAX,EBX
POP RBX
POP R14
POP RBP
RET
|
/* PFS_buffer_default_allocator<PFS_file>::alloc_array(PFS_buffer_default_array<PFS_file>*) */
int8 __thiscall
PFS_buffer_default_allocator<PFS_file>::alloc_array
(PFS_buffer_default_allocator<PFS_file> *this,PFS_buffer_default_array *param_1)
{
long lVar1;
int8 uVar2;
*(int8 *)(param_1 + 0x48) = 0;
*param_1 = (PFS_buffer_default_array)0x1;
*(int4 *)(param_1 + 4) = 0;
uVar2 = 0;
if (*(ulong *)(param_1 + 0x50) != 0) {
lVar1 = pfs_malloc_array(*(PFS_builtin_memory_class **)this,*(ulong *)(param_1 + 0x50),0x2c0,
0x20);
*(long *)(param_1 + 0x48) = lVar1;
if (lVar1 == 0) {
uVar2 = 1;
}
else {
*param_1 = (PFS_buffer_default_array)0x0;
}
}
return uVar2;
}
| |
26,403 | my_context_init | eloqsql/libmariadb/libmariadb/ma_context.c | int
my_context_init(struct my_context *c, size_t stack_size)
{
memset(c, 0, sizeof(*c));
if (!(c->stack_bot= malloc(stack_size)))
return -1; /* Out of memory */
/*
The x86_64 ABI specifies 16-byte stack alignment.
Also put two zero words at the top of the stack.
*/
c->stack_top= (void *)
(( ((intptr)c->stack_bot + stack_size) & ~(intptr)0xf) - 16);
memset(c->stack_top, 0, 16);
#ifdef HAVE_VALGRIND
c->valgrind_stack_id=
VALGRIND_STACK_REGISTER(c->stack_bot, c->stack_top);
#endif
return 0;
} | O3 | c | my_context_init:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq $0x0, 0x50(%rdi)
movq %rsi, %rdi
callq 0x13610
movq %rax, 0x50(%rbx)
testq %rax, %rax
je 0x30793
addq %r14, %rax
andq $-0x10, %rax
leaq -0x10(%rax), %rcx
movq %rcx, 0x48(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, -0x10(%rax)
xorl %eax, %eax
jmp 0x30798
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
| my_context_init:
push rbp
mov rbp, rsp
push r14
push rbx
mov r14, rsi
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi+40h], xmm0
movups xmmword ptr [rdi+30h], xmm0
movups xmmword ptr [rdi+20h], xmm0
movups xmmword ptr [rdi+10h], xmm0
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+50h], 0
mov rdi, rsi
call _malloc
mov [rbx+50h], rax
test rax, rax
jz short loc_30793
add rax, r14
and rax, 0FFFFFFFFFFFFFFF0h
lea rcx, [rax-10h]
mov [rbx+48h], rcx
xorps xmm0, xmm0
movaps xmmword ptr [rax-10h], xmm0
xor eax, eax
jmp short loc_30798
loc_30793:
mov eax, 0FFFFFFFFh
loc_30798:
pop rbx
pop r14
pop rbp
retn
| long long my_context_init(long long a1, long long a2)
{
long long v2; // rax
_OWORD *v3; // rcx
*(_OWORD *)(a1 + 64) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 80) = 0LL;
v2 = malloc(a2);
*(_QWORD *)(a1 + 80) = v2;
if ( !v2 )
return 0xFFFFFFFFLL;
v3 = (_OWORD *)(((a2 + v2) & 0xFFFFFFFFFFFFFFF0LL) - 16);
*(_QWORD *)(a1 + 72) = v3;
*v3 = 0LL;
return 0LL;
}
| my_context_init:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x40],XMM0
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x50],0x0
MOV RDI,RSI
CALL 0x00113610
MOV qword ptr [RBX + 0x50],RAX
TEST RAX,RAX
JZ 0x00130793
ADD RAX,R14
AND RAX,-0x10
LEA RCX,[RAX + -0x10]
MOV qword ptr [RBX + 0x48],RCX
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RAX + -0x10],XMM0
XOR EAX,EAX
JMP 0x00130798
LAB_00130793:
MOV EAX,0xffffffff
LAB_00130798:
POP RBX
POP R14
POP RBP
RET
|
int8 my_context_init(int8 *param_1,size_t param_2)
{
void *pvVar1;
ulong uVar2;
int8 uVar3;
param_1[8] = 0;
param_1[9] = 0;
param_1[6] = 0;
param_1[7] = 0;
param_1[4] = 0;
param_1[5] = 0;
param_1[2] = 0;
param_1[3] = 0;
*param_1 = 0;
param_1[1] = 0;
param_1[10] = 0;
pvVar1 = malloc(param_2);
param_1[10] = pvVar1;
if (pvVar1 == (void *)0x0) {
uVar3 = 0xffffffff;
}
else {
uVar2 = (long)pvVar1 + param_2 & 0xfffffffffffffff0;
param_1[9] = uVar2 - 0x10;
*(int8 *)(uVar2 - 0x10) = 0;
*(int8 *)(uVar2 - 8) = 0;
uVar3 = 0;
}
return uVar3;
}
| |
26,404 | Trie::Trie(Trie&&) | MikePodsytnik[P]TCRtrie/src/Trie.cpp | Trie::Trie(Trie&& other) noexcept
: root_(other.root_), patterns_(std::move(other.patterns_)) {
other.root_ = nullptr;
} | O0 | cpp | Trie::Trie(Trie&&):
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl $0x4, (%rdi)
movl $0x4, 0x4(%rdi)
movb $0x0, 0x8(%rdi)
movl $0x20, 0xc(%rdi)
addq $0x10, %rdi
callq 0x59ef0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, 0x48(%rdi)
addq $0x50, %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
callq 0x59ff0
movq -0x10(%rbp), %rax
movq $0x0, 0x48(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| _ZN4TrieC2EOS_:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rdi, [rbp+var_8]
mov [rbp+var_18], rdi
mov dword ptr [rdi], 4
mov dword ptr [rdi+4], 4
mov byte ptr [rdi+8], 0
mov dword ptr [rdi+0Ch], 20h ; ' '
add rdi, 10h
call _ZNSt13unordered_mapIcS_IcfSt4hashIcESt8equal_toIcESaISt4pairIKcfEEES1_S3_SaIS4_IS5_S8_EEEC2Ev; std::unordered_map<char,std::unordered_map<char,float>>::unordered_map(void)
mov rdi, [rbp+var_18]
mov rax, [rbp+var_10]
mov rax, [rax+48h]
mov [rdi+48h], rax
add rdi, 50h ; 'P'
mov rsi, [rbp+var_10]
add rsi, 50h ; 'P'
call _ZNSt6vectorI10AIRREntitySaIS0_EEC2EOS2_; std::vector<AIRREntity>::vector(std::vector<AIRREntity>&&)
mov rax, [rbp+var_10]
mov qword ptr [rax+48h], 0
add rsp, 20h
pop rbp
retn
| long long Trie::Trie(long long a1, long long a2)
{
long long result; // rax
*(_DWORD *)a1 = 4;
*(_DWORD *)(a1 + 4) = 4;
*(_BYTE *)(a1 + 8) = 0;
*(_DWORD *)(a1 + 12) = 32;
std::unordered_map<char,std::unordered_map<char,float>>::unordered_map(a1 + 16);
*(_QWORD *)(a1 + 72) = *(_QWORD *)(a2 + 72);
std::vector<AIRREntity>::vector(a1 + 80, a2 + 80);
result = a2;
*(_QWORD *)(a2 + 72) = 0LL;
return result;
}
| Trie:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RDI],0x4
MOV dword ptr [RDI + 0x4],0x4
MOV byte ptr [RDI + 0x8],0x0
MOV dword ptr [RDI + 0xc],0x20
ADD RDI,0x10
CALL 0x00159ef0
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x48]
MOV qword ptr [RDI + 0x48],RAX
ADD RDI,0x50
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x50
CALL 0x00159ff0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x48],0x0
ADD RSP,0x20
POP RBP
RET
|
/* Trie::Trie(Trie&&) */
void __thiscall Trie::Trie(Trie *this,Trie *param_1)
{
*(int4 *)this = 4;
*(int4 *)(this + 4) = 4;
this[8] = (Trie)0x0;
*(int4 *)(this + 0xc) = 0x20;
std::
unordered_map<char,std::unordered_map<char,float,std::hash<char>,std::equal_to<char>,std::allocator<std::pair<char_const,float>>>,std::hash<char>,std::equal_to<char>,std::allocator<std::pair<char_const,std::unordered_map<char,float,std::hash<char>,std::equal_to<char>,std::allocator<std::pair<char_const,float>>>>>>
::unordered_map((unordered_map<char,std::unordered_map<char,float,std::hash<char>,std::equal_to<char>,std::allocator<std::pair<char_const,float>>>,std::hash<char>,std::equal_to<char>,std::allocator<std::pair<char_const,std::unordered_map<char,float,std::hash<char>,std::equal_to<char>,std::allocator<std::pair<char_const,float>>>>>>
*)(this + 0x10));
*(int8 *)(this + 0x48) = *(int8 *)(param_1 + 0x48);
std::vector<AIRREntity,std::allocator<AIRREntity>>::vector
((vector<AIRREntity,std::allocator<AIRREntity>> *)(this + 0x50),
(vector *)(param_1 + 0x50));
*(int8 *)(param_1 + 0x48) = 0;
return;
}
| |
26,405 | Trie::Trie(Trie&&) | MikePodsytnik[P]TCRtrie/src/Trie.cpp | Trie::Trie(Trie&& other) noexcept
: root_(other.root_), patterns_(std::move(other.patterns_)) {
other.root_ = nullptr;
} | O1 | cpp | Trie::Trie(Trie&&):
movabsq $0x400000004, %rax # imm = 0x400000004
movq %rax, (%rdi)
movb $0x0, 0x8(%rdi)
movl $0x20, 0xc(%rdi)
leaq 0x40(%rdi), %rax
movq %rax, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movl $0x3f800000, 0x30(%rdi) # imm = 0x3F800000
movups %xmm0, 0x38(%rdi)
movq 0x48(%rsi), %rax
movq %rax, 0x48(%rdi)
movq 0x50(%rsi), %rax
movq %rax, 0x50(%rdi)
movq 0x58(%rsi), %rax
movq %rax, 0x58(%rdi)
movq 0x60(%rsi), %rax
movq %rax, 0x60(%rdi)
movups %xmm0, 0x58(%rsi)
movups %xmm0, 0x48(%rsi)
retq
nop
| _ZN4TrieC2EOS_:
mov rax, 400000004h
mov [rdi], rax
mov byte ptr [rdi+8], 0
mov dword ptr [rdi+0Ch], 20h ; ' '
lea rax, [rdi+40h]
mov [rdi+10h], rax
mov qword ptr [rdi+18h], 1
xorps xmm0, xmm0
movups xmmword ptr [rdi+20h], xmm0
mov dword ptr [rdi+30h], 3F800000h
movups xmmword ptr [rdi+38h], xmm0
mov rax, [rsi+48h]
mov [rdi+48h], rax
mov rax, [rsi+50h]
mov [rdi+50h], rax
mov rax, [rsi+58h]
mov [rdi+58h], rax
mov rax, [rsi+60h]
mov [rdi+60h], rax
movups xmmword ptr [rsi+58h], xmm0
movups xmmword ptr [rsi+48h], xmm0
retn
| long long Trie::Trie(long long a1, _QWORD *a2)
{
long long result; // rax
*(_QWORD *)a1 = 0x400000004LL;
*(_BYTE *)(a1 + 8) = 0;
*(_DWORD *)(a1 + 12) = 32;
*(_QWORD *)(a1 + 16) = a1 + 64;
*(_QWORD *)(a1 + 24) = 1LL;
*(_OWORD *)(a1 + 32) = 0LL;
*(_DWORD *)(a1 + 48) = 1065353216;
*(_OWORD *)(a1 + 56) = 0LL;
*(_QWORD *)(a1 + 72) = a2[9];
*(_QWORD *)(a1 + 80) = a2[10];
*(_QWORD *)(a1 + 88) = a2[11];
result = a2[12];
*(_QWORD *)(a1 + 96) = result;
*(_OWORD *)(a2 + 11) = 0LL;
*(_OWORD *)(a2 + 9) = 0LL;
return result;
}
| Trie:
MOV RAX,0x400000004
MOV qword ptr [RDI],RAX
MOV byte ptr [RDI + 0x8],0x0
MOV dword ptr [RDI + 0xc],0x20
LEA RAX,[RDI + 0x40]
MOV qword ptr [RDI + 0x10],RAX
MOV qword ptr [RDI + 0x18],0x1
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOV dword ptr [RDI + 0x30],0x3f800000
MOVUPS xmmword ptr [RDI + 0x38],XMM0
MOV RAX,qword ptr [RSI + 0x48]
MOV qword ptr [RDI + 0x48],RAX
MOV RAX,qword ptr [RSI + 0x50]
MOV qword ptr [RDI + 0x50],RAX
MOV RAX,qword ptr [RSI + 0x58]
MOV qword ptr [RDI + 0x58],RAX
MOV RAX,qword ptr [RSI + 0x60]
MOV qword ptr [RDI + 0x60],RAX
MOVUPS xmmword ptr [RSI + 0x58],XMM0
MOVUPS xmmword ptr [RSI + 0x48],XMM0
RET
|
/* Trie::Trie(Trie&&) */
void __thiscall Trie::Trie(Trie *this,Trie *param_1)
{
*(int8 *)this = 0x400000004;
this[8] = (Trie)0x0;
*(int4 *)(this + 0xc) = 0x20;
*(Trie **)(this + 0x10) = this + 0x40;
*(int8 *)(this + 0x18) = 1;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int4 *)(this + 0x30) = 0x3f800000;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = *(int8 *)(param_1 + 0x48);
*(int8 *)(this + 0x50) = *(int8 *)(param_1 + 0x50);
*(int8 *)(this + 0x58) = *(int8 *)(param_1 + 0x58);
*(int8 *)(this + 0x60) = *(int8 *)(param_1 + 0x60);
*(int8 *)(param_1 + 0x58) = 0;
*(int8 *)(param_1 + 0x60) = 0;
*(int8 *)(param_1 + 0x48) = 0;
*(int8 *)(param_1 + 0x50) = 0;
return;
}
| |
26,406 | Trie::Trie(Trie&&) | MikePodsytnik[P]TCRtrie/src/Trie.cpp | Trie::Trie(Trie&& other) noexcept
: root_(other.root_), patterns_(std::move(other.patterns_)) {
other.root_ = nullptr;
} | O3 | cpp | Trie::Trie(Trie&&):
movabsq $0x400000004, %rax # imm = 0x400000004
movq %rax, (%rdi)
movb $0x0, 0x8(%rdi)
movl $0x20, 0xc(%rdi)
leaq 0x40(%rdi), %rax
movq %rax, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movl $0x3f800000, 0x30(%rdi) # imm = 0x3F800000
movups %xmm0, 0x38(%rdi)
movups 0x48(%rsi), %xmm1
movups %xmm1, 0x48(%rdi)
movups 0x58(%rsi), %xmm1
movups %xmm1, 0x58(%rdi)
movups %xmm0, 0x58(%rsi)
movups %xmm0, 0x48(%rsi)
retq
nop
| _ZN4TrieC2EOS_:
mov rax, 400000004h
mov [rdi], rax
mov byte ptr [rdi+8], 0
mov dword ptr [rdi+0Ch], 20h ; ' '
lea rax, [rdi+40h]
mov [rdi+10h], rax
mov qword ptr [rdi+18h], 1
xorps xmm0, xmm0
movups xmmword ptr [rdi+20h], xmm0
mov dword ptr [rdi+30h], 3F800000h
movups xmmword ptr [rdi+38h], xmm0
movups xmm1, xmmword ptr [rsi+48h]
movups xmmword ptr [rdi+48h], xmm1
movups xmm1, xmmword ptr [rsi+58h]
movups xmmword ptr [rdi+58h], xmm1
movups xmmword ptr [rsi+58h], xmm0
movups xmmword ptr [rsi+48h], xmm0
retn
| long long Trie::Trie(long long a1, long long a2)
{
long long result; // rax
*(_QWORD *)a1 = 0x400000004LL;
*(_BYTE *)(a1 + 8) = 0;
*(_DWORD *)(a1 + 12) = 32;
result = a1 + 64;
*(_QWORD *)(a1 + 16) = a1 + 64;
*(_QWORD *)(a1 + 24) = 1LL;
*(_OWORD *)(a1 + 32) = 0LL;
*(_DWORD *)(a1 + 48) = 1065353216;
*(_OWORD *)(a1 + 56) = 0LL;
*(_OWORD *)(a1 + 72) = *(_OWORD *)(a2 + 72);
*(_OWORD *)(a1 + 88) = *(_OWORD *)(a2 + 88);
*(_OWORD *)(a2 + 88) = 0LL;
*(_OWORD *)(a2 + 72) = 0LL;
return result;
}
| Trie:
MOV RAX,0x400000004
MOV qword ptr [RDI],RAX
MOV byte ptr [RDI + 0x8],0x0
MOV dword ptr [RDI + 0xc],0x20
LEA RAX,[RDI + 0x40]
MOV qword ptr [RDI + 0x10],RAX
MOV qword ptr [RDI + 0x18],0x1
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOV dword ptr [RDI + 0x30],0x3f800000
MOVUPS xmmword ptr [RDI + 0x38],XMM0
MOVUPS XMM1,xmmword ptr [RSI + 0x48]
MOVUPS xmmword ptr [RDI + 0x48],XMM1
MOVUPS XMM1,xmmword ptr [RSI + 0x58]
MOVUPS xmmword ptr [RDI + 0x58],XMM1
MOVUPS xmmword ptr [RSI + 0x58],XMM0
MOVUPS xmmword ptr [RSI + 0x48],XMM0
RET
|
/* Trie::Trie(Trie&&) */
void __thiscall Trie::Trie(Trie *this,Trie *param_1)
{
int8 uVar1;
*(int8 *)this = 0x400000004;
this[8] = (Trie)0x0;
*(int4 *)(this + 0xc) = 0x20;
*(Trie **)(this + 0x10) = this + 0x40;
*(int8 *)(this + 0x18) = 1;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int4 *)(this + 0x30) = 0x3f800000;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
uVar1 = *(int8 *)(param_1 + 0x50);
*(int8 *)(this + 0x48) = *(int8 *)(param_1 + 0x48);
*(int8 *)(this + 0x50) = uVar1;
uVar1 = *(int8 *)(param_1 + 0x60);
*(int8 *)(this + 0x58) = *(int8 *)(param_1 + 0x58);
*(int8 *)(this + 0x60) = uVar1;
*(int8 *)(param_1 + 0x58) = 0;
*(int8 *)(param_1 + 0x60) = 0;
*(int8 *)(param_1 + 0x48) = 0;
*(int8 *)(param_1 + 0x50) = 0;
return;
}
| |
26,407 | js_regexp_compile | bluesky950520[P]quickjs/quickjs.c | static JSValue js_regexp_compile(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSRegExp *re1, *re;
JSValue pattern1, flags1;
JSValue bc, pattern;
re = js_get_regexp(ctx, this_val, TRUE);
if (!re)
return JS_EXCEPTION;
pattern1 = argv[0];
flags1 = argv[1];
re1 = js_get_regexp(ctx, pattern1, FALSE);
if (re1) {
if (!JS_IsUndefined(flags1))
return JS_ThrowTypeError(ctx, "flags must be undefined");
pattern = js_dup(JS_MKPTR(JS_TAG_STRING, re1->pattern));
bc = js_dup(JS_MKPTR(JS_TAG_STRING, re1->bytecode));
} else {
bc = JS_UNDEFINED;
if (JS_IsUndefined(pattern1))
pattern = JS_AtomToString(ctx, JS_ATOM_empty_string);
else
pattern = JS_ToString(ctx, pattern1);
if (JS_IsException(pattern))
goto fail;
bc = js_compile_regexp(ctx, pattern, flags1);
if (JS_IsException(bc))
goto fail;
}
JS_FreeValue(ctx, JS_MKPTR(JS_TAG_STRING, re->pattern));
JS_FreeValue(ctx, JS_MKPTR(JS_TAG_STRING, re->bytecode));
re->pattern = JS_VALUE_GET_STRING(pattern);
re->bytecode = JS_VALUE_GET_STRING(bc);
if (JS_SetProperty(ctx, this_val, JS_ATOM_lastIndex,
js_int32(0)) < 0)
return JS_EXCEPTION;
return js_dup(this_val);
fail:
JS_FreeValue(ctx, pattern);
JS_FreeValue(ctx, bc);
return JS_EXCEPTION;
} | O1 | c | js_regexp_compile:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, 0x28(%rsp)
cmpl $-0x1, %r14d
jne 0x48d6b
movq 0x28(%rsp), %r13
cmpw $0x12, 0x6(%r13)
jne 0x48d6b
addq $0x30, %r13
jmp 0x48d7b
movq %r12, %rdi
movl $0x12, %esi
callq 0x275f0
xorl %r13d, %r13d
movl $0x6, %ebp
testq %r13, %r13
je 0x48dde
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %r9
movq 0x18(%rbx), %r8
movq %rsi, 0x28(%rsp)
movl %edx, %eax
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
cmpq %rcx, %rax
jne 0x48db7
movq 0x28(%rsp), %rcx
cmpw $0x12, 0x6(%rcx)
jne 0x48db7
addq $0x30, %rcx
jmp 0x48db9
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x48de3
cmpl $0x3, %r8d
jne 0x48e0c
movq (%rcx), %rax
incl (%rax)
movq %rax, 0x40(%rsp)
movq 0x8(%rcx), %rax
incl (%rax)
movq %rax, 0x20(%rsp)
jmp 0x48ea7
xorl %r13d, %r13d
jmp 0x48e20
movl $0x0, 0x20(%rsp)
cmpl $0x3, %eax
jne 0x48e27
movq 0x18(%r12), %rax
movq 0x68(%rax), %rax
movq 0x178(%rax), %rbp
incl (%rbp)
movq $-0x7, %rdx
jmp 0x48e40
leaq 0x56da0(%rip), %rsi # 0x9fbb3
xorl %r13d, %r13d
movq %r12, %rdi
xorl %eax, %eax
callq 0x22567
xorl %ecx, %ecx
jmp 0x48f6e
movq %r12, %rdi
xorl %ecx, %ecx
movq %r8, %rbx
movq %r9, %rbp
callq 0x27add
movq %rbp, %r9
movq %rbx, %r8
movq %rax, %rbp
movq %rbp, 0x40(%rsp)
movl $0x3, %ebx
cmpl $0x6, %edx
je 0x48e79
movq %r12, %rdi
movq %rbp, %rsi
movq %rdx, 0x38(%rsp)
movq 0x38(%rsp), %rdx
movq %r9, %rcx
callq 0x33562
movq %rdx, %rbx
movq 0x38(%rsp), %rdx
movq %rax, 0x20(%rsp)
cmpl $0x6, %ebx
jne 0x48ea7
movq 0x18(%r12), %rdi
movq %rbp, %rsi
callq 0x1d8c6
movq 0x20(%rsp), %rsi
movq 0x18(%r12), %rdi
movq %rbx, %rdx
callq 0x1d8c6
xorl %r13d, %r13d
xorl %ecx, %ecx
movl $0x6, %ebp
jmp 0x48f6e
movq (%r13), %rsi
movq 0x18(%r12), %rdi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jg 0x48ec8
movq $-0x7, %rdx
callq 0x21266
movq 0x8(%r13), %rsi
movq 0x18(%r12), %rdi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
movl $0x6, %ebp
jg 0x48eee
movq $-0x7, %rdx
callq 0x21266
movq 0x40(%rsp), %rax
movq %rax, (%r13)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%r13)
movq %r15, 0x28(%rsp)
movq %r14, 0x30(%rsp)
movups 0x28(%rsp), %xmm0
movups %xmm0, (%rsp)
movq $0x0, 0x18(%rsp)
movl $0x4000, 0x10(%rsp) # imm = 0x4000
xorl %r13d, %r13d
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0x56, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x24388
movl $0x0, %ecx
testl %eax, %eax
js 0x48f6e
movq %r15, 0x28(%rsp)
cmpl $-0x9, %r14d
jb 0x48f5b
movq 0x28(%rsp), %rax
incl (%rax)
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %r15, %rcx
movl %r15d, %r13d
movq %r14, %rbp
orq %rcx, %r13
movq %r13, %rax
movq %rbp, %rdx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_regexp_compile:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov rbx, r8
mov r14, rdx
mov r15, rsi
mov r12, rdi
mov qword ptr [rsp+78h+var_50], rsi
cmp r14d, 0FFFFFFFFh
jnz short loc_48D6B
mov r13, qword ptr [rsp+78h+var_50]
cmp word ptr [r13+6], 12h
jnz short loc_48D6B
add r13, 30h ; '0'
jmp short loc_48D7B
loc_48D6B:
mov rdi, r12
mov esi, 12h
call JS_ThrowTypeErrorInvalidClass
xor r13d, r13d
loc_48D7B:
mov ebp, 6
test r13, r13
jz short loc_48DDE
mov rsi, [rbx]
mov rdx, [rbx+8]
mov r9, [rbx+10h]
mov r8, [rbx+18h]
mov qword ptr [rsp+78h+var_50], rsi
mov eax, edx
mov ecx, 0FFFFFFFFh
cmp rax, rcx
jnz short loc_48DB7
mov rcx, qword ptr [rsp+78h+var_50]
cmp word ptr [rcx+6], 12h
jnz short loc_48DB7
add rcx, 30h ; '0'
jmp short loc_48DB9
loc_48DB7:
xor ecx, ecx
loc_48DB9:
test rcx, rcx
jz short loc_48DE3
cmp r8d, 3
jnz short loc_48E0C
mov rax, [rcx]
inc dword ptr [rax]
mov [rsp+78h+var_38], rax
mov rax, [rcx+8]
inc dword ptr [rax]
mov [rsp+78h+var_58], rax
jmp loc_48EA7
loc_48DDE:
xor r13d, r13d
jmp short loc_48E20
loc_48DE3:
mov dword ptr [rsp+78h+var_58], 0
cmp eax, 3
jnz short loc_48E27
mov rax, [r12+18h]
mov rax, [rax+68h]
mov rbp, [rax+178h]
inc dword ptr [rbp+0]
mov rdx, 0FFFFFFFFFFFFFFF9h
jmp short loc_48E40
loc_48E0C:
lea rsi, aFlagsMustBeUnd; "flags must be undefined"
xor r13d, r13d
mov rdi, r12
xor eax, eax
call JS_ThrowTypeError
loc_48E20:
xor ecx, ecx
jmp loc_48F6E
loc_48E27:
mov rdi, r12
xor ecx, ecx
mov rbx, r8
mov rbp, r9
call JS_ToStringInternal
mov r9, rbp
mov r8, rbx
mov rbp, rax
loc_48E40:
mov [rsp+78h+var_38], rbp
mov ebx, 3
cmp edx, 6
jz short loc_48E79
mov rdi, r12
mov rsi, rbp
mov [rsp+78h+var_40], rdx
mov rdx, [rsp+78h+var_40]
mov rcx, r9
call js_compile_regexp
mov rbx, rdx
mov rdx, [rsp+78h+var_40]
mov [rsp+78h+var_58], rax
cmp ebx, 6
jnz short loc_48EA7
loc_48E79:
mov rdi, [r12+18h]
mov rsi, rbp
call JS_FreeValueRT
mov rsi, [rsp+78h+var_58]
mov rdi, [r12+18h]
mov rdx, rbx
call JS_FreeValueRT
xor r13d, r13d
xor ecx, ecx
mov ebp, 6
jmp loc_48F6E
loc_48EA7:
mov rsi, [r13+0]
mov rdi, [r12+18h]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jg short loc_48EC8
mov rdx, 0FFFFFFFFFFFFFFF9h
call js_free_value_rt
loc_48EC8:
mov rsi, [r13+8]
mov rdi, [r12+18h]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
mov ebp, 6
jg short loc_48EEE
mov rdx, 0FFFFFFFFFFFFFFF9h
call js_free_value_rt
loc_48EEE:
mov rax, [rsp+78h+var_38]
mov [r13+0], rax
mov rax, [rsp+78h+var_58]
mov [r13+8], rax
mov qword ptr [rsp+78h+var_50], r15
mov qword ptr [rsp+78h+var_50+8], r14
movups xmm0, [rsp+78h+var_50]
movups [rsp+78h+var_78], xmm0
mov [rsp+78h+var_60], 0
mov [rsp+78h+var_68], 4000h
xor r13d, r13d
mov rdi, r12
mov rsi, r15
mov rdx, r14
mov ecx, 56h ; 'V'
xor r8d, r8d
xor r9d, r9d
call JS_SetPropertyInternal2
mov ecx, 0
test eax, eax
js short loc_48F6E
mov qword ptr [rsp+78h+var_50], r15
cmp r14d, 0FFFFFFF7h
jb short loc_48F5B
mov rax, qword ptr [rsp+78h+var_50]
inc dword ptr [rax]
loc_48F5B:
mov rcx, 0FFFFFFFF00000000h
and rcx, r15
mov r13d, r15d
mov rbp, r14
loc_48F6E:
or r13, rcx
mov rax, r13
mov rdx, rbp
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| unsigned long long js_regexp_compile(
long long a1,
long long a2,
unsigned long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
long long a12,
long long *a13)
{
long long v17; // r13
long long v18; // rsi
long long v19; // rdx
long long v20; // r9
long long v21; // r8
_QWORD *v22; // rcx
_DWORD *v23; // rax
_DWORD *v24; // rax
long long v25; // r13
_DWORD *v26; // rbp
long long v27; // rdx
unsigned long long v28; // rcx
long long v29; // rbx
long long v30; // rbp
unsigned long long v31; // rax
long long v32; // rbx
unsigned long long v33; // rax
long long v34; // rdx
int *v35; // rsi
long long v36; // rdi
int v37; // eax
_QWORD *v38; // rsi
long long v39; // rdi
int v40; // eax
int v41; // eax
char v43; // [rsp+0h] [rbp-78h]
_DWORD *v44; // [rsp+20h] [rbp-58h]
long long v45; // [rsp+28h] [rbp-50h]
__m128 v46; // [rsp+28h] [rbp-50h]
long long v47; // [rsp+38h] [rbp-40h]
_DWORD *v48; // [rsp+40h] [rbp-38h]
if ( (_DWORD)a3 == -1 && *(_WORD *)(a2 + 6) == 18 )
{
v17 = a2 + 48;
}
else
{
JS_ThrowTypeErrorInvalidClass(a1, 18, a4, a5, a6, a7, *(double *)a8.m128_u64, *(double *)a9.m128_u64, a10, a11);
v17 = 0LL;
}
if ( !v17 )
{
v25 = 0LL;
LABEL_17:
v28 = 0LL;
return v28 | v25;
}
v18 = *a13;
v19 = a13[1];
v20 = a13[2];
v21 = a13[3];
v45 = *a13;
if ( (unsigned int)v19 == 0xFFFFFFFFLL && *(_WORD *)(v45 + 6) == 18 )
v22 = (_QWORD *)(v45 + 48);
else
v22 = 0LL;
if ( !v22 )
{
LODWORD(v44) = 0;
if ( (_DWORD)v19 == 3 )
{
v26 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 104LL) + 376LL);
++*v26;
v27 = -7LL;
}
else
{
v29 = a13[3];
v30 = v20;
v31 = JS_ToStringInternal(a1, v18, v19, 0, v21, v20, a4, a5, a6, a7, a8, a9, a10, a11);
v20 = v30;
v21 = v29;
v26 = (_DWORD *)v31;
}
v48 = v26;
v32 = 3LL;
if ( (_DWORD)v27 == 6
|| (v47 = v27,
v33 = js_compile_regexp(a1, (long long)v26, v27, v20, v21, v20, a4, a5, a6, a7, a8, a9, a10, a11),
v32 = v34,
v27 = v47,
v44 = (_DWORD *)v33,
(_DWORD)v32 == 6) )
{
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v26, v27);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v44, v32);
v25 = 0LL;
v28 = 0LL;
return v28 | v25;
}
goto LABEL_22;
}
if ( (_DWORD)v21 != 3 )
{
v25 = 0LL;
JS_ThrowTypeError(
a1,
(long long)"flags must be undefined",
v19,
(long long)v22,
v21,
v20,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
v43);
goto LABEL_17;
}
v23 = (_DWORD *)*v22;
++*v23;
v48 = v23;
v24 = (_DWORD *)v22[1];
++*v24;
v44 = v24;
LABEL_22:
v35 = *(int **)v17;
v36 = *(_QWORD *)(a1 + 24);
v37 = **(_DWORD **)v17;
**(_DWORD **)v17 = v37 - 1;
if ( v37 <= 1 )
js_free_value_rt(v36, v35, -7);
v38 = *(_QWORD **)(v17 + 8);
v39 = *(_QWORD *)(a1 + 24);
v40 = (*(_DWORD *)v38)--;
if ( v40 <= 1 )
js_free_value_rt(v39, v38, -7);
*(_QWORD *)v17 = v48;
*(_QWORD *)(v17 + 8) = v44;
v46.m128_u64[0] = a2;
v46.m128_u64[1] = a3;
v25 = 0LL;
v41 = JS_SetPropertyInternal2(
a1,
a2,
a3,
0x56u,
0LL,
0LL,
v46,
a5,
a6,
a7,
*(double *)a8.m128_u64,
*(double *)a9.m128_u64,
a10,
a11,
a2,
a3,
0x4000u,
0LL);
v28 = 0LL;
if ( v41 >= 0 )
{
if ( (unsigned int)a3 >= 0xFFFFFFF7 )
++*(_DWORD *)a2;
v28 = a2 & 0xFFFFFFFF00000000LL;
v25 = (unsigned int)a2;
}
return v28 | v25;
}
| |||
26,408 | js_regexp_compile | bluesky950520[P]quickjs/quickjs.c | static JSValue js_regexp_compile(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSRegExp *re1, *re;
JSValue pattern1, flags1;
JSValue bc, pattern;
re = js_get_regexp(ctx, this_val, TRUE);
if (!re)
return JS_EXCEPTION;
pattern1 = argv[0];
flags1 = argv[1];
re1 = js_get_regexp(ctx, pattern1, FALSE);
if (re1) {
if (!JS_IsUndefined(flags1))
return JS_ThrowTypeError(ctx, "flags must be undefined");
pattern = js_dup(JS_MKPTR(JS_TAG_STRING, re1->pattern));
bc = js_dup(JS_MKPTR(JS_TAG_STRING, re1->bytecode));
} else {
bc = JS_UNDEFINED;
if (JS_IsUndefined(pattern1))
pattern = JS_AtomToString(ctx, JS_ATOM_empty_string);
else
pattern = JS_ToString(ctx, pattern1);
if (JS_IsException(pattern))
goto fail;
bc = js_compile_regexp(ctx, pattern, flags1);
if (JS_IsException(bc))
goto fail;
}
JS_FreeValue(ctx, JS_MKPTR(JS_TAG_STRING, re->pattern));
JS_FreeValue(ctx, JS_MKPTR(JS_TAG_STRING, re->bytecode));
re->pattern = JS_VALUE_GET_STRING(pattern);
re->bytecode = JS_VALUE_GET_STRING(bc);
if (JS_SetProperty(ctx, this_val, JS_ATOM_lastIndex,
js_int32(0)) < 0)
return JS_EXCEPTION;
return js_dup(this_val);
fail:
JS_FreeValue(ctx, pattern);
JS_FreeValue(ctx, bc);
return JS_EXCEPTION;
} | O2 | c | js_regexp_compile:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x1
popq %rcx
movq %rdx, 0x10(%rsp)
callq 0x41310
pushq $0x6
popq %rbp
testq %rax, %rax
je 0x3ee4d
movq %rax, %r13
movq 0x8(%r14), %rdx
movq 0x10(%r14), %rcx
movq 0x18(%r14), %rbx
movl %edx, %eax
cmpq $0x3, %rax
je 0x3ee63
movq (%r14), %rsi
cmpl $-0x1, %eax
jne 0x3ee56
cmpw $0x12, 0x6(%rsi)
jne 0x3ee56
cmpl $0x3, %ebx
jne 0x3ef5c
movq 0x30(%rsi), %rax
movq %rax, 0x8(%rsp)
incl (%rax)
movq 0x38(%rsi), %rbx
incl (%rbx)
jmp 0x3eed2
xorl %ebx, %ebx
xorl %ecx, %ecx
jmp 0x3ef44
movq %rcx, %rbp
movq %r12, %rdi
callq 0x1b03c
jmp 0x3ee71
movq %rcx, %rbp
pushq $0x2f
popq %rsi
movq %r12, %rdi
callq 0x1a990
movq %rdx, %r14
cmpl $0x6, %r14d
jne 0x3ee81
pushq $0x3
popq %rbp
xorl %ebx, %ebx
jmp 0x3eeaa
movq %r12, %rdi
movq %rax, 0x8(%rsp)
movq %rax, %rsi
movq %r14, %rdx
movq %rbp, %rcx
movq %rbx, %r8
callq 0x2cbbd
movq %rax, %rbx
movq %rdx, %rbp
cmpl $0x6, %ebp
jne 0x3eecf
movq 0x8(%rsp), %rax
movq %r12, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x1801e
movq %r12, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x1801e
xorl %ebx, %ebx
xorl %ecx, %ecx
pushq $0x6
popq %rbp
jmp 0x3ef44
pushq $0x6
popq %rbp
movq (%r13), %rsi
pushq $-0x7
popq %r14
movq %r12, %rdi
movq %r14, %rdx
callq 0x1801e
movq 0x8(%r13), %rsi
movq %r12, %rdi
movq %r14, %rdx
callq 0x1801e
movq 0x8(%rsp), %rax
movq %rax, (%r13)
movq %rbx, 0x8(%r13)
xorl %ebx, %ebx
pushq $0x56
popq %rcx
movq %r12, %rdi
movq %r15, %rsi
movq 0x10(%rsp), %r14
movq %r14, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x1e446
movl $0x0, %ecx
testl %eax, %eax
js 0x3ef44
cmpl $-0x9, %r14d
jb 0x3ef31
incl (%r15)
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %r15, %rcx
movl %r15d, %ebx
movq %r14, %rbp
orq %rcx, %rbx
movq %rbx, %rax
movq %rbp, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x47ba0(%rip), %rsi # 0x86b03
xorl %ebx, %ebx
movq %r12, %rdi
xorl %eax, %eax
callq 0x1c64d
jmp 0x3ee4f
| js_regexp_compile:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r14, r8
mov r15, rsi
mov r12, rdi
push 1
pop rcx
mov [rsp+48h+var_38], rdx
call js_get_regexp
push 6
pop rbp
test rax, rax
jz short loc_3EE4D
mov r13, rax
mov rdx, [r14+8]
mov rcx, [r14+10h]
mov rbx, [r14+18h]
mov eax, edx
cmp rax, 3
jz short loc_3EE63
mov rsi, [r14]
cmp eax, 0FFFFFFFFh
jnz short loc_3EE56
cmp word ptr [rsi+6], 12h
jnz short loc_3EE56
cmp ebx, 3
jnz loc_3EF5C
mov rax, [rsi+30h]
mov [rsp+48h+var_40], rax
inc dword ptr [rax]
mov rbx, [rsi+38h]
inc dword ptr [rbx]
jmp loc_3EED2
loc_3EE4D:
xor ebx, ebx
loc_3EE4F:
xor ecx, ecx
jmp loc_3EF44
loc_3EE56:
mov rbp, rcx
mov rdi, r12
call JS_ToString
jmp short loc_3EE71
loc_3EE63:
mov rbp, rcx
push 2Fh ; '/'
pop rsi
mov rdi, r12
call JS_AtomToString
loc_3EE71:
mov r14, rdx
cmp r14d, 6
jnz short loc_3EE81
push 3
pop rbp
xor ebx, ebx
jmp short loc_3EEAA
loc_3EE81:
mov rdi, r12
mov [rsp+48h+var_40], rax
mov rsi, rax
mov rdx, r14
mov rcx, rbp
mov r8, rbx
call js_compile_regexp
mov rbx, rax
mov rbp, rdx
cmp ebp, 6
jnz short loc_3EECF
mov rax, [rsp+48h+var_40]
loc_3EEAA:
mov rdi, r12
mov rsi, rax
mov rdx, r14
call JS_FreeValue
mov rdi, r12
mov rsi, rbx
mov rdx, rbp
call JS_FreeValue
xor ebx, ebx
xor ecx, ecx
push 6
pop rbp
jmp short loc_3EF44
loc_3EECF:
push 6
pop rbp
loc_3EED2:
mov rsi, [r13+0]
push 0FFFFFFFFFFFFFFF9h
pop r14
mov rdi, r12
mov rdx, r14
call JS_FreeValue
mov rsi, [r13+8]
mov rdi, r12
mov rdx, r14
call JS_FreeValue
mov rax, [rsp+48h+var_40]
mov [r13+0], rax
mov [r13+8], rbx
xor ebx, ebx
push 56h ; 'V'
pop rcx
mov rdi, r12
mov rsi, r15
mov r14, [rsp+48h+var_38]
mov rdx, r14
xor r8d, r8d
xor r9d, r9d
call JS_SetProperty
mov ecx, 0
test eax, eax
js short loc_3EF44
cmp r14d, 0FFFFFFF7h
jb short loc_3EF31
inc dword ptr [r15]
loc_3EF31:
mov rcx, 0FFFFFFFF00000000h
and rcx, r15
mov ebx, r15d
mov rbp, r14
loc_3EF44:
or rbx, rcx
mov rax, rbx
mov rdx, rbp
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3EF5C:
lea rsi, aFlagsMustBeUnd; "flags must be undefined"
xor ebx, ebx
mov rdi, r12
xor eax, eax
call JS_ThrowTypeError
jmp loc_3EE4F
| unsigned long long js_regexp_compile(
long long a1,
unsigned long long a2,
long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11,
long long a12,
long long *a13)
{
long long regexp; // rax
long long v16; // r8
long long v17; // r9
__m128 v18; // xmm4
__m128 v19; // xmm5
long long *v20; // r13
long long v21; // rdx
long long v22; // rbx
long long v23; // rsi
_DWORD *v24; // rbx
long long v25; // rbx
unsigned long long v26; // rcx
long long v27; // rbp
long long v28; // rax
long long v29; // rdx
double v30; // xmm4_8
double v31; // xmm5_8
long long v32; // r14
long long v33; // rbp
long long v34; // rdx
int v35; // eax
char v37; // [rsp+0h] [rbp-48h]
_DWORD *v38; // [rsp+8h] [rbp-40h]
regexp = js_get_regexp(a1, a2, a3, 1LL);
if ( !regexp )
{
v25 = 0LL;
goto LABEL_8;
}
v20 = (long long *)regexp;
v21 = a13[1];
v22 = a13[3];
if ( (unsigned int)v21 == 3LL )
{
v27 = a13[2];
v28 = JS_AtomToString(a1, 47);
}
else
{
v23 = *a13;
if ( (_DWORD)v21 == -1 && *(_WORD *)(v23 + 6) == 18 )
{
if ( (_DWORD)v22 == 3 )
{
v38 = *(_DWORD **)(v23 + 48);
++*v38;
v24 = *(_DWORD **)(v23 + 56);
++*v24;
goto LABEL_16;
}
v25 = 0LL;
JS_ThrowTypeError(
a1,
(long long)"flags must be undefined",
v21,
a13[2],
v16,
v17,
a4,
a5,
a6,
a7,
v18,
v19,
a10,
a11,
v37);
LABEL_8:
v26 = 0LL;
return v26 | v25;
}
v27 = a13[2];
v28 = JS_ToString(a1, v23, v21);
}
v32 = v29;
if ( (_DWORD)v29 == 6 )
{
v33 = 3LL;
v24 = 0LL;
LABEL_15:
JS_FreeValue(a1, v28, v32);
JS_FreeValue(a1, (long long)v24, v33);
v25 = 0LL;
v26 = 0LL;
return v26 | v25;
}
v38 = (_DWORD *)v28;
v24 = (_DWORD *)js_compile_regexp(a1, v28, v29, v27, v22, a4, a5, a6, a7, v30, v31, a10, a11);
v33 = v34;
if ( (_DWORD)v34 == 6 )
{
v28 = (long long)v38;
goto LABEL_15;
}
LABEL_16:
JS_FreeValue(a1, *v20, -7LL);
JS_FreeValue(a1, v20[1], -7LL);
*v20 = (long long)v38;
v20[1] = (long long)v24;
v25 = 0LL;
v35 = JS_SetProperty(a1, a2, a3, 86, 0, 0);
v26 = 0LL;
if ( v35 >= 0 )
{
if ( (unsigned int)a3 >= 0xFFFFFFF7 )
++*(_DWORD *)a2;
v26 = a2 & 0xFFFFFFFF00000000LL;
v25 = (unsigned int)a2;
}
return v26 | v25;
}
| js_regexp_compile:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R14,R8
MOV R15,RSI
MOV R12,RDI
PUSH 0x1
POP RCX
MOV qword ptr [RSP + 0x10],RDX
CALL 0x00141310
PUSH 0x6
POP RBP
TEST RAX,RAX
JZ 0x0013ee4d
MOV R13,RAX
MOV RDX,qword ptr [R14 + 0x8]
MOV RCX,qword ptr [R14 + 0x10]
MOV RBX,qword ptr [R14 + 0x18]
MOV EAX,EDX
CMP RAX,0x3
JZ 0x0013ee63
MOV RSI,qword ptr [R14]
CMP EAX,-0x1
JNZ 0x0013ee56
CMP word ptr [RSI + 0x6],0x12
JNZ 0x0013ee56
CMP EBX,0x3
JNZ 0x0013ef5c
MOV RAX,qword ptr [RSI + 0x30]
MOV qword ptr [RSP + 0x8],RAX
INC dword ptr [RAX]
MOV RBX,qword ptr [RSI + 0x38]
INC dword ptr [RBX]
JMP 0x0013eed2
LAB_0013ee4d:
XOR EBX,EBX
LAB_0013ee4f:
XOR ECX,ECX
JMP 0x0013ef44
LAB_0013ee56:
MOV RBP,RCX
MOV RDI,R12
CALL 0x0011b03c
JMP 0x0013ee71
LAB_0013ee63:
MOV RBP,RCX
PUSH 0x2f
POP RSI
MOV RDI,R12
CALL 0x0011a990
LAB_0013ee71:
MOV R14,RDX
CMP R14D,0x6
JNZ 0x0013ee81
PUSH 0x3
POP RBP
XOR EBX,EBX
JMP 0x0013eeaa
LAB_0013ee81:
MOV RDI,R12
MOV qword ptr [RSP + 0x8],RAX
MOV RSI,RAX
MOV RDX,R14
MOV RCX,RBP
MOV R8,RBX
CALL 0x0012cbbd
MOV RBX,RAX
MOV RBP,RDX
CMP EBP,0x6
JNZ 0x0013eecf
MOV RAX,qword ptr [RSP + 0x8]
LAB_0013eeaa:
MOV RDI,R12
MOV RSI,RAX
MOV RDX,R14
CALL 0x0011801e
MOV RDI,R12
MOV RSI,RBX
MOV RDX,RBP
CALL 0x0011801e
XOR EBX,EBX
XOR ECX,ECX
PUSH 0x6
POP RBP
JMP 0x0013ef44
LAB_0013eecf:
PUSH 0x6
POP RBP
LAB_0013eed2:
MOV RSI,qword ptr [R13]
PUSH -0x7
POP R14
MOV RDI,R12
MOV RDX,R14
CALL 0x0011801e
MOV RSI,qword ptr [R13 + 0x8]
MOV RDI,R12
MOV RDX,R14
CALL 0x0011801e
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [R13],RAX
MOV qword ptr [R13 + 0x8],RBX
XOR EBX,EBX
PUSH 0x56
POP RCX
MOV RDI,R12
MOV RSI,R15
MOV R14,qword ptr [RSP + 0x10]
MOV RDX,R14
XOR R8D,R8D
XOR R9D,R9D
CALL 0x0011e446
MOV ECX,0x0
TEST EAX,EAX
JS 0x0013ef44
CMP R14D,-0x9
JC 0x0013ef31
INC dword ptr [R15]
LAB_0013ef31:
MOV RCX,-0x100000000
AND RCX,R15
MOV EBX,R15D
MOV RBP,R14
LAB_0013ef44:
OR RBX,RCX
MOV RAX,RBX
MOV RDX,RBP
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013ef5c:
LEA RSI,[0x186b03]
XOR EBX,EBX
MOV RDI,R12
XOR EAX,EAX
CALL 0x0011c64d
JMP 0x0013ee4f
|
int1 [16]
js_regexp_compile(int8 param_1,int *param_2,int8 param_3,int8 param_4,
long *param_5)
{
long lVar1;
long lVar2;
long lVar3;
int iVar4;
int8 *puVar5;
ulong uVar6;
ulong uVar7;
int *piVar8;
int8 uVar9;
int1 auVar10 [16];
int1 auVar11 [16];
int *local_40;
puVar5 = (int8 *)js_get_regexp();
uVar9 = 6;
if (puVar5 == (int8 *)0x0) {
LAB_0013ee4f:
uVar7 = 0;
uVar6 = 0;
goto LAB_0013ef44;
}
lVar1 = param_5[2];
lVar2 = param_5[3];
if ((param_5[1] & 0xffffffffU) == 3) {
auVar10 = JS_AtomToString(param_1,0x2f);
LAB_0013ee71:
local_40 = auVar10._0_8_;
if (auVar10._8_4_ == 6) {
auVar11 = ZEXT816(3) << 0x40;
}
else {
auVar11 = js_compile_regexp(param_1,local_40,auVar10._8_8_,lVar1,lVar2);
piVar8 = auVar11._0_8_;
if (auVar11._8_4_ != 6) goto LAB_0013eed2;
}
JS_FreeValue(param_1,local_40,auVar10._8_8_);
JS_FreeValue(param_1,auVar11._0_8_,auVar11._8_8_);
uVar7 = 0;
uVar6 = 0;
uVar9 = 6;
}
else {
lVar3 = *param_5;
if (((int)param_5[1] != -1) || (*(short *)(lVar3 + 6) != 0x12)) {
auVar10 = JS_ToString(param_1);
goto LAB_0013ee71;
}
if ((int)lVar2 != 3) {
JS_ThrowTypeError(param_1,"flags must be int");
goto LAB_0013ee4f;
}
local_40 = *(int **)(lVar3 + 0x30);
*local_40 = *local_40 + 1;
piVar8 = *(int **)(lVar3 + 0x38);
*piVar8 = *piVar8 + 1;
LAB_0013eed2:
JS_FreeValue(param_1,*puVar5,0xfffffffffffffff9);
JS_FreeValue(param_1,puVar5[1],0xfffffffffffffff9);
*puVar5 = local_40;
puVar5[1] = piVar8;
uVar7 = 0;
iVar4 = JS_SetProperty(param_1,param_2,param_3,0x56,0,0);
uVar6 = 0;
uVar9 = 6;
if (-1 < iVar4) {
if (0xfffffff6 < (uint)param_3) {
*param_2 = *param_2 + 1;
}
uVar6 = (ulong)param_2 & 0xffffffff00000000;
uVar7 = (ulong)param_2 & 0xffffffff;
uVar9 = param_3;
}
}
LAB_0013ef44:
auVar10._8_8_ = uVar9;
auVar10._0_8_ = uVar7 | uVar6;
return auVar10;
}
| |
26,409 | write_hook_for_undo_key_insert | eloqsql/storage/maria/ma_key_recover.c | my_bool write_hook_for_undo_key_insert(enum translog_record_type type,
TRN *trn, MARIA_HA *tbl_info,
LSN *lsn, void *hook_arg)
{
struct st_msg_to_write_hook_for_undo_key *msg=
(struct st_msg_to_write_hook_for_undo_key *) hook_arg;
MARIA_SHARE *share= tbl_info->s;
if (msg->auto_increment > 0)
{
/*
Only reason to set it here is to have a mutex protect from checkpoint
reading at the same time (would see a corrupted value).
The purpose of the following code is to set auto_increment if the row
has a with auto_increment value higher than the current one. We also
want to be able to restore the old value, in case of rollback,
if no one else has tried to set the value.
The logic used is that we only restore the auto_increment value if
tbl_info->last_auto_increment == share->last_auto_increment
when it's time to do the rollback.
*/
DBUG_PRINT("info",("auto_inc: %lu new auto_inc: %lu",
(ulong)share->state.auto_increment,
(ulong)msg->auto_increment));
if (share->state.auto_increment < msg->auto_increment)
{
/* Remember the original value, in case of rollback */
tbl_info->last_auto_increment= share->last_auto_increment=
share->state.auto_increment;
share->state.auto_increment= msg->auto_increment;
}
else
{
/*
If the current value would have affected the original auto_increment
value, set it to an impossible value so that it's not restored on
rollback
*/
if (msg->auto_increment > share->last_auto_increment)
share->last_auto_increment= ~(ulonglong) 0;
}
}
return write_hook_for_undo_key(type, trn, tbl_info, lsn, hook_arg);
} | O0 | c | write_hook_for_undo_key_insert:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jbe 0x445c0
jmp 0x4454b
jmp 0x4454d
movq -0x38(%rbp), %rax
movq 0xd8(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x44598
movq -0x38(%rbp), %rax
movq 0xd8(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x610(%rax)
movq -0x18(%rbp), %rax
movq %rcx, 0x3e8(%rax)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0xd8(%rax)
jmp 0x445be
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x38(%rbp), %rcx
cmpq 0x610(%rcx), %rax
jbe 0x445bc
movq -0x38(%rbp), %rax
movq $-0x1, 0x610(%rax)
jmp 0x445be
jmp 0x445c0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x44480
addq $0x40, %rsp
popq %rbp
retq
nop
| write_hook_for_undo_key_insert:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_28]
mov [rbp+var_30], rax
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
cmp qword ptr [rax+18h], 0
jbe short loc_445C0
jmp short $+2
loc_4454B:
jmp short $+2
loc_4454D:
mov rax, [rbp+var_38]
mov rax, [rax+0D8h]
mov rcx, [rbp+var_30]
cmp rax, [rcx+18h]
jnb short loc_44598
mov rax, [rbp+var_38]
mov rcx, [rax+0D8h]
mov rax, [rbp+var_38]
mov [rax+610h], rcx
mov rax, [rbp+var_18]
mov [rax+3E8h], rcx
mov rax, [rbp+var_30]
mov rcx, [rax+18h]
mov rax, [rbp+var_38]
mov [rax+0D8h], rcx
jmp short loc_445BE
loc_44598:
mov rax, [rbp+var_30]
mov rax, [rax+18h]
mov rcx, [rbp+var_38]
cmp rax, [rcx+610h]
jbe short loc_445BC
mov rax, [rbp+var_38]
mov qword ptr [rax+610h], 0FFFFFFFFFFFFFFFFh
loc_445BC:
jmp short $+2
loc_445BE:
jmp short $+2
loc_445C0:
mov edi, [rbp+var_4]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
mov r8, [rbp+var_28]
call write_hook_for_undo_key
add rsp, 40h
pop rbp
retn
| long long write_hook_for_undo_key_insert(unsigned int a1, long long a2, long long *a3, long long a4, long long a5)
{
long long v5; // rcx
long long v7; // [rsp+8h] [rbp-38h]
v7 = *a3;
if ( *(_QWORD *)(a5 + 24) )
{
if ( *(_QWORD *)(v7 + 216) >= *(_QWORD *)(a5 + 24) )
{
if ( *(_QWORD *)(a5 + 24) > *(_QWORD *)(v7 + 1552) )
*(_QWORD *)(v7 + 1552) = -1LL;
}
else
{
v5 = *(_QWORD *)(v7 + 216);
*(_QWORD *)(v7 + 1552) = v5;
a3[125] = v5;
*(_QWORD *)(v7 + 216) = *(_QWORD *)(a5 + 24);
}
}
return write_hook_for_undo_key(a1, a2, (long long)a3, a4, a5);
}
| write_hook_for_undo_key_insert:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
CMP qword ptr [RAX + 0x18],0x0
JBE 0x001445c0
JMP 0x0014454b
LAB_0014454b:
JMP 0x0014454d
LAB_0014454d:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0xd8]
MOV RCX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RCX + 0x18]
JNC 0x00144598
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RAX + 0xd8]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x610],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x3e8],RCX
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0xd8],RCX
JMP 0x001445be
LAB_00144598:
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RCX + 0x610]
JBE 0x001445bc
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x610],-0x1
LAB_001445bc:
JMP 0x001445be
LAB_001445be:
JMP 0x001445c0
LAB_001445c0:
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + -0x28]
CALL 0x00144480
ADD RSP,0x40
POP RBP
RET
|
void write_hook_for_undo_key_insert
(int4 param_1,int8 param_2,long *param_3,int8 param_4,long param_5)
{
long lVar1;
lVar1 = *param_3;
if (*(long *)(param_5 + 0x18) != 0) {
if (*(ulong *)(lVar1 + 0xd8) < *(ulong *)(param_5 + 0x18)) {
*(long *)(lVar1 + 0x610) = *(long *)(lVar1 + 0xd8);
param_3[0x7d] = *(long *)(lVar1 + 0xd8);
*(int8 *)(lVar1 + 0xd8) = *(int8 *)(param_5 + 0x18);
}
else if (*(ulong *)(lVar1 + 0x610) < *(ulong *)(param_5 + 0x18)) {
*(int8 *)(lVar1 + 0x610) = 0xffffffffffffffff;
}
}
write_hook_for_undo_key(param_1,param_2,param_3,param_4,param_5);
return;
}
| |
26,410 | ma_cmp_static_record | eloqsql/storage/maria/ma_statrec.c | my_bool _ma_cmp_static_record(register MARIA_HA *info,
register const uchar *old)
{
DBUG_ENTER("_ma_cmp_static_record");
if (info->opt_flag & WRITE_CACHE_USED)
{
if (flush_io_cache(&info->rec_cache))
{
DBUG_RETURN(1);
}
info->rec_cache.seek_not_done=1; /* We have done a seek */
}
if ((info->opt_flag & READ_CHECK_USED))
{ /* If check isn't disabled */
info->rec_cache.seek_not_done=1; /* We have done a seek */
if (info->s->file_read(info, info->rec_buff, info->s->base.reclength,
info->cur_row.lastpos, MYF(MY_NABP)))
DBUG_RETURN(1);
if (memcmp(info->rec_buff, old, (uint) info->s->base.reclength))
{
DBUG_DUMP("read",old,info->s->base.reclength);
DBUG_DUMP("disk",info->rec_buff,info->s->base.reclength);
my_errno=HA_ERR_RECORD_CHANGED; /* Record have changed */
DBUG_RETURN(1);
}
}
DBUG_RETURN(0);
} | O3 | c | ma_cmp_static_record:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x61c(%rdi), %eax
testb $0x10, %al
je 0x638c1
leaq 0x4b8(%r14), %rdi
movl $0x1, %esi
callq 0xb0e3d
movb $0x1, %r15b
testl %eax, %eax
jne 0x6392b
movl $0x1, 0x598(%r14)
movl 0x61c(%r14), %eax
testb $0x4, %al
jne 0x638ca
xorl %r15d, %r15d
jmp 0x6392b
movl $0x1, 0x598(%r14)
movq 0x3a0(%r14), %rsi
movq (%r14), %rax
movq 0x98(%r14), %rcx
movq 0x398(%rax), %rdx
movl $0x4, %r8d
movq %r14, %rdi
callq *0x6e0(%rax)
movb $0x1, %r15b
testq %rax, %rax
jne 0x6392b
movq 0x3a0(%r14), %rdi
movq (%r14), %rax
movl 0x398(%rax), %edx
movq %rbx, %rsi
callq 0x2a5d0
testl %eax, %eax
je 0x638c5
callq 0xc14ee
movl $0x7b, (%rax)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| _ma_cmp_static_record:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rsi
mov r14, rdi
mov eax, [rdi+61Ch]
test al, 10h
jz short loc_638C1
lea rdi, [r14+4B8h]
mov esi, 1
call my_b_flush_io_cache
mov r15b, 1
test eax, eax
jnz short loc_6392B
mov dword ptr [r14+598h], 1
mov eax, [r14+61Ch]
loc_638C1:
test al, 4
jnz short loc_638CA
loc_638C5:
xor r15d, r15d
jmp short loc_6392B
loc_638CA:
mov dword ptr [r14+598h], 1
mov rsi, [r14+3A0h]
mov rax, [r14]
mov rcx, [r14+98h]
mov rdx, [rax+398h]
mov r8d, 4
mov rdi, r14
call qword ptr [rax+6E0h]
mov r15b, 1
test rax, rax
jnz short loc_6392B
mov rdi, [r14+3A0h]
mov rax, [r14]
mov edx, [rax+398h]
mov rsi, rbx
call _bcmp
test eax, eax
jz short loc_638C5
call _my_thread_var
mov dword ptr [rax], 7Bh ; '{'
loc_6392B:
mov eax, r15d
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long ma_cmp_static_record(_QWORD *a1, long long a2)
{
unsigned int v2; // r15d
int v4; // eax
long long v5; // rdi
v4 = *((_DWORD *)a1 + 391);
if ( (v4 & 0x10) != 0 )
{
LOBYTE(v2) = 1;
if ( (unsigned int)my_b_flush_io_cache(a1 + 151, 1LL) )
return v2;
*((_DWORD *)a1 + 358) = 1;
v4 = *((_DWORD *)a1 + 391);
}
if ( (v4 & 4) != 0 )
{
*((_DWORD *)a1 + 358) = 1;
LOBYTE(v2) = 1;
if ( (*(long long ( **)(_QWORD *, _QWORD, _QWORD, _QWORD, long long))(*a1 + 1760LL))(
a1,
a1[116],
*(_QWORD *)(*a1 + 920LL),
a1[19],
4LL) )
{
return v2;
}
v5 = a1[116];
if ( (unsigned int)bcmp(v5, a2, *(unsigned int *)(*a1 + 920LL)) )
{
*(_DWORD *)my_thread_var(v5) = 123;
return v2;
}
}
return 0;
}
| _ma_cmp_static_record:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
MOV EAX,dword ptr [RDI + 0x61c]
TEST AL,0x10
JZ 0x001638c1
LEA RDI,[R14 + 0x4b8]
MOV ESI,0x1
CALL 0x001b0e3d
MOV R15B,0x1
TEST EAX,EAX
JNZ 0x0016392b
MOV dword ptr [R14 + 0x598],0x1
MOV EAX,dword ptr [R14 + 0x61c]
LAB_001638c1:
TEST AL,0x4
JNZ 0x001638ca
LAB_001638c5:
XOR R15D,R15D
JMP 0x0016392b
LAB_001638ca:
MOV dword ptr [R14 + 0x598],0x1
MOV RSI,qword ptr [R14 + 0x3a0]
MOV RAX,qword ptr [R14]
MOV RCX,qword ptr [R14 + 0x98]
MOV RDX,qword ptr [RAX + 0x398]
MOV R8D,0x4
MOV RDI,R14
CALL qword ptr [RAX + 0x6e0]
MOV R15B,0x1
TEST RAX,RAX
JNZ 0x0016392b
MOV RDI,qword ptr [R14 + 0x3a0]
MOV RAX,qword ptr [R14]
MOV EDX,dword ptr [RAX + 0x398]
MOV RSI,RBX
CALL 0x0012a5d0
TEST EAX,EAX
JZ 0x001638c5
CALL 0x001c14ee
MOV dword ptr [RAX],0x7b
LAB_0016392b:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
ulong _ma_cmp_static_record(long *param_1,void *param_2)
{
int iVar1;
uint uVar2;
long lVar3;
int4 *puVar4;
ulong unaff_R15;
uVar2 = *(uint *)((long)param_1 + 0x61c);
if ((uVar2 & 0x10) != 0) {
iVar1 = my_b_flush_io_cache(param_1 + 0x97,1);
unaff_R15 = CONCAT71((int7)(unaff_R15 >> 8),1);
if (iVar1 != 0) goto LAB_0016392b;
*(int4 *)(param_1 + 0xb3) = 1;
uVar2 = *(uint *)((long)param_1 + 0x61c);
}
if ((uVar2 & 4) != 0) {
*(int4 *)(param_1 + 0xb3) = 1;
lVar3 = (**(code **)(*param_1 + 0x6e0))
(param_1,param_1[0x74],*(int8 *)(*param_1 + 0x398),param_1[0x13],4);
unaff_R15 = CONCAT71((int7)(unaff_R15 >> 8),1);
if (lVar3 != 0) goto LAB_0016392b;
iVar1 = bcmp((void *)param_1[0x74],param_2,(ulong)*(uint *)(*param_1 + 0x398));
if (iVar1 != 0) {
puVar4 = (int4 *)_my_thread_var();
*puVar4 = 0x7b;
goto LAB_0016392b;
}
}
unaff_R15 = 0;
LAB_0016392b:
return unaff_R15 & 0xffffffff;
}
| |
26,411 | my_hash_reset | eloqsql/mysys/hash.c | void my_hash_reset(HASH *hash)
{
DBUG_ENTER("my_hash_reset");
DBUG_PRINT("enter",("hash:%p", hash));
my_hash_free_elements(hash);
reset_dynamic(&hash->array);
/* Set row pointers so that the hash can be reused at once */
hash->blength= 1;
DBUG_VOID_RETURN;
} | O3 | c | my_hash_reset:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x18(%rdi), %r14d
testq %r14, %r14
je 0x29b60
movq $0x0, 0x18(%rbx)
cmpq $0x0, 0x60(%rbx)
je 0x29b60
movq 0x28(%rbx), %r15
shlq $0x4, %r14
addq %r15, %r14
movq 0x8(%r15), %rdi
addq $0x10, %r15
callq *0x60(%rbx)
cmpq %r14, %r15
jb 0x29b50
movl $0x0, 0x30(%rbx)
movq $0x1, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| my_hash_reset:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdi
mov r14d, [rdi+18h]
test r14, r14
jz short loc_29B60
mov qword ptr [rbx+18h], 0
cmp qword ptr [rbx+60h], 0
jz short loc_29B60
mov r15, [rbx+28h]
shl r14, 4
add r14, r15
loc_29B50:
mov rdi, [r15+8]
add r15, 10h
call qword ptr [rbx+60h]
cmp r15, r14
jb short loc_29B50
loc_29B60:
mov dword ptr [rbx+30h], 0
mov qword ptr [rbx+10h], 1
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long my_hash_reset(long long a1)
{
long long v2; // r14
unsigned long long v3; // r15
unsigned long long v4; // r14
long long v5; // rdi
long long result; // rax
v2 = *(unsigned int *)(a1 + 24);
if ( *(_DWORD *)(a1 + 24) )
{
*(_QWORD *)(a1 + 24) = 0LL;
if ( *(_QWORD *)(a1 + 96) )
{
v3 = *(_QWORD *)(a1 + 40);
v4 = v3 + 16 * v2;
do
{
v5 = *(_QWORD *)(v3 + 8);
v3 += 16LL;
result = (*(long long ( **)(long long))(a1 + 96))(v5);
}
while ( v3 < v4 );
}
}
*(_DWORD *)(a1 + 48) = 0;
*(_QWORD *)(a1 + 16) = 1LL;
return result;
}
| my_hash_reset:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R14D,dword ptr [RDI + 0x18]
TEST R14,R14
JZ 0x00129b60
MOV qword ptr [RBX + 0x18],0x0
CMP qword ptr [RBX + 0x60],0x0
JZ 0x00129b60
MOV R15,qword ptr [RBX + 0x28]
SHL R14,0x4
ADD R14,R15
LAB_00129b50:
MOV RDI,qword ptr [R15 + 0x8]
ADD R15,0x10
CALL qword ptr [RBX + 0x60]
CMP R15,R14
JC 0x00129b50
LAB_00129b60:
MOV dword ptr [RBX + 0x30],0x0
MOV qword ptr [RBX + 0x10],0x1
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void my_hash_reset(long param_1)
{
int8 *puVar1;
uint uVar2;
ulong uVar3;
ulong uVar4;
uVar2 = *(uint *)(param_1 + 0x18);
if (((ulong)uVar2 != 0) && (*(int8 *)(param_1 + 0x18) = 0, *(long *)(param_1 + 0x60) != 0))
{
uVar4 = *(ulong *)(param_1 + 0x28);
uVar3 = (ulong)uVar2 * 0x10 + uVar4;
do {
puVar1 = (int8 *)(uVar4 + 8);
uVar4 = uVar4 + 0x10;
(**(code **)(param_1 + 0x60))(*puVar1);
} while (uVar4 < uVar3);
}
*(int4 *)(param_1 + 0x30) = 0;
*(int8 *)(param_1 + 0x10) = 1;
return;
}
| |
26,412 | my_get_err_msg | eloqsql/mysys/my_error.c | const char *my_get_err_msg(uint nr)
{
const char *format;
struct my_err_head *meh_p;
/* Search for the range this error is in. */
for (meh_p= my_errmsgs_list; meh_p; meh_p= meh_p->meh_next)
if (nr <= meh_p->meh_last)
break;
/*
If we found the range this error number is in, get the format string.
If the string is empty, or a NULL pointer, or if we're out of return,
we return NULL.
*/
if (!(format= (meh_p && (nr >= meh_p->meh_first)) ?
meh_p->get_errmsgs(nr)[nr - meh_p->meh_first] : NULL) ||
!*format)
return NULL;
return format;
} | O3 | c | my_get_err_msg:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
leaq 0x2c4e34(%rip), %r14 # 0x2ef988
xorl %eax, %eax
movq (%r14), %r14
testq %r14, %r14
je 0x2ab8a
cmpl %ebx, 0x14(%r14)
jb 0x2ab56
cmpl %ebx, 0x10(%r14)
ja 0x2ab88
movl %ebx, %edi
callq *0x8(%r14)
subl 0x10(%r14), %ebx
movq (%rax,%rbx,8), %rcx
testq %rcx, %rcx
je 0x2ab88
xorl %eax, %eax
cmpb $0x0, (%rcx)
cmovneq %rcx, %rax
jmp 0x2ab8a
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
| my_get_err_msg:
push rbp
mov rbp, rsp
push r14
push rbx
mov ebx, edi
lea r14, my_errmsgs_list
xor eax, eax
loc_2AB56:
mov r14, [r14]
test r14, r14
jz short loc_2AB8A
cmp [r14+14h], ebx
jb short loc_2AB56
cmp [r14+10h], ebx
ja short loc_2AB88
mov edi, ebx
call qword ptr [r14+8]
sub ebx, [r14+10h]
mov rcx, [rax+rbx*8]
test rcx, rcx
jz short loc_2AB88
xor eax, eax
cmp byte ptr [rcx], 0
cmovnz rax, rcx
jmp short loc_2AB8A
loc_2AB88:
xor eax, eax
loc_2AB8A:
pop rbx
pop r14
pop rbp
retn
| _BYTE * my_get_err_msg(unsigned int a1)
{
long long **v1; // r14
_BYTE *result; // rax
_BYTE *v3; // rcx
v1 = &my_errmsgs_list;
result = 0LL;
while ( 1 )
{
v1 = (long long **)*v1;
if ( !v1 )
break;
if ( *((_DWORD *)v1 + 5) >= a1 )
{
if ( *((_DWORD *)v1 + 4) > a1 )
return 0LL;
v3 = *(_BYTE **)(((long long ( *)(_QWORD))v1[1])(a1) + 8LL * (a1 - *((_DWORD *)v1 + 4)));
if ( !v3 )
return 0LL;
result = 0LL;
if ( *v3 )
return v3;
return result;
}
}
return result;
}
| my_get_err_msg:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV EBX,EDI
LEA R14,[0x3ef988]
XOR EAX,EAX
LAB_0012ab56:
MOV R14,qword ptr [R14]
TEST R14,R14
JZ 0x0012ab8a
CMP dword ptr [R14 + 0x14],EBX
JC 0x0012ab56
CMP dword ptr [R14 + 0x10],EBX
JA 0x0012ab88
MOV EDI,EBX
CALL qword ptr [R14 + 0x8]
SUB EBX,dword ptr [R14 + 0x10]
MOV RCX,qword ptr [RAX + RBX*0x8]
TEST RCX,RCX
JZ 0x0012ab88
XOR EAX,EAX
CMP byte ptr [RCX],0x0
CMOVNZ RAX,RCX
JMP 0x0012ab8a
LAB_0012ab88:
XOR EAX,EAX
LAB_0012ab8a:
POP RBX
POP R14
POP RBP
RET
|
char * my_get_err_msg(uint param_1)
{
char *pcVar1;
long lVar2;
int **ppuVar3;
ppuVar3 = &my_errmsgs_list;
do {
ppuVar3 = (int **)*ppuVar3;
if (ppuVar3 == (int **)0x0) {
return (char *)0x0;
}
} while (*(uint *)((long)ppuVar3 + 0x14) < param_1);
if (*(uint *)(ppuVar3 + 2) <= param_1) {
lVar2 = (*(code *)ppuVar3[1])(param_1);
pcVar1 = *(char **)(lVar2 + (ulong)(param_1 - *(int *)(ppuVar3 + 2)) * 8);
if (pcVar1 != (char *)0x0) {
if (*pcVar1 == '\0') {
return (char *)0x0;
}
return pcVar1;
}
}
return (char *)0x0;
}
| |
26,413 | my_well_formed_char_length_ucs2 | eloqsql/strings/ctype-ucs2.c | static size_t
my_well_formed_char_length_ucs2(CHARSET_INFO *cs __attribute__((unused)),
const char *b, const char *e,
size_t nchars, MY_STRCOPY_STATUS *status)
{
size_t length= e - b;
if (nchars * 2 <= length)
{
status->m_well_formed_error_pos= NULL;
status->m_source_end_pos= b + (nchars * 2);
return nchars;
}
if (length % 2)
{
status->m_well_formed_error_pos= status->m_source_end_pos= e - 1;
}
else
{
status->m_well_formed_error_pos= NULL;
status->m_source_end_pos= e;
}
return length / 2;
} | O0 | c | my_well_formed_char_length_ucs2:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
shlq %rax
cmpq -0x38(%rbp), %rax
ja 0x5c63f
movq -0x30(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
shlq %rax
addq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5c688
movq -0x38(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x5c666
movq -0x20(%rbp), %rcx
addq $-0x1, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x5c67d
movq -0x30(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
shrq %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| my_well_formed_char_length_ucs2:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
sub rax, rcx
mov [rbp+var_38], rax
mov rax, [rbp+var_28]
shl rax, 1
cmp rax, [rbp+var_38]
ja short loc_5C63F
mov rax, [rbp+var_30]
mov qword ptr [rax+8], 0
mov rcx, [rbp+var_18]
mov rax, [rbp+var_28]
shl rax, 1
add rcx, rax
mov rax, [rbp+var_30]
mov [rax], rcx
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
jmp short loc_5C688
loc_5C63F:
mov rax, [rbp+var_38]
and rax, 1
cmp rax, 0
jz short loc_5C666
mov rcx, [rbp+var_20]
add rcx, 0FFFFFFFFFFFFFFFFh
mov rax, [rbp+var_30]
mov [rax], rcx
mov rax, [rbp+var_30]
mov [rax+8], rcx
jmp short loc_5C67D
loc_5C666:
mov rax, [rbp+var_30]
mov qword ptr [rax+8], 0
mov rcx, [rbp+var_20]
mov rax, [rbp+var_30]
mov [rax], rcx
loc_5C67D:
mov rax, [rbp+var_38]
shr rax, 1
mov [rbp+var_8], rax
loc_5C688:
mov rax, [rbp+var_8]
pop rbp
retn
| unsigned long long my_well_formed_char_length_ucs2(long long a1, long long a2, long long a3, long long a4, _QWORD *a5)
{
unsigned long long v6; // [rsp+0h] [rbp-38h]
v6 = a3 - a2;
if ( 2 * a4 > (unsigned long long)(a3 - a2) )
{
if ( (v6 & 1) != 0 )
{
*a5 = a3 - 1;
a5[1] = a3 - 1;
}
else
{
a5[1] = 0LL;
*a5 = a3;
}
return v6 >> 1;
}
else
{
a5[1] = 0LL;
*a5 = 2 * a4 + a2;
return a4;
}
}
| my_well_formed_char_length_ucs2:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
SUB RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x28]
SHL RAX,0x1
CMP RAX,qword ptr [RBP + -0x38]
JA 0x0015c63f
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x8],0x0
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x28]
SHL RAX,0x1
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0015c688
LAB_0015c63f:
MOV RAX,qword ptr [RBP + -0x38]
AND RAX,0x1
CMP RAX,0x0
JZ 0x0015c666
MOV RCX,qword ptr [RBP + -0x20]
ADD RCX,-0x1
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x0015c67d
LAB_0015c666:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x8],0x0
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
LAB_0015c67d:
MOV RAX,qword ptr [RBP + -0x38]
SHR RAX,0x1
MOV qword ptr [RBP + -0x8],RAX
LAB_0015c688:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
ulong my_well_formed_char_length_ucs2
(int8 param_1,long param_2,long param_3,ulong param_4,long *param_5)
{
ulong local_10;
local_10 = param_3 - param_2;
if (param_4 * 2 < local_10 || param_4 * 2 - local_10 == 0) {
param_5[1] = 0;
*param_5 = param_2 + param_4 * 2;
local_10 = param_4;
}
else {
if ((local_10 & 1) == 0) {
param_5[1] = 0;
*param_5 = param_3;
}
else {
*param_5 = param_3 + -1;
param_5[1] = param_3 + -1;
}
local_10 = local_10 >> 1;
}
return local_10;
}
| |
26,414 | strmake_root | eloqsql/mysys/my_alloc.c | char *strmake_root(MEM_ROOT *root, const char *str, size_t len)
{
char *pos;
if ((pos=alloc_root(root,len+1)))
{
if (len)
memcpy(pos,str,len);
pos[len]=0;
}
return pos;
} | O0 | c | strmake_root:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
callq 0x35410
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x35d13
cmpq $0x0, -0x18(%rbp)
je 0x35d07
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x24260
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| strmake_root:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_18]
add rsi, 1
call alloc_root
mov [rbp+var_20], rax
cmp rax, 0
jz short loc_35D13
cmp [rbp+var_18], 0
jz short loc_35D07
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
call _memcpy
loc_35D07:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
mov byte ptr [rax+rcx], 0
loc_35D13:
mov rax, [rbp+var_20]
add rsp, 20h
pop rbp
retn
| char * strmake_root(_QWORD **a1, long long a2, long long a3)
{
char *v4; // [rsp+0h] [rbp-20h]
v4 = alloc_root(a1, a3 + 1);
if ( v4 )
{
if ( a3 )
memcpy(v4, a2, a3);
v4[a3] = 0;
}
return v4;
}
| strmake_root:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x18]
ADD RSI,0x1
CALL 0x00135410
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JZ 0x00135d13
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00135d07
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x00124260
LAB_00135d07:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + RCX*0x1],0x0
LAB_00135d13:
MOV RAX,qword ptr [RBP + -0x20]
ADD RSP,0x20
POP RBP
RET
|
void * strmake_root(int8 param_1,void *param_2,size_t param_3)
{
void *__dest;
__dest = (void *)alloc_root(param_1,param_3 + 1);
if (__dest != (void *)0x0) {
if (param_3 != 0) {
memcpy(__dest,param_2,param_3);
}
*(int1 *)((long)__dest + param_3) = 0;
}
return __dest;
}
| |
26,415 | SDL::OpenGL1Render::Line(SDL::Vec2f const&, SDL::Vec2f const&) | SDL3Lite/source/Renders/OpenGL1/OpenGL1Render.cpp | void OpenGL1Render::Line(const SDL::Vec2f& first, const SDL::Vec2f& last)
{
GLclampf r;
GLclampf g;
GLclampf b;
Normalize(_color, r, g, b);
glBegin(GL_LINES);
glColor3f(r, g, b);
glVertex2f(first.x, first.y);
glVertex2f(last.x, last.y);
glEnd();
} | O0 | cpp | SDL::OpenGL1Render::Line(SDL::Vec2f const&, SDL::Vec2f const&):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
leaq -0x1c(%rbp), %rsi
leaq -0x20(%rbp), %rdx
leaq -0x24(%rbp), %rcx
callq 0x1cf80
movl $0x1, %edi
callq *0x17348(%rip) # 0x3b4f0
movq 0x17371(%rip), %rax # 0x3b520
movss -0x1c(%rbp), %xmm0
movss -0x20(%rbp), %xmm1
movss -0x24(%rbp), %xmm2
callq *%rax
movq 0x176f1(%rip), %rax # 0x3b8b8
movq -0x10(%rbp), %rcx
movss (%rcx), %xmm0
movq -0x10(%rbp), %rcx
movss 0x4(%rcx), %xmm1
callq *%rax
movq 0x176d7(%rip), %rax # 0x3b8b8
movq -0x18(%rbp), %rcx
movss (%rcx), %xmm0
movq -0x18(%rbp), %rcx
movss 0x4(%rcx), %xmm1
callq *%rax
callq *0x17416(%rip) # 0x3b610
addq $0x30, %rsp
popq %rbp
retq
| _ZN3SDL13OpenGL1Render4LineERKNS_5Vec2fES3_:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rdi, [rbp+var_8]
add rdi, 18h
lea rsi, [rbp+var_1C]
lea rdx, [rbp+var_20]
lea rcx, [rbp+var_24]
call _ZN3SDL9NormalizeERKNS_5ColorERfS3_S3_; SDL::Normalize(SDL::Color const&,float &,float &,float &)
mov edi, 1
call cs:glBegin
mov rax, cs:glColor3f
movss xmm0, [rbp+var_1C]
movss xmm1, [rbp+var_20]
movss xmm2, [rbp+var_24]
call rax ; glColor3f
mov rax, cs:glVertex2f
mov rcx, [rbp+var_10]
movss xmm0, dword ptr [rcx]
mov rcx, [rbp+var_10]
movss xmm1, dword ptr [rcx+4]
call rax ; glVertex2f
mov rax, cs:glVertex2f
mov rcx, [rbp+var_18]
movss xmm0, dword ptr [rcx]
mov rcx, [rbp+var_18]
movss xmm1, dword ptr [rcx+4]
call rax ; glVertex2f
call cs:glEnd
add rsp, 30h
pop rbp
retn
| long long SDL::OpenGL1Render::Line(
SDL::OpenGL1Render *this,
const SDL::Vec2f *a2,
const SDL::Vec2f *a3,
long long a4,
float *a5)
{
float v6; // [rsp+Ch] [rbp-24h] BYREF
float v7; // [rsp+10h] [rbp-20h] BYREF
float v8; // [rsp+14h] [rbp-1Ch] BYREF
float *v9; // [rsp+18h] [rbp-18h]
float *v10; // [rsp+20h] [rbp-10h]
SDL::OpenGL1Render *v11; // [rsp+28h] [rbp-8h]
v11 = this;
v10 = (float *)a2;
v9 = (float *)a3;
SDL::Normalize((SDL::OpenGL1Render *)((char *)this + 24), (const SDL::Color *)&v8, &v7, &v6, a5);
glBegin(1LL);
glColor3f(v8, v7, v6);
glVertex2f(*v10, v10[1]);
glVertex2f(*v9, v9[1]);
return glEnd();
}
| Line:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x18
LEA RSI,[RBP + -0x1c]
LEA RDX,[RBP + -0x20]
LEA RCX,[RBP + -0x24]
CALL 0x0011cf80
MOV EDI,0x1
CALL qword ptr [0x0013b4f0]
MOV RAX,qword ptr [0x0013b520]
MOVSS XMM0,dword ptr [RBP + -0x1c]
MOVSS XMM1,dword ptr [RBP + -0x20]
MOVSS XMM2,dword ptr [RBP + -0x24]
CALL RAX
MOV RAX,qword ptr [0x0013b8b8]
MOV RCX,qword ptr [RBP + -0x10]
MOVSS XMM0,dword ptr [RCX]
MOV RCX,qword ptr [RBP + -0x10]
MOVSS XMM1,dword ptr [RCX + 0x4]
CALL RAX
MOV RAX,qword ptr [0x0013b8b8]
MOV RCX,qword ptr [RBP + -0x18]
MOVSS XMM0,dword ptr [RCX]
MOV RCX,qword ptr [RBP + -0x18]
MOVSS XMM1,dword ptr [RCX + 0x4]
CALL RAX
CALL qword ptr [0x0013b610]
ADD RSP,0x30
POP RBP
RET
|
/* SDL::OpenGL1Render::Line(SDL::Vec2f const&, SDL::Vec2f const&) */
void __thiscall SDL::OpenGL1Render::Line(OpenGL1Render *this,Vec2f *param_1,Vec2f *param_2)
{
float local_2c;
float local_28;
float local_24;
Vec2f *local_20;
Vec2f *local_18;
OpenGL1Render *local_10;
local_20 = param_2;
local_18 = param_1;
local_10 = this;
Normalize((Color *)(this + 0x18),&local_24,&local_28,&local_2c);
(*glBegin)(1);
(*glColor3f)(local_24,local_28,local_2c);
(*glVertex2f)(*(int4 *)local_18,*(int4 *)(local_18 + 4));
(*glVertex2f)(*(int4 *)local_20,*(int4 *)(local_20 + 4));
(*glEnd)();
return;
}
| |
26,416 | JS_CreateProperty | bluesky950520[P]quickjs/quickjs.c | static int JS_CreateProperty(JSContext *ctx, JSObject *p,
JSAtom prop, JSValue val,
JSValue getter, JSValue setter,
int flags)
{
JSProperty *pr;
int ret, prop_flags;
/* add a new property or modify an existing exotic one */
if (p->is_exotic) {
if (p->class_id == JS_CLASS_ARRAY) {
uint32_t idx, len;
if (p->fast_array) {
if (__JS_AtomIsTaggedInt(prop)) {
idx = __JS_AtomToUInt32(prop);
if (idx == p->u.array.count) {
if (!p->extensible)
goto not_extensible;
if (flags & (JS_PROP_HAS_GET | JS_PROP_HAS_SET))
goto convert_to_array;
prop_flags = get_prop_flags(flags, 0);
if (prop_flags != JS_PROP_C_W_E)
goto convert_to_array;
return add_fast_array_element(ctx, p,
js_dup(val), flags);
} else {
goto convert_to_array;
}
} else if (JS_AtomIsArrayIndex(ctx, &idx, prop)) {
/* convert the fast array to normal array */
convert_to_array:
if (convert_fast_array_to_array(ctx, p))
return -1;
goto generic_array;
}
} else if (JS_AtomIsArrayIndex(ctx, &idx, prop)) {
JSProperty *plen;
JSShapeProperty *pslen;
generic_array:
/* update the length field */
plen = &p->prop[0];
JS_ToUint32(ctx, &len, plen->u.value);
if ((idx + 1) > len) {
pslen = get_shape_prop(p->shape);
if (unlikely(!(pslen->flags & JS_PROP_WRITABLE)))
return JS_ThrowTypeErrorReadOnly(ctx, flags, JS_ATOM_length);
/* XXX: should update the length after defining
the property */
len = idx + 1;
set_value(ctx, &plen->u.value, js_uint32(len));
}
}
} else if (p->class_id >= JS_CLASS_UINT8C_ARRAY &&
p->class_id <= JS_CLASS_FLOAT64_ARRAY) {
ret = JS_AtomIsNumericIndex(ctx, prop);
if (ret != 0) {
if (ret < 0)
return -1;
return JS_ThrowTypeErrorOrFalse(ctx, flags, "cannot create numeric index in typed array");
}
} else if (!(flags & JS_PROP_NO_EXOTIC)) {
const JSClassExoticMethods *em = ctx->rt->class_array[p->class_id].exotic;
if (em) {
if (em->define_own_property) {
return em->define_own_property(ctx, JS_MKPTR(JS_TAG_OBJECT, p),
prop, val, getter, setter, flags);
}
ret = JS_IsExtensible(ctx, JS_MKPTR(JS_TAG_OBJECT, p));
if (ret < 0)
return -1;
if (!ret)
goto not_extensible;
}
}
}
if (!p->extensible) {
not_extensible:
return JS_ThrowTypeErrorOrFalse(ctx, flags, "object is not extensible");
}
if (flags & (JS_PROP_HAS_GET | JS_PROP_HAS_SET)) {
prop_flags = (flags & (JS_PROP_CONFIGURABLE | JS_PROP_ENUMERABLE)) |
JS_PROP_GETSET;
} else {
prop_flags = flags & JS_PROP_C_W_E;
}
pr = add_property(ctx, p, prop, prop_flags);
if (unlikely(!pr))
return -1;
if (flags & (JS_PROP_HAS_GET | JS_PROP_HAS_SET)) {
pr->u.getset.getter = NULL;
if ((flags & JS_PROP_HAS_GET) && JS_IsFunction(ctx, getter)) {
pr->u.getset.getter =
JS_VALUE_GET_OBJ(js_dup(getter));
}
pr->u.getset.setter = NULL;
if ((flags & JS_PROP_HAS_SET) && JS_IsFunction(ctx, setter)) {
pr->u.getset.setter =
JS_VALUE_GET_OBJ(js_dup(setter));
}
} else {
if (flags & JS_PROP_HAS_VALUE) {
pr->u.value = js_dup(val);
} else {
pr->u.value = JS_UNDEFINED;
}
}
return TRUE;
} | O1 | c | JS_CreateProperty:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, %ebx
movq %r8, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %r14
movb 0x5(%rsi), %al
testb $0x4, %al
jne 0xfb45
testb $0x1, 0x5(%r13)
jne 0xfb78
leaq 0x8f446(%rip), %rdx # 0x9ef71
movq %r14, %rdi
movl %ebx, %esi
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x261e2
movzwl 0x6(%r13), %ecx
cmpq $0x2, %rcx
jne 0xfc46
testb $0x8, %al
jne 0xfc8f
leaq 0x34(%rsp), %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x3d7ed
testl %eax, %eax
jne 0xfddc
jmp 0xfe5b
movl %ebx, %eax
andl $0x5, %eax
orl $0x10, %eax
movl %ebx, %ecx
andl $0x7, %ecx
testw $0x1800, %bx # imm = 0x1800
cmovnel %eax, %ecx
movq %r14, %rdi
movq %r13, %rsi
movl %ebp, %edx
callq 0x3bf45
testq %rax, %rax
je 0xfd7a
movq %rax, %r13
testw $0x1800, %bx # imm = 0x1800
je 0xfc73
andq $0x0, (%r13)
btl $0xb, %ebx
jae 0xfbf3
leaq 0x80(%rsp), %rax
movq (%rax), %r15
movq 0x8(%rax), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x22dbe
testl %eax, %eax
je 0xfbf3
movq %r15, 0x28(%rsp)
cmpl $-0x9, %r12d
jb 0xfbef
movq 0x28(%rsp), %rax
incl (%rax)
movq %r15, (%r13)
andq $0x0, 0x8(%r13)
pushq $0x1
popq %r15
btl $0xc, %ebx
jae 0xfe71
leaq 0x90(%rsp), %rax
movq (%rax), %rbx
movq 0x8(%rax), %r12
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x22dbe
testl %eax, %eax
je 0xfe71
movq %rbx, 0x28(%rsp)
cmpl $-0x9, %r12d
jb 0xfc3d
movq 0x28(%rsp), %rax
incl (%rax)
movq %rbx, 0x8(%r13)
jmp 0xfe71
leal -0x15(%rcx), %eax
cmpw $0xb, %ax
ja 0xfcb3
movq %r14, %rdi
movl %ebp, %esi
callq 0x24060
testl %eax, %eax
je 0xfb1d
js 0xfd7a
leaq 0x8f4f2(%rip), %rdx # 0x9f160
jmp 0xfb2b
btl $0xd, %ebx
jb 0xfd2f
andl $0x0, (%r13)
movq $0x3, 0x8(%r13)
jmp 0xfd52
testl %ebp, %ebp
js 0xfd5b
leaq 0x34(%rsp), %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x3d7ed
testl %eax, %eax
jne 0xfdc0
jmp 0xfe5b
btl $0x11, %ebx
jb 0xfb1d
movq 0x18(%r14), %rax
movq 0x80(%rax), %rax
imulq $0x28, %rcx, %rcx
movq 0x20(%rax,%rcx), %rax
testq %rax, %rax
je 0xfe97
pushq $0x1
popq %r12
movq 0x18(%rax), %rax
testq %rax, %rax
je 0xfe83
leaq 0x90(%rsp), %rcx
movups (%rcx), %xmm0
movups %xmm0, 0x10(%rsp)
leaq 0x80(%rsp), %rcx
movupd (%rcx), %xmm0
movupd %xmm0, (%rsp)
movl %ebx, 0x20(%rsp)
pushq $-0x1
popq %rdx
movq %r14, %rdi
movq %r13, %rsi
movl %ebp, %ecx
movq 0x38(%rsp), %r8
movq 0x40(%rsp), %r9
callq *%rax
movl %eax, %r15d
jmp 0xfe9a
movq 0x38(%rsp), %rdx
movq %rdx, 0x28(%rsp)
movq 0x40(%rsp), %rcx
cmpl $-0x9, %ecx
jb 0xfd4a
movq 0x28(%rsp), %rax
incl (%rax)
movq %rdx, (%r13)
movq %rcx, 0x8(%r13)
pushq $0x1
popq %r15
jmp 0xfe71
movl %ebp, %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
movl %ecx, 0x34(%rsp)
cmpl 0x40(%r13), %ecx
jne 0xfdc0
testb $0x1, %al
jne 0xfd7e
pushq $0x2
popq %r12
jmp 0xfe5e
pushq $-0x1
jmp 0xfd54
testw $0x1800, %bx # imm = 0x1800
jne 0xfdc0
movl %ebx, %eax
shrl $0x8, %eax
andl %ebx, %eax
notl %eax
testb $0x7, %al
jne 0xfdc0
movq 0x38(%rsp), %rdx
movq %rdx, 0x28(%rsp)
movq 0x40(%rsp), %rcx
cmpl $-0x9, %ecx
jb 0xfdad
movq 0x28(%rsp), %rax
incl (%rax)
movq %r14, %rdi
movq %r13, %rsi
movl %ebx, %r8d
callq 0x3da97
movl %eax, %r15d
jmp 0xfdd3
movq %r14, %rdi
movq %r13, %rsi
callq 0x267b0
testl %eax, %eax
je 0xfddc
pushq $-0x1
popq %r15
pushq $0x1
popq %r12
jmp 0xfe5e
movq 0x20(%r13), %r15
movq (%r15), %rdx
movq 0x8(%r15), %rcx
movq %rdx, 0x28(%rsp)
cmpl $-0x9, %ecx
jb 0xfdf8
movq 0x28(%rsp), %rax
incl (%rax)
leaq 0x28(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x279c3
movl 0x34(%rsp), %eax
incl %eax
cmpl (%r12), %eax
jbe 0xfe5b
movq 0x18(%r13), %rcx
testb $0x8, 0x43(%rcx)
je 0xfebb
movl %eax, 0x28(%rsp)
xorl %r12d, %r12d
movl %eax, %ecx
cvtsi2sd %rcx, %xmm0
testl %eax, %eax
movq %xmm0, %rax
cmovnsq %rcx, %rax
pushq $0x7
popq %rcx
cmovnsq %r12, %rcx
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rax, (%r15)
movq %rcx, 0x8(%r15)
movq 0x18(%r14), %rdi
callq 0x1d8c6
jmp 0xfe5e
xorl %r12d, %r12d
testl %r12d, %r12d
je 0xfb1d
cmpl $0x2, %r12d
je 0xfb24
movl %r15d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x1
popq %rdx
movq %r14, %rdi
movq %r13, %rsi
callq 0xf6fb
testl %eax, %eax
js 0xfeaf
je 0xfeb5
xorl %r12d, %r12d
cmpl $0x2, %r12d
je 0xfb24
testl %r12d, %r12d
je 0xfb1d
jmp 0xfe71
pushq $-0x1
popq %r15
jmp 0xfe9a
pushq $0x2
popq %r12
jmp 0xfe9a
pushq $0x32
popq %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x3db62
jmp 0xfdbb
| JS_CreateProperty:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov ebx, r9d
mov [rsp+78h+var_38], r8
mov [rsp+78h+var_40], rcx
mov ebp, edx
mov r13, rsi
mov r14, rdi
mov al, [rsi+5]
test al, 4
jnz short loc_FB45
loc_FB1D:
test byte ptr [r13+5], 1
jnz short loc_FB78
loc_FB24:
lea rdx, aObjectIsNotExt; "object is not extensible"
loc_FB2B:
mov rdi, r14
mov esi, ebx
xor eax, eax
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp JS_ThrowTypeErrorOrFalse
loc_FB45:
movzx ecx, word ptr [r13+6]
cmp rcx, 2
jnz loc_FC46
test al, 8
jnz loc_FC8F
lea rsi, [rsp+78h+var_44]
mov rdi, r14
mov edx, ebp
call JS_AtomIsArrayIndex
test eax, eax
jnz loc_FDDC
jmp loc_FE5B
loc_FB78:
mov eax, ebx
and eax, 5
or eax, 10h
mov ecx, ebx
and ecx, 7
test bx, 1800h
cmovnz ecx, eax
mov rdi, r14
mov rsi, r13
mov edx, ebp
call add_property
test rax, rax
jz loc_FD7A
mov r13, rax
test bx, 1800h
jz loc_FC73
and qword ptr [r13+0], 0
bt ebx, 0Bh
jnb short loc_FBF3
lea rax, [rsp+78h+arg_0]
mov r15, [rax]
mov r12, [rax+8]
mov rdi, r14
mov rsi, r15
mov rdx, r12
call JS_IsFunction
test eax, eax
jz short loc_FBF3
mov [rsp+78h+var_50], r15
cmp r12d, 0FFFFFFF7h
jb short loc_FBEF
mov rax, [rsp+78h+var_50]
inc dword ptr [rax]
loc_FBEF:
mov [r13+0], r15
loc_FBF3:
and qword ptr [r13+8], 0
push 1
pop r15
bt ebx, 0Ch
jnb loc_FE71
lea rax, [rsp+78h+arg_10]
mov rbx, [rax]
mov r12, [rax+8]
mov rdi, r14
mov rsi, rbx
mov rdx, r12
call JS_IsFunction
test eax, eax
jz loc_FE71
mov [rsp+78h+var_50], rbx
cmp r12d, 0FFFFFFF7h
jb short loc_FC3D
mov rax, [rsp+78h+var_50]
inc dword ptr [rax]
loc_FC3D:
mov [r13+8], rbx
jmp loc_FE71
loc_FC46:
lea eax, [rcx-15h]
cmp ax, 0Bh
ja short loc_FCB3
mov rdi, r14
mov esi, ebp
call JS_AtomIsNumericIndex
test eax, eax
jz loc_FB1D
js loc_FD7A
lea rdx, aCannotCreateNu; "cannot create numeric index in typed ar"...
jmp loc_FB2B
loc_FC73:
bt ebx, 0Dh
jb loc_FD2F
and dword ptr [r13+0], 0
mov qword ptr [r13+8], 3
jmp loc_FD52
loc_FC8F:
test ebp, ebp
js loc_FD5B
lea rsi, [rsp+78h+var_44]
mov rdi, r14
mov edx, ebp
call JS_AtomIsArrayIndex
test eax, eax
jnz loc_FDC0
jmp loc_FE5B
loc_FCB3:
bt ebx, 11h
jb loc_FB1D
mov rax, [r14+18h]
mov rax, [rax+80h]
imul rcx, 28h ; '('
mov rax, [rax+rcx+20h]
test rax, rax
jz loc_FE97
push 1
pop r12
mov rax, [rax+18h]
test rax, rax
jz loc_FE83
lea rcx, [rsp+78h+arg_10]
movups xmm0, xmmword ptr [rcx]
movups [rsp+78h+var_68], xmm0
lea rcx, [rsp+78h+arg_0]
movupd xmm0, xmmword ptr [rcx]
movupd [rsp+78h+var_78], xmm0
mov [rsp+78h+var_58], ebx
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rdi, r14
mov rsi, r13
mov ecx, ebp
mov r8, [rsp+78h+var_40]
mov r9, [rsp+78h+var_38]
call rax
mov r15d, eax
jmp loc_FE9A
loc_FD2F:
mov rdx, [rsp+78h+var_40]
mov [rsp+78h+var_50], rdx
mov rcx, [rsp+78h+var_38]
cmp ecx, 0FFFFFFF7h
jb short loc_FD4A
mov rax, [rsp+78h+var_50]
inc dword ptr [rax]
loc_FD4A:
mov [r13+0], rdx
mov [r13+8], rcx
loc_FD52:
push 1
loc_FD54:
pop r15
jmp loc_FE71
loc_FD5B:
mov ecx, ebp
and ecx, 7FFFFFFFh
mov [rsp+78h+var_44], ecx
cmp ecx, [r13+40h]
jnz short loc_FDC0
test al, 1
jnz short loc_FD7E
push 2
pop r12
jmp loc_FE5E
loc_FD7A:
push 0FFFFFFFFFFFFFFFFh
jmp short loc_FD54
loc_FD7E:
test bx, 1800h
jnz short loc_FDC0
mov eax, ebx
shr eax, 8
and eax, ebx
not eax
test al, 7
jnz short loc_FDC0
mov rdx, [rsp+78h+var_40]
mov [rsp+78h+var_50], rdx
mov rcx, [rsp+78h+var_38]
cmp ecx, 0FFFFFFF7h
jb short loc_FDAD
mov rax, [rsp+78h+var_50]
inc dword ptr [rax]
loc_FDAD:
mov rdi, r14
mov rsi, r13
mov r8d, ebx
call add_fast_array_element
loc_FDBB:
mov r15d, eax
jmp short loc_FDD3
loc_FDC0:
mov rdi, r14
mov rsi, r13
call convert_fast_array_to_array
test eax, eax
jz short loc_FDDC
push 0FFFFFFFFFFFFFFFFh
pop r15
loc_FDD3:
push 1
pop r12
jmp loc_FE5E
loc_FDDC:
mov r15, [r13+20h]
mov rdx, [r15]
mov rcx, [r15+8]
mov [rsp+78h+var_50], rdx
cmp ecx, 0FFFFFFF7h
jb short loc_FDF8
mov rax, [rsp+78h+var_50]
inc dword ptr [rax]
loc_FDF8:
lea r12, [rsp+78h+var_50]
mov rdi, r14
mov rsi, r12
call JS_ToInt32Free
mov eax, [rsp+78h+var_44]
inc eax
cmp eax, [r12]
jbe short loc_FE5B
mov rcx, [r13+18h]
test byte ptr [rcx+43h], 8
jz loc_FEBB
mov dword ptr [rsp+78h+var_50], eax
xor r12d, r12d
mov ecx, eax
cvtsi2sd xmm0, rcx
test eax, eax
movq rax, xmm0
cmovns rax, rcx
push 7
pop rcx
cmovns rcx, r12
mov rsi, [r15]
mov rdx, [r15+8]
mov [r15], rax
mov [r15+8], rcx
mov rdi, [r14+18h]
call JS_FreeValueRT
jmp short loc_FE5E
loc_FE5B:
xor r12d, r12d
loc_FE5E:
test r12d, r12d
jz loc_FB1D
cmp r12d, 2
jz loc_FB24
loc_FE71:
mov eax, r15d
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_FE83:
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rdi, r14
mov rsi, r13
call JS_IsExtensible
test eax, eax
js short loc_FEAF
jz short loc_FEB5
loc_FE97:
xor r12d, r12d
loc_FE9A:
cmp r12d, 2
jz loc_FB24
test r12d, r12d
jz loc_FB1D
jmp short loc_FE71
loc_FEAF:
push 0FFFFFFFFFFFFFFFFh
pop r15
jmp short loc_FE9A
loc_FEB5:
push 2
pop r12
jmp short loc_FE9A
loc_FEBB:
push 32h ; '2'
pop rdx
mov rdi, r14
mov esi, ebx
call JS_ThrowTypeErrorReadOnly
jmp loc_FDBB
| long long JS_CreateProperty(
long long a1,
long long a2,
unsigned int a3,
long long a4,
long long a5,
unsigned int a6,
_DWORD *a7,
long long a8,
_DWORD *a9,
long long a10)
{
long long v10; // r15
char v14; // al
const char *v15; // rdx
long long v17; // rcx
_QWORD *v18; // rax
_QWORD *v19; // r13
int IsNumericIndex; // eax
long long v21; // rax
int v22; // r12d
long long ( *v23)(long long, long long, long long, _QWORD, _DWORD *, long long, _DWORD *, long long, _DWORD *, long long, unsigned int); // rax
_DWORD *v24; // rdx
long long v25; // rcx
int v26; // r12d
_DWORD *v27; // rdx
long long v28; // rcx
int Only; // eax
long long v30; // rcx
int v31; // eax
double v32; // rcx
bool v33; // sf
double v34; // rax
long long v35; // rcx
_DWORD *v36; // rsi
int IsExtensible; // eax
int v38; // [rsp-8h] [rbp-80h]
_DWORD *v39; // [rsp+28h] [rbp-50h] BYREF
int v40; // [rsp+34h] [rbp-44h] BYREF
_DWORD *v41; // [rsp+38h] [rbp-40h]
long long v42; // [rsp+40h] [rbp-38h]
v42 = a5;
v41 = (_DWORD *)a4;
v14 = *(_BYTE *)(a2 + 5);
if ( (v14 & 4) == 0 )
goto LABEL_2;
a4 = *(unsigned __int16 *)(a2 + 6);
if ( a4 != 2 )
{
if ( (unsigned __int16)(a4 - 21) <= 0xBu )
{
IsNumericIndex = JS_AtomIsNumericIndex(a1, a3);
if ( IsNumericIndex )
{
if ( IsNumericIndex >= 0 )
{
v15 = "cannot create numeric index in typed array";
return JS_ThrowTypeErrorOrFalse(a1, a6, (_DWORD)v15, a4, a5, a6, (char)a7);
}
goto LABEL_44;
}
goto LABEL_2;
}
if ( (a6 & 0x20000) != 0 )
goto LABEL_2;
a4 *= 40LL;
v21 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 128LL) + a4 + 32);
if ( !v21 )
goto LABEL_69;
v22 = 1;
v23 = *(long long ( **)(long long, long long, long long, _QWORD, _DWORD *, long long, _DWORD *, long long, _DWORD *, long long, unsigned int))(v21 + 24);
if ( v23 )
{
LODWORD(v10) = v23(a1, a2, -1LL, a3, v41, v42, a7, a8, a9, a10, a6);
goto LABEL_70;
}
IsExtensible = JS_IsExtensible(a1, a2, -1);
if ( IsExtensible < 0 )
{
LODWORD(v10) = -1;
}
else
{
if ( IsExtensible )
{
LABEL_69:
v22 = 0;
goto LABEL_70;
}
v22 = 2;
}
LABEL_70:
if ( v22 == 2 )
goto LABEL_3;
if ( v22 )
return (unsigned int)v10;
LABEL_2:
if ( (*(_BYTE *)(a2 + 5) & 1) == 0 )
{
LABEL_3:
v15 = "object is not extensible";
return JS_ThrowTypeErrorOrFalse(a1, a6, (_DWORD)v15, a4, a5, a6, (char)a7);
}
v17 = a6 & 7;
if ( (a6 & 0x1800) != 0 )
v17 = a6 & 5 | 0x10;
v18 = (_QWORD *)add_property(a1, a2, a3, v17);
if ( v18 )
{
v19 = v18;
if ( (a6 & 0x1800) != 0 )
{
*v18 = 0LL;
if ( (a6 & 0x800) != 0 && (unsigned int)JS_IsFunction(a1, a7, a8) )
{
v39 = a7;
if ( (unsigned int)a8 >= 0xFFFFFFF7 )
++*v39;
*v19 = a7;
}
v19[1] = 0LL;
LODWORD(v10) = 1;
if ( (a6 & 0x1000) != 0 && (unsigned int)JS_IsFunction(a1, a9, a10) )
{
v39 = a9;
if ( (unsigned int)a10 >= 0xFFFFFFF7 )
++*v39;
v19[1] = a9;
}
return (unsigned int)v10;
}
if ( (a6 & 0x2000) != 0 )
{
v24 = v41;
v39 = v41;
v25 = v42;
if ( (unsigned int)v42 >= 0xFFFFFFF7 )
++*v39;
*v18 = v24;
v18[1] = v25;
}
else
{
*(_DWORD *)v18 = 0;
v18[1] = 3LL;
}
v38 = 1;
goto LABEL_40;
}
LABEL_44:
v38 = -1;
LABEL_40:
LODWORD(v10) = v38;
return (unsigned int)v10;
}
if ( (v14 & 8) == 0 )
{
if ( !(unsigned int)JS_AtomIsArrayIndex(a1, &v40, a3) )
{
LABEL_63:
v26 = 0;
goto LABEL_64;
}
LABEL_54:
v10 = *(_QWORD *)(a2 + 32);
v30 = *(_QWORD *)(v10 + 8);
v39 = *(_DWORD **)v10;
if ( (unsigned int)v30 >= 0xFFFFFFF7 )
++*v39;
JS_ToInt32Free(a1, &v39);
v31 = v40 + 1;
if ( v40 + 1 <= (unsigned int)v39 )
goto LABEL_63;
if ( (*(_BYTE *)(*(_QWORD *)(a2 + 24) + 67LL) & 8) != 0 )
{
LODWORD(v39) = v40 + 1;
v26 = 0;
*(_QWORD *)&v32 = (unsigned int)v31;
v33 = v31 < 0;
v34 = (double)v31;
if ( !v33 )
v34 = v32;
v35 = 7LL;
if ( !v33 )
v35 = 0LL;
v36 = *(_DWORD **)v10;
*(double *)v10 = v34;
*(_QWORD *)(v10 + 8) = v35;
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v36);
goto LABEL_64;
}
Only = JS_ThrowTypeErrorReadOnly(a1, a6, 50LL);
goto LABEL_50;
}
if ( (a3 & 0x80000000) == 0 )
{
if ( !(unsigned int)JS_AtomIsArrayIndex(a1, &v40, a3) )
goto LABEL_63;
LABEL_51:
if ( (unsigned int)convert_fast_array_to_array(a1, a2) )
{
LODWORD(v10) = -1;
goto LABEL_53;
}
goto LABEL_54;
}
LODWORD(a4) = a3 & 0x7FFFFFFF;
v40 = a3 & 0x7FFFFFFF;
if ( (a3 & 0x7FFFFFFF) != *(_DWORD *)(a2 + 64) )
goto LABEL_51;
if ( (v14 & 1) != 0 )
{
if ( (a6 & 0x1800) == 0 && (~(a6 & (a6 >> 8)) & 7) == 0 )
{
v27 = v41;
v39 = v41;
v28 = v42;
if ( (unsigned int)v42 >= 0xFFFFFFF7 )
++*v39;
Only = add_fast_array_element(a1, a2, v27, v28, a6);
LABEL_50:
LODWORD(v10) = Only;
LABEL_53:
v26 = 1;
goto LABEL_64;
}
goto LABEL_51;
}
v26 = 2;
LABEL_64:
if ( !v26 )
goto LABEL_2;
if ( v26 == 2 )
goto LABEL_3;
return (unsigned int)v10;
}
| JS_CreateProperty:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV EBX,R9D
MOV qword ptr [RSP + 0x40],R8
MOV qword ptr [RSP + 0x38],RCX
MOV EBP,EDX
MOV R13,RSI
MOV R14,RDI
MOV AL,byte ptr [RSI + 0x5]
TEST AL,0x4
JNZ 0x0010fb45
LAB_0010fb1d:
TEST byte ptr [R13 + 0x5],0x1
JNZ 0x0010fb78
LAB_0010fb24:
LEA RDX,[0x19ef71]
LAB_0010fb2b:
MOV RDI,R14
MOV ESI,EBX
XOR EAX,EAX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001261e2
LAB_0010fb45:
MOVZX ECX,word ptr [R13 + 0x6]
CMP RCX,0x2
JNZ 0x0010fc46
TEST AL,0x8
JNZ 0x0010fc8f
LEA RSI,[RSP + 0x34]
MOV RDI,R14
MOV EDX,EBP
CALL 0x0013d7ed
TEST EAX,EAX
JNZ 0x0010fddc
JMP 0x0010fe5b
LAB_0010fb78:
MOV EAX,EBX
AND EAX,0x5
OR EAX,0x10
MOV ECX,EBX
AND ECX,0x7
TEST BX,0x1800
CMOVNZ ECX,EAX
MOV RDI,R14
MOV RSI,R13
MOV EDX,EBP
CALL 0x0013bf45
TEST RAX,RAX
JZ 0x0010fd7a
MOV R13,RAX
TEST BX,0x1800
JZ 0x0010fc73
AND qword ptr [R13],0x0
BT EBX,0xb
JNC 0x0010fbf3
LEA RAX,[RSP + 0x80]
MOV R15,qword ptr [RAX]
MOV R12,qword ptr [RAX + 0x8]
MOV RDI,R14
MOV RSI,R15
MOV RDX,R12
CALL 0x00122dbe
TEST EAX,EAX
JZ 0x0010fbf3
MOV qword ptr [RSP + 0x28],R15
CMP R12D,-0x9
JC 0x0010fbef
MOV RAX,qword ptr [RSP + 0x28]
INC dword ptr [RAX]
LAB_0010fbef:
MOV qword ptr [R13],R15
LAB_0010fbf3:
AND qword ptr [R13 + 0x8],0x0
PUSH 0x1
POP R15
BT EBX,0xc
JNC 0x0010fe71
LEA RAX,[RSP + 0x90]
MOV RBX,qword ptr [RAX]
MOV R12,qword ptr [RAX + 0x8]
MOV RDI,R14
MOV RSI,RBX
MOV RDX,R12
CALL 0x00122dbe
TEST EAX,EAX
JZ 0x0010fe71
MOV qword ptr [RSP + 0x28],RBX
CMP R12D,-0x9
JC 0x0010fc3d
MOV RAX,qword ptr [RSP + 0x28]
INC dword ptr [RAX]
LAB_0010fc3d:
MOV qword ptr [R13 + 0x8],RBX
JMP 0x0010fe71
LAB_0010fc46:
LEA EAX,[RCX + -0x15]
CMP AX,0xb
JA 0x0010fcb3
MOV RDI,R14
MOV ESI,EBP
CALL 0x00124060
TEST EAX,EAX
JZ 0x0010fb1d
JS 0x0010fd7a
LEA RDX,[0x19f160]
JMP 0x0010fb2b
LAB_0010fc73:
BT EBX,0xd
JC 0x0010fd2f
AND dword ptr [R13],0x0
MOV qword ptr [R13 + 0x8],0x3
JMP 0x0010fd52
LAB_0010fc8f:
TEST EBP,EBP
JS 0x0010fd5b
LEA RSI,[RSP + 0x34]
MOV RDI,R14
MOV EDX,EBP
CALL 0x0013d7ed
TEST EAX,EAX
JNZ 0x0010fdc0
JMP 0x0010fe5b
LAB_0010fcb3:
BT EBX,0x11
JC 0x0010fb1d
MOV RAX,qword ptr [R14 + 0x18]
MOV RAX,qword ptr [RAX + 0x80]
IMUL RCX,RCX,0x28
MOV RAX,qword ptr [RAX + RCX*0x1 + 0x20]
TEST RAX,RAX
JZ 0x0010fe97
PUSH 0x1
POP R12
MOV RAX,qword ptr [RAX + 0x18]
TEST RAX,RAX
JZ 0x0010fe83
LEA RCX,[RSP + 0x90]
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RSP + 0x10],XMM0
LEA RCX,[RSP + 0x80]
MOVUPD XMM0,xmmword ptr [RCX]
MOVUPD xmmword ptr [RSP],XMM0
MOV dword ptr [RSP + 0x20],EBX
PUSH -0x1
POP RDX
MOV RDI,R14
MOV RSI,R13
MOV ECX,EBP
MOV R8,qword ptr [RSP + 0x38]
MOV R9,qword ptr [RSP + 0x40]
CALL RAX
MOV R15D,EAX
JMP 0x0010fe9a
LAB_0010fd2f:
MOV RDX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x28],RDX
MOV RCX,qword ptr [RSP + 0x40]
CMP ECX,-0x9
JC 0x0010fd4a
MOV RAX,qword ptr [RSP + 0x28]
INC dword ptr [RAX]
LAB_0010fd4a:
MOV qword ptr [R13],RDX
MOV qword ptr [R13 + 0x8],RCX
LAB_0010fd52:
PUSH 0x1
LAB_0010fd54:
POP R15
JMP 0x0010fe71
LAB_0010fd5b:
MOV ECX,EBP
AND ECX,0x7fffffff
MOV dword ptr [RSP + 0x34],ECX
CMP ECX,dword ptr [R13 + 0x40]
JNZ 0x0010fdc0
TEST AL,0x1
JNZ 0x0010fd7e
PUSH 0x2
POP R12
JMP 0x0010fe5e
LAB_0010fd7a:
PUSH -0x1
JMP 0x0010fd54
LAB_0010fd7e:
TEST BX,0x1800
JNZ 0x0010fdc0
MOV EAX,EBX
SHR EAX,0x8
AND EAX,EBX
NOT EAX
TEST AL,0x7
JNZ 0x0010fdc0
MOV RDX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x28],RDX
MOV RCX,qword ptr [RSP + 0x40]
CMP ECX,-0x9
JC 0x0010fdad
MOV RAX,qword ptr [RSP + 0x28]
INC dword ptr [RAX]
LAB_0010fdad:
MOV RDI,R14
MOV RSI,R13
MOV R8D,EBX
CALL 0x0013da97
LAB_0010fdbb:
MOV R15D,EAX
JMP 0x0010fdd3
LAB_0010fdc0:
MOV RDI,R14
MOV RSI,R13
CALL 0x001267b0
TEST EAX,EAX
JZ 0x0010fddc
PUSH -0x1
POP R15
LAB_0010fdd3:
PUSH 0x1
POP R12
JMP 0x0010fe5e
LAB_0010fddc:
MOV R15,qword ptr [R13 + 0x20]
MOV RDX,qword ptr [R15]
MOV RCX,qword ptr [R15 + 0x8]
MOV qword ptr [RSP + 0x28],RDX
CMP ECX,-0x9
JC 0x0010fdf8
MOV RAX,qword ptr [RSP + 0x28]
INC dword ptr [RAX]
LAB_0010fdf8:
LEA R12,[RSP + 0x28]
MOV RDI,R14
MOV RSI,R12
CALL 0x001279c3
MOV EAX,dword ptr [RSP + 0x34]
INC EAX
CMP EAX,dword ptr [R12]
JBE 0x0010fe5b
MOV RCX,qword ptr [R13 + 0x18]
TEST byte ptr [RCX + 0x43],0x8
JZ 0x0010febb
MOV dword ptr [RSP + 0x28],EAX
XOR R12D,R12D
MOV ECX,EAX
CVTSI2SD XMM0,RCX
TEST EAX,EAX
MOVQ RAX,XMM0
CMOVNS RAX,RCX
PUSH 0x7
POP RCX
CMOVNS RCX,R12
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
MOV qword ptr [R15],RAX
MOV qword ptr [R15 + 0x8],RCX
MOV RDI,qword ptr [R14 + 0x18]
CALL 0x0011d8c6
JMP 0x0010fe5e
LAB_0010fe5b:
XOR R12D,R12D
LAB_0010fe5e:
TEST R12D,R12D
JZ 0x0010fb1d
CMP R12D,0x2
JZ 0x0010fb24
LAB_0010fe71:
MOV EAX,R15D
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0010fe83:
PUSH -0x1
POP RDX
MOV RDI,R14
MOV RSI,R13
CALL 0x0010f6fb
TEST EAX,EAX
JS 0x0010feaf
JZ 0x0010feb5
LAB_0010fe97:
XOR R12D,R12D
LAB_0010fe9a:
CMP R12D,0x2
JZ 0x0010fb24
TEST R12D,R12D
JZ 0x0010fb1d
JMP 0x0010fe71
LAB_0010feaf:
PUSH -0x1
POP R15
JMP 0x0010fe9a
LAB_0010feb5:
PUSH 0x2
POP R12
JMP 0x0010fe9a
LAB_0010febb:
PUSH 0x32
POP RDX
MOV RDI,R14
MOV ESI,EBX
CALL 0x0013db62
JMP 0x0010fdbb
|
ulong JS_CreateProperty(long param_1,long param_2,uint param_3,int *param_4,int8 param_5,
ulong param_6,int *param_7,int8 param_8,int *param_9,
int8 param_10)
{
byte bVar1;
ushort uVar2;
long lVar3;
code *pcVar4;
double dVar5;
double dVar6;
int iVar7;
uint uVar8;
int iVar9;
ulong uVar10;
int8 *puVar11;
double dVar12;
double dVar13;
char *pcVar14;
uint uVar15;
double *unaff_R15;
double *pdStackY_80;
int *local_50;
uint local_44;
int *local_40;
int8 local_38;
uVar10 = param_6 & 0xffffffff;
bVar1 = *(byte *)(param_2 + 5);
uVar15 = (uint)param_6;
local_40 = param_4;
local_38 = param_5;
if ((bVar1 & 4) == 0) goto LAB_0010fb1d;
uVar2 = *(ushort *)(param_2 + 6);
if ((ulong)uVar2 != 2) {
if ((ushort)(uVar2 - 0x15) < 0xc) {
iVar7 = JS_AtomIsNumericIndex(param_1,param_3);
if (iVar7 == 0) goto LAB_0010fb1d;
if (-1 < iVar7) {
pcVar14 = "cannot create numeric index in typed array";
goto LAB_0010fb2b;
}
}
else {
if ((uVar15 >> 0x11 & 1) == 0) {
lVar3 = *(long *)(*(long *)(*(long *)(param_1 + 0x18) + 0x80) + 0x20 + (ulong)uVar2 * 0x28);
if (lVar3 == 0) {
LAB_0010fe97:
iVar7 = 0;
}
else {
iVar7 = 1;
pcVar4 = *(code **)(lVar3 + 0x18);
if (pcVar4 == (code *)0x0) {
iVar9 = JS_IsExtensible(param_1,param_2,0xffffffffffffffff);
if (iVar9 < 0) {
pdStackY_80 = (double *)0xffffffffffffffff;
unaff_R15 = pdStackY_80;
}
else {
if (iVar9 != 0) goto LAB_0010fe97;
iVar7 = 2;
}
}
else {
uVar8 = (*pcVar4)(param_1,param_2,0xffffffffffffffff,param_3,param_4,param_5,
param_7._0_4_,(uint)param_8,param_9,param_10,uVar15);
unaff_R15 = (double *)(ulong)uVar8;
}
}
if (iVar7 == 2) goto LAB_0010fb24;
if (iVar7 != 0) goto LAB_0010fe71;
}
LAB_0010fb1d:
if ((*(byte *)(param_2 + 5) & 1) == 0) goto LAB_0010fb24;
uVar8 = uVar15 & 7;
if ((param_6 & 0x1800) != 0) {
uVar8 = uVar15 & 5 | 0x10;
}
puVar11 = (int8 *)add_property(param_1,param_2,param_3,uVar8);
if (puVar11 != (int8 *)0x0) {
if ((param_6 & 0x1800) == 0) {
if ((uVar15 >> 0xd & 1) == 0) {
*(int4 *)puVar11 = 0;
puVar11[1] = 3;
}
else {
if (0xfffffff6 < (uint)local_38) {
*local_40 = *local_40 + 1;
}
*puVar11 = local_40;
puVar11[1] = local_38;
}
pdStackY_80 = (double *)0x1;
unaff_R15 = pdStackY_80;
}
else {
*puVar11 = 0;
if ((uVar15 >> 0xb & 1) != 0) {
iVar7 = JS_IsFunction(param_1,param_7,param_8);
if (iVar7 != 0) {
if (0xfffffff6 < (uint)param_8) {
*param_7 = *param_7 + 1;
}
*puVar11 = param_7;
local_50 = param_7;
}
}
puVar11[1] = 0;
unaff_R15 = (double *)0x1;
if (((uVar15 >> 0xc & 1) != 0) &&
(iVar7 = JS_IsFunction(param_1,param_9,param_10), iVar7 != 0)) {
if (0xfffffff6 < (uint)param_10) {
*param_9 = *param_9 + 1;
}
puVar11[1] = param_9;
}
}
goto LAB_0010fe71;
}
}
pdStackY_80 = (double *)0xffffffffffffffff;
unaff_R15 = pdStackY_80;
LAB_0010fe71:
return (ulong)unaff_R15 & 0xffffffff;
}
if ((bVar1 & 8) == 0) {
iVar7 = JS_AtomIsArrayIndex(param_1,&local_44,param_3);
if (iVar7 != 0) {
LAB_0010fddc:
unaff_R15 = *(double **)(param_2 + 0x20);
local_50 = (int *)*unaff_R15;
if (0xfffffff6 < SUB84(unaff_R15[1],0)) {
*local_50 = *local_50 + 1;
}
JS_ToInt32Free(param_1,&local_50);
uVar8 = local_44 + 1;
if ((uint)local_50 < uVar8) {
if ((*(byte *)(*(long *)(param_2 + 0x18) + 0x43) & 8) == 0) {
uVar8 = JS_ThrowTypeErrorReadOnly(param_1,uVar10,0x32);
LAB_0010fdbb:
unaff_R15 = (double *)(ulong)uVar8;
goto LAB_0010fdd3;
}
local_50 = (int *)CONCAT44(local_50._4_4_,uVar8);
iVar7 = 0;
dVar12 = (double)uVar8;
if (-1 < (int)uVar8) {
dVar12 = (double)(ulong)uVar8;
}
dVar13 = 3.45845952088873e-323;
if (-1 < (int)uVar8) {
dVar13 = 0.0;
}
dVar5 = *unaff_R15;
dVar6 = unaff_R15[1];
*unaff_R15 = dVar12;
unaff_R15[1] = dVar13;
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),dVar5,dVar6);
goto LAB_0010fe5e;
}
}
LAB_0010fe5b:
iVar7 = 0;
}
else if ((int)param_3 < 0) {
local_44 = param_3 & 0x7fffffff;
if (local_44 != *(uint *)(param_2 + 0x40)) goto LAB_0010fdc0;
if ((bVar1 & 1) != 0) {
if (((param_6 & 0x1800) != 0) || ((~((uint)(uVar10 >> 8) & uVar15) & 7) != 0))
goto LAB_0010fdc0;
if (0xfffffff6 < (uint)param_5) {
*param_4 = *param_4 + 1;
}
local_50 = param_4;
uVar8 = add_fast_array_element(param_1,param_2,param_4,param_5,uVar10);
goto LAB_0010fdbb;
}
iVar7 = 2;
}
else {
iVar7 = JS_AtomIsArrayIndex(param_1,&local_44,param_3);
if (iVar7 == 0) goto LAB_0010fe5b;
LAB_0010fdc0:
iVar7 = convert_fast_array_to_array(param_1,param_2);
if (iVar7 == 0) goto LAB_0010fddc;
unaff_R15 = (double *)0xffffffffffffffff;
LAB_0010fdd3:
iVar7 = 1;
}
LAB_0010fe5e:
if (iVar7 == 0) goto LAB_0010fb1d;
if (iVar7 != 2) goto LAB_0010fe71;
LAB_0010fb24:
pcVar14 = "object is not extensible";
LAB_0010fb2b:
uVar10 = JS_ThrowTypeErrorOrFalse(param_1,uVar10,pcVar14);
return uVar10;
}
| |
26,417 | JS_CreateProperty | bluesky950520[P]quickjs/quickjs.c | static int JS_CreateProperty(JSContext *ctx, JSObject *p,
JSAtom prop, JSValue val,
JSValue getter, JSValue setter,
int flags)
{
JSProperty *pr;
int ret, prop_flags;
/* add a new property or modify an existing exotic one */
if (p->is_exotic) {
if (p->class_id == JS_CLASS_ARRAY) {
uint32_t idx, len;
if (p->fast_array) {
if (__JS_AtomIsTaggedInt(prop)) {
idx = __JS_AtomToUInt32(prop);
if (idx == p->u.array.count) {
if (!p->extensible)
goto not_extensible;
if (flags & (JS_PROP_HAS_GET | JS_PROP_HAS_SET))
goto convert_to_array;
prop_flags = get_prop_flags(flags, 0);
if (prop_flags != JS_PROP_C_W_E)
goto convert_to_array;
return add_fast_array_element(ctx, p,
js_dup(val), flags);
} else {
goto convert_to_array;
}
} else if (JS_AtomIsArrayIndex(ctx, &idx, prop)) {
/* convert the fast array to normal array */
convert_to_array:
if (convert_fast_array_to_array(ctx, p))
return -1;
goto generic_array;
}
} else if (JS_AtomIsArrayIndex(ctx, &idx, prop)) {
JSProperty *plen;
JSShapeProperty *pslen;
generic_array:
/* update the length field */
plen = &p->prop[0];
JS_ToUint32(ctx, &len, plen->u.value);
if ((idx + 1) > len) {
pslen = get_shape_prop(p->shape);
if (unlikely(!(pslen->flags & JS_PROP_WRITABLE)))
return JS_ThrowTypeErrorReadOnly(ctx, flags, JS_ATOM_length);
/* XXX: should update the length after defining
the property */
len = idx + 1;
set_value(ctx, &plen->u.value, js_uint32(len));
}
}
} else if (p->class_id >= JS_CLASS_UINT8C_ARRAY &&
p->class_id <= JS_CLASS_FLOAT64_ARRAY) {
ret = JS_AtomIsNumericIndex(ctx, prop);
if (ret != 0) {
if (ret < 0)
return -1;
return JS_ThrowTypeErrorOrFalse(ctx, flags, "cannot create numeric index in typed array");
}
} else if (!(flags & JS_PROP_NO_EXOTIC)) {
const JSClassExoticMethods *em = ctx->rt->class_array[p->class_id].exotic;
if (em) {
if (em->define_own_property) {
return em->define_own_property(ctx, JS_MKPTR(JS_TAG_OBJECT, p),
prop, val, getter, setter, flags);
}
ret = JS_IsExtensible(ctx, JS_MKPTR(JS_TAG_OBJECT, p));
if (ret < 0)
return -1;
if (!ret)
goto not_extensible;
}
}
}
if (!p->extensible) {
not_extensible:
return JS_ThrowTypeErrorOrFalse(ctx, flags, "object is not extensible");
}
if (flags & (JS_PROP_HAS_GET | JS_PROP_HAS_SET)) {
prop_flags = (flags & (JS_PROP_CONFIGURABLE | JS_PROP_ENUMERABLE)) |
JS_PROP_GETSET;
} else {
prop_flags = flags & JS_PROP_C_W_E;
}
pr = add_property(ctx, p, prop, prop_flags);
if (unlikely(!pr))
return -1;
if (flags & (JS_PROP_HAS_GET | JS_PROP_HAS_SET)) {
pr->u.getset.getter = NULL;
if ((flags & JS_PROP_HAS_GET) && JS_IsFunction(ctx, getter)) {
pr->u.getset.getter =
JS_VALUE_GET_OBJ(js_dup(getter));
}
pr->u.getset.setter = NULL;
if ((flags & JS_PROP_HAS_SET) && JS_IsFunction(ctx, setter)) {
pr->u.getset.setter =
JS_VALUE_GET_OBJ(js_dup(setter));
}
} else {
if (flags & JS_PROP_HAS_VALUE) {
pr->u.value = js_dup(val);
} else {
pr->u.value = JS_UNDEFINED;
}
}
return TRUE;
} | O2 | c | JS_CreateProperty:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, %ebx
movq %r8, %r15
movq %rcx, 0x38(%rsp)
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %r14
movb 0x5(%rsi), %al
pushq $-0x1
popq %rbp
testb $0x4, %al
je 0x2072d
movzwl 0x6(%r13), %ecx
cmpq $0x2, %rcx
jne 0x20596
movq %r15, 0x40(%rsp)
testb $0x8, %al
jne 0x205c4
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
movl %r12d, %edx
callq 0x36088
testl %eax, %eax
jne 0x206c9
jmp 0x20728
leal -0x15(%rcx), %eax
cmpw $0xb, %ax
ja 0x205ea
movq %r14, %rdi
movl %r12d, %esi
callq 0x1e08f
testl %eax, %eax
je 0x2072d
js 0x20832
leaq 0x65af1(%rip), %rdx # 0x860b0
jmp 0x2073b
testl %r12d, %r12d
js 0x2065e
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
movl %r12d, %edx
callq 0x36088
testl %eax, %eax
jne 0x206b3
jmp 0x20728
btl $0x11, %ebx
jb 0x2072d
movq 0x18(%r14), %rax
movq 0x80(%rax), %rax
imulq $0x28, %rcx, %rcx
movq 0x20(%rax,%rcx), %rax
testq %rax, %rax
je 0x2072d
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x20843
leaq 0x90(%rsp), %rcx
movups (%rcx), %xmm0
movups %xmm0, 0x10(%rsp)
leaq 0x80(%rsp), %rcx
movupd (%rcx), %xmm0
movupd %xmm0, (%rsp)
movl %ebx, 0x20(%rsp)
pushq $-0x1
popq %rdx
movq %r14, %rdi
movq %r13, %rsi
movl %r12d, %ecx
movq 0x38(%rsp), %r8
movq %r15, %r9
callq *%rax
jmp 0x20834
movl %r12d, %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
movl %ecx, 0x30(%rsp)
cmpl 0x40(%r13), %ecx
jne 0x206b3
testb $0x1, %al
je 0x20734
testw $0x1800, %bx # imm = 0x1800
jne 0x206b3
movl %ebx, %eax
shrl $0x8, %eax
andl %ebx, %eax
notl %eax
testb $0x7, %al
jne 0x206b3
movq 0x40(%rsp), %rcx
cmpl $-0x9, %ecx
movq 0x38(%rsp), %rdx
jb 0x2069e
incl (%rdx)
movq %r14, %rdi
movq %r13, %rsi
movl %ebx, %r8d
callq 0x362ab
movl %eax, %ebp
jmp 0x20832
movq %r14, %rdi
movq %r13, %rsi
callq 0x20237
testl %eax, %eax
je 0x206c9
pushq $-0x1
jmp 0x20831
movq 0x20(%r13), %r15
movq (%r15), %rdx
movq 0x8(%r15), %rcx
leaq 0x34(%rsp), %rsi
movq %r14, %rdi
callq 0x215d7
movl 0x30(%rsp), %eax
incl %eax
leaq 0x34(%rsp), %rcx
cmpl (%rcx), %eax
jbe 0x20728
movq 0x18(%r13), %rcx
testb $0x8, 0x43(%rcx)
je 0x20860
xorl %esi, %esi
movl %eax, %ecx
cvtsi2sd %rcx, %xmm0
testl %eax, %eax
movq %xmm0, %rdx
cmovnsq %rcx, %rdx
movl %eax, 0x34(%rsp)
pushq $0x7
popq %rcx
cmovnsq %rsi, %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0x19eec
movq 0x40(%rsp), %r15
testb $0x1, 0x5(%r13)
jne 0x20755
leaq 0x65786(%rip), %rdx # 0x85ec1
movq %r14, %rdi
movl %ebx, %esi
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1fd06
movl %ebx, %eax
andl $0x5, %eax
orl $0x10, %eax
movl %ebx, %ecx
andl $0x7, %ecx
testw $0x1800, %bx # imm = 0x1800
cmovnel %eax, %ecx
movq %r14, %rdi
movq %r13, %rsi
movl %r12d, %edx
callq 0x34d1a
testq %rax, %rax
je 0x20832
movq %rax, %r12
testw $0x1800, %bx # imm = 0x1800
je 0x20803
andq $0x0, (%r12)
btl $0xb, %ebx
jae 0x207c4
leaq 0x80(%rsp), %rax
movq (%rax), %r15
movq 0x8(%rax), %r13
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x1ce7d
testl %eax, %eax
je 0x207c4
cmpl $-0x9, %r13d
jb 0x207c0
incl (%r15)
movq %r15, (%r12)
andq $0x0, 0x8(%r12)
pushq $0x1
popq %rbp
btl $0xc, %ebx
jae 0x20832
leaq 0x90(%rsp), %rax
movq (%rax), %rbx
movq 0x8(%rax), %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1ce7d
testl %eax, %eax
je 0x20832
cmpl $-0x9, %r15d
jb 0x207fc
incl (%rbx)
movq %rbx, 0x8(%r12)
jmp 0x20832
btl $0xd, %ebx
jb 0x20819
andl $0x0, (%r12)
movq $0x3, 0x8(%r12)
jmp 0x2082f
cmpl $-0x9, %r15d
movq 0x38(%rsp), %rax
jb 0x20826
incl (%rax)
movq %rax, (%r12)
movq %r15, 0x8(%r12)
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x1
popq %rdx
movq %r14, %rdi
movq %r13, %rsi
callq 0x1de0a
testl %eax, %eax
js 0x20832
jne 0x2072d
jmp 0x20734
pushq $0x32
popq %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x36367
jmp 0x206ac
| JS_CreateProperty:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov ebx, r9d
mov r15, r8
mov [rsp+78h+var_40], rcx
mov r12d, edx
mov r13, rsi
mov r14, rdi
mov al, [rsi+5]
push 0FFFFFFFFFFFFFFFFh
pop rbp
test al, 4
jz loc_2072D
movzx ecx, word ptr [r13+6]
cmp rcx, 2
jnz short loc_20596
mov [rsp+78h+var_38], r15
test al, 8
jnz short loc_205C4
lea rsi, [rsp+78h+var_48]
mov rdi, r14
mov edx, r12d
call JS_AtomIsArrayIndex
test eax, eax
jnz loc_206C9
jmp loc_20728
loc_20596:
lea eax, [rcx-15h]
cmp ax, 0Bh
ja short loc_205EA
mov rdi, r14
mov esi, r12d
call JS_AtomIsNumericIndex
test eax, eax
jz loc_2072D
js loc_20832
lea rdx, aCannotCreateNu; "cannot create numeric index in typed ar"...
jmp loc_2073B
loc_205C4:
test r12d, r12d
js loc_2065E
lea rsi, [rsp+78h+var_48]
mov rdi, r14
mov edx, r12d
call JS_AtomIsArrayIndex
test eax, eax
jnz loc_206B3
jmp loc_20728
loc_205EA:
bt ebx, 11h
jb loc_2072D
mov rax, [r14+18h]
mov rax, [rax+80h]
imul rcx, 28h ; '('
mov rax, [rax+rcx+20h]
test rax, rax
jz loc_2072D
mov rax, [rax+18h]
test rax, rax
jz loc_20843
lea rcx, [rsp+78h+arg_10]
movups xmm0, xmmword ptr [rcx]
movups [rsp+78h+var_68], xmm0
lea rcx, [rsp+78h+arg_0]
movupd xmm0, xmmword ptr [rcx]
movupd [rsp+78h+var_78], xmm0
mov [rsp+78h+var_58], ebx
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rdi, r14
mov rsi, r13
mov ecx, r12d
mov r8, [rsp+78h+var_40]
mov r9, r15
call rax
jmp loc_20834
loc_2065E:
mov ecx, r12d
and ecx, 7FFFFFFFh
mov [rsp+78h+var_48], ecx
cmp ecx, [r13+40h]
jnz short loc_206B3
test al, 1
jz loc_20734
test bx, 1800h
jnz short loc_206B3
mov eax, ebx
shr eax, 8
and eax, ebx
not eax
test al, 7
jnz short loc_206B3
mov rcx, [rsp+78h+var_38]
cmp ecx, 0FFFFFFF7h
mov rdx, [rsp+78h+var_40]
jb short loc_2069E
inc dword ptr [rdx]
loc_2069E:
mov rdi, r14
mov rsi, r13
mov r8d, ebx
call add_fast_array_element
loc_206AC:
mov ebp, eax
jmp loc_20832
loc_206B3:
mov rdi, r14
mov rsi, r13
call convert_fast_array_to_array
test eax, eax
jz short loc_206C9
push 0FFFFFFFFFFFFFFFFh
jmp loc_20831
loc_206C9:
mov r15, [r13+20h]
mov rdx, [r15]
mov rcx, [r15+8]
lea rsi, [rsp+78h+var_44]
mov rdi, r14
call JS_ToInt32
mov eax, [rsp+78h+var_48]
inc eax
lea rcx, [rsp+78h+var_44]
cmp eax, [rcx]
jbe short loc_20728
mov rcx, [r13+18h]
test byte ptr [rcx+43h], 8
jz loc_20860
xor esi, esi
mov ecx, eax
cvtsi2sd xmm0, rcx
test eax, eax
movq rdx, xmm0
cmovns rdx, rcx
mov [rsp+78h+var_44], eax
push 7
pop rcx
cmovns rcx, rsi
mov rdi, r14
mov rsi, r15
call set_value
loc_20728:
mov r15, [rsp+78h+var_38]
loc_2072D:
test byte ptr [r13+5], 1
jnz short loc_20755
loc_20734:
lea rdx, aObjectIsNotExt; "object is not extensible"
loc_2073B:
mov rdi, r14
mov esi, ebx
xor eax, eax
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp JS_ThrowTypeErrorOrFalse
loc_20755:
mov eax, ebx
and eax, 5
or eax, 10h
mov ecx, ebx
and ecx, 7
test bx, 1800h
cmovnz ecx, eax
mov rdi, r14
mov rsi, r13
mov edx, r12d
call add_property
test rax, rax
jz loc_20832
mov r12, rax
test bx, 1800h
jz short loc_20803
and qword ptr [r12], 0
bt ebx, 0Bh
jnb short loc_207C4
lea rax, [rsp+78h+arg_0]
mov r15, [rax]
mov r13, [rax+8]
mov rdi, r14
mov rsi, r15
mov rdx, r13
call JS_IsFunction
test eax, eax
jz short loc_207C4
cmp r13d, 0FFFFFFF7h
jb short loc_207C0
inc dword ptr [r15]
loc_207C0:
mov [r12], r15
loc_207C4:
and qword ptr [r12+8], 0
push 1
pop rbp
bt ebx, 0Ch
jnb short loc_20832
lea rax, [rsp+78h+arg_10]
mov rbx, [rax]
mov r15, [rax+8]
mov rdi, r14
mov rsi, rbx
mov rdx, r15
call JS_IsFunction
test eax, eax
jz short loc_20832
cmp r15d, 0FFFFFFF7h
jb short loc_207FC
inc dword ptr [rbx]
loc_207FC:
mov [r12+8], rbx
jmp short loc_20832
loc_20803:
bt ebx, 0Dh
jb short loc_20819
and dword ptr [r12], 0
mov qword ptr [r12+8], 3
jmp short loc_2082F
loc_20819:
cmp r15d, 0FFFFFFF7h
mov rax, [rsp+78h+var_40]
jb short loc_20826
inc dword ptr [rax]
loc_20826:
mov [r12], rax
mov [r12+8], r15
loc_2082F:
push 1
loc_20831:
pop rbp
loc_20832:
mov eax, ebp
loc_20834:
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_20843:
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rdi, r14
mov rsi, r13
call JS_IsExtensible
test eax, eax
js short loc_20832
jnz loc_2072D
jmp loc_20734
loc_20860:
push 32h ; '2'
pop rdx
mov rdi, r14
mov esi, ebx
call JS_ThrowTypeErrorReadOnly
jmp loc_206AC
| long long JS_CreateProperty(
long long a1,
long long a2,
unsigned int a3,
_DWORD *a4,
long long a5,
unsigned int a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14,
_DWORD *a15,
long long a16,
_DWORD *a17,
long long a18)
{
long long v19; // r15
char v21; // al
unsigned int v22; // ebp
long long v23; // rcx
int IsNumericIndex; // eax
long long v26; // rax
long long ( *v27)(long long, long long, long long, _QWORD, _DWORD *, long long, _DWORD *, long long, _DWORD *, long long, unsigned int); // rax
long long v28; // rcx
_DWORD *v29; // rdx
long long *v31; // r15
int v32; // eax
double v33; // rdx
long long v34; // rcx
long long v35; // rcx
_QWORD *v36; // rax
_QWORD *v37; // r12
_DWORD *v38; // rax
int IsExtensible; // eax
int v41; // [rsp+30h] [rbp-48h] BYREF
unsigned int v42; // [rsp+34h] [rbp-44h] BYREF
_DWORD *v43; // [rsp+38h] [rbp-40h]
long long v44; // [rsp+40h] [rbp-38h]
v19 = a5;
v43 = a4;
v21 = *(_BYTE *)(a2 + 5);
v22 = -1;
if ( (v21 & 4) != 0 )
{
v23 = *(unsigned __int16 *)(a2 + 6);
if ( v23 == 2 )
{
v44 = a5;
if ( (v21 & 8) != 0 )
{
if ( (a3 & 0x80000000) != 0 )
{
v41 = a3 & 0x7FFFFFFF;
if ( (a3 & 0x7FFFFFFF) == *(_DWORD *)(a2 + 64) )
{
if ( (v21 & 1) == 0 )
return JS_ThrowTypeErrorOrFalse(a1, a6, (long long)"object is not extensible");
if ( (a6 & 0x1800) == 0 && (~(a6 & (a6 >> 8)) & 7) == 0 )
{
v28 = v44;
v29 = v43;
if ( (unsigned int)v44 >= 0xFFFFFFF7 )
++*v43;
return (unsigned int)add_fast_array_element(a1, a2, v29, v28, a6);
}
}
}
else if ( !(unsigned int)JS_AtomIsArrayIndex(a1, &v41, a3) )
{
goto LABEL_34;
}
if ( (unsigned int)convert_fast_array_to_array(a1, a2) )
return (unsigned int)-1;
}
else if ( !(unsigned int)JS_AtomIsArrayIndex(a1, &v41, a3) )
{
goto LABEL_34;
}
v31 = *(long long **)(a2 + 32);
JS_ToInt32(a1, &v42, *v31, v31[1]);
v32 = v41 + 1;
if ( v41 + 1 <= v42 )
{
LABEL_34:
v19 = v44;
goto LABEL_35;
}
if ( (*(_BYTE *)(*(_QWORD *)(a2 + 24) + 67LL) & 8) != 0 )
{
v33 = (double)v32;
if ( v32 >= 0 )
*(_QWORD *)&v33 = (unsigned int)v32;
v42 = v41 + 1;
v34 = 7LL;
if ( v32 >= 0 )
v34 = 0LL;
set_value(a1, v31, *(long long *)&v33, v34);
goto LABEL_34;
}
return (unsigned int)JS_ThrowTypeErrorReadOnly(a1, a6, 50LL);
}
if ( (unsigned __int16)(v23 - 21) > 0xBu )
{
if ( (a6 & 0x20000) == 0 )
{
v26 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 128LL) + 40 * v23 + 32);
if ( v26 )
{
v27 = *(long long ( **)(long long, long long, long long, _QWORD, _DWORD *, long long, _DWORD *, long long, _DWORD *, long long, unsigned int))(v26 + 24);
if ( v27 )
return v27(a1, a2, -1LL, a3, v43, a5, a15, a16, a17, a18, a6);
IsExtensible = JS_IsExtensible(a1, a2, -1LL, a7, a8, a9, a10, a11, a12, a13, a14);
if ( IsExtensible < 0 )
return v22;
if ( !IsExtensible )
return JS_ThrowTypeErrorOrFalse(a1, a6, (long long)"object is not extensible");
}
}
}
else
{
IsNumericIndex = JS_AtomIsNumericIndex(a1);
if ( IsNumericIndex )
{
if ( IsNumericIndex >= 0 )
return JS_ThrowTypeErrorOrFalse(a1, a6, (long long)"cannot create numeric index in typed array");
return v22;
}
}
}
LABEL_35:
if ( (*(_BYTE *)(a2 + 5) & 1) == 0 )
return JS_ThrowTypeErrorOrFalse(a1, a6, (long long)"object is not extensible");
v35 = a6 & 7;
if ( (a6 & 0x1800) != 0 )
v35 = a6 & 5 | 0x10;
v36 = (_QWORD *)add_property(a1, a2, a3, v35);
if ( v36 )
{
v37 = v36;
if ( (a6 & 0x1800) != 0 )
{
*v36 = 0LL;
if ( (a6 & 0x800) != 0 && (unsigned int)JS_IsFunction(a1, (long long)a15, a16) )
{
if ( (unsigned int)a16 >= 0xFFFFFFF7 )
++*a15;
*v37 = a15;
}
v37[1] = 0LL;
v22 = 1;
if ( (a6 & 0x1000) != 0 && (unsigned int)JS_IsFunction(a1, (long long)a17, a18) )
{
if ( (unsigned int)a18 >= 0xFFFFFFF7 )
++*a17;
v37[1] = a17;
}
return v22;
}
if ( (a6 & 0x2000) != 0 )
{
v38 = v43;
if ( (unsigned int)v19 >= 0xFFFFFFF7 )
++*v43;
*v37 = v38;
v37[1] = v19;
}
else
{
*(_DWORD *)v36 = 0;
v36[1] = 3LL;
}
return 1;
}
return v22;
}
| JS_CreateProperty:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV EBX,R9D
MOV R15,R8
MOV qword ptr [RSP + 0x38],RCX
MOV R12D,EDX
MOV R13,RSI
MOV R14,RDI
MOV AL,byte ptr [RSI + 0x5]
PUSH -0x1
POP RBP
TEST AL,0x4
JZ 0x0012072d
MOVZX ECX,word ptr [R13 + 0x6]
CMP RCX,0x2
JNZ 0x00120596
MOV qword ptr [RSP + 0x40],R15
TEST AL,0x8
JNZ 0x001205c4
LEA RSI,[RSP + 0x30]
MOV RDI,R14
MOV EDX,R12D
CALL 0x00136088
TEST EAX,EAX
JNZ 0x001206c9
JMP 0x00120728
LAB_00120596:
LEA EAX,[RCX + -0x15]
CMP AX,0xb
JA 0x001205ea
MOV RDI,R14
MOV ESI,R12D
CALL 0x0011e08f
TEST EAX,EAX
JZ 0x0012072d
JS 0x00120832
LEA RDX,[0x1860b0]
JMP 0x0012073b
LAB_001205c4:
TEST R12D,R12D
JS 0x0012065e
LEA RSI,[RSP + 0x30]
MOV RDI,R14
MOV EDX,R12D
CALL 0x00136088
TEST EAX,EAX
JNZ 0x001206b3
JMP 0x00120728
LAB_001205ea:
BT EBX,0x11
JC 0x0012072d
MOV RAX,qword ptr [R14 + 0x18]
MOV RAX,qword ptr [RAX + 0x80]
IMUL RCX,RCX,0x28
MOV RAX,qword ptr [RAX + RCX*0x1 + 0x20]
TEST RAX,RAX
JZ 0x0012072d
MOV RAX,qword ptr [RAX + 0x18]
TEST RAX,RAX
JZ 0x00120843
LEA RCX,[RSP + 0x90]
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RSP + 0x10],XMM0
LEA RCX,[RSP + 0x80]
MOVUPD XMM0,xmmword ptr [RCX]
MOVUPD xmmword ptr [RSP],XMM0
MOV dword ptr [RSP + 0x20],EBX
PUSH -0x1
POP RDX
MOV RDI,R14
MOV RSI,R13
MOV ECX,R12D
MOV R8,qword ptr [RSP + 0x38]
MOV R9,R15
CALL RAX
JMP 0x00120834
LAB_0012065e:
MOV ECX,R12D
AND ECX,0x7fffffff
MOV dword ptr [RSP + 0x30],ECX
CMP ECX,dword ptr [R13 + 0x40]
JNZ 0x001206b3
TEST AL,0x1
JZ 0x00120734
TEST BX,0x1800
JNZ 0x001206b3
MOV EAX,EBX
SHR EAX,0x8
AND EAX,EBX
NOT EAX
TEST AL,0x7
JNZ 0x001206b3
MOV RCX,qword ptr [RSP + 0x40]
CMP ECX,-0x9
MOV RDX,qword ptr [RSP + 0x38]
JC 0x0012069e
INC dword ptr [RDX]
LAB_0012069e:
MOV RDI,R14
MOV RSI,R13
MOV R8D,EBX
CALL 0x001362ab
LAB_001206ac:
MOV EBP,EAX
JMP 0x00120832
LAB_001206b3:
MOV RDI,R14
MOV RSI,R13
CALL 0x00120237
TEST EAX,EAX
JZ 0x001206c9
PUSH -0x1
JMP 0x00120831
LAB_001206c9:
MOV R15,qword ptr [R13 + 0x20]
MOV RDX,qword ptr [R15]
MOV RCX,qword ptr [R15 + 0x8]
LEA RSI,[RSP + 0x34]
MOV RDI,R14
CALL 0x001215d7
MOV EAX,dword ptr [RSP + 0x30]
INC EAX
LEA RCX,[RSP + 0x34]
CMP EAX,dword ptr [RCX]
JBE 0x00120728
MOV RCX,qword ptr [R13 + 0x18]
TEST byte ptr [RCX + 0x43],0x8
JZ 0x00120860
XOR ESI,ESI
MOV ECX,EAX
CVTSI2SD XMM0,RCX
TEST EAX,EAX
MOVQ RDX,XMM0
CMOVNS RDX,RCX
MOV dword ptr [RSP + 0x34],EAX
PUSH 0x7
POP RCX
CMOVNS RCX,RSI
MOV RDI,R14
MOV RSI,R15
CALL 0x00119eec
LAB_00120728:
MOV R15,qword ptr [RSP + 0x40]
LAB_0012072d:
TEST byte ptr [R13 + 0x5],0x1
JNZ 0x00120755
LAB_00120734:
LEA RDX,[0x185ec1]
LAB_0012073b:
MOV RDI,R14
MOV ESI,EBX
XOR EAX,EAX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0011fd06
LAB_00120755:
MOV EAX,EBX
AND EAX,0x5
OR EAX,0x10
MOV ECX,EBX
AND ECX,0x7
TEST BX,0x1800
CMOVNZ ECX,EAX
MOV RDI,R14
MOV RSI,R13
MOV EDX,R12D
CALL 0x00134d1a
TEST RAX,RAX
JZ 0x00120832
MOV R12,RAX
TEST BX,0x1800
JZ 0x00120803
AND qword ptr [R12],0x0
BT EBX,0xb
JNC 0x001207c4
LEA RAX,[RSP + 0x80]
MOV R15,qword ptr [RAX]
MOV R13,qword ptr [RAX + 0x8]
MOV RDI,R14
MOV RSI,R15
MOV RDX,R13
CALL 0x0011ce7d
TEST EAX,EAX
JZ 0x001207c4
CMP R13D,-0x9
JC 0x001207c0
INC dword ptr [R15]
LAB_001207c0:
MOV qword ptr [R12],R15
LAB_001207c4:
AND qword ptr [R12 + 0x8],0x0
PUSH 0x1
POP RBP
BT EBX,0xc
JNC 0x00120832
LEA RAX,[RSP + 0x90]
MOV RBX,qword ptr [RAX]
MOV R15,qword ptr [RAX + 0x8]
MOV RDI,R14
MOV RSI,RBX
MOV RDX,R15
CALL 0x0011ce7d
TEST EAX,EAX
JZ 0x00120832
CMP R15D,-0x9
JC 0x001207fc
INC dword ptr [RBX]
LAB_001207fc:
MOV qword ptr [R12 + 0x8],RBX
JMP 0x00120832
LAB_00120803:
BT EBX,0xd
JC 0x00120819
AND dword ptr [R12],0x0
MOV qword ptr [R12 + 0x8],0x3
JMP 0x0012082f
LAB_00120819:
CMP R15D,-0x9
MOV RAX,qword ptr [RSP + 0x38]
JC 0x00120826
INC dword ptr [RAX]
LAB_00120826:
MOV qword ptr [R12],RAX
MOV qword ptr [R12 + 0x8],R15
LAB_0012082f:
PUSH 0x1
LAB_00120831:
POP RBP
LAB_00120832:
MOV EAX,EBP
LAB_00120834:
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00120843:
PUSH -0x1
POP RDX
MOV RDI,R14
MOV RSI,R13
CALL 0x0011de0a
TEST EAX,EAX
JS 0x00120832
JNZ 0x0012072d
JMP 0x00120734
LAB_00120860:
PUSH 0x32
POP RDX
MOV RDI,R14
MOV ESI,EBX
CALL 0x00136367
JMP 0x001206ac
|
ulong JS_CreateProperty(long param_1,long param_2,uint param_3,int *param_4,int8 param_5,
ulong param_6,int *param_7,int8 param_8,int *param_9,
int8 param_10)
{
byte bVar1;
ushort uVar2;
long lVar3;
code *pcVar4;
int iVar5;
uint uVar6;
uint uVar7;
ulong uVar8;
int8 *puVar9;
int8 uVar10;
double dVar11;
char *pcVar12;
ulong uStackY_80;
uint local_48;
uint local_44;
int *local_40;
int8 local_38;
uVar8 = param_6 & 0xffffffff;
bVar1 = *(byte *)(param_2 + 5);
uStackY_80 = 0xffffffffffffffff;
uVar7 = (uint)param_6;
local_40 = param_4;
if ((bVar1 & 4) == 0) goto LAB_0012072d;
uVar2 = *(ushort *)(param_2 + 6);
if ((ulong)uVar2 == 2) {
local_38 = param_5;
if ((bVar1 & 8) != 0) {
if (-1 < (int)param_3) {
iVar5 = JS_AtomIsArrayIndex(param_1,&local_48,param_3);
param_5 = local_38;
if (iVar5 == 0) goto LAB_0012072d;
LAB_001206b3:
iVar5 = convert_fast_array_to_array(param_1,param_2);
if (iVar5 != 0) {
uStackY_80 = 0xffffffffffffffff;
goto LAB_00120832;
}
goto LAB_001206c9;
}
local_48 = param_3 & 0x7fffffff;
if (local_48 != *(uint *)(param_2 + 0x40)) goto LAB_001206b3;
if ((bVar1 & 1) == 0) goto LAB_00120734;
if (((param_6 & 0x1800) != 0) || ((~((uint)(uVar8 >> 8) & uVar7) & 7) != 0))
goto LAB_001206b3;
if (0xfffffff6 < (uint)param_5) {
*param_4 = *param_4 + 1;
}
uVar7 = add_fast_array_element(param_1,param_2,param_4,param_5,uVar8);
LAB_001206ac:
uStackY_80 = (ulong)uVar7;
goto LAB_00120832;
}
iVar5 = JS_AtomIsArrayIndex(param_1,&local_48,param_3);
param_5 = local_38;
if (iVar5 == 0) goto LAB_0012072d;
LAB_001206c9:
puVar9 = *(int8 **)(param_2 + 0x20);
JS_ToInt32(param_1,&local_44,*puVar9,puVar9[1]);
uVar6 = local_48 + 1;
param_5 = local_38;
if (local_44 < uVar6) {
if ((*(byte *)(*(long *)(param_2 + 0x18) + 0x43) & 8) == 0) {
uVar7 = JS_ThrowTypeErrorReadOnly(param_1,uVar8,0x32);
goto LAB_001206ac;
}
dVar11 = (double)uVar6;
if (-1 < (int)uVar6) {
dVar11 = (double)(ulong)uVar6;
}
uVar10 = 7;
if (-1 < (int)uVar6) {
uVar10 = 0;
}
local_44 = uVar6;
set_value(param_1,puVar9,dVar11,uVar10);
param_5 = local_38;
}
LAB_0012072d:
if ((*(byte *)(param_2 + 5) & 1) != 0) {
uVar6 = uVar7 & 7;
if ((param_6 & 0x1800) != 0) {
uVar6 = uVar7 & 5 | 0x10;
}
puVar9 = (int8 *)add_property(param_1,param_2,param_3,uVar6);
if (puVar9 != (int8 *)0x0) {
if ((param_6 & 0x1800) == 0) {
if ((uVar7 >> 0xd & 1) == 0) {
*(int4 *)puVar9 = 0;
puVar9[1] = 3;
}
else {
if (0xfffffff6 < (uint)param_5) {
*local_40 = *local_40 + 1;
}
*puVar9 = local_40;
puVar9[1] = param_5;
}
uStackY_80 = 1;
}
else {
*puVar9 = 0;
if (((uVar7 >> 0xb & 1) != 0) &&
(iVar5 = JS_IsFunction(param_1,param_7,param_8), iVar5 != 0)) {
if (0xfffffff6 < (uint)param_8) {
*param_7 = *param_7 + 1;
}
*puVar9 = param_7;
}
puVar9[1] = 0;
uStackY_80 = 1;
if (((uVar7 >> 0xc & 1) != 0) &&
(iVar5 = JS_IsFunction(param_1,param_9,param_10), iVar5 != 0)) {
if (0xfffffff6 < (uint)param_10) {
*param_9 = *param_9 + 1;
}
puVar9[1] = param_9;
}
}
}
LAB_00120832:
return uStackY_80 & 0xffffffff;
}
}
else {
if ((ushort)(uVar2 - 0x15) < 0xc) {
iVar5 = JS_AtomIsNumericIndex(param_1,param_3);
if (iVar5 != 0) {
if (-1 < iVar5) {
pcVar12 = "cannot create numeric index in typed array";
goto LAB_0012073b;
}
goto LAB_00120832;
}
goto LAB_0012072d;
}
if (((uVar7 >> 0x11 & 1) != 0) ||
(lVar3 = *(long *)(*(long *)(*(long *)(param_1 + 0x18) + 0x80) + 0x20 + (ulong)uVar2 * 0x28),
lVar3 == 0)) goto LAB_0012072d;
pcVar4 = *(code **)(lVar3 + 0x18);
if (pcVar4 != (code *)0x0) {
uVar8 = (*pcVar4)(param_1,param_2,0xffffffffffffffff,param_3,param_4,param_5,param_7._0_4_,
(uint)param_8,param_9,param_10,uVar7);
return uVar8;
}
iVar5 = JS_IsExtensible(param_1,param_2,0xffffffffffffffff);
if (iVar5 < 0) goto LAB_00120832;
if (iVar5 != 0) goto LAB_0012072d;
}
LAB_00120734:
pcVar12 = "object is not extensible";
LAB_0012073b:
uVar8 = JS_ThrowTypeErrorOrFalse(param_1,uVar8,pcVar12);
return uVar8;
}
| |
26,418 | js_object_defineProperty | bluesky950520[P]quickjs/quickjs.c | static JSValue js_object_defineProperty(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int magic)
{
JSValue obj, prop, desc;
int ret, flags;
JSAtom atom;
obj = argv[0];
prop = argv[1];
desc = argv[2];
if (JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT)
return JS_ThrowTypeErrorNotAnObject(ctx);
atom = JS_ValueToAtom(ctx, prop);
if (unlikely(atom == JS_ATOM_NULL))
return JS_EXCEPTION;
flags = JS_PROP_THROW | JS_PROP_DEFINE_PROPERTY;
if (magic)
flags = JS_PROP_REFLECT_DEFINE_PROPERTY;
ret = JS_DefinePropertyDesc(ctx, obj, atom, desc, flags);
JS_FreeAtom(ctx, atom);
if (ret < 0) {
return JS_EXCEPTION;
} else if (magic) {
return js_bool(ret);
} else {
return js_dup(obj);
}
} | O0 | c | js_object_defineProperty:
subq $0x88, %rsp
movq %rsi, 0x68(%rsp)
movq %rdx, 0x70(%rsp)
movq %rdi, 0x60(%rsp)
movl %ecx, 0x5c(%rsp)
movq %r8, 0x50(%rsp)
movl %r9d, 0x4c(%rsp)
movq 0x50(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x38(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x28(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x50(%rsp), %rax
movq 0x20(%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x28(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
cmpl $-0x1, %eax
je 0xbe48e
movq 0x60(%rsp), %rdi
callq 0x2f5a0
movq %rax, 0x78(%rsp)
movq %rdx, 0x80(%rsp)
jmp 0xbe582
movq 0x60(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x31200
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xbe4d8
movl $0x0, 0x78(%rsp)
movq $0x6, 0x80(%rsp)
jmp 0xbe582
movl $0x44000, 0x10(%rsp) # imm = 0x44000
cmpl $0x0, 0x4c(%rsp)
je 0xbe4ef
movl $0x80000, 0x10(%rsp) # imm = 0x80000
movq 0x60(%rsp), %rdi
movl 0xc(%rsp), %ecx
movl 0x10(%rsp), %eax
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x18(%rsp), %r8
movq 0x20(%rsp), %r9
movl %eax, (%rsp)
callq 0xc0ae0
movl %eax, 0x14(%rsp)
movq 0x60(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x29040
cmpl $0x0, 0x14(%rsp)
jge 0xbe547
movl $0x0, 0x78(%rsp)
movq $0x6, 0x80(%rsp)
jmp 0xbe582
cmpl $0x0, 0x4c(%rsp)
je 0xbe566
movl 0x14(%rsp), %edi
callq 0x57250
movq %rax, 0x78(%rsp)
movq %rdx, 0x80(%rsp)
jmp 0xbe582
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x216d0
movq %rax, 0x78(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x78(%rsp), %rax
movq 0x80(%rsp), %rdx
addq $0x88, %rsp
retq
nopw (%rax,%rax)
| js_object_defineProperty:
sub rsp, 88h
mov [rsp+88h+var_20], rsi
mov [rsp+88h+var_18], rdx
mov [rsp+88h+var_28], rdi
mov [rsp+88h+var_2C], ecx
mov [rsp+88h+var_38], r8
mov [rsp+88h+var_3C], r9d
mov rax, [rsp+88h+var_38]
mov rcx, [rax]
mov [rsp+88h+var_50], rcx
mov rax, [rax+8]
mov [rsp+88h+var_48], rax
mov rax, [rsp+88h+var_38]
mov rcx, [rax+10h]
mov [rsp+88h+var_60], rcx
mov rax, [rax+18h]
mov [rsp+88h+var_58], rax
mov rax, [rsp+88h+var_38]
mov rcx, [rax+20h]
mov [rsp+88h+var_70], rcx
mov rax, [rax+28h]
mov [rsp+88h+var_68], rax
mov rax, [rsp+88h+var_48]
cmp eax, 0FFFFFFFFh
jz short loc_BE48E
mov rdi, [rsp+88h+var_28]
call JS_ThrowTypeErrorNotAnObject
mov [rsp+88h+var_10], rax
mov [rsp+88h+var_8], rdx
jmp loc_BE582
loc_BE48E:
mov rdi, [rsp+88h+var_28]
mov rsi, [rsp+88h+var_60]
mov rdx, [rsp+88h+var_58]
call JS_ValueToAtom
mov [rsp+88h+var_7C], eax
cmp [rsp+88h+var_7C], 0
setz al
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_BE4D8
mov dword ptr [rsp+88h+var_10], 0
mov [rsp+88h+var_8], 6
jmp loc_BE582
loc_BE4D8:
mov [rsp+88h+var_78], 44000h
cmp [rsp+88h+var_3C], 0
jz short loc_BE4EF
mov [rsp+88h+var_78], 80000h
loc_BE4EF:
mov rdi, [rsp+88h+var_28]
mov ecx, [rsp+88h+var_7C]
mov eax, [rsp+88h+var_78]
mov rsi, [rsp+88h+var_50]
mov rdx, [rsp+88h+var_48]
mov r8, [rsp+88h+var_70]
mov r9, [rsp+88h+var_68]
mov [rsp+88h+var_88], eax
call JS_DefinePropertyDesc
mov [rsp+88h+var_74], eax
mov rdi, [rsp+88h+var_28]
mov esi, [rsp+88h+var_7C]
call JS_FreeAtom
cmp [rsp+88h+var_74], 0
jge short loc_BE547
mov dword ptr [rsp+88h+var_10], 0
mov [rsp+88h+var_8], 6
jmp short loc_BE582
loc_BE547:
cmp [rsp+88h+var_3C], 0
jz short loc_BE566
mov edi, [rsp+88h+var_74]
call js_bool
mov [rsp+88h+var_10], rax
mov [rsp+88h+var_8], rdx
jmp short loc_BE582
loc_BE566:
mov rdi, [rsp+88h+var_50]
mov rsi, [rsp+88h+var_48]
call js_dup
mov [rsp+88h+var_10], rax
mov [rsp+88h+var_8], rdx
loc_BE582:
mov rax, [rsp+88h+var_10]
mov rdx, [rsp+88h+var_8]
add rsp, 88h
retn
| _DWORD * js_object_defineProperty(
long long a1,
long long a2,
long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
long long a12,
_QWORD *a13,
long long a14)
{
unsigned int v15; // [rsp+Ch] [rbp-7Ch]
int v16; // [rsp+10h] [rbp-78h]
int v17; // [rsp+14h] [rbp-74h]
long long v18; // [rsp+18h] [rbp-70h]
long long v19; // [rsp+20h] [rbp-68h]
_DWORD *v20; // [rsp+38h] [rbp-50h]
int v21; // [rsp+4Ch] [rbp-3Ch]
long long v22; // [rsp+78h] [rbp-10h]
v21 = a14;
v20 = (_DWORD *)*a13;
v18 = a13[4];
v19 = a13[5];
if ( (unsigned int)a13[1] != -1 )
return (_DWORD *)JS_ThrowTypeErrorNotAnObject(
a1,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a2,
a3,
a13[4],
(long long)a13,
a14);
v15 = JS_ValueToAtom(a1, a13[2], a13[3]);
if ( v15 )
{
v16 = 278528;
if ( v21 )
v16 = 0x80000;
v17 = JS_DefinePropertyDesc(a1, (_DWORD)v20, -1, v15, v18, v19, v16);
JS_FreeAtom(a1, v15);
if ( v17 >= 0 )
{
if ( v21 )
return (_DWORD *)js_bool(v17);
else
return js_dup(v20, 0xFFFFFFFF);
}
else
{
LODWORD(v22) = 0;
}
}
else
{
LODWORD(v22) = 0;
}
return (_DWORD *)v22;
}
| js_object_defineProperty:
SUB RSP,0x88
MOV qword ptr [RSP + 0x68],RSI
MOV qword ptr [RSP + 0x70],RDX
MOV qword ptr [RSP + 0x60],RDI
MOV dword ptr [RSP + 0x5c],ECX
MOV qword ptr [RSP + 0x50],R8
MOV dword ptr [RSP + 0x4c],R9D
MOV RAX,qword ptr [RSP + 0x50]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP + 0x38],RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x50]
MOV RCX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x28],RCX
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x50]
MOV RCX,qword ptr [RAX + 0x20]
MOV qword ptr [RSP + 0x18],RCX
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x40]
CMP EAX,-0x1
JZ 0x001be48e
MOV RDI,qword ptr [RSP + 0x60]
CALL 0x0012f5a0
MOV qword ptr [RSP + 0x78],RAX
MOV qword ptr [RSP + 0x80],RDX
JMP 0x001be582
LAB_001be48e:
MOV RDI,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
CALL 0x00131200
MOV dword ptr [RSP + 0xc],EAX
CMP dword ptr [RSP + 0xc],0x0
SETZ AL
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001be4d8
MOV dword ptr [RSP + 0x78],0x0
MOV qword ptr [RSP + 0x80],0x6
JMP 0x001be582
LAB_001be4d8:
MOV dword ptr [RSP + 0x10],0x44000
CMP dword ptr [RSP + 0x4c],0x0
JZ 0x001be4ef
MOV dword ptr [RSP + 0x10],0x80000
LAB_001be4ef:
MOV RDI,qword ptr [RSP + 0x60]
MOV ECX,dword ptr [RSP + 0xc]
MOV EAX,dword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x40]
MOV R8,qword ptr [RSP + 0x18]
MOV R9,qword ptr [RSP + 0x20]
MOV dword ptr [RSP],EAX
CALL 0x001c0ae0
MOV dword ptr [RSP + 0x14],EAX
MOV RDI,qword ptr [RSP + 0x60]
MOV ESI,dword ptr [RSP + 0xc]
CALL 0x00129040
CMP dword ptr [RSP + 0x14],0x0
JGE 0x001be547
MOV dword ptr [RSP + 0x78],0x0
MOV qword ptr [RSP + 0x80],0x6
JMP 0x001be582
LAB_001be547:
CMP dword ptr [RSP + 0x4c],0x0
JZ 0x001be566
MOV EDI,dword ptr [RSP + 0x14]
CALL 0x00157250
MOV qword ptr [RSP + 0x78],RAX
MOV qword ptr [RSP + 0x80],RDX
JMP 0x001be582
LAB_001be566:
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x40]
CALL 0x001216d0
MOV qword ptr [RSP + 0x78],RAX
MOV qword ptr [RSP + 0x80],RDX
LAB_001be582:
MOV RAX,qword ptr [RSP + 0x78]
MOV RDX,qword ptr [RSP + 0x80]
ADD RSP,0x88
RET
|
int1 [16] js_object_defineProperty(int8 param_1)
{
int8 uVar1;
int8 uVar2;
int8 uVar3;
int8 uVar4;
int iVar5;
int iVar6;
int8 *in_R8;
int in_R9D;
int1 auVar7 [16];
int4 local_78;
int4 local_10;
int4 uStack_c;
int8 local_8;
uVar1 = *in_R8;
uVar2 = in_R8[1];
uVar3 = in_R8[4];
uVar4 = in_R8[5];
if ((int)uVar2 == -1) {
iVar5 = JS_ValueToAtom(param_1,in_R8[2],in_R8[3]);
if (iVar5 == 0) {
local_10 = 0;
local_8 = 6;
}
else {
local_78 = 0x44000;
if (in_R9D != 0) {
local_78 = 0x80000;
}
iVar6 = JS_DefinePropertyDesc(param_1,uVar1,uVar2,iVar5,uVar3,uVar4,local_78);
JS_FreeAtom(param_1,iVar5);
if (iVar6 < 0) {
local_10 = 0;
local_8 = 6;
}
else if (in_R9D == 0) {
auVar7 = js_dup(uVar1,uVar2);
local_8 = auVar7._8_8_;
local_10 = auVar7._0_4_;
uStack_c = auVar7._4_4_;
}
else {
auVar7 = js_bool(iVar6);
local_8 = auVar7._8_8_;
local_10 = auVar7._0_4_;
uStack_c = auVar7._4_4_;
}
}
}
else {
auVar7 = JS_ThrowTypeErrorNotAnObject(param_1);
local_8 = auVar7._8_8_;
local_10 = auVar7._0_4_;
uStack_c = auVar7._4_4_;
}
auVar7._4_4_ = uStack_c;
auVar7._0_4_ = local_10;
auVar7._8_8_ = local_8;
return auVar7;
}
| |
26,419 | js_object_defineProperty | bluesky950520[P]quickjs/quickjs.c | static JSValue js_object_defineProperty(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int magic)
{
JSValue obj, prop, desc;
int ret, flags;
JSAtom atom;
obj = argv[0];
prop = argv[1];
desc = argv[2];
if (JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT)
return JS_ThrowTypeErrorNotAnObject(ctx);
atom = JS_ValueToAtom(ctx, prop);
if (unlikely(atom == JS_ATOM_NULL))
return JS_EXCEPTION;
flags = JS_PROP_THROW | JS_PROP_DEFINE_PROPERTY;
if (magic)
flags = JS_PROP_REFLECT_DEFINE_PROPERTY;
ret = JS_DefinePropertyDesc(ctx, obj, atom, desc, flags);
JS_FreeAtom(ctx, atom);
if (ret < 0) {
return JS_EXCEPTION;
} else if (magic) {
return js_bool(ret);
} else {
return js_dup(obj);
}
} | O1 | c | js_object_defineProperty:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r12
movq 0x8(%r8), %r15
cmpl $-0x1, %r15d
jne 0x1235a
movl %r9d, %ebp
movq (%r8), %rbx
movq 0x20(%r8), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%r8), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%r8), %rsi
movq 0x18(%r8), %rdx
movq %r12, %rdi
callq 0x24093
pushq $0x6
popq %r14
testl %eax, %eax
je 0x12373
movl %eax, %r13d
testl %ebp, %ebp
movl $0x44000, %eax # imm = 0x44000
movl $0x80000, %ecx # imm = 0x80000
cmovel %eax, %ecx
movl %ecx, (%rsp)
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl %r13d, %ecx
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %r9
callq 0x7126f
movl %ebp, 0x8(%rsp)
movl %eax, %ebp
movq %r12, %rdi
movl %r13d, %esi
callq 0x207d8
testl %ebp, %ebp
js 0x12373
cmpl $0x0, 0x8(%rsp)
je 0x1238e
xorl %ebx, %ebx
testl %ebp, %ebp
setne %bl
pushq $0x1
jmp 0x1236f
leaq 0x8ccc4(%rip), %rsi # 0x9f025
xorl %ebx, %ebx
movq %r12, %rdi
xorl %eax, %eax
callq 0x22567
pushq $0x6
popq %r14
jmp 0x12375
xorl %ebx, %ebx
xorl %ecx, %ecx
movl %ebx, %eax
orq %rcx, %rax
movq %r14, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
incl (%rbx)
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rbx, %rcx
movq %r15, %r14
jmp 0x12377
| js_object_defineProperty:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r12, rdi
mov r15, [r8+8]
cmp r15d, 0FFFFFFFFh
jnz loc_1235A
mov ebp, r9d
mov rbx, [r8]
mov rax, [r8+20h]
mov [rsp+48h+var_40], rax
mov rax, [r8+28h]
mov [rsp+48h+var_38], rax
mov rsi, [r8+10h]
mov rdx, [r8+18h]
mov rdi, r12
call JS_ValueToAtom
push 6
pop r14
test eax, eax
jz short loc_12373
mov r13d, eax
test ebp, ebp
mov eax, 44000h
mov ecx, offset loc_80000
cmovz ecx, eax
mov [rsp+48h+var_48], ecx
mov rdi, r12
mov rsi, rbx
mov rdx, r15
mov ecx, r13d
mov r8, [rsp+48h+var_40]
mov r9, [rsp+48h+var_38]
call JS_DefinePropertyDesc
mov dword ptr [rsp+48h+var_40], ebp
mov ebp, eax
mov rdi, r12
mov esi, r13d
call JS_FreeAtom
test ebp, ebp
js short loc_12373
cmp dword ptr [rsp+48h+var_40], 0
jz short loc_1238E
xor ebx, ebx
test ebp, ebp
setnz bl
push 1
jmp short loc_1236F
loc_1235A:
lea rsi, aOperandPrototy+20h; "not an object"
xor ebx, ebx
mov rdi, r12
xor eax, eax
call JS_ThrowTypeError
push 6
loc_1236F:
pop r14
jmp short loc_12375
loc_12373:
xor ebx, ebx
loc_12375:
xor ecx, ecx
loc_12377:
mov eax, ebx
or rax, rcx
mov rdx, r14
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1238E:
inc dword ptr [rbx]
mov rcx, 0FFFFFFFF00000000h
and rcx, rbx
mov r14, r15
jmp short loc_12377
| unsigned long long js_object_defineProperty(
long long a1,
long long a2,
int a3,
int a4,
unsigned long long *a5,
int a6)
{
unsigned long long v7; // rbx
unsigned int v8; // eax
unsigned int v9; // r13d
void *v10; // rcx
int v11; // eax
int v12; // ebp
unsigned long long v13; // rcx
unsigned long long v15; // [rsp+8h] [rbp-40h]
int v16; // [rsp+8h] [rbp-40h]
unsigned long long v17; // [rsp+10h] [rbp-38h]
if ( (unsigned int)a5[1] == -1 )
{
v7 = *a5;
v15 = a5[4];
v17 = a5[5];
v8 = JS_ValueToAtom(a1, a5[2], a5[3]);
if ( !v8 )
goto LABEL_9;
v9 = v8;
v10 = &loc_80000;
if ( !a6 )
LODWORD(v10) = 278528;
v11 = JS_DefinePropertyDesc(a1, v7, -1, v8, v15, v17, (_DWORD)v10);
v16 = a6;
v12 = v11;
JS_FreeAtom(a1, v9);
if ( v12 >= 0 )
{
if ( !v16 )
{
++*(_DWORD *)v7;
v13 = v7 & 0xFFFFFFFF00000000LL;
return v13 | (unsigned int)v7;
}
LODWORD(v7) = v12 != 0;
}
else
{
LABEL_9:
LODWORD(v7) = 0;
}
}
else
{
LODWORD(v7) = 0;
JS_ThrowTypeError(a1, (unsigned int)"not an object", a3, a4, (_DWORD)a5, a6);
}
v13 = 0LL;
return v13 | (unsigned int)v7;
}
| |||
26,420 | vsort_char | davidesantangelo[P]vsort/vsort.c | VSORT_API void vsort_char(char arr[], int n)
{
vsort_init();
if (!arr || n <= 1)
return;
vsort_log_debug("Starting vsort (char) for %d elements (using qsort fallback).", n);
qsort(arr, n, sizeof(char), default_char_comparator);
vsort_log_debug("vsort (char) completed for %d elements.", n);
} | O3 | c | vsort_char:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x1588
testq %r14, %r14
sete %al
cmpl $0x2, %ebx
setl %cl
orb %al, %cl
je 0x12a0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1fca(%rip), %rdi # 0x3271
movl %ebx, %esi
xorl %eax, %eax
callq 0x2976
movl %ebx, %esi
leaq 0x110e(%rip), %rcx # 0x23c7
movl $0x1, %edx
movq %r14, %rdi
callq 0x1090
leaq 0x1fe2(%rip), %rdi # 0x32af
movl %ebx, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2976
| vsort_char:
push r14
push rbx
push rax
mov ebx, esi
mov r14, rdi
call vsort_init
test r14, r14
setz al
cmp ebx, 2
setl cl
or cl, al
jz short loc_12A0
add rsp, 8
pop rbx
pop r14
retn
loc_12A0:
lea rdi, aStartingVsortC; "Starting vsort (char) for %d elements ("...
mov esi, ebx
xor eax, eax
call vsort_log_debug
mov esi, ebx
lea rcx, default_char_comparator
mov edx, 1
mov rdi, r14
call _qsort
lea rdi, aVsortCharCompl; "vsort (char) completed for %d elements."
mov esi, ebx
xor eax, eax
add rsp, 8
pop rbx
pop r14
jmp vsort_log_debug
| char vsort_char(long long a1, int a2, long long a3, long long a4, long long a5, long long a6, char a7)
{
char v7; // al
int v8; // edx
int v9; // r8d
int v10; // r9d
char result; // al
int v12; // ecx
int v13; // edx
int v14; // ecx
int v15; // r8d
int v16; // r9d
char v17; // [rsp-8h] [rbp-18h]
v17 = v7;
vsort_init();
result = a1 == 0;
LOBYTE(v12) = a1 == 0 || a2 < 2;
if ( !(_BYTE)v12 )
{
vsort_log_debug(
(unsigned int)"Starting vsort (char) for %d elements (using qsort fallback).",
a2,
v8,
v12,
v9,
v10,
v17);
qsort(a1, (unsigned int)a2, 1LL, default_char_comparator);
return vsort_log_debug((unsigned int)"vsort (char) completed for %d elements.", a2, v13, v14, v15, v16, a7);
}
return result;
}
| vsort_char:
PUSH R14
PUSH RBX
PUSH RAX
MOV EBX,ESI
MOV R14,RDI
CALL 0x00101588
TEST R14,R14
SETZ AL
CMP EBX,0x2
SETL CL
OR CL,AL
JZ 0x001012a0
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_001012a0:
LEA RDI,[0x103271]
MOV ESI,EBX
XOR EAX,EAX
CALL 0x00102976
MOV ESI,EBX
LEA RCX,[0x1023c7]
MOV EDX,0x1
MOV RDI,R14
CALL 0x00101090
LEA RDI,[0x1032af]
MOV ESI,EBX
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x00102976
|
void vsort_char(void *param_1,uint param_2)
{
vsort_init();
if ((int)param_2 < 2 || param_1 == (void *)0x0) {
return;
}
vsort_log_debug("Starting vsort (char) for %d elements (using qsort fallback).",param_2);
qsort(param_1,(ulong)param_2,1,default_char_comparator);
vsort_log_debug("vsort (char) completed for %d elements.",param_2);
return;
}
| |
26,421 | ok1 | eloqsql/unittest/mytap/tap.c | void
ok1(int const pass)
{
va_list ap;
memset(&ap, 0, sizeof(ap));
if (!pass && *g_test.todo == '\0')
++g_test.failed;
vemit_tap(pass, NULL, ap);
if (*g_test.todo != '\0')
emit_dir("todo", g_test.todo);
emit_endl();
} | O3 | c | ok1:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
testl %edi, %edi
jne 0x913f2
cmpb $0x0, 0xb6e632(%rip) # 0xbffa1c
jne 0x913f2
incl 0xb6e626(%rip) # 0xbffa18
leaq -0x20(%rbp), %rdx
xorl %esi, %esi
callq 0x91319
cmpb $0x0, 0xb6e618(%rip) # 0xbffa1c
je 0x91439
movq 0x2f2b9b(%rip), %rbx # 0x383fa8
movq (%rbx), %rdi
leaq 0x4aba1(%rip), %rdx # 0xdbfb8
leaq 0x4ab29(%rip), %rcx # 0xdbf47
leaq 0xb6e5f7(%rip), %r8 # 0xbffa1c
movl $0x1, %esi
xorl %eax, %eax
callq 0x29200
movq (%rbx), %rdi
callq 0x29400
movq 0x2f2b68(%rip), %rbx # 0x383fa8
movq (%rbx), %rdi
leaq 0x4e9b6(%rip), %rdx # 0xdfe00
movl $0x1, %esi
xorl %eax, %eax
callq 0x29200
movq (%rbx), %rdi
callq 0x29400
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
| ok1:
push rbp
mov rbp, rsp
push rbx
sub rsp, 18h
xorps xmm0, xmm0
movaps [rbp+var_20], xmm0
mov [rbp+var_10], 0
test edi, edi
jnz short loc_913F2
cmp cs:byte_BFFA1C, 0
jnz short loc_913F2
inc cs:dword_BFFA18
loc_913F2:
lea rdx, [rbp+var_20]
xor esi, esi
call vemit_tap
cmp cs:byte_BFFA1C, 0
jz short loc_91439
mov rbx, cs:stdout_ptr
mov rdi, [rbx]
lea rdx, aSS; " # %s %s"
lea rcx, aTodo; "todo"
lea r8, byte_BFFA1C
mov esi, 1
xor eax, eax
call ___fprintf_chk
mov rdi, [rbx]
call _fflush
loc_91439:
mov rbx, cs:stdout_ptr
mov rdi, [rbx]
lea rdx, asc_DFDFD+3; "\n"
mov esi, 1
xor eax, eax
call ___fprintf_chk
mov rdi, [rbx]
call _fflush
add rsp, 18h
pop rbx
pop rbp
retn
| long long ok1(int a1)
{
long long v1; // rcx
long long v2; // r8
long long v3; // r9
__int128 v5; // [rsp+0h] [rbp-20h] BYREF
long long v6; // [rsp+10h] [rbp-10h]
v5 = 0LL;
v6 = 0LL;
if ( !a1 && !byte_BFFA1C )
++dword_BFFA18;
vemit_tap(a1, 0LL, (long long)&v5);
if ( byte_BFFA1C )
{
__fprintf_chk(stdout, 1LL, " # %s %s", "todo", &byte_BFFA1C);
fflush(stdout);
}
__fprintf_chk(stdout, 1LL, "\n", v1, v2, v3, v5, v6);
return fflush(stdout);
}
| ok1:
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x18
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RBP + -0x20],XMM0
MOV qword ptr [RBP + -0x10],0x0
TEST EDI,EDI
JNZ 0x001913f2
CMP byte ptr [0x00cffa1c],0x0
JNZ 0x001913f2
INC dword ptr [0x00cffa18]
LAB_001913f2:
LEA RDX,[RBP + -0x20]
XOR ESI,ESI
CALL 0x00191319
CMP byte ptr [0x00cffa1c],0x0
JZ 0x00191439
MOV RBX,qword ptr [0x00483fa8]
MOV RDI,qword ptr [RBX]
LEA RDX,[0x1dbfb8]
LEA RCX,[0x1dbf47]
LEA R8,[0xcffa1c]
MOV ESI,0x1
XOR EAX,EAX
CALL 0x00129200
MOV RDI,qword ptr [RBX]
CALL 0x00129400
LAB_00191439:
MOV RBX,qword ptr [0x00483fa8]
MOV RDI,qword ptr [RBX]
LEA RDX,[0x1dfe00]
MOV ESI,0x1
XOR EAX,EAX
CALL 0x00129200
MOV RDI,qword ptr [RBX]
CALL 0x00129400
ADD RSP,0x18
POP RBX
POP RBP
RET
|
void ok1(int8 param_1)
{
int *puVar1;
int8 local_28;
int8 uStack_20;
int8 local_18;
local_28 = 0;
uStack_20 = 0;
local_18 = 0;
if (((int)param_1 == 0) && (DAT_00cffa1c == '\0')) {
DAT_00cffa18 = DAT_00cffa18 + 1;
}
vemit_tap(param_1,0,&local_28);
puVar1 = PTR_stdout_00483fa8;
if (DAT_00cffa1c != '\0') {
__fprintf_chk(*(int8 *)PTR_stdout_00483fa8,1," # %s %s",&DAT_001dbf47,&DAT_00cffa1c);
fflush(*(FILE **)puVar1);
}
puVar1 = PTR_stdout_00483fa8;
__fprintf_chk(*(int8 *)PTR_stdout_00483fa8,1,&DAT_001dfe00);
fflush(*(FILE **)puVar1);
return;
}
| |
26,422 | LefDefParser::defwSpecialNet(char const*) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defwWriter.cpp | int
defwSpecialNet(const char *name)
{
defwFunc = DEFW_SNET; // Current function of writer
if (!defwFile)
return DEFW_UNINITIALIZED;
if (defwState != DEFW_SNET_START &&
defwState != DEFW_SNET_ENDNET)
return DEFW_BAD_ORDER;
defwState = DEFW_SNET;
fprintf(defwFile, " - %s", name);
defwLineItemCounter = 0;
defwCounter--;
return DEFW_OK;
} | O0 | cpp | LefDefParser::defwSpecialNet(char const*):
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
leaq 0x13c18(%rip), %rax # 0x2b168
movl $0x32, (%rax)
leaq 0x13bfb(%rip), %rax # 0x2b158
cmpq $0x0, (%rax)
jne 0x1756d
movl $0x1, 0x14(%rsp)
jmp 0x175e3
leaq 0x13bf0(%rip), %rax # 0x2b164
cmpl $0x31, (%rax)
je 0x1758f
leaq 0x13be4(%rip), %rax # 0x2b164
cmpl $0x34, (%rax)
je 0x1758f
movl $0x2, 0x14(%rsp)
jmp 0x175e3
leaq 0x13bce(%rip), %rax # 0x2b164
movl $0x32, (%rax)
leaq 0x13bb5(%rip), %rax # 0x2b158
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0xcc8d(%rip), %rsi # 0x2423f
movb $0x0, %al
callq 0x10f0
leaq 0x13bbc(%rip), %rax # 0x2b17c
movl $0x0, (%rax)
leaq 0x13bab(%rip), %rax # 0x2b178
movl (%rax), %ecx
addl $-0x1, %ecx
leaq 0x13b9f(%rip), %rax # 0x2b178
movl %ecx, (%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
| _ZN12LefDefParser14defwSpecialNetEPKc:
sub rsp, 18h
mov [rsp+18h+var_10], rdi
lea rax, _ZN12LefDefParser8defwFuncE; LefDefParser::defwFunc
mov dword ptr [rax], 32h ; '2'
lea rax, _ZN12LefDefParser8defwFileE; LefDefParser::defwFile
cmp qword ptr [rax], 0
jnz short loc_1756D
mov [rsp+18h+var_4], 1
jmp short loc_175E3
loc_1756D:
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
cmp dword ptr [rax], 31h ; '1'
jz short loc_1758F
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
cmp dword ptr [rax], 34h ; '4'
jz short loc_1758F
mov [rsp+18h+var_4], 2
jmp short loc_175E3
loc_1758F:
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
mov dword ptr [rax], 32h ; '2'
lea rax, _ZN12LefDefParser8defwFileE; LefDefParser::defwFile
mov rdi, [rax]
mov rdx, [rsp+18h+var_10]
lea rsi, aS; " - %s"
mov al, 0
call _fprintf
lea rax, _ZN12LefDefParser19defwLineItemCounterE; LefDefParser::defwLineItemCounter
mov dword ptr [rax], 0
lea rax, _ZN12LefDefParser11defwCounterE; LefDefParser::defwCounter
mov ecx, [rax]
add ecx, 0FFFFFFFFh
lea rax, _ZN12LefDefParser11defwCounterE; LefDefParser::defwCounter
mov [rax], ecx
mov [rsp+18h+var_4], 0
loc_175E3:
mov eax, [rsp+18h+var_4]
add rsp, 18h
retn
| long long LefDefParser::defwSpecialNet(LefDefParser *this, const char *a2)
{
LefDefParser::defwFunc = 50;
if ( LefDefParser::defwFile )
{
if ( LefDefParser::defwState == 49 || LefDefParser::defwState == 52 )
{
LefDefParser::defwState = 50;
fprintf(LefDefParser::defwFile, " - %s", (const char *)this);
LefDefParser::defwLineItemCounter = 0;
--LefDefParser::defwCounter;
return 0;
}
else
{
return 2;
}
}
else
{
return 1;
}
}
| defwSpecialNet:
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDI
LEA RAX,[0x12b168]
MOV dword ptr [RAX],0x32
LEA RAX,[0x12b158]
CMP qword ptr [RAX],0x0
JNZ 0x0011756d
MOV dword ptr [RSP + 0x14],0x1
JMP 0x001175e3
LAB_0011756d:
LEA RAX,[0x12b164]
CMP dword ptr [RAX],0x31
JZ 0x0011758f
LEA RAX,[0x12b164]
CMP dword ptr [RAX],0x34
JZ 0x0011758f
MOV dword ptr [RSP + 0x14],0x2
JMP 0x001175e3
LAB_0011758f:
LEA RAX,[0x12b164]
MOV dword ptr [RAX],0x32
LEA RAX,[0x12b158]
MOV RDI,qword ptr [RAX]
MOV RDX,qword ptr [RSP + 0x8]
LEA RSI,[0x12423f]
MOV AL,0x0
CALL 0x001010f0
LEA RAX,[0x12b17c]
MOV dword ptr [RAX],0x0
LEA RAX,[0x12b178]
MOV ECX,dword ptr [RAX]
ADD ECX,-0x1
LEA RAX,[0x12b178]
MOV dword ptr [RAX],ECX
MOV dword ptr [RSP + 0x14],0x0
LAB_001175e3:
MOV EAX,dword ptr [RSP + 0x14]
ADD RSP,0x18
RET
|
/* LefDefParser::defwSpecialNet(char const*) */
int4 LefDefParser::defwSpecialNet(char *param_1)
{
int4 local_4;
defwFunc = 0x32;
if (defwFile == (FILE *)0x0) {
local_4 = 1;
}
else if ((defwState == 0x31) || (defwState == 0x34)) {
defwState = 0x32;
fprintf(defwFile," - %s",param_1);
defwLineItemCounter = 0;
defwCounter = defwCounter + -1;
local_4 = 0;
}
else {
local_4 = 2;
}
return local_4;
}
| |
26,423 | my_tell | eloqsql/mysys/my_seek.c | my_off_t my_tell(File fd, myf MyFlags)
{
os_off_t pos;
DBUG_ENTER("my_tell");
DBUG_PRINT("my",("fd: %d MyFlags: %lu",fd, MyFlags));
DBUG_ASSERT(fd >= 0);
#if defined (HAVE_TELL) && !defined (_WIN32) && !defined(_AIX)
pos= tell(fd);
#else
pos= my_seek(fd, 0L, MY_SEEK_CUR,0);
#endif
if (pos == (os_off_t) -1)
{
my_errno= errno;
if (MyFlags & MY_WME)
my_error(EE_CANT_SEEK, MYF(0), my_filename(fd), my_errno);
DBUG_PRINT("error", ("tell: %llu errno: %d", (ulonglong) pos, my_errno));
}
DBUG_PRINT("exit",("pos: %llu", (ulonglong) pos));
DBUG_RETURN((my_off_t) pos);
} | O3 | c | my_tell:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movl %edi, %r14d
xorl %esi, %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0xa1a7c
movq %rax, %rbx
cmpq $-0x1, %rax
jne 0xa1b41
callq 0x297b0
movl (%rax), %r12d
callq 0xa29fe
movl %r12d, (%rax)
testb $0x10, %r15b
je 0xa1b41
movl %r14d, %edi
callq 0xa9edc
movq %rax, %r14
callq 0xa29fe
movl (%rax), %ecx
movl $0x21, %edi
xorl %esi, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x9f0b3
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
| my_tell:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r15, rsi
mov r14d, edi
xor esi, esi
mov edx, 1
xor ecx, ecx
call my_seek
mov rbx, rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_A1B41
call ___errno_location
mov r12d, [rax]
call _my_thread_var
mov [rax], r12d
test r15b, 10h
jz short loc_A1B41
mov edi, r14d
call my_filename
mov r14, rax
call _my_thread_var
mov ecx, [rax]
mov edi, 21h ; '!'
xor esi, esi
mov rdx, r14
xor eax, eax
call my_error
loc_A1B41:
mov rax, rbx
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long my_tell(long long a1, char a2)
{
long long v2; // rbx
int v3; // r12d
long long v4; // r14
unsigned int *v5; // rax
v2 = my_seek(a1, 0LL, 1LL, 0);
if ( v2 == -1 )
{
v3 = *(_DWORD *)__errno_location(a1);
*(_DWORD *)my_thread_var(a1, 0LL) = v3;
if ( (a2 & 0x10) != 0 )
{
v4 = my_filename((unsigned int)a1);
v5 = (unsigned int *)my_thread_var((unsigned int)a1, 0LL);
my_error(0x21u, 0LL, v4, *v5);
}
}
return v2;
}
| my_tell:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R15,RSI
MOV R14D,EDI
XOR ESI,ESI
MOV EDX,0x1
XOR ECX,ECX
CALL 0x001a1a7c
MOV RBX,RAX
CMP RAX,-0x1
JNZ 0x001a1b41
CALL 0x001297b0
MOV R12D,dword ptr [RAX]
CALL 0x001a29fe
MOV dword ptr [RAX],R12D
TEST R15B,0x10
JZ 0x001a1b41
MOV EDI,R14D
CALL 0x001a9edc
MOV R14,RAX
CALL 0x001a29fe
MOV ECX,dword ptr [RAX]
MOV EDI,0x21
XOR ESI,ESI
MOV RDX,R14
XOR EAX,EAX
CALL 0x0019f0b3
LAB_001a1b41:
MOV RAX,RBX
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
long my_tell(ulong param_1,ulong param_2)
{
int iVar1;
long lVar2;
int *piVar3;
int8 uVar4;
int4 *puVar5;
lVar2 = my_seek(param_1,0,1,0);
if (lVar2 == -1) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar3 = (int *)_my_thread_var();
*piVar3 = iVar1;
if ((param_2 & 0x10) != 0) {
uVar4 = my_filename(param_1 & 0xffffffff);
puVar5 = (int4 *)_my_thread_var();
my_error(0x21,0,uVar4,*puVar5);
}
}
return lVar2;
}
| |
26,424 | Parser::parse_if_pred() | BhuvanGudi[P]LexiParse/src/parser.hpp | std::optional<NodeIfPred*> parse_if_pred() // NOLINT(*-no-recursion)
{
if (try_consume(TokenType::elif)) {
try_consume_err(TokenType::open_paren);
const auto elif = m_allocator.alloc<NodeIfPredElif>();
if (const auto expr = parse_expr()) {
elif->expr = expr.value();
}
else {
error_expected("expression");
}
try_consume_err(TokenType::close_paren);
if (const auto scope = parse_scope()) {
elif->scope = scope.value();
}
else {
error_expected("scope");
}
elif->pred = parse_if_pred();
auto pred = m_allocator.emplace<NodeIfPred>(elif);
return pred;
}
if (try_consume(TokenType::else_)) {
auto else_ = m_allocator.alloc<NodeIfPredElse>();
if (const auto scope = parse_scope()) {
else_->scope = scope.value();
}
else {
error_expected("scope");
}
auto pred = m_allocator.emplace<NodeIfPred>(else_);
return pred;
}
return {};
} | O0 | cpp | Parser::parse_if_pred():
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movq %rsi, -0x1e0(%rbp)
leaq -0x50(%rbp), %rdi
movl $0xf, %edx
callq 0xa580
leaq -0x50(%rbp), %rdi
callq 0xa710
movb %al, -0x1d1(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x7bd0
movb -0x1d1(%rbp), %al
testb $0x1, %al
jne 0xa80f
jmp 0xaaa8
movq -0x1e0(%rbp), %rsi
leaq -0x80(%rbp), %rdi
movl $0x3, %edx
callq 0x9f20
leaq -0x80(%rbp), %rdi
callq 0x59c0
movq -0x1e0(%rbp), %rdi
addq $0x20, %rdi
callq 0xf1b0
movq -0x1e0(%rbp), %rdi
movq %rax, -0x88(%rbp)
xorl %esi, %esi
callq 0x98e0
movq %rax, -0x98(%rbp)
movb %dl, -0x90(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x9ec0
testb $0x1, %al
jne 0xa871
jmp 0xa88f
leaq -0x98(%rbp), %rdi
callq 0x9ee0
movq (%rax), %rcx
movq -0x88(%rbp), %rax
movq %rcx, (%rax)
jmp 0xa930
leaq -0xb9(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
callq 0x32e0
movq -0x1e8(%rbp), %rdx
leaq 0xc93c(%rip), %rsi # 0x171ec
leaq -0xb8(%rbp), %rdi
callq 0x90b0
jmp 0xa8be
movq -0x1e0(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x8fe0
jmp 0xa8d3
leaq -0xb8(%rbp), %rdi
callq 0x3bd0
leaq -0xb9(%rbp), %rdi
callq 0x3220
jmp 0xa930
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
jmp 0xa91f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x3bd0
leaq -0xb9(%rbp), %rdi
callq 0x3220
jmp 0xac34
movq -0x1e0(%rbp), %rsi
leaq -0x100(%rbp), %rdi
movl $0x4, %edx
callq 0x9f20
leaq -0x100(%rbp), %rdi
callq 0x59c0
movq -0x1e0(%rbp), %rdi
callq 0xa3e0
movq %rax, -0x110(%rbp)
movb %dl, -0x108(%rbp)
leaq -0x110(%rbp), %rdi
callq 0xa4e0
testb $0x1, %al
jne 0xa97f
jmp 0xa99e
leaq -0x110(%rbp), %rdi
callq 0xa780
movq (%rax), %rcx
movq -0x88(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xaa3f
leaq -0x131(%rbp), %rdi
movq %rdi, -0x1f0(%rbp)
callq 0x32e0
movq -0x1f0(%rbp), %rdx
leaq 0xc838(%rip), %rsi # 0x171f7
leaq -0x130(%rbp), %rdi
callq 0x90b0
jmp 0xa9cd
movq -0x1e0(%rbp), %rdi
leaq -0x130(%rbp), %rsi
callq 0x8fe0
jmp 0xa9e2
leaq -0x130(%rbp), %rdi
callq 0x3bd0
leaq -0x131(%rbp), %rdi
callq 0x3220
jmp 0xaa3f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
jmp 0xaa2e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x3bd0
leaq -0x131(%rbp), %rdi
callq 0x3220
jmp 0xac34
movq -0x1e0(%rbp), %rdi
callq 0xa7c0
movq -0x1e0(%rbp), %rdi
movq %rax, -0x148(%rbp)
movb %dl, -0x140(%rbp)
movq -0x88(%rbp), %rax
movq -0x148(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x140(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x20, %rdi
leaq -0x88(%rbp), %rsi
callq 0xf250
movq %rax, -0x150(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x150(%rbp), %rsi
callq 0xf290
jmp 0xac24
movq -0x1e0(%rbp), %rsi
leaq -0x188(%rbp), %rdi
movl $0x10, %edx
callq 0xa580
leaq -0x188(%rbp), %rdi
callq 0xa710
movb %al, -0x1f1(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x7bd0
movb -0x1f1(%rbp), %al
testb $0x1, %al
jne 0xaaed
jmp 0xac1b
movq -0x1e0(%rbp), %rdi
addq $0x20, %rdi
callq 0xf2c0
movq -0x1e0(%rbp), %rdi
movq %rax, -0x190(%rbp)
callq 0xa3e0
movq %rax, -0x1a0(%rbp)
movb %dl, -0x198(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0xa4e0
testb $0x1, %al
jne 0xab2f
jmp 0xab4d
leaq -0x1a0(%rbp), %rdi
callq 0xa780
movq (%rax), %rcx
movq -0x190(%rbp), %rax
movq %rcx, (%rax)
jmp 0xabeb
leaq -0x1c1(%rbp), %rdi
movq %rdi, -0x200(%rbp)
callq 0x32e0
movq -0x200(%rbp), %rdx
leaq 0xc689(%rip), %rsi # 0x171f7
leaq -0x1c0(%rbp), %rdi
callq 0x90b0
jmp 0xab7c
movq -0x1e0(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x8fe0
jmp 0xab91
leaq -0x1c0(%rbp), %rdi
callq 0x3bd0
leaq -0x1c1(%rbp), %rdi
callq 0x3220
jmp 0xabeb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
jmp 0xabdd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x3bd0
leaq -0x1c1(%rbp), %rdi
callq 0x3220
jmp 0xac34
movq -0x1e0(%rbp), %rdi
addq $0x20, %rdi
leaq -0x190(%rbp), %rsi
callq 0xf360
movq %rax, -0x1d0(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0xf290
jmp 0xac24
leaq -0x10(%rbp), %rdi
callq 0xf0d0
movq -0x10(%rbp), %rax
movb -0x8(%rbp), %dl
addq $0x200, %rsp # imm = 0x200
popq %rbp
retq
movq -0xc8(%rbp), %rdi
callq 0x32d0
| _ZN6Parser13parse_if_predEv:
push rbp
mov rbp, rsp
sub rsp, 200h
mov [rbp+var_18], rdi
mov rsi, [rbp+var_18]
mov [rbp+var_1E0], rsi
lea rdi, [rbp+var_50]
mov edx, 0Fh
call _ZN6Parser11try_consumeE9TokenType; Parser::try_consume(TokenType)
lea rdi, [rbp+var_50]
call _ZNKSt8optionalI5TokenEcvbEv; std::optional<Token>::operator bool(void)
mov [rbp+var_1D1], al
lea rdi, [rbp+var_50]
call _ZNSt8optionalI5TokenED2Ev; std::optional<Token>::~optional()
mov al, [rbp+var_1D1]
test al, 1
jnz short loc_A80F
jmp loc_AAA8
loc_A80F:
mov rsi, [rbp+var_1E0]
lea rdi, [rbp+var_80]
mov edx, 3
call _ZN6Parser15try_consume_errE9TokenType; Parser::try_consume_err(TokenType)
lea rdi, [rbp+var_80]; this
call _ZN5TokenD2Ev; Token::~Token()
mov rdi, [rbp+var_1E0]
add rdi, 20h ; ' '
call _ZN14ArenaAllocator5allocI14NodeIfPredElifEEPT_v; ArenaAllocator::alloc<NodeIfPredElif>(void)
mov rdi, [rbp+var_1E0]; this
mov [rbp+var_88], rax
xor esi, esi; int
call _ZN6Parser10parse_exprEi; Parser::parse_expr(int)
mov [rbp+var_98], rax
mov [rbp+var_90], dl
lea rdi, [rbp+var_98]
call _ZNKSt8optionalIP8NodeExprEcvbEv; std::optional<NodeExpr *>::operator bool(void)
test al, 1
jnz short loc_A871
jmp short loc_A88F
loc_A871:
lea rdi, [rbp+var_98]
call _ZNKRSt8optionalIP8NodeExprE5valueEv; std::optional<NodeExpr *>::value(void)
mov rcx, [rax]
mov rax, [rbp+var_88]
mov [rax], rcx
jmp loc_A930
loc_A88F:
lea rdi, [rbp+var_B9]
mov [rbp+var_1E8], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdx, [rbp+var_1E8]
lea rsi, aExpression; "expression"
lea rdi, [rbp+var_B8]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_A8BE:
mov rdi, [rbp+var_1E0]
lea rsi, [rbp+var_B8]
call _ZNK6Parser14error_expectedERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; Parser::error_expected(std::string const&)
jmp short $+2
loc_A8D3:
lea rdi, [rbp+var_B8]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rbp+var_B9]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_A930
mov rcx, rax
mov eax, edx
mov [rbp+var_C8], rcx
mov [rbp+var_CC], eax
jmp short loc_A91F
mov rcx, rax
mov eax, edx
mov [rbp+var_C8], rcx
mov [rbp+var_CC], eax
lea rdi, [rbp+var_B8]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_A91F:
lea rdi, [rbp+var_B9]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_AC34
loc_A930:
mov rsi, [rbp+var_1E0]
lea rdi, [rbp+var_100]
mov edx, 4
call _ZN6Parser15try_consume_errE9TokenType; Parser::try_consume_err(TokenType)
lea rdi, [rbp+var_100]; this
call _ZN5TokenD2Ev; Token::~Token()
mov rdi, [rbp+var_1E0]; this
call _ZN6Parser11parse_scopeEv; Parser::parse_scope(void)
mov [rbp+var_110], rax
mov [rbp+var_108], dl
lea rdi, [rbp+var_110]
call _ZNKSt8optionalIP9NodeScopeEcvbEv; std::optional<NodeScope *>::operator bool(void)
test al, 1
jnz short loc_A97F
jmp short loc_A99E
loc_A97F:
lea rdi, [rbp+var_110]
call _ZNKRSt8optionalIP9NodeScopeE5valueEv; std::optional<NodeScope *>::value(void)
mov rcx, [rax]
mov rax, [rbp+var_88]
mov [rax+8], rcx
jmp loc_AA3F
loc_A99E:
lea rdi, [rbp+var_131]
mov [rbp+var_1F0], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdx, [rbp+var_1F0]
lea rsi, aScope; "scope"
lea rdi, [rbp+var_130]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_A9CD:
mov rdi, [rbp+var_1E0]
lea rsi, [rbp+var_130]
call _ZNK6Parser14error_expectedERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; Parser::error_expected(std::string const&)
jmp short $+2
loc_A9E2:
lea rdi, [rbp+var_130]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rbp+var_131]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_AA3F
mov rcx, rax
mov eax, edx
mov [rbp+var_C8], rcx
mov [rbp+var_CC], eax
jmp short loc_AA2E
mov rcx, rax
mov eax, edx
mov [rbp+var_C8], rcx
mov [rbp+var_CC], eax
lea rdi, [rbp+var_130]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_AA2E:
lea rdi, [rbp+var_131]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_AC34
loc_AA3F:
mov rdi, [rbp+var_1E0]; this
call _ZN6Parser13parse_if_predEv; Parser::parse_if_pred(void)
mov rdi, [rbp+var_1E0]
mov [rbp+var_148], rax
mov byte ptr [rbp+var_140], dl
mov rax, [rbp+var_88]
mov rcx, [rbp+var_148]
mov [rax+10h], rcx
mov rcx, [rbp+var_140]
mov [rax+18h], rcx
add rdi, 20h ; ' '
lea rsi, [rbp+var_88]
call _ZN14ArenaAllocator7emplaceI10NodeIfPredJRKP14NodeIfPredElifEEEPT_DpOT0_; ArenaAllocator::emplace<NodeIfPred,NodeIfPredElif * const&>(NodeIfPredElif * const&)
mov [rbp+var_150], rax
lea rdi, [rbp+var_10]
lea rsi, [rbp+var_150]
call _ZNSt8optionalIP10NodeIfPredEC2IS1_TnNSt9enable_ifIX7__and_vISt6__not_ISt7is_sameIS2_NSt9remove_cvINSt16remove_referenceIT_E4typeEE4typeEEES5_IS6_ISt10in_place_tSD_EESt16is_constructibleIS1_JS9_EESt14is_convertibleIS9_S1_EEEbE4typeELb1EEEOS9_
jmp loc_AC24
loc_AAA8:
mov rsi, [rbp+var_1E0]
lea rdi, [rbp+var_188]
mov edx, 10h
call _ZN6Parser11try_consumeE9TokenType; Parser::try_consume(TokenType)
lea rdi, [rbp+var_188]
call _ZNKSt8optionalI5TokenEcvbEv; std::optional<Token>::operator bool(void)
mov [rbp+var_1F1], al
lea rdi, [rbp+var_188]
call _ZNSt8optionalI5TokenED2Ev; std::optional<Token>::~optional()
mov al, [rbp+var_1F1]
test al, 1
jnz short loc_AAED
jmp loc_AC1B
loc_AAED:
mov rdi, [rbp+var_1E0]
add rdi, 20h ; ' '
call _ZN14ArenaAllocator5allocI14NodeIfPredElseEEPT_v; ArenaAllocator::alloc<NodeIfPredElse>(void)
mov rdi, [rbp+var_1E0]; this
mov [rbp+var_190], rax
call _ZN6Parser11parse_scopeEv; Parser::parse_scope(void)
mov [rbp+var_1A0], rax
mov [rbp+var_198], dl
lea rdi, [rbp+var_1A0]
call _ZNKSt8optionalIP9NodeScopeEcvbEv; std::optional<NodeScope *>::operator bool(void)
test al, 1
jnz short loc_AB2F
jmp short loc_AB4D
loc_AB2F:
lea rdi, [rbp+var_1A0]
call _ZNKRSt8optionalIP9NodeScopeE5valueEv; std::optional<NodeScope *>::value(void)
mov rcx, [rax]
mov rax, [rbp+var_190]
mov [rax], rcx
jmp loc_ABEB
loc_AB4D:
lea rdi, [rbp+var_1C1]
mov [rbp+var_200], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdx, [rbp+var_200]
lea rsi, aScope; "scope"
lea rdi, [rbp+var_1C0]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_AB7C:
mov rdi, [rbp+var_1E0]
lea rsi, [rbp+var_1C0]
call _ZNK6Parser14error_expectedERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; Parser::error_expected(std::string const&)
jmp short $+2
loc_AB91:
lea rdi, [rbp+var_1C0]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rbp+var_1C1]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_ABEB
mov rcx, rax
mov eax, edx
mov [rbp+var_C8], rcx
mov [rbp+var_CC], eax
jmp short loc_ABDD
mov rcx, rax
mov eax, edx
mov [rbp+var_C8], rcx
mov [rbp+var_CC], eax
lea rdi, [rbp+var_1C0]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_ABDD:
lea rdi, [rbp+var_1C1]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_AC34
loc_ABEB:
mov rdi, [rbp+var_1E0]
add rdi, 20h ; ' '
lea rsi, [rbp+var_190]
call _ZN14ArenaAllocator7emplaceI10NodeIfPredJRP14NodeIfPredElseEEEPT_DpOT0_; ArenaAllocator::emplace<NodeIfPred,NodeIfPredElse *&>(NodeIfPredElse *&)
mov [rbp+var_1D0], rax
lea rdi, [rbp+var_10]
lea rsi, [rbp+var_1D0]
call _ZNSt8optionalIP10NodeIfPredEC2IS1_TnNSt9enable_ifIX7__and_vISt6__not_ISt7is_sameIS2_NSt9remove_cvINSt16remove_referenceIT_E4typeEE4typeEEES5_IS6_ISt10in_place_tSD_EESt16is_constructibleIS1_JS9_EESt14is_convertibleIS9_S1_EEEbE4typeELb1EEEOS9_
jmp short loc_AC24
loc_AC1B:
lea rdi, [rbp+var_10]
call _ZNSt8optionalIP10NodeIfPredEC2Ev; std::optional<NodeIfPred *>::optional(void)
loc_AC24:
mov rax, [rbp+var_10]
mov dl, [rbp+var_8]
add rsp, 200h
pop rbp
retn
loc_AC34:
mov rdi, [rbp+var_C8]
call __Unwind_Resume
| long long Parser::parse_if_pred(Parser *this)
{
char v1; // dl
_QWORD *v2; // rax
char v3; // dl
_QWORD *v4; // rax
char v5; // dl
_QWORD *v6; // rax
char v7; // dl
long long v8; // rcx
char v10; // [rsp+Fh] [rbp-1F1h]
char v11; // [rsp+2Fh] [rbp-1D1h]
long long v12; // [rsp+30h] [rbp-1D0h] BYREF
char v13; // [rsp+3Fh] [rbp-1C1h] BYREF
_BYTE v14[32]; // [rsp+40h] [rbp-1C0h] BYREF
long long v15; // [rsp+60h] [rbp-1A0h] BYREF
char v16; // [rsp+68h] [rbp-198h]
_QWORD *v17; // [rsp+70h] [rbp-190h] BYREF
_BYTE v18[56]; // [rsp+78h] [rbp-188h] BYREF
long long v19; // [rsp+B0h] [rbp-150h] BYREF
long long v20; // [rsp+B8h] [rbp-148h]
long long v21; // [rsp+C0h] [rbp-140h]
char v22; // [rsp+CFh] [rbp-131h] BYREF
_BYTE v23[32]; // [rsp+D0h] [rbp-130h] BYREF
long long v24; // [rsp+F0h] [rbp-110h] BYREF
char v25; // [rsp+F8h] [rbp-108h]
_BYTE v26[52]; // [rsp+100h] [rbp-100h] BYREF
char v27; // [rsp+147h] [rbp-B9h] BYREF
_BYTE v28[32]; // [rsp+148h] [rbp-B8h] BYREF
long long v29; // [rsp+168h] [rbp-98h] BYREF
char v30; // [rsp+170h] [rbp-90h]
_QWORD *v31; // [rsp+178h] [rbp-88h] BYREF
_BYTE v32[48]; // [rsp+180h] [rbp-80h] BYREF
_BYTE v33[56]; // [rsp+1B0h] [rbp-50h] BYREF
Parser *v34; // [rsp+1E8h] [rbp-18h]
long long v35; // [rsp+1F0h] [rbp-10h] BYREF
v34 = this;
Parser::try_consume((long long)v33, this, 15);
v11 = std::optional<Token>::operator bool((long long)v33);
std::optional<Token>::~optional((long long)v33);
if ( (v11 & 1) != 0 )
{
Parser::try_consume_err((Parser *)v32, this, 3u);
Token::~Token((Token *)v32);
v31 = (_QWORD *)ArenaAllocator::alloc<NodeIfPredElif>((char *)this + 32);
v29 = Parser::parse_expr(this, 0);
v30 = v1;
if ( (std::optional<NodeExpr *>::operator bool((long long)&v29) & 1) == 0 )
{
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>((long long)v28, (long long)"expression", (long long)&v27);
Parser::error_expected(this, (long long)v28);
}
v2 = (_QWORD *)std::optional<NodeExpr *>::value((long long)&v29);
*v31 = *v2;
Parser::try_consume_err((Parser *)v26, this, 4u);
Token::~Token((Token *)v26);
v24 = Parser::parse_scope(this);
v25 = v3;
if ( (std::optional<NodeScope *>::operator bool((long long)&v24) & 1) == 0 )
{
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>((long long)v23, (long long)"scope", (long long)&v22);
Parser::error_expected(this, (long long)v23);
}
v4 = (_QWORD *)std::optional<NodeScope *>::value((long long)&v24);
v31[1] = *v4;
v20 = Parser::parse_if_pred(this);
LOBYTE(v21) = v5;
v6 = v31;
v31[2] = v20;
v6[3] = v21;
v19 = ArenaAllocator::emplace<NodeIfPred,NodeIfPredElif * const&>((char *)this + 32, &v31);
ZNSt8optionalIP10NodeIfPredEC2IS1_TnNSt9enable_ifIX7__and_vISt6__not_ISt7is_sameIS2_NSt9remove_cvINSt16remove_referenceIT_E4typeEE4typeEEES5_IS6_ISt10in_place_tSD_EESt16is_constructibleIS1_JS9_EESt14is_convertibleIS9_S1_EEEbE4typeELb1EEEOS9_(
&v35,
&v19);
}
else
{
Parser::try_consume((long long)v18, this, 16);
v10 = std::optional<Token>::operator bool((long long)v18);
std::optional<Token>::~optional((long long)v18);
if ( (v10 & 1) != 0 )
{
v17 = (_QWORD *)ArenaAllocator::alloc<NodeIfPredElse>((char *)this + 32);
v15 = Parser::parse_scope(this);
v16 = v7;
if ( (std::optional<NodeScope *>::operator bool((long long)&v15) & 1) == 0 )
{
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>((long long)v14, (long long)"scope", (long long)&v13);
Parser::error_expected(this, (long long)v14);
}
v8 = *(_QWORD *)std::optional<NodeScope *>::value((long long)&v15);
*v17 = v8;
v12 = ArenaAllocator::emplace<NodeIfPred,NodeIfPredElse *&>((char *)this + 32, &v17);
ZNSt8optionalIP10NodeIfPredEC2IS1_TnNSt9enable_ifIX7__and_vISt6__not_ISt7is_sameIS2_NSt9remove_cvINSt16remove_referenceIT_E4typeEE4typeEEES5_IS6_ISt10in_place_tSD_EESt16is_constructibleIS1_JS9_EESt14is_convertibleIS9_S1_EEEbE4typeELb1EEEOS9_(
&v35,
&v12);
}
else
{
std::optional<NodeIfPred *>::optional(&v35);
}
}
return v35;
}
| parse_if_pred:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x200
MOV qword ptr [RBP + -0x18],RDI
MOV RSI,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x1e0],RSI
LEA RDI,[RBP + -0x50]
MOV EDX,0xf
CALL 0x0010a580
LEA RDI,[RBP + -0x50]
CALL 0x0010a710
MOV byte ptr [RBP + -0x1d1],AL
LEA RDI,[RBP + -0x50]
CALL 0x00107bd0
MOV AL,byte ptr [RBP + -0x1d1]
TEST AL,0x1
JNZ 0x0010a80f
JMP 0x0010aaa8
LAB_0010a80f:
MOV RSI,qword ptr [RBP + -0x1e0]
LEA RDI,[RBP + -0x80]
MOV EDX,0x3
CALL 0x00109f20
LEA RDI,[RBP + -0x80]
CALL 0x001059c0
MOV RDI,qword ptr [RBP + -0x1e0]
ADD RDI,0x20
CALL 0x0010f1b0
MOV RDI,qword ptr [RBP + -0x1e0]
MOV qword ptr [RBP + -0x88],RAX
XOR ESI,ESI
CALL 0x001098e0
MOV qword ptr [RBP + -0x98],RAX
MOV byte ptr [RBP + -0x90],DL
LEA RDI,[RBP + -0x98]
CALL 0x00109ec0
TEST AL,0x1
JNZ 0x0010a871
JMP 0x0010a88f
LAB_0010a871:
LEA RDI,[RBP + -0x98]
CALL 0x00109ee0
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RAX],RCX
JMP 0x0010a930
LAB_0010a88f:
LEA RDI,[RBP + -0xb9]
MOV qword ptr [RBP + -0x1e8],RDI
CALL 0x001032e0
MOV RDX,qword ptr [RBP + -0x1e8]
LAB_0010a8a9:
LEA RSI,[0x1171ec]
LEA RDI,[RBP + -0xb8]
CALL 0x001090b0
JMP 0x0010a8be
LAB_0010a8be:
MOV RDI,qword ptr [RBP + -0x1e0]
LEA RSI,[RBP + -0xb8]
CALL 0x00108fe0
LAB_0010a8d1:
JMP 0x0010a8d3
LAB_0010a8d3:
LEA RDI,[RBP + -0xb8]
CALL 0x00103bd0
LEA RDI,[RBP + -0xb9]
CALL 0x00103220
JMP 0x0010a930
LAB_0010a930:
MOV RSI,qword ptr [RBP + -0x1e0]
LEA RDI,[RBP + -0x100]
MOV EDX,0x4
CALL 0x00109f20
LEA RDI,[RBP + -0x100]
CALL 0x001059c0
MOV RDI,qword ptr [RBP + -0x1e0]
CALL 0x0010a3e0
MOV qword ptr [RBP + -0x110],RAX
MOV byte ptr [RBP + -0x108],DL
LEA RDI,[RBP + -0x110]
CALL 0x0010a4e0
TEST AL,0x1
JNZ 0x0010a97f
JMP 0x0010a99e
LAB_0010a97f:
LEA RDI,[RBP + -0x110]
CALL 0x0010a780
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x0010aa3f
LAB_0010a99e:
LEA RDI,[RBP + -0x131]
MOV qword ptr [RBP + -0x1f0],RDI
CALL 0x001032e0
MOV RDX,qword ptr [RBP + -0x1f0]
LAB_0010a9b8:
LEA RSI,[0x1171f7]
LEA RDI,[RBP + -0x130]
CALL 0x001090b0
JMP 0x0010a9cd
LAB_0010a9cd:
MOV RDI,qword ptr [RBP + -0x1e0]
LEA RSI,[RBP + -0x130]
CALL 0x00108fe0
LAB_0010a9e0:
JMP 0x0010a9e2
LAB_0010a9e2:
LEA RDI,[RBP + -0x130]
CALL 0x00103bd0
LEA RDI,[RBP + -0x131]
CALL 0x00103220
JMP 0x0010aa3f
LAB_0010aa3f:
MOV RDI,qword ptr [RBP + -0x1e0]
CALL 0x0010a7c0
MOV RDI,qword ptr [RBP + -0x1e0]
MOV qword ptr [RBP + -0x148],RAX
MOV byte ptr [RBP + -0x140],DL
MOV RAX,qword ptr [RBP + -0x88]
MOV RCX,qword ptr [RBP + -0x148]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RBP + -0x140]
MOV qword ptr [RAX + 0x18],RCX
ADD RDI,0x20
LEA RSI,[RBP + -0x88]
CALL 0x0010f250
MOV qword ptr [RBP + -0x150],RAX
LEA RDI,[RBP + -0x10]
LEA RSI,[RBP + -0x150]
CALL 0x0010f290
JMP 0x0010ac24
LAB_0010aaa8:
MOV RSI,qword ptr [RBP + -0x1e0]
LEA RDI,[RBP + -0x188]
MOV EDX,0x10
CALL 0x0010a580
LEA RDI,[RBP + -0x188]
CALL 0x0010a710
MOV byte ptr [RBP + -0x1f1],AL
LEA RDI,[RBP + -0x188]
CALL 0x00107bd0
MOV AL,byte ptr [RBP + -0x1f1]
TEST AL,0x1
JNZ 0x0010aaed
JMP 0x0010ac1b
LAB_0010aaed:
MOV RDI,qword ptr [RBP + -0x1e0]
ADD RDI,0x20
CALL 0x0010f2c0
MOV RDI,qword ptr [RBP + -0x1e0]
MOV qword ptr [RBP + -0x190],RAX
CALL 0x0010a3e0
MOV qword ptr [RBP + -0x1a0],RAX
MOV byte ptr [RBP + -0x198],DL
LEA RDI,[RBP + -0x1a0]
CALL 0x0010a4e0
TEST AL,0x1
JNZ 0x0010ab2f
JMP 0x0010ab4d
LAB_0010ab2f:
LEA RDI,[RBP + -0x1a0]
CALL 0x0010a780
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x190]
MOV qword ptr [RAX],RCX
JMP 0x0010abeb
LAB_0010ab4d:
LEA RDI,[RBP + -0x1c1]
MOV qword ptr [RBP + -0x200],RDI
CALL 0x001032e0
MOV RDX,qword ptr [RBP + -0x200]
LAB_0010ab67:
LEA RSI,[0x1171f7]
LEA RDI,[RBP + -0x1c0]
CALL 0x001090b0
JMP 0x0010ab7c
LAB_0010ab7c:
MOV RDI,qword ptr [RBP + -0x1e0]
LEA RSI,[RBP + -0x1c0]
CALL 0x00108fe0
LAB_0010ab8f:
JMP 0x0010ab91
LAB_0010ab91:
LEA RDI,[RBP + -0x1c0]
CALL 0x00103bd0
LEA RDI,[RBP + -0x1c1]
CALL 0x00103220
JMP 0x0010abeb
LAB_0010abeb:
MOV RDI,qword ptr [RBP + -0x1e0]
ADD RDI,0x20
LEA RSI,[RBP + -0x190]
CALL 0x0010f360
MOV qword ptr [RBP + -0x1d0],RAX
LEA RDI,[RBP + -0x10]
LEA RSI,[RBP + -0x1d0]
CALL 0x0010f290
JMP 0x0010ac24
LAB_0010ac1b:
LEA RDI,[RBP + -0x10]
CALL 0x0010f0d0
LAB_0010ac24:
MOV RAX,qword ptr [RBP + -0x10]
MOV DL,byte ptr [RBP + -0x8]
ADD RSP,0x200
POP RBP
RET
|
/* Parser::parse_if_pred() */
int1 [16] __thiscall Parser::parse_if_pred(Parser *this)
{
bool bVar1;
int8 *puVar2;
int1 extraout_DL;
int1 extraout_DL_00;
int1 extraout_DL_01;
int1 extraout_DL_02;
int8 extraout_RDX;
int8 extraout_RDX_00;
int8 extraout_RDX_01;
int8 uVar3;
int1 auVar4 [16];
NodeIfPred *local_1d8;
allocator local_1c9;
string local_1c8 [32];
int8 local_1a8;
int1 local_1a0;
NodeIfPredElse *local_198;
optional local_190 [56];
NodeIfPred *local_158;
int8 local_150;
int1 local_148;
int7 uStack_147;
allocator local_139;
string local_138 [32];
int8 local_118;
int1 local_110;
Token local_108 [71];
allocator local_c1;
string local_c0 [32];
int8 local_a0;
int1 local_98;
NodeIfPredElif *local_90;
Token local_88 [48];
optional local_58 [56];
Parser *local_20;
int8 local_18;
int1 local_10;
local_20 = this;
try_consume(local_58,this,0xf);
bVar1 = std::optional::operator_cast_to_bool(local_58);
std::optional<Token>::~optional((optional<Token> *)local_58);
if (bVar1) {
try_consume_err(local_88,this,3);
Token::~Token(local_88);
local_90 = ArenaAllocator::alloc<NodeIfPredElif>((ArenaAllocator *)(this + 0x20));
local_a0 = parse_expr(this,0);
local_98 = extraout_DL;
bVar1 = std::optional::operator_cast_to_bool((optional *)&local_a0);
if (bVar1) {
puVar2 = (int8 *)std::optional<NodeExpr*>::value((optional<NodeExpr*> *)&local_a0);
*(int8 *)local_90 = *puVar2;
}
else {
std::allocator<char>::allocator();
/* try { // try from 0010a8a9 to 0010a8bb has its CatchHandler @ 0010a8ed */
std::__cxx11::string::string<std::allocator<char>>(local_c0,"expression",&local_c1);
/* try { // try from 0010a8be to 0010a8d0 has its CatchHandler @ 0010a901 */
error_expected(this,local_c0);
std::__cxx11::string::~string(local_c0);
std::allocator<char>::~allocator((allocator<char> *)&local_c1);
}
try_consume_err(local_108,this,4);
Token::~Token(local_108);
local_118 = parse_scope(this);
local_110 = extraout_DL_00;
bVar1 = std::optional::operator_cast_to_bool((optional *)&local_118);
if (bVar1) {
puVar2 = (int8 *)std::optional<NodeScope*>::value((optional<NodeScope*> *)&local_118);
*(int8 *)(local_90 + 8) = *puVar2;
}
else {
std::allocator<char>::allocator();
/* try { // try from 0010a9b8 to 0010a9ca has its CatchHandler @ 0010a9fc */
std::__cxx11::string::string<std::allocator<char>>(local_138,"scope",&local_139);
/* try { // try from 0010a9cd to 0010a9df has its CatchHandler @ 0010aa10 */
error_expected(this,local_138);
std::__cxx11::string::~string(local_138);
std::allocator<char>::~allocator((allocator<char> *)&local_139);
}
local_150 = parse_if_pred(this);
*(int8 *)(local_90 + 0x10) = local_150;
*(ulong *)(local_90 + 0x18) = CONCAT71(uStack_147,extraout_DL_01);
local_148 = extraout_DL_01;
local_158 = ArenaAllocator::emplace<NodeIfPred,NodeIfPredElif*const&>
((ArenaAllocator *)(this + 0x20),&local_90);
_ZNSt8optionalIP10NodeIfPredEC2IS1_TnNSt9enable_ifIX7__and_vISt6__not_ISt7is_sameIS2_NSt9remove_cvINSt16remove_referenceIT_E4typeEE4typeEEES5_IS6_ISt10in_place_tSD_EESt16is_constructibleIS1_JS9_EESt14is_convertibleIS9_S1_EEEbE4typeELb1EEEOS9_
(&local_18,&local_158);
uVar3 = extraout_RDX;
}
else {
try_consume(local_190,this,0x10);
bVar1 = std::optional::operator_cast_to_bool(local_190);
std::optional<Token>::~optional((optional<Token> *)local_190);
if (bVar1) {
local_198 = ArenaAllocator::alloc<NodeIfPredElse>((ArenaAllocator *)(this + 0x20));
local_1a8 = parse_scope(this);
local_1a0 = extraout_DL_02;
bVar1 = std::optional::operator_cast_to_bool((optional *)&local_1a8);
if (bVar1) {
puVar2 = (int8 *)std::optional<NodeScope*>::value((optional<NodeScope*> *)&local_1a8);
*(int8 *)local_198 = *puVar2;
}
else {
std::allocator<char>::allocator();
/* try { // try from 0010ab67 to 0010ab79 has its CatchHandler @ 0010abab */
std::__cxx11::string::string<std::allocator<char>>(local_1c8,"scope",&local_1c9);
/* try { // try from 0010ab7c to 0010ab8e has its CatchHandler @ 0010abbf */
error_expected(this,local_1c8);
std::__cxx11::string::~string(local_1c8);
std::allocator<char>::~allocator((allocator<char> *)&local_1c9);
}
local_1d8 = ArenaAllocator::emplace<NodeIfPred,NodeIfPredElse*&>
((ArenaAllocator *)(this + 0x20),&local_198);
_ZNSt8optionalIP10NodeIfPredEC2IS1_TnNSt9enable_ifIX7__and_vISt6__not_ISt7is_sameIS2_NSt9remove_cvINSt16remove_referenceIT_E4typeEE4typeEEES5_IS6_ISt10in_place_tSD_EESt16is_constructibleIS1_JS9_EESt14is_convertibleIS9_S1_EEEbE4typeELb1EEEOS9_
(&local_18,&local_1d8);
uVar3 = extraout_RDX_00;
}
else {
std::optional<NodeIfPred*>::optional((optional<NodeIfPred*> *)&local_18);
uVar3 = extraout_RDX_01;
}
}
auVar4._9_7_ = (int7)((ulong)uVar3 >> 8);
auVar4[8] = local_10;
auVar4._0_8_ = local_18;
return auVar4;
}
| |
26,425 | Parser::parse_if_pred() | BhuvanGudi[P]LexiParse/src/parser.hpp | std::optional<NodeIfPred*> parse_if_pred() // NOLINT(*-no-recursion)
{
if (try_consume(TokenType::elif)) {
try_consume_err(TokenType::open_paren);
const auto elif = m_allocator.alloc<NodeIfPredElif>();
if (const auto expr = parse_expr()) {
elif->expr = expr.value();
}
else {
error_expected("expression");
}
try_consume_err(TokenType::close_paren);
if (const auto scope = parse_scope()) {
elif->scope = scope.value();
}
else {
error_expected("scope");
}
elif->pred = parse_if_pred();
auto pred = m_allocator.emplace<NodeIfPred>(elif);
return pred;
}
if (try_consume(TokenType::else_)) {
auto else_ = m_allocator.alloc<NodeIfPredElse>();
if (const auto scope = parse_scope()) {
else_->scope = scope.value();
}
else {
error_expected("scope");
}
auto pred = m_allocator.emplace<NodeIfPred>(else_);
return pred;
}
return {};
} | O2 | cpp | Parser::parse_if_pred():
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
pushq $0xf
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4a84
movb 0x30(%r14), %bpl
movq %r14, %rdi
callq 0x4492
cmpb $0x1, %bpl
jne 0x4bd9
leaq 0x78(%rsp), %rdi
pushq $0x3
popq %rdx
movq %rbx, %rsi
callq 0x47d0
leaq 0x80(%rsp), %rdi
callq 0x3954
leaq 0x20(%rbx), %r14
movq %r14, %rdi
callq 0x59a6
movq %rax, %r15
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44e4
testb $0x1, %dl
je 0x4c2f
movq %rax, (%r15)
jmp 0x4c5c
leaq 0x10(%rsp), %r14
pushq $0x10
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4a84
movb 0x30(%r14), %bpl
movq %r14, %rdi
callq 0x4492
cmpb $0x1, %bpl
jne 0x4c89
leaq 0x20(%rbx), %r14
movq %r14, %rdi
callq 0x5a20
movq %rax, %r15
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
callq 0x49de
testb $0x1, %dl
je 0x4cdc
movq %rax, (%r15)
jmp 0x4d09
leaq 0x35b6(%rip), %rsi # 0x81ec
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x43bc
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x4322
leaq 0x10(%rsp), %rdi
callq 0x27ea
leaq 0x48(%rsp), %rdi
pushq $0x4
popq %rdx
movq %rbx, %rsi
callq 0x47d0
leaq 0x50(%rsp), %rdi
callq 0x3954
movq %rbx, %rdi
callq 0x49de
testb $0x1, %dl
je 0x4c90
movq %rax, 0x8(%r15)
jmp 0x4cbd
xorl %edx, %edx
jmp 0x4d18
leaq 0x3560(%rip), %rsi # 0x81f7
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x43bc
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x4322
leaq 0x10(%rsp), %rdi
callq 0x27ea
movq %rbx, %rdi
callq 0x4b5c
movq %rax, 0x10(%r15)
movb %dl, 0x18(%r15)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5a0a
jmp 0x4d16
leaq 0x3514(%rip), %rsi # 0x81f7
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x43bc
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x4322
leaq 0x10(%rsp), %rdi
callq 0x27ea
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5a84
movb $0x1, %dl
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4d2e
jmp 0x4d3d
jmp 0x4d2e
jmp 0x4d3d
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x27ea
jmp 0x4d40
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2270
| _ZN6Parser13parse_if_predEv:
push rbp
push r15
push r14
push rbx
sub rsp, 0A8h
mov rbx, rdi
lea r14, [rsp+0C8h+var_B8]
push 0Fh
pop rdx
mov rdi, r14
mov rsi, rbx
call _ZN6Parser11try_consumeE9TokenType; Parser::try_consume(TokenType)
mov bpl, [r14+30h]
mov rdi, r14
call _ZNSt22_Optional_payload_baseI5TokenE8_M_resetEv; std::_Optional_payload_base<Token>::_M_reset(void)
cmp bpl, 1
jnz short loc_4BD9
lea rdi, [rsp+0C8h+var_50]; this
push 3
pop rdx
mov rsi, rbx; int
call _ZN6Parser15try_consume_errE9TokenType; Parser::try_consume_err(TokenType)
lea rdi, [rsp+0C8h+var_48]
call _ZNSt22_Optional_payload_baseINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE8_M_resetEv; std::_Optional_payload_base<std::string>::_M_reset(void)
lea r14, [rbx+20h]
mov rdi, r14
call _ZN14ArenaAllocator5allocI14NodeIfPredElifEEPT_v; ArenaAllocator::alloc<NodeIfPredElif>(void)
mov r15, rax
mov [rsp+0C8h+var_C0], rax
mov rdi, rbx; this
xor esi, esi; int
call _ZN6Parser10parse_exprEi; Parser::parse_expr(int)
test dl, 1
jz short loc_4C2F
mov [r15], rax
jmp loc_4C5C
loc_4BD9:
lea r14, [rsp+0C8h+var_B8]
push 10h
pop rdx
mov rdi, r14
mov rsi, rbx
call _ZN6Parser11try_consumeE9TokenType; Parser::try_consume(TokenType)
mov bpl, [r14+30h]
mov rdi, r14
call _ZNSt22_Optional_payload_baseI5TokenE8_M_resetEv; std::_Optional_payload_base<Token>::_M_reset(void)
cmp bpl, 1
jnz loc_4C89
lea r14, [rbx+20h]
mov rdi, r14
call _ZN14ArenaAllocator5allocI14NodeIfPredElseEEPT_v; ArenaAllocator::alloc<NodeIfPredElse>(void)
mov r15, rax
mov [rsp+0C8h+var_C0], rax
mov rdi, rbx; this
call _ZN6Parser11parse_scopeEv; Parser::parse_scope(void)
test dl, 1
jz loc_4CDC
mov [r15], rax
jmp loc_4D09
loc_4C2F:
lea rsi, aExpression; "expression"
lea rdi, [rsp+0C8h+var_B8]
lea rdx, [rsp+0C8h+var_C1]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rsi, [rsp+0C8h+var_B8]
mov rdi, rbx; int
call _ZNK6Parser14error_expectedERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; Parser::error_expected(std::string const&)
lea rdi, [rsp+0C8h+var_B8]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_4C5C:
lea rdi, [rsp+0C8h+var_80]; this
push 4
pop rdx
mov rsi, rbx; int
call _ZN6Parser15try_consume_errE9TokenType; Parser::try_consume_err(TokenType)
lea rdi, [rsp+0C8h+var_78]
call _ZNSt22_Optional_payload_baseINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE8_M_resetEv; std::_Optional_payload_base<std::string>::_M_reset(void)
mov rdi, rbx; this
call _ZN6Parser11parse_scopeEv; Parser::parse_scope(void)
test dl, 1
jz short loc_4C90
mov [r15+8], rax
jmp short loc_4CBD
loc_4C89:
xor edx, edx
jmp loc_4D18
loc_4C90:
lea rsi, aScope; "scope"
lea rdi, [rsp+0C8h+var_B8]
lea rdx, [rsp+0C8h+var_C1]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rsi, [rsp+0C8h+var_B8]
mov rdi, rbx; int
call _ZNK6Parser14error_expectedERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; Parser::error_expected(std::string const&)
lea rdi, [rsp+0C8h+var_B8]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_4CBD:
mov rdi, rbx; this
call _ZN6Parser13parse_if_predEv; Parser::parse_if_pred(void)
mov [r15+10h], rax
mov [r15+18h], dl
lea rsi, [rsp+0C8h+var_C0]
mov rdi, r14
call _ZN14ArenaAllocator7emplaceI10NodeIfPredJRKP14NodeIfPredElifEEEPT_DpOT0_; ArenaAllocator::emplace<NodeIfPred,NodeIfPredElif * const&>(NodeIfPredElif * const&)
jmp short loc_4D16
loc_4CDC:
lea rsi, aScope; "scope"
lea rdi, [rsp+0C8h+var_B8]
lea rdx, [rsp+0C8h+var_C1]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rsi, [rsp+0C8h+var_B8]
mov rdi, rbx; int
call _ZNK6Parser14error_expectedERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; Parser::error_expected(std::string const&)
lea rdi, [rsp+0C8h+var_B8]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_4D09:
lea rsi, [rsp+0C8h+var_C0]
mov rdi, r14
call _ZN14ArenaAllocator7emplaceI10NodeIfPredJRP14NodeIfPredElseEEEPT_DpOT0_; ArenaAllocator::emplace<NodeIfPred,NodeIfPredElse *&>(NodeIfPredElse *&)
loc_4D16:
mov dl, 1
loc_4D18:
add rsp, 0A8h
pop rbx
pop r14
pop r15
pop rbp
retn
jmp short loc_4D2E
jmp short loc_4D3D
jmp short loc_4D2E
jmp short loc_4D3D
loc_4D2E:
mov rbx, rax
lea rdi, [rsp+arg_8]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_4D40
loc_4D3D:
mov rbx, rax
loc_4D40:
mov rdi, rbx
call __Unwind_Resume
| long long Parser::parse_if_pred(Parser *this)
{
char v1; // bp
long long v2; // r15
long long v3; // rax
char v4; // dl
char v5; // bp
long long result; // rax
long long ***v7; // r15
long long **v8; // rax
char v9; // dl
long long v10; // rdx
long long **v11; // rax
char v12; // dl
long long v13; // rdx
char v14; // dl
long long v15; // rdx
long long ***v16; // [rsp+8h] [rbp-C0h] BYREF
_QWORD v17[6]; // [rsp+10h] [rbp-B8h] BYREF
char v18; // [rsp+40h] [rbp-88h]
_BYTE v19[8]; // [rsp+48h] [rbp-80h] BYREF
_BYTE v20[40]; // [rsp+50h] [rbp-78h] BYREF
_BYTE v21[8]; // [rsp+78h] [rbp-50h] BYREF
_BYTE v22[72]; // [rsp+80h] [rbp-48h] BYREF
Parser::try_consume((long long)v17, this, 15);
v1 = v18;
std::_Optional_payload_base<Token>::_M_reset((long long)v17);
if ( v1 == 1 )
{
Parser::try_consume_err((Parser *)v21, this, 3u);
std::_Optional_payload_base<std::string>::_M_reset((long long)v22);
v2 = ArenaAllocator::alloc<NodeIfPredElif>((char *)this + 32);
v16 = (long long ***)v2;
v3 = Parser::parse_expr(this, 0);
if ( (v4 & 1) == 0 )
{
std::string::basic_string<std::allocator<char>>(v17, (long long)"expression");
Parser::error_expected(this, (long long)v17, v10);
}
*(_QWORD *)v2 = v3;
Parser::try_consume_err((Parser *)v19, this, 4u);
std::_Optional_payload_base<std::string>::_M_reset((long long)v20);
v11 = Parser::parse_scope(this);
if ( (v12 & 1) == 0 )
{
std::string::basic_string<std::allocator<char>>(v17, (long long)"scope");
Parser::error_expected(this, (long long)v17, v13);
}
*(_QWORD *)(v2 + 8) = v11;
*(_QWORD *)(v2 + 16) = Parser::parse_if_pred(this);
*(_BYTE *)(v2 + 24) = v14;
return ArenaAllocator::emplace<NodeIfPred,NodeIfPredElif * const&>((char *)this + 32, &v16);
}
else
{
Parser::try_consume((long long)v17, this, 16);
v5 = v18;
result = std::_Optional_payload_base<Token>::_M_reset((long long)v17);
if ( v5 == 1 )
{
v7 = (long long ***)ArenaAllocator::alloc<NodeIfPredElse>((char *)this + 32);
v16 = v7;
v8 = Parser::parse_scope(this);
if ( (v9 & 1) == 0 )
{
std::string::basic_string<std::allocator<char>>(v17, (long long)"scope");
Parser::error_expected(this, (long long)v17, v15);
}
*v7 = v8;
return ArenaAllocator::emplace<NodeIfPred,NodeIfPredElse *&>((char *)this + 32, &v16);
}
}
return result;
}
| parse_if_pred:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0xa8
MOV RBX,RDI
LEA R14,[RSP + 0x10]
PUSH 0xf
POP RDX
MOV RDI,R14
MOV RSI,RBX
CALL 0x00104a84
MOV BPL,byte ptr [R14 + 0x30]
MOV RDI,R14
CALL 0x00104492
CMP BPL,0x1
JNZ 0x00104bd9
LEA RDI,[RSP + 0x78]
PUSH 0x3
POP RDX
MOV RSI,RBX
CALL 0x001047d0
LEA RDI,[RSP + 0x80]
CALL 0x00103954
LEA R14,[RBX + 0x20]
MOV RDI,R14
CALL 0x001059a6
MOV R15,RAX
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,RBX
XOR ESI,ESI
CALL 0x001044e4
TEST DL,0x1
JZ 0x00104c2f
MOV qword ptr [R15],RAX
JMP 0x00104c5c
LAB_00104bd9:
LEA R14,[RSP + 0x10]
PUSH 0x10
POP RDX
MOV RDI,R14
MOV RSI,RBX
CALL 0x00104a84
MOV BPL,byte ptr [R14 + 0x30]
MOV RDI,R14
CALL 0x00104492
CMP BPL,0x1
JNZ 0x00104c89
LEA R14,[RBX + 0x20]
MOV RDI,R14
CALL 0x00105a20
MOV R15,RAX
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,RBX
CALL 0x001049de
TEST DL,0x1
JZ 0x00104cdc
MOV qword ptr [R15],RAX
JMP 0x00104d09
LAB_00104c2f:
LEA RSI,[0x1081ec]
LEA RDI,[RSP + 0x10]
LEA RDX,[RSP + 0x7]
CALL 0x001043bc
LAB_00104c45:
LEA RSI,[RSP + 0x10]
MOV RDI,RBX
CALL 0x00104322
LAB_00104c52:
LEA RDI,[RSP + 0x10]
CALL 0x001027ea
LAB_00104c5c:
LEA RDI,[RSP + 0x48]
PUSH 0x4
POP RDX
MOV RSI,RBX
CALL 0x001047d0
LEA RDI,[RSP + 0x50]
CALL 0x00103954
MOV RDI,RBX
CALL 0x001049de
TEST DL,0x1
JZ 0x00104c90
MOV qword ptr [R15 + 0x8],RAX
JMP 0x00104cbd
LAB_00104c89:
XOR EDX,EDX
JMP 0x00104d18
LAB_00104c90:
LEA RSI,[0x1081f7]
LEA RDI,[RSP + 0x10]
LEA RDX,[RSP + 0x7]
CALL 0x001043bc
LAB_00104ca6:
LEA RSI,[RSP + 0x10]
MOV RDI,RBX
CALL 0x00104322
LAB_00104cb3:
LEA RDI,[RSP + 0x10]
CALL 0x001027ea
LAB_00104cbd:
MOV RDI,RBX
CALL 0x00104b5c
MOV qword ptr [R15 + 0x10],RAX
MOV byte ptr [R15 + 0x18],DL
LEA RSI,[RSP + 0x8]
MOV RDI,R14
CALL 0x00105a0a
JMP 0x00104d16
LAB_00104cdc:
LEA RSI,[0x1081f7]
LEA RDI,[RSP + 0x10]
LEA RDX,[RSP + 0x7]
CALL 0x001043bc
LAB_00104cf2:
LEA RSI,[RSP + 0x10]
MOV RDI,RBX
CALL 0x00104322
LAB_00104cff:
LEA RDI,[RSP + 0x10]
CALL 0x001027ea
LAB_00104d09:
LEA RSI,[RSP + 0x8]
MOV RDI,R14
CALL 0x00105a84
LAB_00104d16:
MOV DL,0x1
LAB_00104d18:
ADD RSP,0xa8
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* Parser::parse_if_pred() */
void __thiscall Parser::parse_if_pred(Parser *this)
{
char cVar1;
NodeIfPredElif *pNVar2;
NodeIfPredElse *pNVar3;
int8 uVar4;
NodeIfPredElif extraout_DL;
int1 auVar5 [16];
allocator local_c1;
NodeIfPredElif *local_c0;
_Optional_payload_base<Token> local_b8 [48];
char local_88;
int1 local_80 [8];
_Optional_payload_base<std::__cxx11::string> local_78 [40];
int1 local_50 [8];
_Optional_payload_base<std::__cxx11::string> local_48 [40];
try_consume(local_b8,this,0xf);
cVar1 = local_88;
std::_Optional_payload_base<Token>::_M_reset(local_b8);
if (cVar1 == '\x01') {
try_consume_err(local_50,this,3);
std::_Optional_payload_base<std::__cxx11::string>::_M_reset(local_48);
pNVar2 = ArenaAllocator::alloc<NodeIfPredElif>((ArenaAllocator *)(this + 0x20));
local_c0 = pNVar2;
auVar5 = parse_expr(this,0);
if ((auVar5 & (int1 [16])0x1) == (int1 [16])0x0) {
/* try { // try from 00104c2f to 00104c44 has its CatchHandler @ 00104d3d */
std::__cxx11::string::string<std::allocator<char>>((string *)local_b8,"expression",&local_c1);
/* try { // try from 00104c45 to 00104c51 has its CatchHandler @ 00104d2e */
error_expected(this,(string *)local_b8);
std::__cxx11::string::~string((string *)local_b8);
}
else {
*(long *)pNVar2 = auVar5._0_8_;
}
try_consume_err(local_80,this,4);
std::_Optional_payload_base<std::__cxx11::string>::_M_reset(local_78);
auVar5 = parse_scope(this);
if ((auVar5 & (int1 [16])0x1) == (int1 [16])0x0) {
/* try { // try from 00104c90 to 00104ca5 has its CatchHandler @ 00104d2c */
std::__cxx11::string::string<std::allocator<char>>((string *)local_b8,"scope",&local_c1);
/* try { // try from 00104ca6 to 00104cb2 has its CatchHandler @ 00104d2a */
error_expected(this,(string *)local_b8);
std::__cxx11::string::~string((string *)local_b8);
}
else {
*(long *)(pNVar2 + 8) = auVar5._0_8_;
}
uVar4 = parse_if_pred(this);
*(int8 *)(pNVar2 + 0x10) = uVar4;
pNVar2[0x18] = extraout_DL;
ArenaAllocator::emplace<NodeIfPred,NodeIfPredElif*const&>
((ArenaAllocator *)(this + 0x20),&local_c0);
}
else {
try_consume(local_b8,this,0x10);
std::_Optional_payload_base<Token>::_M_reset(local_b8);
if (local_88 == '\x01') {
pNVar3 = ArenaAllocator::alloc<NodeIfPredElse>((ArenaAllocator *)(this + 0x20));
local_c0 = (NodeIfPredElif *)pNVar3;
auVar5 = parse_scope(this);
if ((auVar5 & (int1 [16])0x1) == (int1 [16])0x0) {
/* try { // try from 00104cdc to 00104cf1 has its CatchHandler @ 00104d28 */
std::__cxx11::string::string<std::allocator<char>>((string *)local_b8,"scope",&local_c1);
/* try { // try from 00104cf2 to 00104cfe has its CatchHandler @ 00104d26 */
error_expected(this,(string *)local_b8);
std::__cxx11::string::~string((string *)local_b8);
}
else {
*(long *)pNVar3 = auVar5._0_8_;
}
ArenaAllocator::emplace<NodeIfPred,NodeIfPredElse*&>
((ArenaAllocator *)(this + 0x20),(NodeIfPredElse **)&local_c0);
}
}
return;
}
| |
26,426 | Parser::parse_if_pred() | BhuvanGudi[P]LexiParse/src/parser.hpp | std::optional<NodeIfPred*> parse_if_pred() // NOLINT(*-no-recursion)
{
if (try_consume(TokenType::elif)) {
try_consume_err(TokenType::open_paren);
const auto elif = m_allocator.alloc<NodeIfPredElif>();
if (const auto expr = parse_expr()) {
elif->expr = expr.value();
}
else {
error_expected("expression");
}
try_consume_err(TokenType::close_paren);
if (const auto scope = parse_scope()) {
elif->scope = scope.value();
}
else {
error_expected("scope");
}
elif->pred = parse_if_pred();
auto pred = m_allocator.emplace<NodeIfPred>(elif);
return pred;
}
if (try_consume(TokenType::else_)) {
auto else_ = m_allocator.alloc<NodeIfPredElse>();
if (const auto scope = parse_scope()) {
else_->scope = scope.value();
}
else {
error_expected("scope");
}
auto pred = m_allocator.emplace<NodeIfPred>(else_);
return pred;
}
return {};
} | O3 | cpp | Parser::parse_if_pred():
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0xf, %edx
callq 0x576a
cmpb $0x1, 0x30(%r14)
jne 0x5a0d
movb $0x0, 0x30(%rsp)
cmpb $0x1, 0x28(%rsp)
jne 0x59a6
leaq 0x18(%rsp), %rax
movb $0x0, 0x10(%rax)
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x59a6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
leaq 0x68(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x3, %edx
callq 0x538e
cmpb $0x1, 0x28(%r14)
jne 0x59e7
leaq 0x80(%rsp), %rax
movb $0x0, 0x10(%rax)
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x59e7
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x2200
leaq 0x20(%rbx), %r14
movq %r14, %rdi
callq 0x6ad6
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4f70
testb $0x1, %dl
je 0x5a7e
movq %rax, (%r15)
jmp 0x5abf
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x10, %edx
callq 0x576a
cmpb $0x1, 0x30(%r14)
jne 0x5b0e
movb $0x0, 0x30(%rsp)
cmpb $0x1, 0x28(%rsp)
jne 0x5a56
leaq 0x18(%rsp), %rax
movb $0x0, 0x10(%rax)
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5a56
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
leaq 0x20(%rbx), %r14
movq %r14, %rdi
callq 0x6b3c
movq %rax, %r15
movq %rbx, %rdi
callq 0x5658
testb $0x1, %dl
je 0x5b77
movq %rax, (%r15)
jmp 0x5bb8
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x37a9(%rip), %rsi # 0x9238
leaq 0x37ac(%rip), %rdx # 0x9242
movq %rsp, %rdi
callq 0x6d44
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x4d7e
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x5abf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2200
leaq 0x38(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movl $0x4, %edx
callq 0x538e
cmpb $0x1, 0x28(%r12)
jne 0x5afb
leaq 0x50(%rsp), %rax
movb $0x0, 0x10(%rax)
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5afb
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x5658
testb $0x1, %dl
je 0x5b15
movq %rax, 0x8(%r15)
jmp 0x5b56
xorl %edx, %edx
jmp 0x5bc9
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x371d(%rip), %rsi # 0x9243
leaq 0x371b(%rip), %rdx # 0x9248
movq %rsp, %rdi
callq 0x6d44
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x4d7e
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x5b56
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x594c
movq %rax, 0x10(%r15)
movb %dl, 0x18(%r15)
movq %r14, %rdi
callq 0x6ba2
movq %r15, (%rax)
movb $0x0, 0x8(%rax)
jmp 0x5bc7
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x36bb(%rip), %rsi # 0x9243
leaq 0x36b9(%rip), %rdx # 0x9248
movq %rsp, %rdi
callq 0x6d44
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x4d7e
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x5bb8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2200
movq %r14, %rdi
callq 0x6ba2
movq %r15, (%rax)
movb $0x1, 0x8(%rax)
movb $0x1, %dl
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x5be0
jmp 0x5bfb
jmp 0x5be0
jmp 0x5bfb
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x5bfe
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0x5bfe
movq %rax, %rbx
movq %rbx, %rdi
callq 0x22d0
| _ZN6Parser13parse_if_predEv:
push r15
push r14
push r12
push rbx
sub rsp, 98h
mov rbx, rdi
mov r14, rsp
mov rdi, r14
mov rsi, rbx
mov edx, 0Fh
call _ZN6Parser11try_consumeE9TokenType; Parser::try_consume(TokenType)
cmp byte ptr [r14+30h], 1
jnz loc_5A0D
mov [rsp+0B8h+var_88], 0
cmp [rsp+0B8h+var_90], 1
jnz short loc_59A6
lea rax, [rsp+0B8h+var_A0]
mov byte ptr [rax+10h], 0
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_59A6
mov rsi, [rsp+0B8h+var_A0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_59A6:
lea r14, [rsp+0B8h+var_50]
mov rdi, r14; this
mov rsi, rbx
mov edx, 3
call _ZN6Parser15try_consume_errE9TokenType; Parser::try_consume_err(TokenType)
cmp byte ptr [r14+28h], 1
jnz short loc_59E7
lea rax, [rsp+0B8h+var_38]
mov byte ptr [rax+10h], 0
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_59E7
mov rsi, [rsp+0B8h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_59E7:
lea r14, [rbx+20h]
mov rdi, r14
call _ZN14ArenaAllocator5allocI14NodeIfPredElifEEPT_v; ArenaAllocator::alloc<NodeIfPredElif>(void)
mov r15, rax
mov rdi, rbx; this
xor esi, esi; int
call _ZN6Parser10parse_exprEi; Parser::parse_expr(int)
test dl, 1
jz short loc_5A7E
mov [r15], rax
jmp loc_5ABF
loc_5A0D:
mov r14, rsp
mov rdi, r14
mov rsi, rbx
mov edx, 10h
call _ZN6Parser11try_consumeE9TokenType; Parser::try_consume(TokenType)
cmp byte ptr [r14+30h], 1
jnz loc_5B0E
mov [rsp+0B8h+var_88], 0
cmp [rsp+0B8h+var_90], 1
jnz short loc_5A56
lea rax, [rsp+0B8h+var_A0]
mov byte ptr [rax+10h], 0
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_5A56
mov rsi, [rsp+0B8h+var_A0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5A56:
lea r14, [rbx+20h]
mov rdi, r14
call _ZN14ArenaAllocator5allocI14NodeIfPredElseEEPT_v; ArenaAllocator::alloc<NodeIfPredElse>(void)
mov r15, rax
mov rdi, rbx; this
call _ZN6Parser11parse_scopeEv; Parser::parse_scope(void)
test dl, 1
jz loc_5B77
mov [r15], rax
jmp loc_5BB8
loc_5A7E:
lea r12, [rsp+0B8h+var_A8]
mov [r12-10h], r12
lea rsi, aExpression; "expression"
lea rdx, aExpression+0Ah; ""
mov rdi, rsp
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rsi, rsp
mov rdi, rbx
call _ZNK6Parser14error_expectedERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; Parser::error_expected(std::string const&)
mov rdi, [rsp+0B8h+var_B8]; void *
cmp rdi, r12
jz short loc_5ABF
mov rsi, [rsp+0B8h+var_A8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5ABF:
lea r12, [rsp+0B8h+var_80]
mov rdi, r12; this
mov rsi, rbx
mov edx, 4
call _ZN6Parser15try_consume_errE9TokenType; Parser::try_consume_err(TokenType)
cmp byte ptr [r12+28h], 1
jnz short loc_5AFB
lea rax, [rsp+0B8h+var_68]
mov byte ptr [rax+10h], 0
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_5AFB
mov rsi, [rsp+0B8h+var_68]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5AFB:
mov rdi, rbx; this
call _ZN6Parser11parse_scopeEv; Parser::parse_scope(void)
test dl, 1
jz short loc_5B15
mov [r15+8], rax
jmp short loc_5B56
loc_5B0E:
xor edx, edx
jmp loc_5BC9
loc_5B15:
lea r12, [rsp+0B8h+var_A8]
mov [r12-10h], r12
lea rsi, aScope; "scope"
lea rdx, aScope+5; ""
mov rdi, rsp
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rsi, rsp
mov rdi, rbx
call _ZNK6Parser14error_expectedERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; Parser::error_expected(std::string const&)
mov rdi, [rsp+0B8h+var_B8]; void *
cmp rdi, r12
jz short loc_5B56
mov rsi, [rsp+0B8h+var_A8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5B56:
mov rdi, rbx; this
call _ZN6Parser13parse_if_predEv; Parser::parse_if_pred(void)
mov [r15+10h], rax
mov [r15+18h], dl
mov rdi, r14
call _ZN14ArenaAllocator5allocI10NodeIfPredEEPT_v; ArenaAllocator::alloc<NodeIfPred>(void)
mov [rax], r15
mov byte ptr [rax+8], 0
jmp short loc_5BC7
loc_5B77:
lea r12, [rsp+0B8h+var_A8]
mov [r12-10h], r12
lea rsi, aScope; "scope"
lea rdx, aScope+5; ""
mov rdi, rsp
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rsi, rsp
mov rdi, rbx
call _ZNK6Parser14error_expectedERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; Parser::error_expected(std::string const&)
mov rdi, [rsp+0B8h+var_B8]; void *
cmp rdi, r12
jz short loc_5BB8
mov rsi, [rsp+0B8h+var_A8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5BB8:
mov rdi, r14
call _ZN14ArenaAllocator5allocI10NodeIfPredEEPT_v; ArenaAllocator::alloc<NodeIfPred>(void)
mov [rax], r15
mov byte ptr [rax+8], 1
loc_5BC7:
mov dl, 1
loc_5BC9:
add rsp, 98h
pop rbx
pop r12
pop r14
pop r15
retn
jmp short loc_5BE0
jmp short loc_5BFB
jmp short loc_5BE0
jmp short loc_5BFB
loc_5BE0:
mov rbx, rax
mov rdi, [rsp+0]; void *
cmp rdi, r12
jz short loc_5BFE
mov rsi, [rsp+arg_8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_5BFE
loc_5BFB:
mov rbx, rax
loc_5BFE:
mov rdi, rbx
call __Unwind_Resume
| long long Parser::parse_if_pred(Parser *this)
{
long long v1; // r15
long long v2; // rax
char v3; // dl
long long result; // rax
long long **v5; // r15
long long *v6; // rax
char v7; // dl
long long *v8; // rax
char v9; // dl
char v10; // dl
void *v11; // [rsp+0h] [rbp-B8h] BYREF
_QWORD *v12; // [rsp+8h] [rbp-B0h]
long long v13; // [rsp+10h] [rbp-A8h] BYREF
_QWORD v14[2]; // [rsp+18h] [rbp-A0h] BYREF
char v15; // [rsp+28h] [rbp-90h]
char v16; // [rsp+30h] [rbp-88h]
_BYTE v17[8]; // [rsp+38h] [rbp-80h] BYREF
long long *v18; // [rsp+40h] [rbp-78h]
long long v19; // [rsp+50h] [rbp-68h] BYREF
char v20; // [rsp+60h] [rbp-58h]
_BYTE v21[8]; // [rsp+68h] [rbp-50h] BYREF
long long *v22; // [rsp+70h] [rbp-48h]
long long v23; // [rsp+80h] [rbp-38h] BYREF
char v24; // [rsp+90h] [rbp-28h]
Parser::try_consume((long long)&v11, (long long *)this, 15);
if ( v16 == 1 )
{
v16 = 0;
if ( v15 == 1 )
{
v15 = 0;
if ( v12 != v14 )
operator delete(v12, v14[0] + 1LL);
}
Parser::try_consume_err((Parser *)v21, (long long *)this, 3u);
if ( v24 == 1 )
{
v24 = 0;
if ( v22 != &v23 )
operator delete(v22, v23 + 1);
}
v1 = ArenaAllocator::alloc<NodeIfPredElif>((char *)this + 32);
v2 = Parser::parse_expr(this, 0);
if ( (v3 & 1) == 0 )
{
v11 = &v13;
std::string::_M_construct<char const*>(&v11, "expression", "");
Parser::error_expected(this, &v11);
}
*(_QWORD *)v1 = v2;
Parser::try_consume_err((Parser *)v17, (long long *)this, 4u);
if ( v20 == 1 )
{
v20 = 0;
if ( v18 != &v19 )
operator delete(v18, v19 + 1);
}
v8 = Parser::parse_scope(this);
if ( (v9 & 1) == 0 )
{
v11 = &v13;
std::string::_M_construct<char const*>(&v11, "scope", "");
Parser::error_expected(this, &v11);
}
*(_QWORD *)(v1 + 8) = v8;
*(_QWORD *)(v1 + 16) = Parser::parse_if_pred(this);
*(_BYTE *)(v1 + 24) = v10;
result = ArenaAllocator::alloc<NodeIfPred>((char *)this + 32);
*(_QWORD *)result = v1;
*(_BYTE *)(result + 8) = 0;
}
else
{
result = Parser::try_consume((long long)&v11, (long long *)this, 16);
if ( v16 == 1 )
{
v16 = 0;
if ( v15 == 1 )
{
v15 = 0;
if ( v12 != v14 )
operator delete(v12, v14[0] + 1LL);
}
v5 = (long long **)ArenaAllocator::alloc<NodeIfPredElse>((char *)this + 32);
v6 = Parser::parse_scope(this);
if ( (v7 & 1) == 0 )
{
v11 = &v13;
std::string::_M_construct<char const*>(&v11, "scope", "");
Parser::error_expected(this, &v11);
}
*v5 = v6;
result = ArenaAllocator::alloc<NodeIfPred>((char *)this + 32);
*(_QWORD *)result = v5;
*(_BYTE *)(result + 8) = 1;
}
}
return result;
}
| parse_if_pred:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x98
MOV RBX,RDI
MOV R14,RSP
MOV RDI,R14
MOV RSI,RBX
MOV EDX,0xf
CALL 0x0010576a
CMP byte ptr [R14 + 0x30],0x1
JNZ 0x00105a0d
MOV byte ptr [RSP + 0x30],0x0
CMP byte ptr [RSP + 0x28],0x1
JNZ 0x001059a6
LEA RAX,[RSP + 0x18]
MOV byte ptr [RAX + 0x10],0x0
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001059a6
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00102200
LAB_001059a6:
LEA R14,[RSP + 0x68]
MOV RDI,R14
MOV RSI,RBX
MOV EDX,0x3
CALL 0x0010538e
CMP byte ptr [R14 + 0x28],0x1
JNZ 0x001059e7
LEA RAX,[RSP + 0x80]
MOV byte ptr [RAX + 0x10],0x0
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001059e7
MOV RSI,qword ptr [RSP + 0x80]
INC RSI
CALL 0x00102200
LAB_001059e7:
LEA R14,[RBX + 0x20]
MOV RDI,R14
CALL 0x00106ad6
MOV R15,RAX
MOV RDI,RBX
XOR ESI,ESI
CALL 0x00104f70
TEST DL,0x1
JZ 0x00105a7e
MOV qword ptr [R15],RAX
JMP 0x00105abf
LAB_00105a0d:
MOV R14,RSP
MOV RDI,R14
MOV RSI,RBX
MOV EDX,0x10
CALL 0x0010576a
CMP byte ptr [R14 + 0x30],0x1
JNZ 0x00105b0e
MOV byte ptr [RSP + 0x30],0x0
CMP byte ptr [RSP + 0x28],0x1
JNZ 0x00105a56
LEA RAX,[RSP + 0x18]
MOV byte ptr [RAX + 0x10],0x0
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00105a56
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00102200
LAB_00105a56:
LEA R14,[RBX + 0x20]
MOV RDI,R14
CALL 0x00106b3c
MOV R15,RAX
MOV RDI,RBX
CALL 0x00105658
TEST DL,0x1
JZ 0x00105b77
MOV qword ptr [R15],RAX
JMP 0x00105bb8
LAB_00105a7e:
LEA R12,[RSP + 0x10]
MOV qword ptr [R12 + -0x10],R12
LAB_00105a88:
LEA RSI,[0x109238]
LEA RDX,[0x109242]
MOV RDI,RSP
CALL 0x00106d44
LAB_00105a9e:
MOV RSI,RSP
MOV RDI,RBX
CALL 0x00104d7e
LAB_00105aa9:
MOV RDI,qword ptr [RSP]
CMP RDI,R12
JZ 0x00105abf
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x00102200
LAB_00105abf:
LEA R12,[RSP + 0x38]
MOV RDI,R12
MOV RSI,RBX
MOV EDX,0x4
CALL 0x0010538e
CMP byte ptr [R12 + 0x28],0x1
JNZ 0x00105afb
LEA RAX,[RSP + 0x50]
MOV byte ptr [RAX + 0x10],0x0
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00105afb
MOV RSI,qword ptr [RSP + 0x50]
INC RSI
CALL 0x00102200
LAB_00105afb:
MOV RDI,RBX
CALL 0x00105658
TEST DL,0x1
JZ 0x00105b15
MOV qword ptr [R15 + 0x8],RAX
JMP 0x00105b56
LAB_00105b0e:
XOR EDX,EDX
JMP 0x00105bc9
LAB_00105b15:
LEA R12,[RSP + 0x10]
MOV qword ptr [R12 + -0x10],R12
LAB_00105b1f:
LEA RSI,[0x109243]
LEA RDX,[0x109248]
MOV RDI,RSP
CALL 0x00106d44
LAB_00105b35:
MOV RSI,RSP
MOV RDI,RBX
CALL 0x00104d7e
LAB_00105b40:
MOV RDI,qword ptr [RSP]
CMP RDI,R12
JZ 0x00105b56
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x00102200
LAB_00105b56:
MOV RDI,RBX
CALL 0x0010594c
MOV qword ptr [R15 + 0x10],RAX
MOV byte ptr [R15 + 0x18],DL
MOV RDI,R14
CALL 0x00106ba2
MOV qword ptr [RAX],R15
MOV byte ptr [RAX + 0x8],0x0
JMP 0x00105bc7
LAB_00105b77:
LEA R12,[RSP + 0x10]
MOV qword ptr [R12 + -0x10],R12
LAB_00105b81:
LEA RSI,[0x109243]
LEA RDX,[0x109248]
MOV RDI,RSP
CALL 0x00106d44
LAB_00105b97:
MOV RSI,RSP
MOV RDI,RBX
CALL 0x00104d7e
LAB_00105ba2:
MOV RDI,qword ptr [RSP]
CMP RDI,R12
JZ 0x00105bb8
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x00102200
LAB_00105bb8:
MOV RDI,R14
CALL 0x00106ba2
MOV qword ptr [RAX],R15
MOV byte ptr [RAX + 0x8],0x1
LAB_00105bc7:
MOV DL,0x1
LAB_00105bc9:
ADD RSP,0x98
POP RBX
POP R12
POP R14
POP R15
RET
|
/* Parser::parse_if_pred() */
void __thiscall Parser::parse_if_pred(Parser *this)
{
NodeIfPredElif *pNVar1;
NodeIfPredElse *pNVar2;
int8 uVar3;
NodeIfPred *pNVar4;
NodeIfPredElif extraout_DL;
int1 auVar5 [16];
long *local_b8;
long *local_b0;
long local_a8;
long local_a0 [2];
char local_90;
char local_88;
int1 local_80 [8];
long *local_78;
long local_68 [2];
char local_58;
int1 local_50 [8];
long *local_48;
long local_38 [2];
char local_28;
try_consume(&local_b8,this,0xf);
if (local_88 == '\x01') {
local_88 = 0;
if ((local_90 == '\x01') && (local_90 = '\0', local_b0 != local_a0)) {
operator_delete(local_b0,local_a0[0] + 1);
}
try_consume_err(local_50,this,3);
if ((local_28 == '\x01') && (local_28 = '\0', local_48 != local_38)) {
operator_delete(local_48,local_38[0] + 1);
}
pNVar1 = ArenaAllocator::alloc<NodeIfPredElif>((ArenaAllocator *)(this + 0x20));
auVar5 = parse_expr(this,0);
if ((auVar5 & (int1 [16])0x1) == (int1 [16])0x0) {
local_b8 = &local_a8;
/* try { // try from 00105a88 to 00105a9d has its CatchHandler @ 00105bfb */
std::__cxx11::string::_M_construct<char_const*>(&local_b8,"expression","");
/* try { // try from 00105a9e to 00105aa8 has its CatchHandler @ 00105be0 */
error_expected(this,(string *)&local_b8);
if (local_b8 != &local_a8) {
operator_delete(local_b8,local_a8 + 1);
}
}
else {
*(long *)pNVar1 = auVar5._0_8_;
}
try_consume_err(local_80,this,4);
if ((local_58 == '\x01') && (local_58 = '\0', local_78 != local_68)) {
operator_delete(local_78,local_68[0] + 1);
}
auVar5 = parse_scope(this);
if ((auVar5 & (int1 [16])0x1) == (int1 [16])0x0) {
local_b8 = &local_a8;
/* try { // try from 00105b1f to 00105b34 has its CatchHandler @ 00105bde */
std::__cxx11::string::_M_construct<char_const*>(&local_b8,"scope","");
/* try { // try from 00105b35 to 00105b3f has its CatchHandler @ 00105bdc */
error_expected(this,(string *)&local_b8);
if (local_b8 != &local_a8) {
operator_delete(local_b8,local_a8 + 1);
}
}
else {
*(long *)(pNVar1 + 8) = auVar5._0_8_;
}
uVar3 = parse_if_pred(this);
*(int8 *)(pNVar1 + 0x10) = uVar3;
pNVar1[0x18] = extraout_DL;
pNVar4 = ArenaAllocator::alloc<NodeIfPred>((ArenaAllocator *)(this + 0x20));
*(NodeIfPredElif **)pNVar4 = pNVar1;
pNVar4[8] = (NodeIfPred)0x0;
}
else {
try_consume(&local_b8,this,0x10);
if (local_88 == '\x01') {
local_88 = 0;
if ((local_90 == '\x01') && (local_90 = '\0', local_b0 != local_a0)) {
operator_delete(local_b0,local_a0[0] + 1);
}
pNVar2 = ArenaAllocator::alloc<NodeIfPredElse>((ArenaAllocator *)(this + 0x20));
auVar5 = parse_scope(this);
if ((auVar5 & (int1 [16])0x1) == (int1 [16])0x0) {
local_b8 = &local_a8;
/* try { // try from 00105b81 to 00105b96 has its CatchHandler @ 00105bda */
std::__cxx11::string::_M_construct<char_const*>(&local_b8,"scope","");
/* try { // try from 00105b97 to 00105ba1 has its CatchHandler @ 00105bd8 */
error_expected(this,(string *)&local_b8);
if (local_b8 != &local_a8) {
operator_delete(local_b8,local_a8 + 1);
}
}
else {
*(long *)pNVar2 = auVar5._0_8_;
}
pNVar4 = ArenaAllocator::alloc<NodeIfPred>((ArenaAllocator *)(this + 0x20));
*(NodeIfPredElse **)pNVar4 = pNVar2;
pNVar4[8] = (NodeIfPred)0x1;
}
}
return;
}
| |
26,427 | ggml_graph_compute_secondary_thread | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c | static thread_ret_t ggml_graph_compute_secondary_thread(void* data) {
struct ggml_compute_state * state = (struct ggml_compute_state *) data;
struct ggml_threadpool * threadpool = state->threadpool;
ggml_thread_apply_priority(threadpool->prio);
if (ggml_thread_cpumask_is_valid(state->cpumask)) {
ggml_thread_apply_affinity(state->cpumask);
}
while (true) {
// Check if we need to sleep
while (threadpool->pause) {
GGML_PRINT_DEBUG("thread #%d inside pause loop\n", state->ith);
ggml_mutex_lock_shared(&threadpool->mutex);
if (threadpool->pause) {
ggml_cond_wait(&threadpool->cond, &threadpool->mutex);
}
GGML_PRINT_DEBUG("thread #%d resuming after wait\n", state->ith);
ggml_mutex_unlock_shared(&threadpool->mutex);
}
// This needs to be checked for after the cond_wait
if (threadpool->stop) break;
// Check if there is new work
// The main thread is the only one that can dispatch new work
ggml_graph_compute_check_for_work(state);
if (state->pending) {
state->pending = false;
ggml_graph_compute_thread(state);
}
}
return (thread_ret_t) 0;
} | O1 | c | ggml_graph_compute_secondary_thread:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x210(%rdi), %r14
movl 0xe0(%r14), %edi
callq 0x21733
cmpb $0x0, 0x8(%rbx)
jne 0x2158f
xorl %ecx, %ecx
movq %rcx, %rax
cmpq $0x1ff, %rcx # imm = 0x1FF
je 0x21587
leaq 0x1(%rax), %rcx
cmpb $0x1, 0x9(%rbx,%rax)
jne 0x21570
cmpq $0x1fe, %rax # imm = 0x1FE
ja 0x21598
leaq 0x8(%rbx), %rdi
callq 0x217d4
leaq 0x28(%r14), %r15
movb 0xc9(%r14), %al
testb $0x1, %al
je 0x215cf
movq %r14, %rdi
callq 0x8850
movb 0xc9(%r14), %al
testb $0x1, %al
je 0x215c5
movq %r15, %rdi
movq %r14, %rsi
callq 0x88c0
movq %r14, %rdi
callq 0x8430
jmp 0x2159c
movb 0xc8(%r14), %al
testb $0x1, %al
jne 0x21727
movq 0x210(%rbx), %r12
movl 0xdc(%r12), %eax
cmpl %eax, 0x218(%rbx)
jge 0x21670
movl 0xe4(%r12), %eax
shlq $0x11, %rax
xorl %ecx, %ecx
movb $0x1, %dl
cmpb $0x0, 0x20c(%rbx)
jne 0x21660
movq 0x210(%rbx), %rsi
movb 0xc8(%rsi), %dil
testb $0x1, %dil
jne 0x21660
movb 0xc9(%rsi), %dil
testb $0x1, %dil
jne 0x21660
movl 0x68(%rsi), %edx
cmpl 0x208(%rbx), %edx
je 0x2165a
movq 0x210(%rbx), %rsi
movl 0xdc(%rsi), %esi
cmpl %esi, 0x218(%rbx)
setl 0x20c(%rbx)
movl %edx, 0x208(%rbx)
movb 0x20c(%rbx), %dl
testb %dl, %dl
jne 0x21670
cmpq %rax, %rcx
jae 0x21670
pause
incq %rcx
jmp 0x21603
cmpb $0x1, 0x20c(%rbx)
jne 0x2167e
mfence
jmp 0x21697
movq %r12, %rdi
callq 0x8850
cmpb $0x0, 0x20c(%rbx)
je 0x216b8
movq %r12, %rdi
callq 0x8430
cmpb $0x1, 0x20c(%rbx)
jne 0x2159c
movb $0x0, 0x20c(%rbx)
movq %rbx, %rdi
callq 0xb1dd
jmp 0x2159c
leaq 0x28(%r12), %r13
movq 0x210(%rbx), %rax
movb 0xc8(%rax), %cl
testb $0x1, %cl
jne 0x2168f
movb 0xc9(%rax), %cl
testb $0x1, %cl
jne 0x2168f
movl 0x68(%rax), %eax
cmpl 0x208(%rbx), %eax
je 0x21705
movq 0x210(%rbx), %rcx
movl 0xdc(%rcx), %ecx
cmpl %ecx, 0x218(%rbx)
setl 0x20c(%rbx)
movl %eax, 0x208(%rbx)
cmpb $0x0, 0x20c(%rbx)
jne 0x2168f
movq %r13, %rdi
movq %r12, %rsi
callq 0x88c0
cmpb $0x1, 0x20c(%rbx)
jne 0x216bd
jmp 0x2168f
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| ggml_graph_compute_secondary_thread:
push r15
push r14
push r13
push r12
push rbx
mov rbx, rdi
mov r14, [rdi+210h]
mov edi, [r14+0E0h]
call ggml_thread_apply_priority
cmp byte ptr [rbx+8], 0
jnz short loc_2158F
xor ecx, ecx
loc_21570:
mov rax, rcx
cmp rcx, 1FFh
jz short loc_21587
lea rcx, [rax+1]
cmp byte ptr [rbx+rax+9], 1
jnz short loc_21570
loc_21587:
cmp rax, 1FEh
ja short loc_21598
loc_2158F:
lea rdi, [rbx+8]
call ggml_thread_apply_affinity
loc_21598:
lea r15, [r14+28h]
loc_2159C:
mov al, [r14+0C9h]
test al, 1
jz short loc_215CF
mov rdi, r14
call _pthread_mutex_lock
mov al, [r14+0C9h]
test al, 1
jz short loc_215C5
mov rdi, r15
mov rsi, r14
call _pthread_cond_wait
loc_215C5:
mov rdi, r14
call _pthread_mutex_unlock
jmp short loc_2159C
loc_215CF:
mov al, [r14+0C8h]
test al, 1
jnz loc_21727
mov r12, [rbx+210h]
mov eax, [r12+0DCh]
cmp [rbx+218h], eax
jge short loc_21670
mov eax, [r12+0E4h]
shl rax, 11h
xor ecx, ecx
loc_21603:
mov dl, 1
cmp byte ptr [rbx+20Ch], 0
jnz short loc_21660
mov rsi, [rbx+210h]
mov dil, [rsi+0C8h]
test dil, 1
jnz short loc_21660
mov dil, [rsi+0C9h]
test dil, 1
jnz short loc_21660
mov edx, [rsi+68h]
cmp edx, [rbx+208h]
jz short loc_2165A
mov rsi, [rbx+210h]
mov esi, [rsi+0DCh]
cmp [rbx+218h], esi
setl byte ptr [rbx+20Ch]
mov [rbx+208h], edx
loc_2165A:
mov dl, [rbx+20Ch]
loc_21660:
test dl, dl
jnz short loc_21670
cmp rcx, rax
jnb short loc_21670
pause
inc rcx
jmp short loc_21603
loc_21670:
cmp byte ptr [rbx+20Ch], 1
jnz short loc_2167E
mfence
jmp short loc_21697
loc_2167E:
mov rdi, r12
call _pthread_mutex_lock
cmp byte ptr [rbx+20Ch], 0
jz short loc_216B8
loc_2168F:
mov rdi, r12
call _pthread_mutex_unlock
loc_21697:
cmp byte ptr [rbx+20Ch], 1
jnz loc_2159C
mov byte ptr [rbx+20Ch], 0
mov rdi, rbx
call ggml_graph_compute_thread
jmp loc_2159C
loc_216B8:
lea r13, [r12+28h]
loc_216BD:
mov rax, [rbx+210h]
mov cl, [rax+0C8h]
test cl, 1
jnz short loc_2168F
mov cl, [rax+0C9h]
test cl, 1
jnz short loc_2168F
mov eax, [rax+68h]
cmp eax, [rbx+208h]
jz short loc_21705
mov rcx, [rbx+210h]
mov ecx, [rcx+0DCh]
cmp [rbx+218h], ecx
setl byte ptr [rbx+20Ch]
mov [rbx+208h], eax
loc_21705:
cmp byte ptr [rbx+20Ch], 0
jnz short loc_2168F
mov rdi, r13
mov rsi, r12
call _pthread_cond_wait
cmp byte ptr [rbx+20Ch], 1
jnz short loc_216BD
jmp loc_2168F
loc_21727:
xor eax, eax
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| long long ggml_graph_compute_secondary_thread(long long a1)
{
long long v1; // r14
unsigned long long v2; // rcx
unsigned long long v3; // rax
long long v4; // r12
unsigned long long v5; // rax
unsigned long long i; // rcx
char v7; // dl
long long v8; // rsi
int v9; // edx
long long v10; // rax
int v11; // eax
v1 = *(_QWORD *)(a1 + 528);
ggml_thread_apply_priority(*(unsigned int *)(v1 + 224));
if ( *(_BYTE *)(a1 + 8) )
goto LABEL_6;
v2 = 0LL;
do
{
v3 = v2;
if ( v2 == 511 )
break;
++v2;
}
while ( *(_BYTE *)(a1 + v3 + 9) != 1 );
if ( v3 <= 0x1FE )
LABEL_6:
ggml_thread_apply_affinity(a1 + 8);
while ( 1 )
{
while ( (*(_BYTE *)(v1 + 201) & 1) != 0 )
{
pthread_mutex_lock(v1);
if ( (*(_BYTE *)(v1 + 201) & 1) != 0 )
pthread_cond_wait(v1 + 40, v1);
pthread_mutex_unlock(v1);
}
if ( (*(_BYTE *)(v1 + 200) & 1) != 0 )
break;
v4 = *(_QWORD *)(a1 + 528);
if ( *(_DWORD *)(a1 + 536) < *(_DWORD *)(v4 + 220) )
{
v5 = (unsigned long long)*(unsigned int *)(v4 + 228) << 17;
for ( i = 0LL; ; ++i )
{
v7 = 1;
if ( !*(_BYTE *)(a1 + 524) )
{
v8 = *(_QWORD *)(a1 + 528);
if ( (*(_BYTE *)(v8 + 200) & 1) == 0 && (*(_BYTE *)(v8 + 201) & 1) == 0 )
{
v9 = *(_DWORD *)(v8 + 104);
if ( v9 != *(_DWORD *)(a1 + 520) )
{
*(_BYTE *)(a1 + 524) = *(_DWORD *)(a1 + 536) < *(_DWORD *)(*(_QWORD *)(a1 + 528) + 220LL);
*(_DWORD *)(a1 + 520) = v9;
}
v7 = *(_BYTE *)(a1 + 524);
}
}
if ( v7 || i >= v5 )
break;
_mm_pause();
}
}
if ( *(_BYTE *)(a1 + 524) == 1 )
{
_mm_mfence();
}
else
{
pthread_mutex_lock(v4);
if ( !*(_BYTE *)(a1 + 524) )
{
do
{
v10 = *(_QWORD *)(a1 + 528);
if ( (*(_BYTE *)(v10 + 200) & 1) != 0 || (*(_BYTE *)(v10 + 201) & 1) != 0 )
break;
v11 = *(_DWORD *)(v10 + 104);
if ( v11 != *(_DWORD *)(a1 + 520) )
{
*(_BYTE *)(a1 + 524) = *(_DWORD *)(a1 + 536) < *(_DWORD *)(*(_QWORD *)(a1 + 528) + 220LL);
*(_DWORD *)(a1 + 520) = v11;
}
if ( *(_BYTE *)(a1 + 524) )
break;
pthread_cond_wait(v4 + 40, v4);
}
while ( *(_BYTE *)(a1 + 524) != 1 );
}
pthread_mutex_unlock(v4);
}
if ( *(_BYTE *)(a1 + 524) == 1 )
{
*(_BYTE *)(a1 + 524) = 0;
ggml_graph_compute_thread(a1);
}
}
return 0LL;
}
| ggml_graph_compute_secondary_thread:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV RBX,RDI
MOV R14,qword ptr [RDI + 0x210]
MOV EDI,dword ptr [R14 + 0xe0]
CALL 0x00121733
CMP byte ptr [RBX + 0x8],0x0
JNZ 0x0012158f
XOR ECX,ECX
LAB_00121570:
MOV RAX,RCX
CMP RCX,0x1ff
JZ 0x00121587
LEA RCX,[RAX + 0x1]
CMP byte ptr [RBX + RAX*0x1 + 0x9],0x1
JNZ 0x00121570
LAB_00121587:
CMP RAX,0x1fe
JA 0x00121598
LAB_0012158f:
LEA RDI,[RBX + 0x8]
CALL 0x001217d4
LAB_00121598:
LEA R15,[R14 + 0x28]
LAB_0012159c:
MOV AL,byte ptr [R14 + 0xc9]
TEST AL,0x1
JZ 0x001215cf
MOV RDI,R14
CALL 0x00108850
MOV AL,byte ptr [R14 + 0xc9]
TEST AL,0x1
JZ 0x001215c5
MOV RDI,R15
MOV RSI,R14
CALL 0x001088c0
LAB_001215c5:
MOV RDI,R14
CALL 0x00108430
JMP 0x0012159c
LAB_001215cf:
MOV AL,byte ptr [R14 + 0xc8]
TEST AL,0x1
JNZ 0x00121727
MOV R12,qword ptr [RBX + 0x210]
MOV EAX,dword ptr [R12 + 0xdc]
CMP dword ptr [RBX + 0x218],EAX
JGE 0x00121670
MOV EAX,dword ptr [R12 + 0xe4]
SHL RAX,0x11
XOR ECX,ECX
LAB_00121603:
MOV DL,0x1
CMP byte ptr [RBX + 0x20c],0x0
JNZ 0x00121660
MOV RSI,qword ptr [RBX + 0x210]
MOV DIL,byte ptr [RSI + 0xc8]
TEST DIL,0x1
JNZ 0x00121660
MOV DIL,byte ptr [RSI + 0xc9]
TEST DIL,0x1
JNZ 0x00121660
MOV EDX,dword ptr [RSI + 0x68]
CMP EDX,dword ptr [RBX + 0x208]
JZ 0x0012165a
MOV RSI,qword ptr [RBX + 0x210]
MOV ESI,dword ptr [RSI + 0xdc]
CMP dword ptr [RBX + 0x218],ESI
SETL byte ptr [RBX + 0x20c]
MOV dword ptr [RBX + 0x208],EDX
LAB_0012165a:
MOV DL,byte ptr [RBX + 0x20c]
LAB_00121660:
TEST DL,DL
JNZ 0x00121670
CMP RCX,RAX
JNC 0x00121670
PAUSE
INC RCX
JMP 0x00121603
LAB_00121670:
CMP byte ptr [RBX + 0x20c],0x1
JNZ 0x0012167e
MFENCE
JMP 0x00121697
LAB_0012167e:
MOV RDI,R12
CALL 0x00108850
CMP byte ptr [RBX + 0x20c],0x0
JZ 0x001216b8
LAB_0012168f:
MOV RDI,R12
CALL 0x00108430
LAB_00121697:
CMP byte ptr [RBX + 0x20c],0x1
JNZ 0x0012159c
MOV byte ptr [RBX + 0x20c],0x0
MOV RDI,RBX
CALL 0x0010b1dd
JMP 0x0012159c
LAB_001216b8:
LEA R13,[R12 + 0x28]
LAB_001216bd:
MOV RAX,qword ptr [RBX + 0x210]
MOV CL,byte ptr [RAX + 0xc8]
TEST CL,0x1
JNZ 0x0012168f
MOV CL,byte ptr [RAX + 0xc9]
TEST CL,0x1
JNZ 0x0012168f
MOV EAX,dword ptr [RAX + 0x68]
CMP EAX,dword ptr [RBX + 0x208]
JZ 0x00121705
MOV RCX,qword ptr [RBX + 0x210]
MOV ECX,dword ptr [RCX + 0xdc]
CMP dword ptr [RBX + 0x218],ECX
SETL byte ptr [RBX + 0x20c]
MOV dword ptr [RBX + 0x208],EAX
LAB_00121705:
CMP byte ptr [RBX + 0x20c],0x0
JNZ 0x0012168f
MOV RDI,R13
MOV RSI,R12
CALL 0x001088c0
CMP byte ptr [RBX + 0x20c],0x1
JNZ 0x001216bd
JMP 0x0012168f
LAB_00121727:
XOR EAX,EAX
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
int8 ggml_graph_compute_secondary_thread(long param_1)
{
uint uVar1;
int iVar2;
pthread_mutex_t *__mutex;
pthread_mutex_t *__mutex_00;
long lVar3;
ulong uVar4;
ulong uVar5;
char cVar6;
__mutex = *(pthread_mutex_t **)(param_1 + 0x210);
ggml_thread_apply_priority(*(int4 *)((long)__mutex + 0xe0));
if (*(char *)(param_1 + 8) == '\0') {
uVar5 = 0;
do {
uVar4 = uVar5;
if (uVar4 == 0x1ff) break;
uVar5 = uVar4 + 1;
} while (*(char *)(param_1 + 9 + uVar4) != '\x01');
if (0x1fe < uVar4) goto LAB_00121598;
}
ggml_thread_apply_affinity(param_1 + 8);
LAB_00121598:
do {
while ((*(byte *)((long)__mutex + 0xc9) & 1) != 0) {
pthread_mutex_lock(__mutex);
if ((*(byte *)((long)__mutex + 0xc9) & 1) != 0) {
pthread_cond_wait((pthread_cond_t *)(__mutex + 1),__mutex);
}
pthread_mutex_unlock(__mutex);
}
if ((__mutex[5].__size[0] & 1U) != 0) {
return 0;
}
__mutex_00 = *(pthread_mutex_t **)(param_1 + 0x210);
if (*(int *)(param_1 + 0x218) < *(int *)((long)__mutex_00 + 0xdc)) {
uVar1 = *(uint *)((long)__mutex_00 + 0xe4);
uVar5 = 0;
while( true ) {
cVar6 = '\x01';
if (((*(char *)(param_1 + 0x20c) == '\0') &&
(lVar3 = *(long *)(param_1 + 0x210), (*(byte *)(lVar3 + 200) & 1) == 0)) &&
((*(byte *)(lVar3 + 0xc9) & 1) == 0)) {
iVar2 = *(int *)(lVar3 + 0x68);
if (iVar2 != *(int *)(param_1 + 0x208)) {
*(bool *)(param_1 + 0x20c) =
*(int *)(param_1 + 0x218) < *(int *)(*(long *)(param_1 + 0x210) + 0xdc);
*(int *)(param_1 + 0x208) = iVar2;
}
cVar6 = *(char *)(param_1 + 0x20c);
}
if ((cVar6 != '\0') || ((ulong)uVar1 << 0x11 <= uVar5)) break;
uVar5 = uVar5 + 1;
}
}
if (*(char *)(param_1 + 0x20c) != '\x01') {
pthread_mutex_lock(__mutex_00);
if (*(char *)(param_1 + 0x20c) == '\0') {
while ((lVar3 = *(long *)(param_1 + 0x210), (*(byte *)(lVar3 + 200) & 1) == 0 &&
((*(byte *)(lVar3 + 0xc9) & 1) == 0))) {
iVar2 = *(int *)(lVar3 + 0x68);
if (iVar2 != *(int *)(param_1 + 0x208)) {
*(bool *)(param_1 + 0x20c) =
*(int *)(param_1 + 0x218) < *(int *)(*(long *)(param_1 + 0x210) + 0xdc);
*(int *)(param_1 + 0x208) = iVar2;
}
if ((*(char *)(param_1 + 0x20c) != '\0') ||
(pthread_cond_wait((pthread_cond_t *)(__mutex_00 + 1),__mutex_00),
*(char *)(param_1 + 0x20c) == '\x01')) break;
}
}
pthread_mutex_unlock(__mutex_00);
}
if (*(char *)(param_1 + 0x20c) == '\x01') {
*(int1 *)(param_1 + 0x20c) = 0;
ggml_graph_compute_thread(param_1);
}
} while( true );
}
| |
26,428 | ggml_graph_compute_secondary_thread | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c | static thread_ret_t ggml_graph_compute_secondary_thread(void* data) {
struct ggml_compute_state * state = (struct ggml_compute_state *) data;
struct ggml_threadpool * threadpool = state->threadpool;
ggml_thread_apply_priority(threadpool->prio);
if (ggml_thread_cpumask_is_valid(state->cpumask)) {
ggml_thread_apply_affinity(state->cpumask);
}
while (true) {
// Check if we need to sleep
while (threadpool->pause) {
GGML_PRINT_DEBUG("thread #%d inside pause loop\n", state->ith);
ggml_mutex_lock_shared(&threadpool->mutex);
if (threadpool->pause) {
ggml_cond_wait(&threadpool->cond, &threadpool->mutex);
}
GGML_PRINT_DEBUG("thread #%d resuming after wait\n", state->ith);
ggml_mutex_unlock_shared(&threadpool->mutex);
}
// This needs to be checked for after the cond_wait
if (threadpool->stop) break;
// Check if there is new work
// The main thread is the only one that can dispatch new work
ggml_graph_compute_check_for_work(state);
if (state->pending) {
state->pending = false;
ggml_graph_compute_thread(state);
}
}
return (thread_ret_t) 0;
} | O2 | c | ggml_graph_compute_secondary_thread:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x210(%rdi), %r14
movl 0xe0(%r14), %edi
callq 0xb785
leaq 0x8(%rbx), %r15
movq %r15, %rdi
callq 0xb818
testb %al, %al
je 0xb694
movq %r15, %rdi
callq 0xb83a
leaq 0x28(%r14), %r15
movb 0xc9(%r14), %al
testb $0x1, %al
je 0xb6cb
movq %r14, %rdi
callq 0x8980
movb 0xc9(%r14), %al
testb $0x1, %al
je 0xb6c1
movq %r15, %rdi
movq %r14, %rsi
callq 0x8a00
movq %r14, %rdi
callq 0x84f0
jmp 0xb698
movb 0xc8(%r14), %al
testb $0x1, %al
jne 0xb774
movq 0x210(%rbx), %r12
movl 0xdc(%r12), %eax
cmpl %eax, 0x218(%rbx)
jge 0xb717
movl 0xe4(%r12), %r13d
shlq $0x11, %r13
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0xb8e2
testb %al, %al
jne 0xb717
cmpq %r13, %rbp
jae 0xb717
pause
incq %rbp
jmp 0xb6ff
cmpb $0x1, 0x20c(%rbx)
jne 0xb725
mfence
jmp 0xb753
movq %r12, %rdi
callq 0x8980
leaq 0x28(%r12), %r13
movq %rbx, %rdi
callq 0xb8e2
testb %al, %al
jne 0xb74b
movq %r13, %rdi
movq %r12, %rsi
callq 0x8a00
jmp 0xb732
movq %r12, %rdi
callq 0x84f0
cmpb $0x1, 0x20c(%rbx)
jne 0xb698
movb $0x0, 0x20c(%rbx)
movq %rbx, %rdi
callq 0xaf72
jmp 0xb698
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| ggml_graph_compute_secondary_thread:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
mov r14, [rdi+210h]
mov edi, [r14+0E0h]
call ggml_thread_apply_priority
lea r15, [rbx+8]
mov rdi, r15
call ggml_thread_cpumask_is_valid
test al, al
jz short loc_B694
mov rdi, r15
call ggml_thread_apply_affinity
loc_B694:
lea r15, [r14+28h]
loc_B698:
mov al, [r14+0C9h]
test al, 1
jz short loc_B6CB
mov rdi, r14
call _pthread_mutex_lock
mov al, [r14+0C9h]
test al, 1
jz short loc_B6C1
mov rdi, r15
mov rsi, r14
call _pthread_cond_wait
loc_B6C1:
mov rdi, r14
call _pthread_mutex_unlock
jmp short loc_B698
loc_B6CB:
mov al, [r14+0C8h]
test al, 1
jnz loc_B774
mov r12, [rbx+210h]
mov eax, [r12+0DCh]
cmp [rbx+218h], eax
jge short loc_B717
mov r13d, [r12+0E4h]
shl r13, 11h
xor ebp, ebp
loc_B6FF:
mov rdi, rbx
call ggml_graph_compute_thread_ready
test al, al
jnz short loc_B717
cmp rbp, r13
jnb short loc_B717
pause
inc rbp
jmp short loc_B6FF
loc_B717:
cmp byte ptr [rbx+20Ch], 1
jnz short loc_B725
mfence
jmp short loc_B753
loc_B725:
mov rdi, r12
call _pthread_mutex_lock
lea r13, [r12+28h]
loc_B732:
mov rdi, rbx
call ggml_graph_compute_thread_ready
test al, al
jnz short loc_B74B
mov rdi, r13
mov rsi, r12
call _pthread_cond_wait
jmp short loc_B732
loc_B74B:
mov rdi, r12
call _pthread_mutex_unlock
loc_B753:
cmp byte ptr [rbx+20Ch], 1
jnz loc_B698
mov byte ptr [rbx+20Ch], 0
mov rdi, rbx
call ggml_graph_compute_thread
jmp loc_B698
loc_B774:
xor eax, eax
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ggml_graph_compute_secondary_thread(long long a1, long long a2)
{
long long v2; // r14
long long v3; // rdx
long long v4; // r12
unsigned long long v5; // r13
unsigned long long i; // rbp
v2 = *(_QWORD *)(a1 + 528);
ggml_thread_apply_priority(*(unsigned int *)(v2 + 224));
if ( (unsigned __int8)ggml_thread_cpumask_is_valid(a1 + 8) )
ggml_thread_apply_affinity(a1 + 8);
while ( 1 )
{
while ( (*(_BYTE *)(v2 + 201) & 1) != 0 )
{
pthread_mutex_lock(v2);
if ( (*(_BYTE *)(v2 + 201) & 1) != 0 )
{
a2 = v2;
pthread_cond_wait(v2 + 40, v2);
}
pthread_mutex_unlock(v2);
}
if ( (*(_BYTE *)(v2 + 200) & 1) != 0 )
break;
v4 = *(_QWORD *)(a1 + 528);
if ( *(_DWORD *)(a1 + 536) < *(_DWORD *)(v4 + 220) )
{
v5 = (unsigned long long)*(unsigned int *)(v4 + 228) << 17;
for ( i = 0LL; !(unsigned __int8)ggml_graph_compute_thread_ready(a1) && i < v5; ++i )
_mm_pause();
}
if ( *(_BYTE *)(a1 + 524) == 1 )
{
_mm_mfence();
}
else
{
pthread_mutex_lock(v4);
while ( !(unsigned __int8)ggml_graph_compute_thread_ready(a1) )
{
a2 = v4;
pthread_cond_wait(v4 + 40, v4);
}
pthread_mutex_unlock(v4);
}
if ( *(_BYTE *)(a1 + 524) == 1 )
{
*(_BYTE *)(a1 + 524) = 0;
ggml_graph_compute_thread(a1, a2, v3);
}
}
return 0LL;
}
| ggml_graph_compute_secondary_thread:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R14,qword ptr [RDI + 0x210]
MOV EDI,dword ptr [R14 + 0xe0]
CALL 0x0010b785
LEA R15,[RBX + 0x8]
MOV RDI,R15
CALL 0x0010b818
TEST AL,AL
JZ 0x0010b694
MOV RDI,R15
CALL 0x0010b83a
LAB_0010b694:
LEA R15,[R14 + 0x28]
LAB_0010b698:
MOV AL,byte ptr [R14 + 0xc9]
TEST AL,0x1
JZ 0x0010b6cb
MOV RDI,R14
CALL 0x00108980
MOV AL,byte ptr [R14 + 0xc9]
TEST AL,0x1
JZ 0x0010b6c1
MOV RDI,R15
MOV RSI,R14
CALL 0x00108a00
LAB_0010b6c1:
MOV RDI,R14
CALL 0x001084f0
JMP 0x0010b698
LAB_0010b6cb:
MOV AL,byte ptr [R14 + 0xc8]
TEST AL,0x1
JNZ 0x0010b774
MOV R12,qword ptr [RBX + 0x210]
MOV EAX,dword ptr [R12 + 0xdc]
CMP dword ptr [RBX + 0x218],EAX
JGE 0x0010b717
MOV R13D,dword ptr [R12 + 0xe4]
SHL R13,0x11
XOR EBP,EBP
LAB_0010b6ff:
MOV RDI,RBX
CALL 0x0010b8e2
TEST AL,AL
JNZ 0x0010b717
CMP RBP,R13
JNC 0x0010b717
PAUSE
INC RBP
JMP 0x0010b6ff
LAB_0010b717:
CMP byte ptr [RBX + 0x20c],0x1
JNZ 0x0010b725
MFENCE
JMP 0x0010b753
LAB_0010b725:
MOV RDI,R12
CALL 0x00108980
LEA R13,[R12 + 0x28]
LAB_0010b732:
MOV RDI,RBX
CALL 0x0010b8e2
TEST AL,AL
JNZ 0x0010b74b
MOV RDI,R13
MOV RSI,R12
CALL 0x00108a00
JMP 0x0010b732
LAB_0010b74b:
MOV RDI,R12
CALL 0x001084f0
LAB_0010b753:
CMP byte ptr [RBX + 0x20c],0x1
JNZ 0x0010b698
MOV byte ptr [RBX + 0x20c],0x0
MOV RDI,RBX
CALL 0x0010af72
JMP 0x0010b698
LAB_0010b774:
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 ggml_graph_compute_secondary_thread(long param_1)
{
uint uVar1;
pthread_mutex_t *__mutex;
pthread_mutex_t *__mutex_00;
char cVar2;
ulong uVar3;
__mutex = *(pthread_mutex_t **)(param_1 + 0x210);
ggml_thread_apply_priority(*(int4 *)((long)__mutex + 0xe0));
cVar2 = ggml_thread_cpumask_is_valid(param_1 + 8);
if (cVar2 != '\0') {
ggml_thread_apply_affinity(param_1 + 8);
}
while( true ) {
while ((*(byte *)((long)__mutex + 0xc9) & 1) != 0) {
pthread_mutex_lock(__mutex);
if ((*(byte *)((long)__mutex + 0xc9) & 1) != 0) {
pthread_cond_wait((pthread_cond_t *)(__mutex + 1),__mutex);
}
pthread_mutex_unlock(__mutex);
}
if ((__mutex[5].__size[0] & 1U) != 0) break;
__mutex_00 = *(pthread_mutex_t **)(param_1 + 0x210);
if (*(int *)(param_1 + 0x218) < *(int *)((long)__mutex_00 + 0xdc)) {
uVar1 = *(uint *)((long)__mutex_00 + 0xe4);
for (uVar3 = 0;
(cVar2 = ggml_graph_compute_thread_ready(param_1), cVar2 == '\0' &&
(uVar3 < (ulong)uVar1 << 0x11)); uVar3 = uVar3 + 1) {
}
}
if (*(char *)(param_1 + 0x20c) != '\x01') {
pthread_mutex_lock(__mutex_00);
while (cVar2 = ggml_graph_compute_thread_ready(param_1), cVar2 == '\0') {
pthread_cond_wait((pthread_cond_t *)(__mutex_00 + 1),__mutex_00);
}
pthread_mutex_unlock(__mutex_00);
}
if (*(char *)(param_1 + 0x20c) == '\x01') {
*(int1 *)(param_1 + 0x20c) = 0;
ggml_graph_compute_thread(param_1);
}
}
return 0;
}
| |
26,429 | ggml_graph_compute_secondary_thread | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c | static thread_ret_t ggml_graph_compute_secondary_thread(void* data) {
struct ggml_compute_state * state = (struct ggml_compute_state *) data;
struct ggml_threadpool * threadpool = state->threadpool;
ggml_thread_apply_priority(threadpool->prio);
if (ggml_thread_cpumask_is_valid(state->cpumask)) {
ggml_thread_apply_affinity(state->cpumask);
}
while (true) {
// Check if we need to sleep
while (threadpool->pause) {
GGML_PRINT_DEBUG("thread #%d inside pause loop\n", state->ith);
ggml_mutex_lock_shared(&threadpool->mutex);
if (threadpool->pause) {
ggml_cond_wait(&threadpool->cond, &threadpool->mutex);
}
GGML_PRINT_DEBUG("thread #%d resuming after wait\n", state->ith);
ggml_mutex_unlock_shared(&threadpool->mutex);
}
// This needs to be checked for after the cond_wait
if (threadpool->stop) break;
// Check if there is new work
// The main thread is the only one that can dispatch new work
ggml_graph_compute_check_for_work(state);
if (state->pending) {
state->pending = false;
ggml_graph_compute_thread(state);
}
}
return (thread_ret_t) 0;
} | O3 | c | ggml_graph_compute_secondary_thread:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x210(%rdi), %r14
movl 0xe0(%r14), %edi
callq 0x22053
cmpb $0x0, 0x8(%rbx)
je 0x22020
leaq 0x8(%rbx), %rdi
callq 0x220e8
leaq 0x28(%r14), %r15
movb 0xc9(%r14), %al
testb $0x1, %al
je 0x21e9c
movq %r14, %rdi
callq 0x8850
movb 0xc9(%r14), %al
testb $0x1, %al
je 0x21e92
movq %r15, %rdi
movq %r14, %rsi
callq 0x88c0
movq %r14, %rdi
callq 0x8430
jmp 0x21e69
movb 0xc8(%r14), %al
testb $0x1, %al
jne 0x22014
movq 0x210(%rbx), %r12
movl 0xdc(%r12), %ecx
movb 0x20c(%rbx), %al
cmpl %ecx, 0x218(%rbx)
jge 0x21f5a
testb $0x1, %al
jne 0x21f5a
movl 0xe4(%r12), %eax
shlq $0x11, %rax
xorl %ecx, %ecx
movq 0x210(%rbx), %rdx
movb 0xc8(%rdx), %sil
testb $0x1, %sil
jne 0x21f54
movb 0xc9(%rdx), %sil
testb $0x1, %sil
jne 0x21f54
movl 0x68(%rdx), %edx
cmpl 0x208(%rbx), %edx
jne 0x21f17
movb 0x20c(%rbx), %sil
jmp 0x21f3b
movq 0x210(%rbx), %rsi
movl 0xdc(%rsi), %esi
cmpl %esi, 0x218(%rbx)
setl %sil
setl 0x20c(%rbx)
movl %edx, 0x208(%rbx)
testb $0x1, %sil
jne 0x21f54
cmpq %rax, %rcx
jae 0x21f54
pause
incq %rcx
cmpb $0x1, 0x20c(%rbx)
jne 0x21ee2
movb 0x20c(%rbx), %al
testb $0x1, %al
je 0x21f63
mfence
jmp 0x21f7c
movq %r12, %rdi
callq 0x8850
cmpb $0x0, 0x20c(%rbx)
je 0x21f9d
movq %r12, %rdi
callq 0x8430
cmpb $0x1, 0x20c(%rbx)
jne 0x21e69
movb $0x0, 0x20c(%rbx)
movq %rbx, %rdi
callq 0xb6b9
jmp 0x21e69
leaq 0x28(%r12), %r13
movq 0x210(%rbx), %rax
movb 0xc8(%rax), %cl
testb $0x1, %cl
jne 0x21f74
movb 0xc9(%rax), %cl
testb $0x1, %cl
jne 0x21f74
movl 0x68(%rax), %eax
cmpl 0x208(%rbx), %eax
jne 0x21fd5
testb $0x1, 0x20c(%rbx)
je 0x21ffb
jmp 0x21f74
movq 0x210(%rbx), %rcx
movl 0xdc(%rcx), %ecx
cmpl %ecx, 0x218(%rbx)
setl 0x20c(%rbx)
movl %eax, 0x208(%rbx)
jl 0x21f74
movq %r13, %rdi
movq %r12, %rsi
callq 0x88c0
cmpb $0x1, 0x20c(%rbx)
jne 0x21fa2
jmp 0x21f74
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq $-0x1, %rax
cmpq $0x1fe, %rax # imm = 0x1FE
je 0x21e65
leaq 0x1(%rax), %rcx
cmpb $0x1, 0xa(%rbx,%rax)
movq %rcx, %rax
jne 0x22027
cmpq $0x1fe, %rcx # imm = 0x1FE
jbe 0x21e5c
jmp 0x21e65
| ggml_graph_compute_secondary_thread:
push r15
push r14
push r13
push r12
push rbx
mov rbx, rdi
mov r14, [rdi+210h]
mov edi, [r14+0E0h]
call ggml_thread_apply_priority
cmp byte ptr [rbx+8], 0
jz loc_22020
loc_21E5C:
lea rdi, [rbx+8]
call ggml_thread_apply_affinity
loc_21E65:
lea r15, [r14+28h]
loc_21E69:
mov al, [r14+0C9h]
test al, 1
jz short loc_21E9C
mov rdi, r14
call _pthread_mutex_lock
mov al, [r14+0C9h]
test al, 1
jz short loc_21E92
mov rdi, r15
mov rsi, r14
call _pthread_cond_wait
loc_21E92:
mov rdi, r14
call _pthread_mutex_unlock
jmp short loc_21E69
loc_21E9C:
mov al, [r14+0C8h]
test al, 1
jnz loc_22014
mov r12, [rbx+210h]
mov ecx, [r12+0DCh]
mov al, [rbx+20Ch]
cmp [rbx+218h], ecx
jge loc_21F5A
test al, 1
jnz loc_21F5A
mov eax, [r12+0E4h]
shl rax, 11h
xor ecx, ecx
loc_21EE2:
mov rdx, [rbx+210h]
mov sil, [rdx+0C8h]
test sil, 1
jnz short loc_21F54
mov sil, [rdx+0C9h]
test sil, 1
jnz short loc_21F54
mov edx, [rdx+68h]
cmp edx, [rbx+208h]
jnz short loc_21F17
mov sil, [rbx+20Ch]
jmp short loc_21F3B
loc_21F17:
mov rsi, [rbx+210h]
mov esi, [rsi+0DCh]
cmp [rbx+218h], esi
setl sil
setl byte ptr [rbx+20Ch]
mov [rbx+208h], edx
loc_21F3B:
test sil, 1
jnz short loc_21F54
cmp rcx, rax
jnb short loc_21F54
pause
inc rcx
cmp byte ptr [rbx+20Ch], 1
jnz short loc_21EE2
loc_21F54:
mov al, [rbx+20Ch]
loc_21F5A:
test al, 1
jz short loc_21F63
mfence
jmp short loc_21F7C
loc_21F63:
mov rdi, r12
call _pthread_mutex_lock
cmp byte ptr [rbx+20Ch], 0
jz short loc_21F9D
loc_21F74:
mov rdi, r12
call _pthread_mutex_unlock
loc_21F7C:
cmp byte ptr [rbx+20Ch], 1
jnz loc_21E69
mov byte ptr [rbx+20Ch], 0
mov rdi, rbx
call ggml_graph_compute_thread
jmp loc_21E69
loc_21F9D:
lea r13, [r12+28h]
loc_21FA2:
mov rax, [rbx+210h]
mov cl, [rax+0C8h]
test cl, 1
jnz short loc_21F74
mov cl, [rax+0C9h]
test cl, 1
jnz short loc_21F74
mov eax, [rax+68h]
cmp eax, [rbx+208h]
jnz short loc_21FD5
test byte ptr [rbx+20Ch], 1
jz short loc_21FFB
jmp short loc_21F74
loc_21FD5:
mov rcx, [rbx+210h]
mov ecx, [rcx+0DCh]
cmp [rbx+218h], ecx
setl byte ptr [rbx+20Ch]
mov [rbx+208h], eax
jl loc_21F74
loc_21FFB:
mov rdi, r13
mov rsi, r12
call _pthread_cond_wait
cmp byte ptr [rbx+20Ch], 1
jnz short loc_21FA2
jmp loc_21F74
loc_22014:
xor eax, eax
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_22020:
mov rax, 0FFFFFFFFFFFFFFFFh
loc_22027:
cmp rax, 1FEh
jz loc_21E65
lea rcx, [rax+1]
cmp byte ptr [rbx+rax+0Ah], 1
mov rax, rcx
jnz short loc_22027
cmp rcx, 1FEh
jbe loc_21E5C
jmp loc_21E65
| long long ggml_graph_compute_secondary_thread(long long a1)
{
long long v1; // r14
long long v2; // r12
char v3; // al
unsigned long long v4; // rax
unsigned long long v5; // rcx
long long v6; // rdx
int v7; // edx
char v8; // si
long long v9; // rax
int v10; // eax
bool v11; // cc
long long v13; // rax
unsigned long long v14; // rcx
v1 = *(_QWORD *)(a1 + 528);
ggml_thread_apply_priority(*(unsigned int *)(v1 + 224));
if ( *(_BYTE *)(a1 + 8) )
{
LABEL_2:
ggml_thread_apply_affinity(a1 + 8);
}
else
{
v13 = -1LL;
while ( v13 != 510 )
{
v14 = v13 + 1;
if ( *(_BYTE *)(a1 + v13++ + 10) == 1 )
{
if ( v14 <= 0x1FE )
goto LABEL_2;
goto LABEL_3;
}
}
}
while ( 1 )
{
LABEL_3:
while ( (*(_BYTE *)(v1 + 201) & 1) != 0 )
{
pthread_mutex_lock(v1);
if ( (*(_BYTE *)(v1 + 201) & 1) != 0 )
pthread_cond_wait(v1 + 40, v1);
pthread_mutex_unlock(v1);
}
if ( (*(_BYTE *)(v1 + 200) & 1) != 0 )
return 0LL;
v2 = *(_QWORD *)(a1 + 528);
v3 = *(_BYTE *)(a1 + 524);
if ( *(_DWORD *)(a1 + 536) < *(_DWORD *)(v2 + 220) && (v3 & 1) == 0 )
{
v4 = (unsigned long long)*(unsigned int *)(v2 + 228) << 17;
v5 = 0LL;
do
{
v6 = *(_QWORD *)(a1 + 528);
if ( (*(_BYTE *)(v6 + 200) & 1) != 0 || (*(_BYTE *)(v6 + 201) & 1) != 0 )
break;
v7 = *(_DWORD *)(v6 + 104);
if ( v7 == *(_DWORD *)(a1 + 520) )
{
v8 = *(_BYTE *)(a1 + 524);
}
else
{
v8 = *(_DWORD *)(a1 + 536) < *(_DWORD *)(*(_QWORD *)(a1 + 528) + 220LL);
*(_BYTE *)(a1 + 524) = v8;
*(_DWORD *)(a1 + 520) = v7;
}
if ( (v8 & 1) != 0 )
break;
if ( v5 >= v4 )
break;
_mm_pause();
++v5;
}
while ( *(_BYTE *)(a1 + 524) != 1 );
v3 = *(_BYTE *)(a1 + 524);
}
if ( (v3 & 1) != 0 )
{
_mm_mfence();
}
else
{
pthread_mutex_lock(v2);
if ( !*(_BYTE *)(a1 + 524) )
{
do
{
v9 = *(_QWORD *)(a1 + 528);
if ( (*(_BYTE *)(v9 + 200) & 1) != 0 || (*(_BYTE *)(v9 + 201) & 1) != 0 )
break;
v10 = *(_DWORD *)(v9 + 104);
if ( v10 == *(_DWORD *)(a1 + 520) )
{
if ( (*(_BYTE *)(a1 + 524) & 1) != 0 )
break;
}
else
{
v11 = *(_DWORD *)(a1 + 536) < *(_DWORD *)(*(_QWORD *)(a1 + 528) + 220LL);
*(_BYTE *)(a1 + 524) = v11;
*(_DWORD *)(a1 + 520) = v10;
if ( v11 )
break;
}
pthread_cond_wait(v2 + 40, v2);
}
while ( *(_BYTE *)(a1 + 524) != 1 );
}
pthread_mutex_unlock(v2);
}
if ( *(_BYTE *)(a1 + 524) == 1 )
{
*(_BYTE *)(a1 + 524) = 0;
ggml_graph_compute_thread(a1);
}
}
}
| ggml_graph_compute_secondary_thread:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV RBX,RDI
MOV R14,qword ptr [RDI + 0x210]
MOV EDI,dword ptr [R14 + 0xe0]
CALL 0x00122053
CMP byte ptr [RBX + 0x8],0x0
JZ 0x00122020
LAB_00121e5c:
LEA RDI,[RBX + 0x8]
CALL 0x001220e8
LAB_00121e65:
LEA R15,[R14 + 0x28]
LAB_00121e69:
MOV AL,byte ptr [R14 + 0xc9]
TEST AL,0x1
JZ 0x00121e9c
MOV RDI,R14
CALL 0x00108850
MOV AL,byte ptr [R14 + 0xc9]
TEST AL,0x1
JZ 0x00121e92
MOV RDI,R15
MOV RSI,R14
CALL 0x001088c0
LAB_00121e92:
MOV RDI,R14
CALL 0x00108430
JMP 0x00121e69
LAB_00121e9c:
MOV AL,byte ptr [R14 + 0xc8]
TEST AL,0x1
JNZ 0x00122014
MOV R12,qword ptr [RBX + 0x210]
MOV ECX,dword ptr [R12 + 0xdc]
MOV AL,byte ptr [RBX + 0x20c]
CMP dword ptr [RBX + 0x218],ECX
JGE 0x00121f5a
TEST AL,0x1
JNZ 0x00121f5a
MOV EAX,dword ptr [R12 + 0xe4]
SHL RAX,0x11
XOR ECX,ECX
LAB_00121ee2:
MOV RDX,qword ptr [RBX + 0x210]
MOV SIL,byte ptr [RDX + 0xc8]
TEST SIL,0x1
JNZ 0x00121f54
MOV SIL,byte ptr [RDX + 0xc9]
TEST SIL,0x1
JNZ 0x00121f54
MOV EDX,dword ptr [RDX + 0x68]
CMP EDX,dword ptr [RBX + 0x208]
JNZ 0x00121f17
MOV SIL,byte ptr [RBX + 0x20c]
JMP 0x00121f3b
LAB_00121f17:
MOV RSI,qword ptr [RBX + 0x210]
MOV ESI,dword ptr [RSI + 0xdc]
CMP dword ptr [RBX + 0x218],ESI
SETL SIL
SETL byte ptr [RBX + 0x20c]
MOV dword ptr [RBX + 0x208],EDX
LAB_00121f3b:
TEST SIL,0x1
JNZ 0x00121f54
CMP RCX,RAX
JNC 0x00121f54
PAUSE
INC RCX
CMP byte ptr [RBX + 0x20c],0x1
JNZ 0x00121ee2
LAB_00121f54:
MOV AL,byte ptr [RBX + 0x20c]
LAB_00121f5a:
TEST AL,0x1
JZ 0x00121f63
MFENCE
JMP 0x00121f7c
LAB_00121f63:
MOV RDI,R12
CALL 0x00108850
CMP byte ptr [RBX + 0x20c],0x0
JZ 0x00121f9d
LAB_00121f74:
MOV RDI,R12
CALL 0x00108430
LAB_00121f7c:
CMP byte ptr [RBX + 0x20c],0x1
JNZ 0x00121e69
MOV byte ptr [RBX + 0x20c],0x0
MOV RDI,RBX
CALL 0x0010b6b9
JMP 0x00121e69
LAB_00121f9d:
LEA R13,[R12 + 0x28]
LAB_00121fa2:
MOV RAX,qword ptr [RBX + 0x210]
MOV CL,byte ptr [RAX + 0xc8]
TEST CL,0x1
JNZ 0x00121f74
MOV CL,byte ptr [RAX + 0xc9]
TEST CL,0x1
JNZ 0x00121f74
MOV EAX,dword ptr [RAX + 0x68]
CMP EAX,dword ptr [RBX + 0x208]
JNZ 0x00121fd5
TEST byte ptr [RBX + 0x20c],0x1
JZ 0x00121ffb
JMP 0x00121f74
LAB_00121fd5:
MOV RCX,qword ptr [RBX + 0x210]
MOV ECX,dword ptr [RCX + 0xdc]
CMP dword ptr [RBX + 0x218],ECX
SETL byte ptr [RBX + 0x20c]
MOV dword ptr [RBX + 0x208],EAX
JL 0x00121f74
LAB_00121ffb:
MOV RDI,R13
MOV RSI,R12
CALL 0x001088c0
CMP byte ptr [RBX + 0x20c],0x1
JNZ 0x00121fa2
JMP 0x00121f74
LAB_00122014:
XOR EAX,EAX
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_00122020:
MOV RAX,-0x1
LAB_00122027:
CMP RAX,0x1fe
JZ 0x00121e65
LEA RCX,[RAX + 0x1]
CMP byte ptr [RBX + RAX*0x1 + 0xa],0x1
MOV RAX,RCX
JNZ 0x00122027
CMP RCX,0x1fe
JBE 0x00121e5c
JMP 0x00121e65
|
int8 ggml_graph_compute_secondary_thread(long param_1)
{
ulong uVar1;
char *pcVar2;
uint uVar3;
int iVar4;
int iVar5;
pthread_mutex_t *__mutex;
pthread_mutex_t *__mutex_00;
long lVar6;
ulong uVar7;
byte bVar8;
__mutex = *(pthread_mutex_t **)(param_1 + 0x210);
ggml_thread_apply_priority(*(int4 *)((long)__mutex + 0xe0));
if (*(char *)(param_1 + 8) == '\0') {
uVar7 = 0xffffffffffffffff;
do {
if (uVar7 == 0x1fe) goto LAB_00121e65;
uVar1 = uVar7 + 1;
pcVar2 = (char *)(param_1 + 10 + uVar7);
uVar7 = uVar1;
} while (*pcVar2 != '\x01');
if (0x1fe < uVar1) goto LAB_00121e65;
}
ggml_thread_apply_affinity(param_1 + 8);
LAB_00121e65:
do {
while ((*(byte *)((long)__mutex + 0xc9) & 1) != 0) {
pthread_mutex_lock(__mutex);
if ((*(byte *)((long)__mutex + 0xc9) & 1) != 0) {
pthread_cond_wait((pthread_cond_t *)(__mutex + 1),__mutex);
}
pthread_mutex_unlock(__mutex);
}
if ((__mutex[5].__size[0] & 1U) != 0) {
return 0;
}
__mutex_00 = *(pthread_mutex_t **)(param_1 + 0x210);
bVar8 = *(byte *)(param_1 + 0x20c);
if ((*(int *)(param_1 + 0x218) < *(int *)((long)__mutex_00 + 0xdc)) && ((bVar8 & 1) == 0)) {
uVar3 = *(uint *)((long)__mutex_00 + 0xe4);
uVar7 = 0;
while ((lVar6 = *(long *)(param_1 + 0x210), (*(byte *)(lVar6 + 200) & 1) == 0 &&
((*(byte *)(lVar6 + 0xc9) & 1) == 0))) {
iVar4 = *(int *)(lVar6 + 0x68);
if (iVar4 == *(int *)(param_1 + 0x208)) {
bVar8 = *(byte *)(param_1 + 0x20c);
}
else {
iVar5 = *(int *)(*(long *)(param_1 + 0x210) + 0xdc);
bVar8 = *(int *)(param_1 + 0x218) < iVar5;
*(bool *)(param_1 + 0x20c) = *(int *)(param_1 + 0x218) < iVar5;
*(int *)(param_1 + 0x208) = iVar4;
}
if ((((bVar8 & 1) != 0) || ((ulong)uVar3 << 0x11 <= uVar7)) ||
(uVar7 = uVar7 + 1, *(char *)(param_1 + 0x20c) == '\x01')) break;
}
bVar8 = *(byte *)(param_1 + 0x20c);
}
if ((bVar8 & 1) == 0) {
pthread_mutex_lock(__mutex_00);
if (*(char *)(param_1 + 0x20c) == '\0') {
do {
lVar6 = *(long *)(param_1 + 0x210);
if (((*(byte *)(lVar6 + 200) & 1) != 0) || ((*(byte *)(lVar6 + 0xc9) & 1) != 0)) break;
iVar4 = *(int *)(lVar6 + 0x68);
if (iVar4 == *(int *)(param_1 + 0x208)) {
if ((*(byte *)(param_1 + 0x20c) & 1) != 0) break;
}
else {
iVar5 = *(int *)(*(long *)(param_1 + 0x210) + 0xdc);
*(bool *)(param_1 + 0x20c) = *(int *)(param_1 + 0x218) < iVar5;
*(int *)(param_1 + 0x208) = iVar4;
if (*(int *)(param_1 + 0x218) < iVar5) break;
}
pthread_cond_wait((pthread_cond_t *)(__mutex_00 + 1),__mutex_00);
} while (*(char *)(param_1 + 0x20c) != '\x01');
}
pthread_mutex_unlock(__mutex_00);
}
if (*(char *)(param_1 + 0x20c) == '\x01') {
*(int1 *)(param_1 + 0x20c) = 0;
ggml_graph_compute_thread(param_1);
}
} while( true );
}
| |
26,430 | uf_zerofill_skip_zero | eloqsql/storage/maria/ma_packrec.c | static void uf_zerofill_skip_zero(MARIA_COLUMNDEF *rec,
MARIA_BIT_BUFF *bit_buff,
uchar *to, uchar *end)
{
if (get_bit(bit_buff))
bzero((char*) to,(uint) (end-to));
else
{
end-=rec->space_length_bits;
decode_bytes(rec,bit_buff,to,end);
bzero((char*) end,rec->space_length_bits);
}
} | O3 | c | uf_zerofill_skip_zero:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movl 0x4(%rsi), %eax
testl %eax, %eax
je 0x3a7ec
movl (%r12), %ecx
decl %eax
movl %eax, 0x4(%r12)
btl %eax, %ecx
jae 0x3a804
subl %r14d, %ebx
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
jmp 0x3a825
movq %r12, %rdi
callq 0x3a788
movl $0x1f, 0x4(%r12)
cmpl $0x0, (%r12)
js 0x3a7df
movl 0x24(%r15), %eax
subq %rax, %rbx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x3a945
movl 0x24(%r15), %edx
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x292c0
| uf_zerofill_skip_zero:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, rcx
mov r14, rdx
mov r12, rsi
mov r15, rdi
mov eax, [rsi+4]
test eax, eax
jz short loc_3A7EC
mov ecx, [r12]
dec eax
mov [r12+4], eax
bt ecx, eax
jnb short loc_3A804
loc_3A7DF:
sub ebx, r14d
mov rdi, r14
xor esi, esi
mov rdx, rbx
jmp short loc_3A825
loc_3A7EC:
mov rdi, r12
call fill_buffer
mov dword ptr [r12+4], 1Fh
cmp dword ptr [r12], 0
js short loc_3A7DF
loc_3A804:
mov eax, [r15+24h]
sub rbx, rax
mov rdi, r15
mov rsi, r12
mov rdx, r14
mov rcx, rbx
call decode_bytes
mov edx, [r15+24h]
mov rdi, rbx
xor esi, esi
loc_3A825:
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp _memset
| long long uf_zerofill_skip_zero(long long a1, int *a2, long long a3, long long a4)
{
int v6; // eax
int v7; // ecx
unsigned int v8; // eax
long long v10; // rbx
v6 = a2[1];
if ( v6 )
{
v7 = *a2;
v8 = v6 - 1;
a2[1] = v8;
if ( _bittest(&v7, v8) )
return memset(a3, 0LL, (unsigned int)(a4 - a3));
}
else
{
fill_buffer((long long)a2);
a2[1] = 31;
if ( *a2 < 0 )
return memset(a3, 0LL, (unsigned int)(a4 - a3));
}
v10 = a4 - *(unsigned int *)(a1 + 36);
decode_bytes(a1, a2, a3, v10);
return memset(v10, 0LL, *(unsigned int *)(a1 + 36));
}
| uf_zerofill_skip_zero:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RCX
MOV R14,RDX
MOV R12,RSI
MOV R15,RDI
MOV EAX,dword ptr [RSI + 0x4]
TEST EAX,EAX
JZ 0x0013a7ec
MOV ECX,dword ptr [R12]
DEC EAX
MOV dword ptr [R12 + 0x4],EAX
BT ECX,EAX
JNC 0x0013a804
LAB_0013a7df:
SUB EBX,R14D
MOV RDI,R14
XOR ESI,ESI
MOV RDX,RBX
JMP 0x0013a825
LAB_0013a7ec:
MOV RDI,R12
CALL 0x0013a788
MOV dword ptr [R12 + 0x4],0x1f
CMP dword ptr [R12],0x0
JS 0x0013a7df
LAB_0013a804:
MOV EAX,dword ptr [R15 + 0x24]
SUB RBX,RAX
MOV RDI,R15
MOV RSI,R12
MOV RDX,R14
MOV RCX,RBX
CALL 0x0013a945
MOV EDX,dword ptr [R15 + 0x24]
MOV RDI,RBX
XOR ESI,ESI
LAB_0013a825:
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x001292c0
|
void uf_zerofill_skip_zero(long param_1,uint *param_2,void *param_3,long param_4)
{
uint uVar1;
void *__s;
if (param_2[1] == 0) {
fill_buffer(param_2);
param_2[1] = 0x1f;
if (-1 < (int)*param_2) goto LAB_0013a804;
}
else {
uVar1 = param_2[1] - 1;
param_2[1] = uVar1;
if ((*param_2 >> (uVar1 & 0x1f) & 1) == 0) {
LAB_0013a804:
__s = (void *)(param_4 - (ulong)*(uint *)(param_1 + 0x24));
decode_bytes(param_1,param_2,param_3,__s);
uVar1 = *(uint *)(param_1 + 0x24);
goto LAB_0013a825;
}
}
uVar1 = (int)param_4 - (int)param_3;
__s = param_3;
LAB_0013a825:
memset(__s,0,(ulong)uVar1);
return;
}
| |
26,431 | mi_read_cache | eloqsql/storage/myisam/mi_cache.c | int _mi_read_cache(IO_CACHE *info, uchar *buff, my_off_t pos, size_t length,
int flag)
{
size_t read_length,in_buff_length;
my_off_t offset;
uchar *in_buff_pos;
DBUG_ENTER("_mi_read_cache");
DBUG_ASSERT(!(info->myflags & MY_ENCRYPT));
if (pos < info->pos_in_file)
{
read_length=length;
if ((my_off_t) read_length > (my_off_t) (info->pos_in_file-pos))
read_length=(size_t)(info->pos_in_file-pos);
info->seek_not_done=1;
if (mysql_file_pread(info->file, buff, read_length, pos, MYF(MY_NABP)))
DBUG_RETURN(1);
if (!(length-=read_length))
DBUG_RETURN(0);
pos+=read_length;
buff+=read_length;
}
if (pos >= info->pos_in_file &&
(offset= (my_off_t) (pos - info->pos_in_file)) <
(my_off_t) (info->read_end - info->request_pos))
{
in_buff_pos=info->request_pos+ (uint)offset;
in_buff_length= MY_MIN(length, (size_t)(info->read_end-in_buff_pos));
memcpy(buff,info->request_pos+(uint) offset, in_buff_length);
if (!(length-=in_buff_length))
DBUG_RETURN(0);
pos+=in_buff_length;
buff+=in_buff_length;
}
else
in_buff_length=0;
if (flag & READING_NEXT)
{
if (pos != (info->pos_in_file +
(uint) (info->read_end - info->request_pos)))
{
info->pos_in_file=pos; /* Force start here */
info->read_pos=info->read_end=info->request_pos; /* Everything used */
info->seek_not_done=1;
}
else
info->read_pos=info->read_end; /* All block used */
if (!_my_b_read(info,buff,length))
DBUG_RETURN(0);
read_length=info->error;
}
else
{
info->seek_not_done=1;
if ((read_length= mysql_file_pread(info->file, buff, length, pos,
MYF(0))) == length)
DBUG_RETURN(0);
}
if (!(flag & READING_HEADER) || (int) read_length == -1 ||
read_length+in_buff_length < 3)
{
DBUG_PRINT("error",
("Error %d reading next-multi-part block (Got %d bytes)",
my_errno, (int) read_length));
if (!my_errno || my_errno == -1 || my_errno == HA_ERR_FILE_TOO_SHORT)
my_errno= HA_ERR_WRONG_IN_RECORD;
DBUG_RETURN(1);
}
bzero(buff+read_length,MI_BLOCK_INFO_HEADER_LENGTH - in_buff_length -
read_length);
DBUG_RETURN(0);
} | O0 | c | mi_read_cache:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
jmp 0xdb84e
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0xdb916
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq -0x20(%rbp), %rcx
cmpq %rcx, %rax
jbe 0xdb88a
movq -0x10(%rbp), %rax
movq (%rax), %rax
subq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, 0xe0(%rax)
movq -0x10(%rbp), %rax
movl 0xd4(%rax), %edx
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x20(%rbp), %r9
leaq 0x83b94(%rip), %rdi # 0x15f449
movl $0x35, %esi
movq $0x4, (%rsp)
callq 0xdbba0
cmpq $0x0, %rax
je 0xdb8db
jmp 0xdb8cf
movl $0x1, -0x4(%rbp)
jmp 0xdbb8f
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xdb8fe
jmp 0xdb8f2
movl $0x0, -0x4(%rbp)
jmp 0xdbb8f
movq -0x38(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jb 0xdb9ff
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq (%rcx), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x10(%rbp), %rdx
movq 0x28(%rdx), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jae 0xdb9ff
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x48(%rbp), %rcx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x50(%rbp), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jae 0xdb989
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0xdb99c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x50(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x48(%rbp), %rax
movl %eax, %eax
addq %rax, %rsi
movq -0x40(%rbp), %rdx
callq 0x2a0b0
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xdb9e5
jmp 0xdb9d9
movl $0x0, -0x4(%rbp)
jmp 0xdbb8f
movq -0x40(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xdba07
movq $0x0, -0x40(%rbp)
movl -0x2c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xdbab6
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq -0x10(%rbp), %rdx
movq 0x18(%rdx), %rdx
movq -0x10(%rbp), %rsi
movq 0x28(%rsi), %rsi
subq %rsi, %rdx
movl %edx, %edx
addq %rdx, %rcx
cmpq %rcx, %rax
je 0xdba71
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0xe0(%rax)
jmp 0xdba81
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xe5e50
cmpl $0x0, %eax
jne 0xdbaa5
jmp 0xdba99
movl $0x0, -0x4(%rbp)
jmp 0xdbb8f
movq -0x10(%rbp), %rax
movslq 0xe4(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xdbb0f
movq -0x10(%rbp), %rax
movl $0x1, 0xe0(%rax)
movq -0x10(%rbp), %rax
movl 0xd4(%rax), %edx
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x20(%rbp), %r9
leaq 0x83968(%rip), %rdi # 0x15f449
movl $0x5d, %esi
xorl %eax, %eax
movq $0x0, (%rsp)
callq 0xdbba0
movq %rax, -0x38(%rbp)
cmpq -0x28(%rbp), %rax
jne 0xdbb0d
jmp 0xdbb01
movl $0x0, -0x4(%rbp)
jmp 0xdbb8f
jmp 0xdbb0f
movl -0x2c(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xdbb31
movq -0x38(%rbp), %rax
cmpl $-0x1, %eax
je 0xdbb31
movq -0x38(%rbp), %rax
addq -0x40(%rbp), %rax
cmpq $0x3, %rax
jae 0xdbb6c
jmp 0xdbb33
jmp 0xdbb35
callq 0xfea30
cmpl $0x0, (%rax)
je 0xdbb56
callq 0xfea30
cmpl $-0x1, (%rax)
je 0xdbb56
callq 0xfea30
cmpl $0xaf, (%rax)
jne 0xdbb61
callq 0xfea30
movl $0x7f, (%rax)
jmp 0xdbb63
movl $0x1, -0x4(%rbp)
jmp 0xdbb8f
movq -0x18(%rbp), %rdi
addq -0x38(%rbp), %rdi
movl $0x14, %edx
subq -0x40(%rbp), %rdx
subq -0x38(%rbp), %rdx
xorl %esi, %esi
callq 0x2a2a0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _mi_read_cache:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_2C], r8d
jmp short $+2
loc_DB84E:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_10]
cmp rax, [rcx]
jnb loc_DB916
mov rax, [rbp+var_28]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov rcx, [rbp+var_10]
mov rcx, [rcx]
sub rcx, [rbp+var_20]
cmp rax, rcx
jbe short loc_DB88A
mov rax, [rbp+var_10]
mov rax, [rax]
sub rax, [rbp+var_20]
mov [rbp+var_38], rax
loc_DB88A:
mov rax, [rbp+var_10]
mov dword ptr [rax+0E0h], 1
mov rax, [rbp+var_10]
mov edx, [rax+0D4h]
mov rcx, [rbp+var_18]
mov r8, [rbp+var_38]
mov r9, [rbp+var_20]
lea rdi, aWorkspaceLlm4b_36; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 35h ; '5'
mov [rsp+60h+var_60], 4
call inline_mysql_file_pread_8
cmp rax, 0
jz short loc_DB8DB
jmp short $+2
loc_DB8CF:
mov [rbp+var_4], 1
jmp loc_DBB8F
loc_DB8DB:
mov rcx, [rbp+var_38]
mov rax, [rbp+var_28]
sub rax, rcx
mov [rbp+var_28], rax
cmp rax, 0
jnz short loc_DB8FE
jmp short $+2
loc_DB8F2:
mov [rbp+var_4], 0
jmp loc_DBB8F
loc_DB8FE:
mov rax, [rbp+var_38]
add rax, [rbp+var_20]
mov [rbp+var_20], rax
mov rax, [rbp+var_38]
add rax, [rbp+var_18]
mov [rbp+var_18], rax
loc_DB916:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_10]
cmp rax, [rcx]
jb loc_DB9FF
mov rax, [rbp+var_20]
mov rcx, [rbp+var_10]
sub rax, [rcx]
mov [rbp+var_48], rax
mov rcx, [rbp+var_10]
mov rcx, [rcx+18h]
mov rdx, [rbp+var_10]
mov rdx, [rdx+28h]
sub rcx, rdx
cmp rax, rcx
jnb loc_DB9FF
mov rax, [rbp+var_10]
mov rax, [rax+28h]
mov rcx, [rbp+var_48]
mov ecx, ecx
add rax, rcx
mov [rbp+var_50], rax
mov rax, [rbp+var_28]
mov rcx, [rbp+var_10]
mov rcx, [rcx+18h]
mov rdx, [rbp+var_50]
sub rcx, rdx
cmp rax, rcx
jnb short loc_DB989
mov rax, [rbp+var_28]
mov [rbp+var_58], rax
jmp short loc_DB99C
loc_DB989:
mov rax, [rbp+var_10]
mov rax, [rax+18h]
mov rcx, [rbp+var_50]
sub rax, rcx
mov [rbp+var_58], rax
loc_DB99C:
mov rax, [rbp+var_58]
mov [rbp+var_40], rax
mov rdi, [rbp+var_18]
mov rax, [rbp+var_10]
mov rsi, [rax+28h]
mov rax, [rbp+var_48]
mov eax, eax
add rsi, rax
mov rdx, [rbp+var_40]
call _memcpy
mov rcx, [rbp+var_40]
mov rax, [rbp+var_28]
sub rax, rcx
mov [rbp+var_28], rax
cmp rax, 0
jnz short loc_DB9E5
jmp short $+2
loc_DB9D9:
mov [rbp+var_4], 0
jmp loc_DBB8F
loc_DB9E5:
mov rax, [rbp+var_40]
add rax, [rbp+var_20]
mov [rbp+var_20], rax
mov rax, [rbp+var_40]
add rax, [rbp+var_18]
mov [rbp+var_18], rax
jmp short loc_DBA07
loc_DB9FF:
mov [rbp+var_40], 0
loc_DBA07:
mov eax, [rbp+var_2C]
and eax, 1
cmp eax, 0
jz loc_DBAB6
mov rax, [rbp+var_20]
mov rcx, [rbp+var_10]
mov rcx, [rcx]
mov rdx, [rbp+var_10]
mov rdx, [rdx+18h]
mov rsi, [rbp+var_10]
mov rsi, [rsi+28h]
sub rdx, rsi
mov edx, edx
add rcx, rdx
cmp rax, rcx
jz short loc_DBA71
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+28h]
mov rax, [rbp+var_10]
mov [rax+18h], rcx
mov rax, [rbp+var_10]
mov [rax+10h], rcx
mov rax, [rbp+var_10]
mov dword ptr [rax+0E0h], 1
jmp short loc_DBA81
loc_DBA71:
mov rax, [rbp+var_10]
mov rcx, [rax+18h]
mov rax, [rbp+var_10]
mov [rax+10h], rcx
loc_DBA81:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_28]
call _my_b_read
cmp eax, 0
jnz short loc_DBAA5
jmp short $+2
loc_DBA99:
mov [rbp+var_4], 0
jmp loc_DBB8F
loc_DBAA5:
mov rax, [rbp+var_10]
movsxd rax, dword ptr [rax+0E4h]
mov [rbp+var_38], rax
jmp short loc_DBB0F
loc_DBAB6:
mov rax, [rbp+var_10]
mov dword ptr [rax+0E0h], 1
mov rax, [rbp+var_10]
mov edx, [rax+0D4h]
mov rcx, [rbp+var_18]
mov r8, [rbp+var_28]
mov r9, [rbp+var_20]
lea rdi, aWorkspaceLlm4b_36; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 5Dh ; ']'
xor eax, eax
mov [rsp+60h+var_60], 0
call inline_mysql_file_pread_8
mov [rbp+var_38], rax
cmp rax, [rbp+var_28]
jnz short loc_DBB0D
jmp short $+2
loc_DBB01:
mov [rbp+var_4], 0
jmp loc_DBB8F
loc_DBB0D:
jmp short $+2
loc_DBB0F:
mov eax, [rbp+var_2C]
and eax, 2
cmp eax, 0
jz short loc_DBB31
mov rax, [rbp+var_38]
cmp eax, 0FFFFFFFFh
jz short loc_DBB31
mov rax, [rbp+var_38]
add rax, [rbp+var_40]
cmp rax, 3
jnb short loc_DBB6C
loc_DBB31:
jmp short $+2
loc_DBB33:
jmp short $+2
loc_DBB35:
call _my_thread_var
cmp dword ptr [rax], 0
jz short loc_DBB56
call _my_thread_var
cmp dword ptr [rax], 0FFFFFFFFh
jz short loc_DBB56
call _my_thread_var
cmp dword ptr [rax], 0AFh
jnz short loc_DBB61
loc_DBB56:
call _my_thread_var
mov dword ptr [rax], 7Fh
loc_DBB61:
jmp short $+2
loc_DBB63:
mov [rbp+var_4], 1
jmp short loc_DBB8F
loc_DBB6C:
mov rdi, [rbp+var_18]
add rdi, [rbp+var_38]
mov edx, 14h
sub rdx, [rbp+var_40]
sub rdx, [rbp+var_38]
xor esi, esi
call _memset
mov [rbp+var_4], 0
loc_DBB8F:
mov eax, [rbp+var_4]
add rsp, 60h
pop rbp
retn
| long long mi_read_cache(char *a1, const char *a2, unsigned long long a3, unsigned long long a4, char a5)
{
long long v5; // rcx
const char *v6; // rsi
unsigned long long v8; // [rsp+8h] [rbp-58h]
long long v9; // [rsp+10h] [rbp-50h]
unsigned long long v10; // [rsp+18h] [rbp-48h]
unsigned long long v11; // [rsp+20h] [rbp-40h]
unsigned long long v12; // [rsp+28h] [rbp-38h]
long long v13; // [rsp+28h] [rbp-38h]
unsigned long long v15; // [rsp+38h] [rbp-28h]
unsigned long long v16; // [rsp+40h] [rbp-20h]
const char *v17; // [rsp+48h] [rbp-18h]
char *v18; // [rsp+50h] [rbp-10h]
v18 = a1;
v17 = a2;
v16 = a3;
v15 = a4;
if ( a3 < *(_QWORD *)a1 )
{
v12 = a4;
if ( a4 > *(_QWORD *)a1 - a3 )
v12 = *(_QWORD *)a1 - a3;
*((_DWORD *)a1 + 56) = 1;
if ( inline_mysql_file_pread_8(
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_cache.c",
53,
*((_DWORD *)a1 + 53),
(_DWORD)a2,
v12,
a3,
4LL) )
{
return 1;
}
v15 -= v12;
if ( !v15 )
return 0;
v16 += v12;
v17 = &a2[v12];
}
if ( v16 < *(_QWORD *)a1 || (v10 = v16 - *(_QWORD *)a1, v10 >= *((_QWORD *)a1 + 3) - *((_QWORD *)a1 + 5)) )
{
v11 = 0LL;
}
else
{
v9 = (unsigned int)v10 + *((_QWORD *)a1 + 5);
if ( v15 >= *((_QWORD *)a1 + 3) - v9 )
v8 = *((_QWORD *)a1 + 3) - v9;
else
v8 = v15;
v11 = v8;
memcpy(v17, (unsigned int)v10 + *((_QWORD *)a1 + 5), v8);
v15 -= v8;
if ( !v15 )
return 0;
v16 += v8;
v17 += v8;
}
if ( (a5 & 1) != 0 )
{
if ( v16 == (unsigned int)*((_QWORD *)a1 + 3) - (unsigned int)*((_QWORD *)a1 + 5) + *(_QWORD *)a1 )
{
*((_QWORD *)a1 + 2) = *((_QWORD *)a1 + 3);
}
else
{
*(_QWORD *)a1 = v16;
v5 = *((_QWORD *)a1 + 5);
*((_QWORD *)a1 + 3) = v5;
*((_QWORD *)a1 + 2) = v5;
*((_DWORD *)a1 + 56) = 1;
}
v6 = v17;
if ( !(unsigned int)my_b_read(a1, v17, v15) )
return 0;
v13 = *((int *)a1 + 57);
}
else
{
*((_DWORD *)a1 + 56) = 1;
a1 = "/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_cache.c";
v6 = (_BYTE *)(&qword_58 + 5);
v13 = inline_mysql_file_pread_8(
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_cache.c",
93,
*((_DWORD *)v18 + 53),
(_DWORD)v17,
v15,
v16,
0LL);
if ( v13 == v15 )
return 0;
}
if ( (a5 & 2) != 0 && (_DWORD)v13 != -1 && v11 + v13 >= 3 )
{
memset(&v17[v13], 0LL, 20 - v11 - v13);
return 0;
}
else
{
if ( !*(_DWORD *)my_thread_var(a1, v6)
|| *(_DWORD *)my_thread_var(a1, v6) == -1
|| *(_DWORD *)my_thread_var(a1, v6) == 175 )
{
*(_DWORD *)my_thread_var(a1, v6) = 127;
}
return 1;
}
}
| _mi_read_cache:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV dword ptr [RBP + -0x2c],R8D
JMP 0x001db84e
LAB_001db84e:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX]
JNC 0x001db916
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX]
SUB RCX,qword ptr [RBP + -0x20]
CMP RAX,RCX
JBE 0x001db88a
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
SUB RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x38],RAX
LAB_001db88a:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe0],0x1
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0xd4]
MOV RCX,qword ptr [RBP + -0x18]
MOV R8,qword ptr [RBP + -0x38]
MOV R9,qword ptr [RBP + -0x20]
LEA RDI,[0x25f449]
MOV ESI,0x35
MOV qword ptr [RSP],0x4
CALL 0x001dbba0
CMP RAX,0x0
JZ 0x001db8db
JMP 0x001db8cf
LAB_001db8cf:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001dbb8f
LAB_001db8db:
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
CMP RAX,0x0
JNZ 0x001db8fe
JMP 0x001db8f2
LAB_001db8f2:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001dbb8f
LAB_001db8fe:
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x18],RAX
LAB_001db916:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX]
JC 0x001db9ff
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
SUB RAX,qword ptr [RCX]
MOV qword ptr [RBP + -0x48],RAX
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x18]
MOV RDX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RDX + 0x28]
SUB RCX,RDX
CMP RAX,RCX
JNC 0x001db9ff
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x28]
MOV RCX,qword ptr [RBP + -0x48]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x18]
MOV RDX,qword ptr [RBP + -0x50]
SUB RCX,RDX
CMP RAX,RCX
JNC 0x001db989
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x58],RAX
JMP 0x001db99c
LAB_001db989:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RBP + -0x50]
SUB RAX,RCX
MOV qword ptr [RBP + -0x58],RAX
LAB_001db99c:
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x28]
MOV RAX,qword ptr [RBP + -0x48]
MOV EAX,EAX
ADD RSI,RAX
MOV RDX,qword ptr [RBP + -0x40]
CALL 0x0012a0b0
MOV RCX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
CMP RAX,0x0
JNZ 0x001db9e5
JMP 0x001db9d9
LAB_001db9d9:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001dbb8f
LAB_001db9e5:
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001dba07
LAB_001db9ff:
MOV qword ptr [RBP + -0x40],0x0
LAB_001dba07:
MOV EAX,dword ptr [RBP + -0x2c]
AND EAX,0x1
CMP EAX,0x0
JZ 0x001dbab6
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX]
MOV RDX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RDX + 0x18]
MOV RSI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RSI + 0x28]
SUB RDX,RSI
MOV EDX,EDX
ADD RCX,RDX
CMP RAX,RCX
JZ 0x001dba71
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe0],0x1
JMP 0x001dba81
LAB_001dba71:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],RCX
LAB_001dba81:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x001e5e50
CMP EAX,0x0
JNZ 0x001dbaa5
JMP 0x001dba99
LAB_001dba99:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001dbb8f
LAB_001dbaa5:
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RAX,dword ptr [RAX + 0xe4]
MOV qword ptr [RBP + -0x38],RAX
JMP 0x001dbb0f
LAB_001dbab6:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe0],0x1
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0xd4]
MOV RCX,qword ptr [RBP + -0x18]
MOV R8,qword ptr [RBP + -0x28]
MOV R9,qword ptr [RBP + -0x20]
LEA RDI,[0x25f449]
MOV ESI,0x5d
XOR EAX,EAX
MOV qword ptr [RSP],0x0
CALL 0x001dbba0
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,qword ptr [RBP + -0x28]
JNZ 0x001dbb0d
JMP 0x001dbb01
LAB_001dbb01:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001dbb8f
LAB_001dbb0d:
JMP 0x001dbb0f
LAB_001dbb0f:
MOV EAX,dword ptr [RBP + -0x2c]
AND EAX,0x2
CMP EAX,0x0
JZ 0x001dbb31
MOV RAX,qword ptr [RBP + -0x38]
CMP EAX,-0x1
JZ 0x001dbb31
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,qword ptr [RBP + -0x40]
CMP RAX,0x3
JNC 0x001dbb6c
LAB_001dbb31:
JMP 0x001dbb33
LAB_001dbb33:
JMP 0x001dbb35
LAB_001dbb35:
CALL 0x001fea30
CMP dword ptr [RAX],0x0
JZ 0x001dbb56
CALL 0x001fea30
CMP dword ptr [RAX],-0x1
JZ 0x001dbb56
CALL 0x001fea30
CMP dword ptr [RAX],0xaf
JNZ 0x001dbb61
LAB_001dbb56:
CALL 0x001fea30
MOV dword ptr [RAX],0x7f
LAB_001dbb61:
JMP 0x001dbb63
LAB_001dbb63:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001dbb8f
LAB_001dbb6c:
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,qword ptr [RBP + -0x38]
MOV EDX,0x14
SUB RDX,qword ptr [RBP + -0x40]
SUB RDX,qword ptr [RBP + -0x38]
XOR ESI,ESI
CALL 0x0012a2a0
MOV dword ptr [RBP + -0x4],0x0
LAB_001dbb8f:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x60
POP RBP
RET
|
int4 _mi_read_cache(ulong *param_1,void *param_2,ulong param_3,ulong param_4,uint param_5)
{
int iVar1;
long lVar2;
ulong uVar3;
int *piVar4;
int4 *puVar5;
size_t local_60;
size_t local_48;
ulong local_40;
ulong local_30;
ulong local_28;
void *local_20;
int4 local_c;
local_30 = param_4;
local_28 = param_3;
local_20 = param_2;
if (param_3 < *param_1) {
local_40 = param_4;
if (*param_1 - param_3 < param_4) {
local_40 = *param_1 - param_3;
}
*(int4 *)(param_1 + 0x1c) = 1;
lVar2 = inline_mysql_file_pread
("/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_cache.c",0x35,
*(int4 *)((long)param_1 + 0xd4),param_2,local_40,param_3,4);
if (lVar2 != 0) {
return 1;
}
local_30 = param_4 - local_40;
if (local_30 == 0) {
return 0;
}
local_28 = local_40 + param_3;
local_20 = (void *)(local_40 + (long)param_2);
}
if ((local_28 < *param_1) || (uVar3 = local_28 - *param_1, param_1[3] - param_1[5] <= uVar3)) {
local_48 = 0;
}
else {
lVar2 = param_1[5] + (uVar3 & 0xffffffff);
if (local_30 < param_1[3] - lVar2) {
local_60 = local_30;
}
else {
local_60 = param_1[3] - lVar2;
}
local_48 = local_60;
memcpy(local_20,(void *)(param_1[5] + (uVar3 & 0xffffffff)),local_60);
local_30 = local_30 - local_60;
if (local_30 == 0) {
return 0;
}
local_28 = local_60 + local_28;
local_20 = (void *)(local_60 + (long)local_20);
}
if ((param_5 & 1) == 0) {
*(int4 *)(param_1 + 0x1c) = 1;
local_40 = inline_mysql_file_pread
("/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_cache.c",0x5d,
*(int4 *)((long)param_1 + 0xd4),local_20,local_30,local_28,0);
if (local_40 == local_30) {
return 0;
}
}
else {
if (local_28 == *param_1 + (ulong)(uint)((int)param_1[3] - (int)param_1[5])) {
param_1[2] = param_1[3];
}
else {
*param_1 = local_28;
param_1[3] = param_1[5];
param_1[2] = param_1[5];
*(int4 *)(param_1 + 0x1c) = 1;
}
iVar1 = _my_b_read(param_1,local_20,local_30);
if (iVar1 == 0) {
return 0;
}
local_40 = (ulong)*(int *)((long)param_1 + 0xe4);
}
if ((((param_5 & 2) == 0) || ((int)local_40 == -1)) || (local_40 + local_48 < 3)) {
piVar4 = (int *)_my_thread_var();
if (((*piVar4 == 0) || (piVar4 = (int *)_my_thread_var(), *piVar4 == -1)) ||
(piVar4 = (int *)_my_thread_var(), *piVar4 == 0xaf)) {
puVar5 = (int4 *)_my_thread_var();
*puVar5 = 0x7f;
}
local_c = 1;
}
else {
memset((void *)((long)local_20 + local_40),0,(0x14 - local_48) - local_40);
local_c = 0;
}
return local_c;
}
| |
26,432 | common_sampler_sample(common_sampler*, llama_context*, int, bool) | monkey531[P]llama/common/sampling.cpp | llama_token common_sampler_sample(struct common_sampler * gsmpl, struct llama_context * ctx, int idx, bool grammar_first) {
gsmpl->set_logits(ctx, idx);
auto & grmr = gsmpl->grmr;
auto & chain = gsmpl->chain;
auto & cur_p = gsmpl->cur_p; // initialized by set_logits
if (grammar_first) {
llama_sampler_apply(grmr, &cur_p);
}
llama_sampler_apply(chain, &cur_p);
GGML_ASSERT(cur_p.selected != -1 && "no selected token during sampling - check your sampling configuration");
const llama_token id = cur_p.data[cur_p.selected].id;
if (grammar_first) {
return id;
}
// check if it the sampled token fits the grammar
{
llama_token_data single_token_data = { id, 1.0f, 0.0f };
llama_token_data_array single_token_data_array = { &single_token_data, 1, -1, false };
llama_sampler_apply(grmr, &single_token_data_array);
const bool is_valid = single_token_data_array.data[0].logit != -INFINITY;
if (is_valid) {
return id;
}
}
// resampling:
// if the token is not valid, sample again, but first apply the grammar sampler and then the sampling chain
gsmpl->set_logits(ctx, idx);
llama_sampler_apply(grmr, &cur_p);
llama_sampler_apply(chain, &cur_p);
GGML_ASSERT(cur_p.selected != -1 && "no selected token during re-sampling - check your sampling configuration");
return cur_p.data[cur_p.selected].id;
} | O2 | cpp | common_sampler_sample(common_sampler*, llama_context*, int, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %r12d
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
callq 0xa4478
leaq 0x198(%rbx), %r14
testl %r12d, %r12d
je 0xa36fd
movq 0x138(%rbx), %rdi
movq %r14, %rsi
callq 0x24df0
movq 0x140(%rbx), %rdi
movq %r14, %rsi
callq 0x24df0
movq 0x1a8(%rbx), %rax
cmpq $-0x1, %rax
je 0xa37d9
movq (%r14), %rcx
imulq $0xc, %rax, %rax
movl (%rcx,%rax), %r13d
testb %r12b, %r12b
jne 0xa37c7
leaq 0xc(%rsp), %rax
movl %r13d, (%rax)
leaq 0x18(%rsp), %r12
movq %rax, (%r12)
movq $0x1, 0x8(%r12)
orq $-0x1, 0x10(%r12)
movss 0x11913(%rip), %xmm0 # 0xb506c
movlps %xmm0, 0x4(%rax)
movb $0x0, 0x18(%r12)
movq 0x138(%rbx), %rdi
movq %r12, %rsi
callq 0x24df0
movq (%r12), %rax
movss 0x21a6a(%rip), %xmm0 # 0xc51e8
ucomiss 0x4(%rax), %xmm0
jb 0xa37c7
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xa4478
movq 0x138(%rbx), %rdi
movq %r14, %rsi
callq 0x24df0
movq 0x140(%rbx), %rdi
movq %r14, %rsi
callq 0x24df0
movq 0x1a8(%rbx), %rax
cmpq $-0x1, %rax
je 0xa37f5
movq (%r14), %rcx
imulq $0xc, %rax, %rax
movl (%rcx,%rax), %r13d
movl %r13d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x21b7d(%rip), %rdi # 0xc535d
leaq 0x12309(%rip), %rdx # 0xb5af0
leaq 0x21c39(%rip), %rcx # 0xc5427
movl $0x133, %esi # imm = 0x133
jmp 0xa380f
leaq 0x21b61(%rip), %rdi # 0xc535d
leaq 0x122ed(%rip), %rdx # 0xb5af0
leaq 0x21c7d(%rip), %rcx # 0xc5487
movl $0x14f, %esi # imm = 0x14F
xorl %eax, %eax
callq 0x24f20
| _Z21common_sampler_sampleP14common_samplerP13llama_contextib:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r12d, ecx
mov ebp, edx
mov r15, rsi
mov rbx, rdi
call _ZN14common_sampler10set_logitsEP13llama_contexti; common_sampler::set_logits(llama_context *,int)
lea r14, [rbx+198h]
test r12d, r12d
jz short loc_A36FD
mov rdi, [rbx+138h]
mov rsi, r14
call _llama_sampler_apply
loc_A36FD:
mov rdi, [rbx+140h]
mov rsi, r14
call _llama_sampler_apply
mov rax, [rbx+1A8h]
cmp rax, 0FFFFFFFFFFFFFFFFh
jz loc_A37D9
mov rcx, [r14]
imul rax, 0Ch
mov r13d, [rcx+rax]
test r12b, r12b
jnz loc_A37C7
lea rax, [rsp+68h+var_5C]
mov [rax], r13d
lea r12, [rsp+68h+var_50]
mov [r12], rax
mov qword ptr [r12+8], 1
or qword ptr [r12+10h], 0FFFFFFFFFFFFFFFFh
movss xmm0, cs:dword_B506C
movlps qword ptr [rax+4], xmm0
mov byte ptr [r12+18h], 0
mov rdi, [rbx+138h]
mov rsi, r12
call _llama_sampler_apply
mov rax, [r12]
movss xmm0, cs:dword_C51E8
ucomiss xmm0, dword ptr [rax+4]
jb short loc_A37C7
mov rdi, rbx
mov rsi, r15
mov edx, ebp
call _ZN14common_sampler10set_logitsEP13llama_contexti; common_sampler::set_logits(llama_context *,int)
mov rdi, [rbx+138h]
mov rsi, r14
call _llama_sampler_apply
mov rdi, [rbx+140h]
mov rsi, r14
call _llama_sampler_apply
mov rax, [rbx+1A8h]
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_A37F5
mov rcx, [r14]
imul rax, 0Ch
mov r13d, [rcx+rax]
loc_A37C7:
mov eax, r13d
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_A37D9:
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCurPSelected1N; "cur_p.selected != -1 && \"no selected t"...
mov esi, 133h
jmp short loc_A380F
loc_A37F5:
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCurPSelected1N_0; "cur_p.selected != -1 && \"no selected t"...
mov esi, 14Fh
loc_A380F:
xor eax, eax
call _ggml_abort
| long long common_sampler_sample(_QWORD *a1, long long a2, unsigned int a3, int a4)
{
_QWORD *v6; // r14
long long v7; // rax
unsigned int v8; // r13d
long long v9; // rax
int v11; // [rsp+Ch] [rbp-5Ch] BYREF
double v12; // [rsp+10h] [rbp-58h] BYREF
_QWORD v13[3]; // [rsp+18h] [rbp-50h] BYREF
char v14; // [rsp+30h] [rbp-38h]
((void (*)(void))common_sampler::set_logits)();
v6 = a1 + 51;
if ( a4 )
llama_sampler_apply(a1[39], a1 + 51);
llama_sampler_apply(a1[40], a1 + 51);
v7 = a1[53];
if ( v7 == -1 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/sampling.cpp",
307LL,
"GGML_ASSERT(%s) failed",
"cur_p.selected != -1 && \"no selected token during sampling - check your sampling configuration\"");
}
else
{
v8 = *(_DWORD *)(*v6 + 12 * v7);
if ( (_BYTE)a4 )
return v8;
v11 = *(_DWORD *)(*v6 + 12 * v7);
v13[0] = &v11;
v13[1] = 1LL;
v13[2] = -1LL;
_mm_storel_ps(&v12, (__m128)0x3F800000u);
v14 = 0;
llama_sampler_apply(a1[39], v13);
if ( *(float *)(v13[0] + 4LL) > -INFINITY )
return v8;
common_sampler::set_logits(a1, a2, a3);
llama_sampler_apply(a1[39], a1 + 51);
llama_sampler_apply(a1[40], a1 + 51);
v9 = a1[53];
if ( v9 != -1 )
return *(unsigned int *)(*v6 + 12 * v9);
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/sampling.cpp",
335LL,
"GGML_ASSERT(%s) failed",
"cur_p.selected != -1 && \"no selected token during re-sampling - check your sampling configuration\"");
}
return common_sampler_sample_and_accept_n();
}
| common_sampler_sample:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R12D,ECX
MOV EBP,EDX
MOV R15,RSI
MOV RBX,RDI
CALL 0x001a4478
LEA R14,[RBX + 0x198]
TEST R12D,R12D
JZ 0x001a36fd
MOV RDI,qword ptr [RBX + 0x138]
MOV RSI,R14
CALL 0x00124df0
LAB_001a36fd:
MOV RDI,qword ptr [RBX + 0x140]
MOV RSI,R14
CALL 0x00124df0
MOV RAX,qword ptr [RBX + 0x1a8]
CMP RAX,-0x1
JZ 0x001a37d9
MOV RCX,qword ptr [R14]
IMUL RAX,RAX,0xc
MOV R13D,dword ptr [RCX + RAX*0x1]
TEST R12B,R12B
JNZ 0x001a37c7
LEA RAX,[RSP + 0xc]
MOV dword ptr [RAX],R13D
LEA R12,[RSP + 0x18]
MOV qword ptr [R12],RAX
MOV qword ptr [R12 + 0x8],0x1
OR qword ptr [R12 + 0x10],-0x1
MOVSS XMM0,dword ptr [0x001b506c]
MOVLPS qword ptr [RAX + 0x4],XMM0
MOV byte ptr [R12 + 0x18],0x0
MOV RDI,qword ptr [RBX + 0x138]
MOV RSI,R12
CALL 0x00124df0
MOV RAX,qword ptr [R12]
MOVSS XMM0,dword ptr [0x001c51e8]
UCOMISS XMM0,dword ptr [RAX + 0x4]
JC 0x001a37c7
MOV RDI,RBX
MOV RSI,R15
MOV EDX,EBP
CALL 0x001a4478
MOV RDI,qword ptr [RBX + 0x138]
MOV RSI,R14
CALL 0x00124df0
MOV RDI,qword ptr [RBX + 0x140]
MOV RSI,R14
CALL 0x00124df0
MOV RAX,qword ptr [RBX + 0x1a8]
CMP RAX,-0x1
JZ 0x001a37f5
MOV RCX,qword ptr [R14]
IMUL RAX,RAX,0xc
MOV R13D,dword ptr [RCX + RAX*0x1]
LAB_001a37c7:
MOV EAX,R13D
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001a37d9:
LEA RDI,[0x1c535d]
LEA RDX,[0x1b5af0]
LEA RCX,[0x1c5427]
MOV ESI,0x133
JMP 0x001a380f
LAB_001a37f5:
LEA RDI,[0x1c535d]
LEA RDX,[0x1b5af0]
LEA RCX,[0x1c5487]
MOV ESI,0x14f
LAB_001a380f:
XOR EAX,EAX
CALL 0x00124f20
|
/* common_sampler_sample(common_sampler*, llama_context*, int, bool) */
int4
common_sampler_sample(common_sampler *param_1,llama_context *param_2,int param_3,bool param_4)
{
common_sampler *pcVar1;
int7 in_register_00000009;
char *pcVar2;
int8 uVar3;
int4 uVar4;
int4 local_5c;
ulong local_58;
int4 *local_50;
int8 local_48;
int8 local_40;
int1 local_38;
common_sampler::set_logits(param_1,param_2,param_3);
pcVar1 = param_1 + 0x198;
if ((int)CONCAT71(in_register_00000009,param_4) != 0) {
llama_sampler_apply(*(int8 *)(param_1 + 0x138),pcVar1);
}
llama_sampler_apply(*(int8 *)(param_1 + 0x140),pcVar1);
if (*(long *)(param_1 + 0x1a8) != -1) {
uVar4 = *(int4 *)(*(long *)pcVar1 + *(long *)(param_1 + 0x1a8) * 0xc);
if (!param_4) {
local_50 = &local_5c;
local_48 = 1;
local_40 = 0xffffffffffffffff;
local_58 = (ulong)DAT_001b506c;
local_38 = 0;
local_5c = uVar4;
llama_sampler_apply(*(int8 *)(param_1 + 0x138),&local_50);
if ((float)local_50[1] <= DAT_001c51e8) {
common_sampler::set_logits(param_1,param_2,param_3);
llama_sampler_apply(*(int8 *)(param_1 + 0x138),pcVar1);
llama_sampler_apply(*(int8 *)(param_1 + 0x140),pcVar1);
if (*(long *)(param_1 + 0x1a8) == -1) {
pcVar2 =
"cur_p.selected != -1 && \"no selected token during re-sampling - check your sampling configuration\""
;
uVar3 = 0x14f;
goto LAB_001a380f;
}
uVar4 = *(int4 *)(*(long *)pcVar1 + *(long *)(param_1 + 0x1a8) * 0xc);
}
}
return uVar4;
}
pcVar2 =
"cur_p.selected != -1 && \"no selected token during sampling - check your sampling configuration\""
;
uVar3 = 0x133;
LAB_001a380f:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/sampling.cpp",uVar3,
"GGML_ASSERT(%s) failed",pcVar2);
}
| |
26,433 | common_sampler_sample(common_sampler*, llama_context*, int, bool) | monkey531[P]llama/common/sampling.cpp | llama_token common_sampler_sample(struct common_sampler * gsmpl, struct llama_context * ctx, int idx, bool grammar_first) {
gsmpl->set_logits(ctx, idx);
auto & grmr = gsmpl->grmr;
auto & chain = gsmpl->chain;
auto & cur_p = gsmpl->cur_p; // initialized by set_logits
if (grammar_first) {
llama_sampler_apply(grmr, &cur_p);
}
llama_sampler_apply(chain, &cur_p);
GGML_ASSERT(cur_p.selected != -1 && "no selected token during sampling - check your sampling configuration");
const llama_token id = cur_p.data[cur_p.selected].id;
if (grammar_first) {
return id;
}
// check if it the sampled token fits the grammar
{
llama_token_data single_token_data = { id, 1.0f, 0.0f };
llama_token_data_array single_token_data_array = { &single_token_data, 1, -1, false };
llama_sampler_apply(grmr, &single_token_data_array);
const bool is_valid = single_token_data_array.data[0].logit != -INFINITY;
if (is_valid) {
return id;
}
}
// resampling:
// if the token is not valid, sample again, but first apply the grammar sampler and then the sampling chain
gsmpl->set_logits(ctx, idx);
llama_sampler_apply(grmr, &cur_p);
llama_sampler_apply(chain, &cur_p);
GGML_ASSERT(cur_p.selected != -1 && "no selected token during re-sampling - check your sampling configuration");
return cur_p.data[cur_p.selected].id;
} | O3 | cpp | common_sampler_sample(common_sampler*, llama_context*, int, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %r12d
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
callq 0xdc276
leaq 0x198(%rbx), %r14
testl %r12d, %r12d
je 0xdb18d
movq 0x138(%rbx), %rdi
movq %r14, %rsi
callq 0x1bdf0
movq 0x140(%rbx), %rdi
movq %r14, %rsi
callq 0x1bdf0
movq 0x1a8(%rbx), %rax
cmpq $-0x1, %rax
je 0xdb26c
movq (%r14), %rcx
leaq (%rax,%rax,2), %rax
movl (%rcx,%rax,4), %r13d
testb %r12b, %r12b
jne 0xdb25a
leaq 0xc(%rsp), %rax
movl %r13d, (%rax)
movss 0x17e37(%rip), %xmm0 # 0xf3008
movlps %xmm0, 0x4(%rax)
leaq 0x18(%rsp), %r12
movq %rax, (%r12)
movq $0x1, 0x8(%r12)
movq $-0x1, 0x10(%r12)
movb $0x0, 0x18(%r12)
movq 0x138(%rbx), %rdi
movq %r12, %rsi
callq 0x1bdf0
movq (%r12), %rax
movss 0x28023(%rip), %xmm0 # 0x103234
ucomiss 0x4(%rax), %xmm0
jb 0xdb25a
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xdc276
movq 0x138(%rbx), %rdi
movq %r14, %rsi
callq 0x1bdf0
movq 0x140(%rbx), %rdi
movq %r14, %rsi
callq 0x1bdf0
movq 0x1a8(%rbx), %rax
cmpq $-0x1, %rax
je 0xdb288
movq (%r14), %rcx
leaq (%rax,%rax,2), %rax
movl (%rcx,%rax,4), %r13d
movl %r13d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28136(%rip), %rdi # 0x1033a9
leaq 0x188c6(%rip), %rdx # 0xf3b40
leaq 0x281f2(%rip), %rcx # 0x103473
movl $0x133, %esi # imm = 0x133
jmp 0xdb2a2
leaq 0x2811a(%rip), %rdi # 0x1033a9
leaq 0x188aa(%rip), %rdx # 0xf3b40
leaq 0x28236(%rip), %rcx # 0x1034d3
movl $0x14f, %esi # imm = 0x14F
xorl %eax, %eax
callq 0x1bf10
| _Z21common_sampler_sampleP14common_samplerP13llama_contextib:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r12d, ecx
mov ebp, edx
mov r15, rsi
mov rbx, rdi
call _ZN14common_sampler10set_logitsEP13llama_contexti; common_sampler::set_logits(llama_context *,int)
lea r14, [rbx+198h]
test r12d, r12d
jz short loc_DB18D
mov rdi, [rbx+138h]
mov rsi, r14
call _llama_sampler_apply
loc_DB18D:
mov rdi, [rbx+140h]
mov rsi, r14
call _llama_sampler_apply
mov rax, [rbx+1A8h]
cmp rax, 0FFFFFFFFFFFFFFFFh
jz loc_DB26C
mov rcx, [r14]
lea rax, [rax+rax*2]
mov r13d, [rcx+rax*4]
test r12b, r12b
jnz loc_DB25A
lea rax, [rsp+68h+var_5C]
mov [rax], r13d
movss xmm0, cs:dword_F3008
movlps qword ptr [rax+4], xmm0
lea r12, [rsp+68h+var_50]
mov [r12], rax
mov qword ptr [r12+8], 1
mov qword ptr [r12+10h], 0FFFFFFFFFFFFFFFFh
mov byte ptr [r12+18h], 0
mov rdi, [rbx+138h]
mov rsi, r12
call _llama_sampler_apply
mov rax, [r12]
movss xmm0, cs:dword_103234
ucomiss xmm0, dword ptr [rax+4]
jb short loc_DB25A
mov rdi, rbx
mov rsi, r15
mov edx, ebp
call _ZN14common_sampler10set_logitsEP13llama_contexti; common_sampler::set_logits(llama_context *,int)
mov rdi, [rbx+138h]
mov rsi, r14
call _llama_sampler_apply
mov rdi, [rbx+140h]
mov rsi, r14
call _llama_sampler_apply
mov rax, [rbx+1A8h]
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_DB288
mov rcx, [r14]
lea rax, [rax+rax*2]
mov r13d, [rcx+rax*4]
loc_DB25A:
mov eax, r13d
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_DB26C:
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCurPSelected1N; "cur_p.selected != -1 && \"no selected t"...
mov esi, 133h
jmp short loc_DB2A2
loc_DB288:
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCurPSelected1N_0; "cur_p.selected != -1 && \"no selected t"...
mov esi, 14Fh
loc_DB2A2:
xor eax, eax
call _ggml_abort
| long long common_sampler_sample(_QWORD *a1, long long a2, unsigned int a3, int a4)
{
_QWORD *v6; // r14
long long v7; // rax
unsigned int v8; // r13d
long long v9; // rax
double v11; // xmm0_8
int v12; // [rsp+Ch] [rbp-5Ch] BYREF
double v13; // [rsp+10h] [rbp-58h] BYREF
_QWORD v14[3]; // [rsp+18h] [rbp-50h] BYREF
char v15; // [rsp+30h] [rbp-38h]
((void (*)(void))common_sampler::set_logits)();
v6 = a1 + 51;
if ( a4 )
llama_sampler_apply(a1[39], a1 + 51);
llama_sampler_apply(a1[40], a1 + 51);
v7 = a1[53];
if ( v7 == -1 )
{
v11 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/sampling.cpp",
307LL,
"GGML_ASSERT(%s) failed",
"cur_p.selected != -1 && \"no selected token during sampling - check your sampling configuration\"");
}
else
{
v8 = *(_DWORD *)(*v6 + 12 * v7);
if ( (_BYTE)a4 )
return v8;
v12 = *(_DWORD *)(*v6 + 12 * v7);
_mm_storel_ps(&v13, (__m128)0x3F800000u);
v14[0] = &v12;
v14[1] = 1LL;
v14[2] = -1LL;
v15 = 0;
llama_sampler_apply(a1[39], v14);
if ( *(float *)(v14[0] + 4LL) > -INFINITY )
return v8;
common_sampler::set_logits(a1, a2, a3);
llama_sampler_apply(a1[39], a1 + 51);
llama_sampler_apply(a1[40], a1 + 51);
v9 = a1[53];
if ( v9 != -1 )
return *(unsigned int *)(*v6 + 12 * v9);
v11 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/sampling.cpp",
335LL,
"GGML_ASSERT(%s) failed",
"cur_p.selected != -1 && \"no selected token during re-sampling - check your sampling configuration\"");
}
return common_sampler_sample_and_accept_n(v11);
}
| common_sampler_sample:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R12D,ECX
MOV EBP,EDX
MOV R15,RSI
MOV RBX,RDI
CALL 0x001dc276
LEA R14,[RBX + 0x198]
TEST R12D,R12D
JZ 0x001db18d
MOV RDI,qword ptr [RBX + 0x138]
MOV RSI,R14
CALL 0x0011bdf0
LAB_001db18d:
MOV RDI,qword ptr [RBX + 0x140]
MOV RSI,R14
CALL 0x0011bdf0
MOV RAX,qword ptr [RBX + 0x1a8]
CMP RAX,-0x1
JZ 0x001db26c
MOV RCX,qword ptr [R14]
LEA RAX,[RAX + RAX*0x2]
MOV R13D,dword ptr [RCX + RAX*0x4]
TEST R12B,R12B
JNZ 0x001db25a
LEA RAX,[RSP + 0xc]
MOV dword ptr [RAX],R13D
MOVSS XMM0,dword ptr [0x001f3008]
MOVLPS qword ptr [RAX + 0x4],XMM0
LEA R12,[RSP + 0x18]
MOV qword ptr [R12],RAX
MOV qword ptr [R12 + 0x8],0x1
MOV qword ptr [R12 + 0x10],-0x1
MOV byte ptr [R12 + 0x18],0x0
MOV RDI,qword ptr [RBX + 0x138]
MOV RSI,R12
CALL 0x0011bdf0
MOV RAX,qword ptr [R12]
MOVSS XMM0,dword ptr [0x00203234]
UCOMISS XMM0,dword ptr [RAX + 0x4]
JC 0x001db25a
MOV RDI,RBX
MOV RSI,R15
MOV EDX,EBP
CALL 0x001dc276
MOV RDI,qword ptr [RBX + 0x138]
MOV RSI,R14
CALL 0x0011bdf0
MOV RDI,qword ptr [RBX + 0x140]
MOV RSI,R14
CALL 0x0011bdf0
MOV RAX,qword ptr [RBX + 0x1a8]
CMP RAX,-0x1
JZ 0x001db288
MOV RCX,qword ptr [R14]
LEA RAX,[RAX + RAX*0x2]
MOV R13D,dword ptr [RCX + RAX*0x4]
LAB_001db25a:
MOV EAX,R13D
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001db26c:
LEA RDI,[0x2033a9]
LEA RDX,[0x1f3b40]
LEA RCX,[0x203473]
MOV ESI,0x133
JMP 0x001db2a2
LAB_001db288:
LEA RDI,[0x2033a9]
LEA RDX,[0x1f3b40]
LEA RCX,[0x2034d3]
MOV ESI,0x14f
LAB_001db2a2:
XOR EAX,EAX
CALL 0x0011bf10
|
/* common_sampler_sample(common_sampler*, llama_context*, int, bool) */
int4
common_sampler_sample(common_sampler *param_1,llama_context *param_2,int param_3,bool param_4)
{
common_sampler *pcVar1;
int7 in_register_00000009;
char *pcVar2;
int8 uVar3;
int4 uVar4;
int4 local_5c;
ulong local_58;
int4 *local_50;
int8 local_48;
int8 local_40;
int1 local_38;
common_sampler::set_logits(param_1,param_2,param_3);
pcVar1 = param_1 + 0x198;
if ((int)CONCAT71(in_register_00000009,param_4) != 0) {
llama_sampler_apply(*(int8 *)(param_1 + 0x138),pcVar1);
}
llama_sampler_apply(*(int8 *)(param_1 + 0x140),pcVar1);
if (*(long *)(param_1 + 0x1a8) != -1) {
uVar4 = *(int4 *)(*(long *)pcVar1 + *(long *)(param_1 + 0x1a8) * 0xc);
if (!param_4) {
local_50 = &local_5c;
local_58 = (ulong)DAT_001f3008;
local_48 = 1;
local_40 = 0xffffffffffffffff;
local_38 = 0;
local_5c = uVar4;
llama_sampler_apply(*(int8 *)(param_1 + 0x138),&local_50);
if ((float)local_50[1] <= DAT_00203234) {
common_sampler::set_logits(param_1,param_2,param_3);
llama_sampler_apply(*(int8 *)(param_1 + 0x138),pcVar1);
llama_sampler_apply(*(int8 *)(param_1 + 0x140),pcVar1);
if (*(long *)(param_1 + 0x1a8) == -1) {
pcVar2 =
"cur_p.selected != -1 && \"no selected token during re-sampling - check your sampling configuration\""
;
uVar3 = 0x14f;
goto LAB_001db2a2;
}
uVar4 = *(int4 *)(*(long *)pcVar1 + *(long *)(param_1 + 0x1a8) * 0xc);
}
}
return uVar4;
}
pcVar2 =
"cur_p.selected != -1 && \"no selected token during sampling - check your sampling configuration\""
;
uVar3 = 0x133;
LAB_001db2a2:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/sampling.cpp",uVar3,
"GGML_ASSERT(%s) failed",pcVar2);
}
| |
26,434 | mysql_stmt_fetch_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_stmt_fetch_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_stmt_fetch,
(parms->stmt),
parms->stmt->mysql,
int,
r_int)
} | O0 | c | mysql_stmt_fetch_start_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x506e0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| mysql_stmt_fetch_start_internal:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+38h]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rdi, [rax]
call mysql_stmt_fetch
mov [rbp+var_14], eax
mov ecx, [rbp+var_14]
mov rax, [rbp+var_20]
mov [rax+8], ecx
mov rax, [rbp+var_20]
mov dword ptr [rax], 0
add rsp, 20h
pop rbp
retn
| _DWORD * mysql_stmt_fetch_start_internal(long long *a1)
{
_DWORD *result; // rax
_DWORD *v2; // [rsp+0h] [rbp-20h]
v2 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(*a1 + 56) + 1152LL) + 40LL);
v2[2] = mysql_stmt_fetch(*a1);
result = v2;
*v2 = 0;
return result;
}
| mysql_stmt_fetch_start_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
CALL 0x001506e0
MOV dword ptr [RBP + -0x14],EAX
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x8],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0x0
ADD RSP,0x20
POP RBP
RET
|
void mysql_stmt_fetch_start_internal(long *param_1)
{
int4 *puVar1;
int4 uVar2;
puVar1 = *(int4 **)(*(long *)(*(long *)(*param_1 + 0x38) + 0x480) + 0x28);
uVar2 = mysql_stmt_fetch(*param_1);
puVar1[2] = uVar2;
*puVar1 = 0;
return;
}
| |
26,435 | minja::Value::to_str[abi:cxx11]() const | monkey531[P]llama/common/./minja.hpp | std::string to_str() const {
if (is_string()) return get<std::string>();
if (is_number_integer()) return std::to_string(get<int64_t>());
if (is_number_float()) return std::to_string(get<double>());
if (is_boolean()) return get<bool>() ? "True" : "False";
if (is_null()) return "None";
return dump();
} | O0 | cpp | minja::Value::to_str[abi:cxx11]() const:
subq $0x58, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0xa1f30
testb $0x1, %al
jne 0xe4f60
jmp 0xe4f74
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rdi
callq 0xa4860
jmp 0xe50bd
movq 0x28(%rsp), %rdi
callq 0x9fb00
testb $0x1, %al
jne 0xe4f84
jmp 0xe4fa0
movq 0x28(%rsp), %rdi
callq 0x9fb20
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0xe6050
jmp 0xe50bd
movq 0x28(%rsp), %rdi
callq 0xe5fd0
testb $0x1, %al
jne 0xe4fb0
jmp 0xe4fc9
movq 0x28(%rsp), %rdi
callq 0x9fc90
movq 0x18(%rsp), %rdi
callq 0xe61a0
jmp 0xe50bd
movq 0x28(%rsp), %rdi
callq 0xa1f10
testb $0x1, %al
jne 0xe4fd9
jmp 0xe504c
movq 0x28(%rsp), %rdi
callq 0xa4730
movb %al, %dl
leaq 0xe7c8e(%rip), %rcx # 0x1ccc7a
leaq 0xe7c8c(%rip), %rax # 0x1ccc7f
testb %dl, %dl
cmovneq %rcx, %rax
movq %rax, 0x8(%rsp)
leaq 0x47(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x50d60
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x61bd0
jmp 0xe5023
leaq 0x47(%rsp), %rdi
callq 0x510a0
jmp 0xe50bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x47(%rsp), %rdi
callq 0x510a0
jmp 0xe50c7
movq 0x28(%rsp), %rdi
callq 0xa18f0
testb $0x1, %al
jne 0xe505c
jmp 0xe50a7
leaq 0x33(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x50d60
movq 0x18(%rsp), %rdi
movq (%rsp), %rdx
leaq 0xe8035(%rip), %rsi # 0x1cd0af
callq 0x61bd0
jmp 0xe5081
leaq 0x33(%rsp), %rdi
callq 0x510a0
jmp 0xe50bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x33(%rsp), %rdi
callq 0x510a0
jmp 0xe50c7
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rdi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x9feb0
movq 0x20(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x50940
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| _ZNK5minja5Value6to_strB5cxx11Ev:
sub rsp, 58h
mov [rsp+58h+var_40], rdi; int
mov rax, rdi
mov qword ptr [rsp+58h+var_38], rax; __int16
mov qword ptr [rsp+58h+var_8], rdi; char
mov [rsp+58h+var_10], rsi; int
mov rdi, [rsp+58h+var_10]; this
mov [rsp+58h+var_30], rdi; __int64
call _ZNK5minja5Value9is_stringEv; minja::Value::is_string(void)
test al, 1
jnz short loc_E4F60
jmp short loc_E4F74
loc_E4F60:
mov rsi, [rsp+58h+var_30]; int
mov rdi, [rsp+58h+var_40]; int
call _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v; minja::Value::get<std::string>(void)
jmp loc_E50BD
loc_E4F74:
mov rdi, [rsp+58h+var_30]; this
call _ZNK5minja5Value17is_number_integerEv; minja::Value::is_number_integer(void)
test al, 1
jnz short loc_E4F84
jmp short loc_E4FA0
loc_E4F84:
mov rdi, [rsp+58h+var_30]
call _ZNK5minja5Value3getIlEET_v; minja::Value::get<long>(void)
mov rdi, [rsp+58h+var_40]; this
mov rsi, rax; __int64
call _ZNSt7__cxx119to_stringEl; std::to_string(long)
jmp loc_E50BD
loc_E4FA0:
mov rdi, [rsp+58h+var_30]; this
call _ZNK5minja5Value15is_number_floatEv; minja::Value::is_number_float(void)
test al, 1
jnz short loc_E4FB0
jmp short loc_E4FC9
loc_E4FB0:
mov rdi, [rsp+58h+var_30]
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
mov rdi, [rsp+58h+var_40]; this
call _ZNSt7__cxx119to_stringEd; std::to_string(double)
jmp loc_E50BD
loc_E4FC9:
mov rdi, [rsp+58h+var_30]; this
call _ZNK5minja5Value10is_booleanEv; minja::Value::is_boolean(void)
test al, 1
jnz short loc_E4FD9
jmp short loc_E504C
loc_E4FD9:
mov rdi, [rsp+58h+var_30]
call _ZNK5minja5Value3getIbEET_v; minja::Value::get<bool>(void)
mov dl, al
lea rcx, aTrue; "True"
lea rax, aFalse_0; "False"
test dl, dl
cmovnz rax, rcx
mov [rsp+58h+var_50], rax
lea rdi, [rsp+58h+var_11]
mov [rsp+58h+var_48], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdi, [rsp+58h+var_40]
mov rsi, [rsp+58h+var_50]
mov rdx, [rsp+58h+var_48]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_E5023:
lea rdi, [rsp+58h+var_11]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_E50BD
mov rcx, rax
mov eax, edx
mov [rsp+arg_30], rcx
mov [rsp+arg_2C], eax
lea rdi, [rsp+arg_3F]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_E50C7
loc_E504C:
mov rdi, [rsp+58h+var_30]; this
call _ZNK5minja5Value7is_nullEv; minja::Value::is_null(void)
test al, 1
jnz short loc_E505C
jmp short loc_E50A7
loc_E505C:
lea rdi, [rsp+58h+var_25]
mov [rsp+58h+var_58], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdi, [rsp+58h+var_40]
mov rdx, [rsp+58h+var_58]
lea rsi, aNone; "None"
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_E5081:
lea rdi, [rsp+58h+var_25]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_E50BD
mov rcx, rax
mov eax, edx
mov [rsp+arg_30], rcx
mov [rsp+arg_2C], eax
lea rdi, [rsp+arg_2B]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_E50C7
loc_E50A7:
mov rsi, [rsp+58h+var_30]
mov rdi, [rsp+58h+var_40]
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
loc_E50BD:
mov rax, qword ptr [rsp+58h+var_38]
add rsp, 58h
retn
loc_E50C7:
mov rdi, [rsp+arg_30]
call __Unwind_Resume
| void * minja::Value::to_str[abi:cxx11](void *a1, minja::Value *a2, double a3)
{
long long v3; // rax
char v4; // dl
const char *v5; // rax
long long v7; // [rsp+8h] [rbp-50h]
_BYTE v8[20]; // [rsp+33h] [rbp-25h] BYREF
char v9; // [rsp+47h] [rbp-11h] BYREF
minja::Value *v10; // [rsp+48h] [rbp-10h]
char v11[8]; // [rsp+50h] [rbp-8h]
*(_QWORD *)v11 = a1;
v10 = a2;
if ( minja::Value::is_string(a2) )
{
minja::Value::get<std::string>(a1, a2);
}
else if ( (minja::Value::is_number_integer(a2) & 1) != 0 )
{
v3 = minja::Value::get<long>(a2);
std::to_string((std::__cxx11 *)a1, v3);
}
else if ( (minja::Value::is_number_float(a2) & 1) != 0 )
{
minja::Value::get<double>(a2);
std::to_string((std::__cxx11 *)a1, a3);
}
else if ( (minja::Value::is_boolean(a2) & 1) != 0 )
{
v4 = minja::Value::get<bool>(a2);
v5 = "False";
if ( v4 )
v5 = "True";
v7 = (long long)v5;
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>((long long)a1, v7, (long long)&v9);
std::allocator<char>::~allocator(&v9);
}
else if ( (minja::Value::is_null(a2) & 1) != 0 )
{
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>((long long)a1, (long long)"None", (long long)v8);
std::allocator<char>::~allocator(v8);
}
else
{
minja::Value::dump[abi:cxx11]((long long)a1, (long long)a2, 0xFFFFFFFF, 0);
}
return a1;
}
| to_str[abi:cxx11]:
SUB RSP,0x58
MOV qword ptr [RSP + 0x18],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x50],RDI
MOV qword ptr [RSP + 0x48],RSI
MOV RDI,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x28],RDI
CALL 0x001a1f30
TEST AL,0x1
JNZ 0x001e4f60
JMP 0x001e4f74
LAB_001e4f60:
MOV RSI,qword ptr [RSP + 0x28]
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001a4860
JMP 0x001e50bd
LAB_001e4f74:
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x0019fb00
TEST AL,0x1
JNZ 0x001e4f84
JMP 0x001e4fa0
LAB_001e4f84:
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x0019fb20
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,RAX
CALL 0x001e6050
JMP 0x001e50bd
LAB_001e4fa0:
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x001e5fd0
TEST AL,0x1
JNZ 0x001e4fb0
JMP 0x001e4fc9
LAB_001e4fb0:
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x0019fc90
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001e61a0
JMP 0x001e50bd
LAB_001e4fc9:
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x001a1f10
TEST AL,0x1
JNZ 0x001e4fd9
JMP 0x001e504c
LAB_001e4fd9:
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x001a4730
MOV DL,AL
LEA RCX,[0x2ccc7a]
LEA RAX,[0x2ccc7f]
TEST DL,DL
CMOVNZ RAX,RCX
MOV qword ptr [RSP + 0x8],RAX
LEA RDI,[RSP + 0x47]
MOV qword ptr [RSP + 0x10],RDI
CALL 0x00150d60
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
LAB_001e501c:
CALL 0x00161bd0
JMP 0x001e5023
LAB_001e5023:
LEA RDI,[RSP + 0x47]
CALL 0x001510a0
JMP 0x001e50bd
LAB_001e504c:
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x001a18f0
TEST AL,0x1
JNZ 0x001e505c
JMP 0x001e50a7
LAB_001e505c:
LEA RDI,[RSP + 0x33]
MOV qword ptr [RSP],RDI
CALL 0x00150d60
MOV RDI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP]
LAB_001e5073:
LEA RSI,[0x2cd0af]
CALL 0x00161bd0
LAB_001e507f:
JMP 0x001e5081
LAB_001e5081:
LEA RDI,[RSP + 0x33]
CALL 0x001510a0
JMP 0x001e50bd
LAB_001e50a7:
MOV RSI,qword ptr [RSP + 0x28]
MOV RDI,qword ptr [RSP + 0x18]
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0019feb0
LAB_001e50bd:
MOV RAX,qword ptr [RSP + 0x20]
ADD RSP,0x58
RET
|
/* minja::Value::to_str[abi:cxx11]() const */
__cxx11 * minja::Value::to_str_abi_cxx11_(void)
{
bool bVar1;
ulong uVar2;
long lVar3;
char *pcVar4;
Value *in_RSI;
__cxx11 *in_RDI;
double dVar5;
allocator local_25 [20];
allocator local_11 [17];
uVar2 = is_string(in_RSI);
if ((uVar2 & 1) == 0) {
uVar2 = is_number_integer(in_RSI);
if ((uVar2 & 1) == 0) {
uVar2 = is_number_float(in_RSI);
if ((uVar2 & 1) == 0) {
uVar2 = is_boolean(in_RSI);
if ((uVar2 & 1) == 0) {
uVar2 = is_null(in_RSI);
if ((uVar2 & 1) == 0) {
dump_abi_cxx11_((int)in_RDI,SUB81(in_RSI,0));
}
else {
std::allocator<char>::allocator();
/* try { // try from 001e5073 to 001e507e has its CatchHandler @ 001e508d */
std::__cxx11::string::string<std::allocator<char>>((string *)in_RDI,"None",local_25);
std::allocator<char>::~allocator((allocator<char> *)local_25);
}
}
else {
bVar1 = get<bool>(in_RSI);
pcVar4 = "False";
if (bVar1) {
pcVar4 = "True";
}
std::allocator<char>::allocator();
/* try { // try from 001e501c to 001e5020 has its CatchHandler @ 001e5032 */
std::__cxx11::string::string<std::allocator<char>>((string *)in_RDI,pcVar4,local_11);
std::allocator<char>::~allocator((allocator<char> *)local_11);
}
}
else {
dVar5 = get<double>(in_RSI);
std::__cxx11::to_string(in_RDI,dVar5);
}
}
else {
lVar3 = get<long>(in_RSI);
std::__cxx11::to_string(in_RDI,lVar3);
}
}
else {
get<std::__cxx11::string>();
}
return in_RDI;
}
| |
26,436 | my_strntol_8bit | eloqsql/strings/ctype-simple.c | long my_strntol_8bit(CHARSET_INFO *cs,
const char *nptr, size_t l, int base,
char **endptr, int *err)
{
int negative;
register uint32 cutoff;
register uint cutlim;
register uint32 i;
register const char *s;
register uchar c;
const char *save, *e;
int overflow;
*err= 0; /* Initialize error indicator */
s = nptr;
e = nptr+l;
for ( ; s<e && my_isspace(cs, *s) ; s++);
if (s == e)
{
goto noconv;
}
/* Check for a sign. */
if (*s == '-')
{
negative = 1;
++s;
}
else if (*s == '+')
{
negative = 0;
++s;
}
else
negative = 0;
save = s;
cutoff = ((uint32)~0L) / (uint32) base;
cutlim = (uint) (((uint32)~0L) % (uint32) base);
overflow = 0;
i = 0;
for (c = *s; s != e; c = *++s)
{
if (c>='0' && c<='9')
c -= '0';
else if (c>='A' && c<='Z')
c = c - 'A' + 10;
else if (c>='a' && c<='z')
c = c - 'a' + 10;
else
break;
if (c >= base)
break;
if (i > cutoff || (i == cutoff && c > cutlim))
overflow = 1;
else
{
i *= (uint32) base;
i += c;
}
}
if (s == save)
goto noconv;
if (endptr != NULL)
*endptr = (char *) s;
if (negative)
{
if (i > (uint32) INT_MIN32)
overflow = 1;
}
else if (i > INT_MAX32)
overflow = 1;
if (overflow)
{
err[0]= ERANGE;
return negative ? INT_MIN32 : INT_MAX32;
}
return (negative ? -((long) i) : (long) i);
noconv:
err[0]= EDOM;
if (endptr != NULL)
*endptr = (char *) nptr;
return 0L;
} | O0 | c | my_strntol_8bit:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %rcx
xorl %eax, %eax
cmpq -0x68(%rbp), %rcx
movb %al, -0x6d(%rbp)
jae 0x1150c8
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x50(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl 0x1(%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x6d(%rbp)
movb -0x6d(%rbp), %al
testb $0x1, %al
jne 0x1150d1
jmp 0x1150e1
jmp 0x1150d3
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x115099
movq -0x50(%rbp), %rax
cmpq -0x68(%rbp), %rax
jne 0x1150f0
jmp 0x1152e5
movq -0x50(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x115111
movl $0x1, -0x3c(%rbp)
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x11513b
movq -0x50(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x115132
movl $0x0, -0x3c(%rbp)
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x115139
movl $0x0, -0x3c(%rbp)
jmp 0x11513b
movq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
xorl %edx, %edx
divl -0x24(%rbp)
movl %eax, -0x40(%rbp)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
xorl %edx, %edx
divl -0x24(%rbp)
movl %edx, -0x44(%rbp)
movl $0x0, -0x6c(%rbp)
movl $0x0, -0x48(%rbp)
movq -0x50(%rbp), %rax
movb (%rax), %al
movb %al, -0x51(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x68(%rbp), %rax
je 0x115245
movzbl -0x51(%rbp), %eax
cmpl $0x30, %eax
jl 0x1151a0
movzbl -0x51(%rbp), %eax
cmpl $0x39, %eax
jg 0x1151a0
movzbl -0x51(%rbp), %eax
subl $0x30, %eax
movb %al, -0x51(%rbp)
jmp 0x1151e8
movzbl -0x51(%rbp), %eax
cmpl $0x41, %eax
jl 0x1151c1
movzbl -0x51(%rbp), %eax
cmpl $0x5a, %eax
jg 0x1151c1
movzbl -0x51(%rbp), %eax
subl $0x41, %eax
addl $0xa, %eax
movb %al, -0x51(%rbp)
jmp 0x1151e6
movzbl -0x51(%rbp), %eax
cmpl $0x61, %eax
jl 0x1151e2
movzbl -0x51(%rbp), %eax
cmpl $0x7a, %eax
jg 0x1151e2
movzbl -0x51(%rbp), %eax
subl $0x61, %eax
addl $0xa, %eax
movb %al, -0x51(%rbp)
jmp 0x1151e4
jmp 0x115245
jmp 0x1151e6
jmp 0x1151e8
movzbl -0x51(%rbp), %eax
cmpl -0x24(%rbp), %eax
jl 0x1151f3
jmp 0x115245
movl -0x48(%rbp), %eax
cmpl -0x40(%rbp), %eax
ja 0x11520c
movl -0x48(%rbp), %eax
cmpl -0x40(%rbp), %eax
jne 0x115215
movzbl -0x51(%rbp), %eax
cmpl -0x44(%rbp), %eax
jbe 0x115215
movl $0x1, -0x6c(%rbp)
jmp 0x115229
movl -0x24(%rbp), %eax
imull -0x48(%rbp), %eax
movl %eax, -0x48(%rbp)
movzbl -0x51(%rbp), %eax
addl -0x48(%rbp), %eax
movl %eax, -0x48(%rbp)
jmp 0x11522b
movq -0x50(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x50(%rbp)
movb 0x1(%rax), %al
movb %al, -0x51(%rbp)
jmp 0x115174
movq -0x50(%rbp), %rax
cmpq -0x60(%rbp), %rax
jne 0x115254
jmp 0x1152e5
cmpq $0x0, -0x30(%rbp)
je 0x115266
movq -0x50(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
cmpl $0x0, -0x3c(%rbp)
je 0x11527e
cmpl $0x80000000, -0x48(%rbp) # imm = 0x80000000
jbe 0x11527c
movl $0x1, -0x6c(%rbp)
jmp 0x115292
movl -0x48(%rbp), %eax
cmpq $0x7fffffff, %rax # imm = 0x7FFFFFFF
jle 0x115290
movl $0x1, -0x6c(%rbp)
jmp 0x115292
cmpl $0x0, -0x6c(%rbp)
je 0x1152be
movq -0x38(%rbp), %rax
movl $0x22, (%rax)
movl -0x3c(%rbp), %edx
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
movq $-0x80000000, %rcx # imm = 0x80000000
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x115309
cmpl $0x0, -0x3c(%rbp)
je 0x1152d4
movl -0x48(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
movq %rax, -0x78(%rbp)
jmp 0x1152db
movl -0x48(%rbp), %eax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x115309
movq -0x38(%rbp), %rax
movl $0x21, (%rax)
cmpq $0x0, -0x30(%rbp)
je 0x115301
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| my_strntol_8bit:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
mov rax, [rbp+var_38]
mov dword ptr [rax], 0
mov rax, [rbp+var_18]
mov [rbp+var_50], rax
mov rax, [rbp+var_18]
add rax, [rbp+var_20]
mov [rbp+var_68], rax
loc_115099:
mov rcx, [rbp+var_50]
xor eax, eax
cmp rcx, [rbp+var_68]
mov [rbp+var_6D], al
jnb short loc_1150C8
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rcx, [rbp+var_50]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx+1]
and eax, 8
cmp eax, 0
setnz al
mov [rbp+var_6D], al
loc_1150C8:
mov al, [rbp+var_6D]
test al, 1
jnz short loc_1150D1
jmp short loc_1150E1
loc_1150D1:
jmp short $+2
loc_1150D3:
mov rax, [rbp+var_50]
add rax, 1
mov [rbp+var_50], rax
jmp short loc_115099
loc_1150E1:
mov rax, [rbp+var_50]
cmp rax, [rbp+var_68]
jnz short loc_1150F0
jmp loc_1152E5
loc_1150F0:
mov rax, [rbp+var_50]
movsx eax, byte ptr [rax]
cmp eax, 2Dh ; '-'
jnz short loc_115111
mov [rbp+var_3C], 1
mov rax, [rbp+var_50]
add rax, 1
mov [rbp+var_50], rax
jmp short loc_11513B
loc_115111:
mov rax, [rbp+var_50]
movsx eax, byte ptr [rax]
cmp eax, 2Bh ; '+'
jnz short loc_115132
mov [rbp+var_3C], 0
mov rax, [rbp+var_50]
add rax, 1
mov [rbp+var_50], rax
jmp short loc_115139
loc_115132:
mov [rbp+var_3C], 0
loc_115139:
jmp short $+2
loc_11513B:
mov rax, [rbp+var_50]
mov [rbp+var_60], rax
mov eax, 0FFFFFFFFh
xor edx, edx
div [rbp+var_24]
mov [rbp+var_40], eax
mov eax, 0FFFFFFFFh
xor edx, edx
div [rbp+var_24]
mov [rbp+var_44], edx
mov [rbp+var_6C], 0
mov [rbp+var_48], 0
mov rax, [rbp+var_50]
mov al, [rax]
mov [rbp+var_51], al
loc_115174:
mov rax, [rbp+var_50]
cmp rax, [rbp+var_68]
jz loc_115245
movzx eax, [rbp+var_51]
cmp eax, 30h ; '0'
jl short loc_1151A0
movzx eax, [rbp+var_51]
cmp eax, 39h ; '9'
jg short loc_1151A0
movzx eax, [rbp+var_51]
sub eax, 30h ; '0'
mov [rbp+var_51], al
jmp short loc_1151E8
loc_1151A0:
movzx eax, [rbp+var_51]
cmp eax, 41h ; 'A'
jl short loc_1151C1
movzx eax, [rbp+var_51]
cmp eax, 5Ah ; 'Z'
jg short loc_1151C1
movzx eax, [rbp+var_51]
sub eax, 41h ; 'A'
add eax, 0Ah
mov [rbp+var_51], al
jmp short loc_1151E6
loc_1151C1:
movzx eax, [rbp+var_51]
cmp eax, 61h ; 'a'
jl short loc_1151E2
movzx eax, [rbp+var_51]
cmp eax, 7Ah ; 'z'
jg short loc_1151E2
movzx eax, [rbp+var_51]
sub eax, 61h ; 'a'
add eax, 0Ah
mov [rbp+var_51], al
jmp short loc_1151E4
loc_1151E2:
jmp short loc_115245
loc_1151E4:
jmp short $+2
loc_1151E6:
jmp short $+2
loc_1151E8:
movzx eax, [rbp+var_51]
cmp eax, [rbp+var_24]
jl short loc_1151F3
jmp short loc_115245
loc_1151F3:
mov eax, [rbp+var_48]
cmp eax, [rbp+var_40]
ja short loc_11520C
mov eax, [rbp+var_48]
cmp eax, [rbp+var_40]
jnz short loc_115215
movzx eax, [rbp+var_51]
cmp eax, [rbp+var_44]
jbe short loc_115215
loc_11520C:
mov [rbp+var_6C], 1
jmp short loc_115229
loc_115215:
mov eax, [rbp+var_24]
imul eax, [rbp+var_48]
mov [rbp+var_48], eax
movzx eax, [rbp+var_51]
add eax, [rbp+var_48]
mov [rbp+var_48], eax
loc_115229:
jmp short $+2
loc_11522B:
mov rax, [rbp+var_50]
mov rcx, rax
add rcx, 1
mov [rbp+var_50], rcx
mov al, [rax+1]
mov [rbp+var_51], al
jmp loc_115174
loc_115245:
mov rax, [rbp+var_50]
cmp rax, [rbp+var_60]
jnz short loc_115254
jmp loc_1152E5
loc_115254:
cmp [rbp+var_30], 0
jz short loc_115266
mov rcx, [rbp+var_50]
mov rax, [rbp+var_30]
mov [rax], rcx
loc_115266:
cmp [rbp+var_3C], 0
jz short loc_11527E
cmp [rbp+var_48], 80000000h
jbe short loc_11527C
mov [rbp+var_6C], 1
loc_11527C:
jmp short loc_115292
loc_11527E:
mov eax, [rbp+var_48]
cmp rax, 7FFFFFFFh
jle short loc_115290
mov [rbp+var_6C], 1
loc_115290:
jmp short $+2
loc_115292:
cmp [rbp+var_6C], 0
jz short loc_1152BE
mov rax, [rbp+var_38]
mov dword ptr [rax], 22h ; '"'
mov edx, [rbp+var_3C]
mov eax, 7FFFFFFFh
mov rcx, 0FFFFFFFF80000000h
cmp edx, 0
cmovnz rax, rcx
mov [rbp+var_8], rax
jmp short loc_115309
loc_1152BE:
cmp [rbp+var_3C], 0
jz short loc_1152D4
mov eax, [rbp+var_48]
mov ecx, eax
xor eax, eax
sub rax, rcx
mov [rbp+var_78], rax
jmp short loc_1152DB
loc_1152D4:
mov eax, [rbp+var_48]
mov [rbp+var_78], rax
loc_1152DB:
mov rax, [rbp+var_78]
mov [rbp+var_8], rax
jmp short loc_115309
loc_1152E5:
mov rax, [rbp+var_38]
mov dword ptr [rax], 21h ; '!'
cmp [rbp+var_30], 0
jz short loc_115301
mov rcx, [rbp+var_18]
mov rax, [rbp+var_30]
mov [rax], rcx
loc_115301:
mov [rbp+var_8], 0
loc_115309:
mov rax, [rbp+var_8]
pop rbp
retn
| long long my_strntol_8bit(long long a1, _BYTE *a2, long long a3, int a4, _QWORD *a5, _DWORD *a6)
{
_BYTE *v6; // rax
long long v7; // rax
bool v10; // [rsp+Bh] [rbp-6Dh]
int v11; // [rsp+Ch] [rbp-6Ch]
_BYTE *v12; // [rsp+10h] [rbp-68h]
_BYTE *v13; // [rsp+18h] [rbp-60h]
unsigned __int8 v14; // [rsp+27h] [rbp-51h]
unsigned __int8 v15; // [rsp+27h] [rbp-51h]
_BYTE *v16; // [rsp+28h] [rbp-50h]
unsigned int v17; // [rsp+30h] [rbp-48h]
unsigned long long v18; // [rsp+34h] [rbp-44h]
int v19; // [rsp+3Ch] [rbp-3Ch]
*a6 = 0;
v16 = a2;
v12 = &a2[a3];
while ( 1 )
{
v10 = 0;
if ( v16 < v12 )
v10 = (*(_BYTE *)(*(_QWORD *)(a1 + 64) + (unsigned __int8)*v16 + 1LL) & 8) != 0;
if ( !v10 )
break;
++v16;
}
if ( v16 == v12 )
goto LABEL_45;
if ( *v16 == 45 )
{
v19 = 1;
++v16;
}
else
{
v19 = 0;
if ( *v16 == 43 )
++v16;
}
v13 = v16;
v11 = 0;
v17 = 0;
v14 = *v16;
while ( v16 != v12 )
{
if ( v14 < 0x30u || v14 > 0x39u )
{
if ( v14 < 0x41u || v14 > 0x5Au )
{
if ( v14 < 0x61u || v14 > 0x7Au )
break;
v15 = v14 - 97 + 10;
}
else
{
v15 = v14 - 65 + 10;
}
}
else
{
v15 = v14 - 48;
}
if ( v15 >= a4 )
break;
LODWORD(v18) = 0xFFFFFFFF % a4;
HIDWORD(v18) = 0xFFFFFFFF / a4;
if ( __PAIR64__(v17, v15) <= v18 )
v17 = v17 * a4 + v15;
else
v11 = 1;
v6 = v16++;
v14 = v6[1];
}
if ( v16 == v13 )
{
LABEL_45:
*a6 = 33;
if ( a5 )
*a5 = a2;
return 0LL;
}
else
{
if ( a5 )
*a5 = v16;
if ( v19 )
{
if ( v17 > 0x80000000 )
v11 = 1;
}
else if ( v17 > 0x7FFFFFFFuLL )
{
v11 = 1;
}
if ( v11 )
{
*a6 = 34;
v7 = 0x7FFFFFFFLL;
if ( v19 )
return 0xFFFFFFFF80000000LL;
return v7;
}
else if ( v19 )
{
return -(long long)v17;
}
else
{
return v17;
}
}
}
| |||
26,437 | my_strntol_8bit | eloqsql/strings/ctype-simple.c | long my_strntol_8bit(CHARSET_INFO *cs,
const char *nptr, size_t l, int base,
char **endptr, int *err)
{
int negative;
register uint32 cutoff;
register uint cutlim;
register uint32 i;
register const char *s;
register uchar c;
const char *save, *e;
int overflow;
*err= 0; /* Initialize error indicator */
s = nptr;
e = nptr+l;
for ( ; s<e && my_isspace(cs, *s) ; s++);
if (s == e)
{
goto noconv;
}
/* Check for a sign. */
if (*s == '-')
{
negative = 1;
++s;
}
else if (*s == '+')
{
negative = 0;
++s;
}
else
negative = 0;
save = s;
cutoff = ((uint32)~0L) / (uint32) base;
cutlim = (uint) (((uint32)~0L) % (uint32) base);
overflow = 0;
i = 0;
for (c = *s; s != e; c = *++s)
{
if (c>='0' && c<='9')
c -= '0';
else if (c>='A' && c<='Z')
c = c - 'A' + 10;
else if (c>='a' && c<='z')
c = c - 'a' + 10;
else
break;
if (c >= base)
break;
if (i > cutoff || (i == cutoff && c > cutlim))
overflow = 1;
else
{
i *= (uint32) base;
i += c;
}
}
if (s == save)
goto noconv;
if (endptr != NULL)
*endptr = (char *) s;
if (negative)
{
if (i > (uint32) INT_MIN32)
overflow = 1;
}
else if (i > INT_MAX32)
overflow = 1;
if (overflow)
{
err[0]= ERANGE;
return negative ? INT_MIN32 : INT_MAX32;
}
return (negative ? -((long) i) : (long) i);
noconv:
err[0]= EDOM;
if (endptr != NULL)
*endptr = (char *) nptr;
return 0L;
} | O3 | c | my_strntol_8bit:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl $0x0, (%r9)
leaq (%rsi,%rdx), %r11
movq %rsi, %r10
testq %rdx, %rdx
jle 0xcc7f7
movq 0x40(%rdi), %rax
movq %rsi, %r10
movzbl (%r10), %edx
testb $0x8, 0x1(%rax,%rdx)
je 0xcc7f7
incq %r10
cmpq %r11, %r10
jb 0xcc7e4
cmpq %r11, %r10
je 0xcc8fc
movb (%r10), %dil
leal -0x2b(%rdi), %eax
andb $-0x3, %al
cmpb $0x1, %al
adcq $0x0, %r10
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
xorl %edx, %edx
divl %ecx
xorl %ebx, %ebx
cmpq %r11, %r10
je 0xcc8a8
movq %rdi, -0x30(%rbp)
xorl %r12d, %r12d
movq %r10, %r14
xorl %r13d, %r13d
movl %r13d, %ebx
movl %r12d, %r15d
movb (%r14), %r12b
leal -0x30(%r12), %edi
cmpb $0xa, %dil
jb 0xcc866
leal -0x41(%r12), %edi
cmpb $0x19, %dil
ja 0xcc854
addb $-0x37, %r12b
jmp 0xcc863
leal -0x61(%r12), %edi
cmpb $0x19, %dil
ja 0xcc8a2
addb $-0x57, %r12b
movl %r12d, %edi
movzbl %dil, %edi
cmpl %ecx, %edi
jge 0xcc8a2
movl $0x1, %r12d
cmpl %eax, %ebx
jbe 0xcc87d
movl %ebx, %r13d
jmp 0xcc891
jne 0xcc886
movl %eax, %r13d
cmpl %edi, %edx
jb 0xcc891
imull %ecx, %ebx
addl %edi, %ebx
movl %ebx, %r13d
movl %r15d, %r12d
incq %r14
cmpq %r11, %r14
jne 0xcc82f
movl %r13d, %ebx
movq %r11, %r14
movl %r12d, %r15d
movq -0x30(%rbp), %rdi
jmp 0xcc8ae
movq %r11, %r14
xorl %r15d, %r15d
cmpq %r10, %r14
je 0xcc8fc
testq %r8, %r8
je 0xcc8bb
movq %r14, (%r8)
cmpl $0x80000001, %ebx # imm = 0x80000001
movl $0x1, %eax
movl %r15d, %ecx
cmovael %eax, %ecx
testl %ebx, %ebx
cmovsl %eax, %r15d
cmpb $0x2d, %dil
cmovel %ecx, %r15d
testl %r15d, %r15d
je 0xcc918
cmpb $0x2d, %dil
movl $0x22, (%r9)
movq $-0x80000000, %rcx # imm = 0x80000000
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
cmoveq %rcx, %rax
jmp 0xcc90d
movl $0x21, (%r9)
testq %r8, %r8
je 0xcc90b
movq %rsi, (%r8)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ebx, %ecx
movq %rcx, %rax
negq %rax
cmpb $0x2d, %dil
cmovneq %rcx, %rax
jmp 0xcc90d
| my_strntol_8bit:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
mov dword ptr [r9], 0
lea r11, [rsi+rdx]
mov r10, rsi
test rdx, rdx
jle short loc_CC7F7
mov rax, [rdi+40h]
mov r10, rsi
loc_CC7E4:
movzx edx, byte ptr [r10]
test byte ptr [rax+rdx+1], 8
jz short loc_CC7F7
inc r10
cmp r10, r11
jb short loc_CC7E4
loc_CC7F7:
cmp r10, r11
jz loc_CC8FC
mov dil, [r10]
lea eax, [rdi-2Bh]
and al, 0FDh
cmp al, 1
adc r10, 0
mov eax, 0FFFFFFFFh
xor edx, edx
div ecx
xor ebx, ebx
cmp r10, r11
jz loc_CC8A8
mov [rbp+var_30], rdi
xor r12d, r12d
mov r14, r10
xor r13d, r13d
loc_CC82F:
mov ebx, r13d
mov r15d, r12d
mov r12b, [r14]
lea edi, [r12-30h]
cmp dil, 0Ah
jb short loc_CC866
lea edi, [r12-41h]
cmp dil, 19h
ja short loc_CC854
add r12b, 0C9h
jmp short loc_CC863
loc_CC854:
lea edi, [r12-61h]
cmp dil, 19h
ja short loc_CC8A2
add r12b, 0A9h
loc_CC863:
mov edi, r12d
loc_CC866:
movzx edi, dil
cmp edi, ecx
jge short loc_CC8A2
mov r12d, 1
cmp ebx, eax
jbe short loc_CC87D
mov r13d, ebx
jmp short loc_CC891
loc_CC87D:
jnz short loc_CC886
mov r13d, eax
cmp edx, edi
jb short loc_CC891
loc_CC886:
imul ebx, ecx
add ebx, edi
mov r13d, ebx
mov r12d, r15d
loc_CC891:
inc r14
cmp r14, r11
jnz short loc_CC82F
mov ebx, r13d
mov r14, r11
mov r15d, r12d
loc_CC8A2:
mov rdi, [rbp+var_30]
jmp short loc_CC8AE
loc_CC8A8:
mov r14, r11
xor r15d, r15d
loc_CC8AE:
cmp r14, r10
jz short loc_CC8FC
test r8, r8
jz short loc_CC8BB
mov [r8], r14
loc_CC8BB:
cmp ebx, 80000001h
mov eax, 1
mov ecx, r15d
cmovnb ecx, eax
test ebx, ebx
cmovs r15d, eax
cmp dil, 2Dh ; '-'
cmovz r15d, ecx
test r15d, r15d
jz short loc_CC918
cmp dil, 2Dh ; '-'
mov dword ptr [r9], 22h ; '"'
mov rcx, 0FFFFFFFF80000000h
mov eax, 7FFFFFFFh
cmovz rax, rcx
jmp short loc_CC90D
loc_CC8FC:
mov dword ptr [r9], 21h ; '!'
test r8, r8
jz short loc_CC90B
mov [r8], rsi
loc_CC90B:
xor eax, eax
loc_CC90D:
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_CC918:
mov ecx, ebx
mov rax, rcx
neg rax
cmp dil, 2Dh ; '-'
cmovnz rax, rcx
jmp short loc_CC90D
| long long my_strntol_8bit(
long long a1,
unsigned __int8 *a2,
long long a3,
unsigned int a4,
unsigned __int8 **a5,
_DWORD *a6)
{
unsigned __int8 *v6; // r11
unsigned __int8 *v7; // r10
unsigned __int8 v8; // di
unsigned __int8 *v9; // r10
unsigned int v10; // eax
unsigned int v11; // ebx
int v12; // r12d
unsigned __int8 *v13; // r14
unsigned int v14; // r13d
int v15; // r15d
unsigned __int8 v16; // r12
unsigned __int8 v17; // di
unsigned __int8 v18; // r12
int v19; // ecx
long long result; // rax
unsigned __int8 v21; // [rsp+0h] [rbp-30h]
*a6 = 0;
v6 = &a2[a3];
v7 = a2;
if ( a3 > 0 )
{
v7 = a2;
do
{
if ( (*(_BYTE *)(*(_QWORD *)(a1 + 64) + *v7 + 1LL) & 8) == 0 )
break;
++v7;
}
while ( v7 < v6 );
}
if ( v7 == v6 )
goto LABEL_36;
v8 = *v7;
v9 = &v7[((*v7 - 43) & 0xFD) == 0];
v10 = 0xFFFFFFFF / a4;
v11 = 0;
if ( v9 == v6 )
{
v13 = &a2[a3];
v15 = 0;
}
else
{
v21 = v8;
v12 = 0;
v13 = v9;
v14 = 0;
while ( 1 )
{
v11 = v14;
v15 = v12;
v16 = *v13;
v17 = *v13 - 48;
if ( v17 >= 0xAu )
{
if ( (unsigned __int8)(v16 - 65) > 0x19u )
{
if ( (unsigned __int8)(v16 - 97) > 0x19u )
break;
v18 = v16 - 87;
}
else
{
v18 = v16 - 55;
}
v17 = v18;
}
if ( v17 >= (int)a4 )
break;
v12 = 1;
if ( v14 <= v10 )
{
if ( v14 != v10 || (v14 = 0xFFFFFFFF / a4, 0xFFFFFFFF % a4 >= v17) )
{
v14 = v17 + a4 * v11;
v12 = v15;
}
}
if ( ++v13 == v6 )
{
v11 = v14;
v13 = &a2[a3];
v15 = v12;
break;
}
}
v8 = v21;
}
if ( v13 == v9 )
{
LABEL_36:
*a6 = 33;
if ( a5 )
*a5 = a2;
return 0LL;
}
else
{
if ( a5 )
*a5 = v13;
v19 = v15;
if ( v11 >= 0x80000001 )
v19 = 1;
if ( (v11 & 0x80000000) != 0 )
v15 = 1;
if ( v8 == 45 )
v15 = v19;
if ( v15 )
{
*a6 = 34;
result = 0x7FFFFFFFLL;
if ( v8 == 45 )
return 0xFFFFFFFF80000000LL;
}
else
{
result = -(long long)v11;
if ( v8 != 45 )
return v11;
}
}
return result;
}
| my_strntol_8bit:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV dword ptr [R9],0x0
LEA R11,[RSI + RDX*0x1]
MOV R10,RSI
TEST RDX,RDX
JLE 0x001cc7f7
MOV RAX,qword ptr [RDI + 0x40]
MOV R10,RSI
LAB_001cc7e4:
MOVZX EDX,byte ptr [R10]
TEST byte ptr [RAX + RDX*0x1 + 0x1],0x8
JZ 0x001cc7f7
INC R10
CMP R10,R11
JC 0x001cc7e4
LAB_001cc7f7:
CMP R10,R11
JZ 0x001cc8fc
MOV DIL,byte ptr [R10]
LEA EAX,[RDI + -0x2b]
AND AL,0xfd
CMP AL,0x1
ADC R10,0x0
MOV EAX,0xffffffff
XOR EDX,EDX
DIV ECX
XOR EBX,EBX
CMP R10,R11
JZ 0x001cc8a8
MOV qword ptr [RBP + -0x30],RDI
XOR R12D,R12D
MOV R14,R10
XOR R13D,R13D
LAB_001cc82f:
MOV EBX,R13D
MOV R15D,R12D
MOV R12B,byte ptr [R14]
LEA EDI,[R12 + -0x30]
CMP DIL,0xa
JC 0x001cc866
LEA EDI,[R12 + -0x41]
CMP DIL,0x19
JA 0x001cc854
ADD R12B,0xc9
JMP 0x001cc863
LAB_001cc854:
LEA EDI,[R12 + -0x61]
CMP DIL,0x19
JA 0x001cc8a2
ADD R12B,0xa9
LAB_001cc863:
MOV EDI,R12D
LAB_001cc866:
MOVZX EDI,DIL
CMP EDI,ECX
JGE 0x001cc8a2
MOV R12D,0x1
CMP EBX,EAX
JBE 0x001cc87d
MOV R13D,EBX
JMP 0x001cc891
LAB_001cc87d:
JNZ 0x001cc886
MOV R13D,EAX
CMP EDX,EDI
JC 0x001cc891
LAB_001cc886:
IMUL EBX,ECX
ADD EBX,EDI
MOV R13D,EBX
MOV R12D,R15D
LAB_001cc891:
INC R14
CMP R14,R11
JNZ 0x001cc82f
MOV EBX,R13D
MOV R14,R11
MOV R15D,R12D
LAB_001cc8a2:
MOV RDI,qword ptr [RBP + -0x30]
JMP 0x001cc8ae
LAB_001cc8a8:
MOV R14,R11
XOR R15D,R15D
LAB_001cc8ae:
CMP R14,R10
JZ 0x001cc8fc
TEST R8,R8
JZ 0x001cc8bb
MOV qword ptr [R8],R14
LAB_001cc8bb:
CMP EBX,0x80000001
MOV EAX,0x1
MOV ECX,R15D
CMOVNC ECX,EAX
TEST EBX,EBX
CMOVS R15D,EAX
CMP DIL,0x2d
CMOVZ R15D,ECX
TEST R15D,R15D
JZ 0x001cc918
CMP DIL,0x2d
MOV dword ptr [R9],0x22
MOV RCX,-0x80000000
MOV EAX,0x7fffffff
CMOVZ RAX,RCX
JMP 0x001cc90d
LAB_001cc8fc:
MOV dword ptr [R9],0x21
TEST R8,R8
JZ 0x001cc90b
MOV qword ptr [R8],RSI
LAB_001cc90b:
XOR EAX,EAX
LAB_001cc90d:
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001cc918:
MOV ECX,EBX
MOV RAX,RCX
NEG RAX
CMP DIL,0x2d
CMOVNZ RAX,RCX
JMP 0x001cc90d
|
ulong my_strntol_8bit(long param_1,byte *param_2,long param_3,uint param_4,ulong *param_5,
int4 *param_6)
{
byte *pbVar1;
byte bVar2;
byte bVar3;
bool bVar4;
bool bVar5;
uint uVar6;
uint uVar7;
byte *pbVar8;
byte bVar9;
uint uVar10;
byte *pbVar11;
byte *pbVar12;
*param_6 = 0;
pbVar1 = param_2 + param_3;
pbVar8 = param_2;
if (0 < param_3) {
do {
if ((*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)*pbVar8) & 8) == 0) break;
pbVar8 = pbVar8 + 1;
} while (pbVar8 < pbVar1);
}
if (pbVar8 != pbVar1) {
bVar2 = *pbVar8;
pbVar8 = pbVar8 + ((bVar2 - 0x2b & 0xfd) == 0);
uVar10 = 0;
if (pbVar8 == pbVar1) {
bVar4 = false;
pbVar12 = pbVar1;
}
else {
bVar4 = false;
uVar10 = 0;
pbVar11 = pbVar8;
do {
bVar3 = *pbVar11;
bVar9 = bVar3 - 0x30;
pbVar12 = pbVar11;
if (9 < bVar9) {
if ((byte)(bVar3 + 0xbf) < 0x1a) {
bVar9 = bVar3 - 0x37;
}
else {
if (0x19 < (byte)(bVar3 + 0x9f)) break;
bVar9 = bVar3 + 0xa9;
}
}
if ((int)param_4 <= (int)(uint)bVar9) break;
uVar7 = (uint)(0xffffffff / (ulong)param_4);
uVar6 = uVar10;
bVar5 = true;
if ((uVar10 <= uVar7) &&
((uVar10 != uVar7 || (uVar6 = uVar7, (uint)bVar9 <= (uint)(0xffffffff % (ulong)param_4)))
)) {
uVar6 = uVar10 * param_4 + (uint)bVar9;
bVar5 = bVar4;
}
bVar4 = bVar5;
uVar10 = uVar6;
pbVar11 = pbVar11 + 1;
pbVar12 = pbVar1;
} while (pbVar11 != pbVar1);
}
if (pbVar12 != pbVar8) {
if (param_5 != (ulong *)0x0) {
*param_5 = (ulong)pbVar12;
}
bVar5 = bVar4;
if (0x80000000 < uVar10) {
bVar5 = true;
}
if ((int)uVar10 < 0) {
bVar4 = true;
}
if (bVar2 == 0x2d) {
bVar4 = bVar5;
}
if (bVar4) {
*param_6 = 0x22;
if (bVar2 != 0x2d) {
return 0x7fffffff;
}
return 0xffffffff80000000;
}
if (bVar2 == 0x2d) {
return -(ulong)uVar10;
}
return (ulong)uVar10;
}
}
*param_6 = 0x21;
if (param_5 != (ulong *)0x0) {
*param_5 = (ulong)param_2;
}
return 0;
}
| |
26,438 | common_init()::$_0::__invoke(ggml_log_level, char const*, void*) | monkey531[P]llama/common/common.cpp | void common_init() {
llama_log_set([](ggml_log_level level, const char * text, void * /*user_data*/) {
if (LOG_DEFAULT_LLAMA <= common_log_verbosity_thold) {
common_log_add(common_log_main(), level, "%s", text);
}
}, NULL);
#ifdef NDEBUG
const char * build_type = "";
#else
const char * build_type = " (debug)";
#endif
LOG_INF("build: %d (%s) with %s for %s%s\n", LLAMA_BUILD_NUMBER, LLAMA_COMMIT, LLAMA_COMPILER, LLAMA_BUILD_TARGET, build_type);
} | O3 | cpp | common_init()::$_0::__invoke(ggml_log_level, char const*, void*):
leaq 0xb5867(%rip), %rax # 0x12d428
cmpl $0x0, (%rax)
js 0x77bef
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
callq 0xcbf1f
leaq 0x73876(%rip), %rdx # 0xeb450
movq %rax, %rdi
movl %ebp, %esi
movq %rbx, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xcbfbc
retq
| _ZZ11common_initvEN3$_08__invokeE14ggml_log_levelPKcPv:
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js short locret_77BEF
push rbp
push rbx
push rax
mov rbx, rsi
mov ebp, edi
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aSetCustomJinja_0+0FEh; "%s"
mov rdi, rax
mov esi, ebp
mov rcx, rbx
xor eax, eax
add rsp, 8
pop rbx
pop rbp
jmp _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
locret_77BEF:
retn
| void * common_init(void)::$_0::__invoke(int a1, int a2)
{
void *result; // rax
int v3; // eax
int v4; // r8d
int v5; // r9d
result = &common_log_verbosity_thold;
if ( common_log_verbosity_thold >= 0 )
{
v3 = common_log_main();
return (void *)common_log_add(v3, a1, (unsigned int)"%s", a2, v4, v5);
}
return result;
}
| __invoke:
LEA RAX,[0x22d428]
CMP dword ptr [RAX],0x0
JS 0x00177bef
PUSH RBP
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV EBP,EDI
CALL 0x001cbf1f
LEA RDX,[0x1eb450]
MOV RDI,RAX
MOV ESI,EBP
MOV RCX,RBX
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x001cbfbc
LAB_00177bef:
RET
|
/* __invoke(ggml_log_level, char const*, void*) */
void common_init()::$_0::__invoke(int4 param_1,int8 param_2)
{
int8 uVar1;
if (-1 < common_log_verbosity_thold) {
uVar1 = common_log_main();
common_log_add(uVar1,param_1,"%s",param_2);
return;
}
return;
}
| |
26,439 | js_async_generator_function_call | bluesky950520[P]quickjs/quickjs.c | static JSValue js_async_generator_function_call(JSContext *ctx, JSValue func_obj,
JSValue this_obj,
int argc, JSValue *argv,
int flags)
{
JSValue obj, func_ret;
JSAsyncGeneratorData *s;
s = js_mallocz(ctx, sizeof(*s));
if (!s)
return JS_EXCEPTION;
s->state = JS_ASYNC_GENERATOR_STATE_SUSPENDED_START;
init_list_head(&s->queue);
if (async_func_init(ctx, &s->func_state, func_obj, this_obj, argc, argv)) {
s->state = JS_ASYNC_GENERATOR_STATE_COMPLETED;
goto fail;
}
/* execute the function up to 'OP_initial_yield' (no yield nor
await are possible) */
func_ret = async_func_resume(ctx, &s->func_state);
if (JS_IsException(func_ret))
goto fail;
JS_FreeValue(ctx, func_ret);
obj = js_create_from_ctor(ctx, func_obj, JS_CLASS_ASYNC_GENERATOR);
if (JS_IsException(obj))
goto fail;
s->generator = JS_VALUE_GET_OBJ(obj);
JS_SetOpaqueInternal(obj, s);
return obj;
fail:
js_async_generator_free(ctx->rt, s);
return JS_EXCEPTION;
} | O1 | c | js_async_generator_function_call:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %ebp
movq %r8, %r12
movq %rcx, %r13
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, %r15
movl $0x88, %esi
callq 0xee06
pushq $0x6
popq %rbx
testq %rax, %rax
jne 0x10854
xorl %eax, %eax
movq %rbx, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x60(%rsp), %rax
andl $0x0, 0x8(%r14)
leaq 0x78(%r14), %rcx
movq %rcx, 0x78(%r14)
movq %rcx, 0x80(%r14)
movq %r14, %rsi
addq $0x10, %rsi
movq %r15, %rdi
movq %rsi, 0x18(%rsp)
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %r13, %r8
movq %r12, %r9
pushq %rax
pushq %rbp
callq 0x10be0
popq %rcx
popq %rdx
testl %eax, %eax
je 0x108a6
movl $0x5, 0x8(%r14)
jmp 0x108e9
movq 0x8(%rsp), %r13
movq 0x10(%rsp), %r12
movq %r15, %rdi
movq 0x18(%rsp), %rsi
callq 0x43156
cmpl $0x6, %edx
je 0x108e9
movq 0x18(%r15), %rdi
movq %rax, %rsi
callq 0x1d8c6
pushq $0x39
popq %rcx
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x36d56
movq %rax, 0x20(%rsp)
cmpl $0x6, %edx
jne 0x108fa
movq 0x18(%r15), %rdi
movq %r14, %rsi
callq 0x52c17
jmp 0x10840
movq 0x20(%rsp), %rax
movq %rax, (%r14)
movq %r14, 0x30(%rax)
movq %rdx, %rbx
jmp 0x10842
| js_async_generator_function_call:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov ebp, r9d
mov r12, r8
mov r13, rcx
mov [rsp+58h+var_48], rdx
mov [rsp+58h+var_50], rsi
mov r15, rdi
mov esi, 88h
call js_mallocz
push 6
pop rbx
test rax, rax
jnz short loc_10854
loc_10840:
xor eax, eax
loc_10842:
mov rdx, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_10854:
mov r14, rax
mov rax, [rsp+58h+arg_0]
and dword ptr [r14+8], 0
lea rcx, [r14+78h]
mov [r14+78h], rcx
mov [r14+80h], rcx
mov rsi, r14
add rsi, 10h
mov rdi, r15
mov [rsp+58h+var_40], rsi
mov rdx, [rsp+58h+var_50]
mov rcx, [rsp+58h+var_48]
mov r8, r13
mov r9, r12
push rax
push rbp
call async_func_init
pop rcx
pop rdx
test eax, eax
jz short loc_108A6
mov dword ptr [r14+8], 5
jmp short loc_108E9
loc_108A6:
mov r13, [rsp+58h+var_50]
mov r12, [rsp+58h+var_48]
mov rdi, r15
mov rsi, [rsp+58h+var_40]
call async_func_resume
cmp edx, 6
jz short loc_108E9
mov rdi, [r15+18h]
mov rsi, rax
call JS_FreeValueRT
push 39h ; '9'
pop rcx
mov rdi, r15
mov rsi, r13
mov rdx, r12
call js_create_from_ctor
mov [rsp+58h+var_38], rax
cmp edx, 6
jnz short loc_108FA
loc_108E9:
mov rdi, [r15+18h]
mov rsi, r14
call js_async_generator_free
jmp loc_10840
loc_108FA:
mov rax, [rsp+58h+var_38]
mov [r14], rax
mov [rax+30h], r14
mov rbx, rdx
jmp loc_10842
| long long js_async_generator_function_call(
long long a1,
long long a2,
long long a3,
int a4,
int a5,
int a6,
long long a7)
{
long long v10; // rax
long long result; // rax
long long v12; // r14
int v13; // eax
long long v14; // rdx
long long v15; // rax
long long v16; // [rsp-8h] [rbp-60h]
long long v18; // [rsp+18h] [rbp-40h]
long long v19; // [rsp+20h] [rbp-38h]
v10 = js_mallocz(a1, 0x88uLL);
if ( v10 )
{
v12 = v10;
*(_DWORD *)(v10 + 8) = 0;
*(_QWORD *)(v10 + 120) = v10 + 120;
*(_QWORD *)(v10 + 128) = v10 + 120;
v18 = v10 + 16;
v13 = async_func_init(a1, (int)v10 + 16, a2, a3, a4, a5, a6, a7);
v14 = v16;
if ( v13 )
{
*(_DWORD *)(v12 + 8) = 5;
}
else
{
v15 = async_func_resume(a1, v18, v16);
if ( (_DWORD)v14 != 6 )
{
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v15);
v19 = js_create_from_ctor(a1, a2, a3, 57LL);
if ( (_DWORD)v14 != 6 )
{
result = v19;
*(_QWORD *)v12 = v19;
*(_QWORD *)(v19 + 48) = v12;
return result;
}
}
}
js_async_generator_free(*(_QWORD *)(a1 + 24), v12, v14);
}
return 0LL;
}
| js_async_generator_function_call:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV EBP,R9D
MOV R12,R8
MOV R13,RCX
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RSP + 0x8],RSI
MOV R15,RDI
MOV ESI,0x88
CALL 0x0010ee06
PUSH 0x6
POP RBX
TEST RAX,RAX
JNZ 0x00110854
LAB_00110840:
XOR EAX,EAX
LAB_00110842:
MOV RDX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00110854:
MOV R14,RAX
MOV RAX,qword ptr [RSP + 0x60]
AND dword ptr [R14 + 0x8],0x0
LEA RCX,[R14 + 0x78]
MOV qword ptr [R14 + 0x78],RCX
MOV qword ptr [R14 + 0x80],RCX
MOV RSI,R14
ADD RSI,0x10
MOV RDI,R15
MOV qword ptr [RSP + 0x18],RSI
MOV RDX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x10]
MOV R8,R13
MOV R9,R12
PUSH RAX
PUSH RBP
CALL 0x00110be0
POP RCX
POP RDX
TEST EAX,EAX
JZ 0x001108a6
MOV dword ptr [R14 + 0x8],0x5
JMP 0x001108e9
LAB_001108a6:
MOV R13,qword ptr [RSP + 0x8]
MOV R12,qword ptr [RSP + 0x10]
MOV RDI,R15
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x00143156
CMP EDX,0x6
JZ 0x001108e9
MOV RDI,qword ptr [R15 + 0x18]
MOV RSI,RAX
CALL 0x0011d8c6
PUSH 0x39
POP RCX
MOV RDI,R15
MOV RSI,R13
MOV RDX,R12
CALL 0x00136d56
MOV qword ptr [RSP + 0x20],RAX
CMP EDX,0x6
JNZ 0x001108fa
LAB_001108e9:
MOV RDI,qword ptr [R15 + 0x18]
MOV RSI,R14
CALL 0x00152c17
JMP 0x00110840
LAB_001108fa:
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [R14],RAX
MOV qword ptr [RAX + 0x30],R14
MOV RBX,RDX
JMP 0x00110842
|
int1 [16]
js_async_generator_function_call
(long param_1,int8 param_2,int8 param_3,int8 param_4,int8 param_5,
int4 param_6,int8 param_7)
{
int iVar1;
long *plVar2;
int1 auVar3 [12];
int1 auVar4 [16];
plVar2 = (long *)js_mallocz(param_1,0x88);
if (plVar2 != (long *)0x0) {
*(int4 *)(plVar2 + 1) = 0;
plVar2[0xf] = (long)(plVar2 + 0xf);
plVar2[0x10] = (long)(plVar2 + 0xf);
iVar1 = async_func_init(param_1,plVar2 + 2,param_2,param_3,param_4,param_5);
if (iVar1 == 0) {
auVar3 = async_func_resume(param_1,plVar2 + 2,param_7,param_6);
if (auVar3._8_4_ != 6) {
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),auVar3._0_8_);
auVar4 = js_create_from_ctor(param_1,param_2,param_3,0x39);
if (auVar4._8_4_ != 6) {
*plVar2 = auVar4._0_8_;
*(long **)(auVar4._0_8_ + 0x30) = plVar2;
return auVar4;
}
}
}
else {
*(int4 *)(plVar2 + 1) = 5;
}
js_async_generator_free(*(int8 *)(param_1 + 0x18),plVar2);
}
return ZEXT816(6) << 0x40;
}
| |
26,440 | mysql_local_infile_read | eloqsql/libmariadb/libmariadb/ma_loaddata.c | static
int mysql_local_infile_read(void *ptr, char * buf, unsigned int buf_len)
{
MYSQL_INFILE_INFO *info = (MYSQL_INFILE_INFO *)ptr;
size_t count;
count= ma_read((void *)buf, 1, (size_t)buf_len, info->fp);
if (count == (size_t)-1)
{
info->error_no = errno;
snprintf((char *)info->error_msg, sizeof(info->error_msg),
CER(CR_FILE_READ), info->filename, info->error_no);
}
return((int)count);
} | O0 | c | mysql_local_infile_read:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %edx
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movl $0x1, %esi
callq 0x3a7f0
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0x31720
callq 0x13050
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rdi
addq $0xc, %rdi
leaq 0x33d43(%rip), %rax # 0x65440
movq 0x28(%rax), %rdx
movq -0x20(%rbp), %rax
movq 0x210(%rax), %rcx
movq -0x20(%rbp), %rax
movl 0x8(%rax), %r8d
movl $0x201, %esi # imm = 0x201
movb $0x0, %al
callq 0x136e0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| mysql_local_infile_read:
push rbp
mov rbp, rsp
sub rsp, 30h
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 rdi, [rbp+var_10]
mov eax, [rbp+var_14]
mov edx, eax
mov rax, [rbp+var_20]
mov rcx, [rax]
mov esi, 1
call ma_read
mov [rbp+var_28], rax
cmp [rbp+var_28], 0FFFFFFFFFFFFFFFFh
jnz short loc_31720
call ___errno_location
mov ecx, [rax]
mov rax, [rbp+var_20]
mov [rax+8], ecx
mov rdi, [rbp+var_20]
add rdi, 0Ch
lea rax, mariadb_client_errors
mov rdx, [rax+28h]
mov rax, [rbp+var_20]
mov rcx, [rax+210h]
mov rax, [rbp+var_20]
mov r8d, [rax+8]
mov esi, 201h
mov al, 0
call _snprintf
loc_31720:
mov rax, [rbp+var_28]
add rsp, 30h
pop rbp
retn
| long long mysql_local_infile_read(long long a1, long long a2, unsigned int a3)
{
long long v4; // [rsp+8h] [rbp-28h]
v4 = ma_read(a2, 1LL, a3, *(_QWORD *)a1);
if ( v4 == -1 )
{
*(_DWORD *)(a1 + 8) = *(_DWORD *)__errno_location();
snprintf(a1 + 12, 513LL, mariadb_client_errors[5], *(_QWORD *)(a1 + 528), *(unsigned int *)(a1 + 8));
}
return v4;
}
| mysql_local_infile_read:
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 RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x14]
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX]
MOV ESI,0x1
CALL 0x0013a7f0
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],-0x1
JNZ 0x00131720
CALL 0x00113050
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x8],ECX
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0xc
LEA RAX,[0x165440]
MOV RDX,qword ptr [RAX + 0x28]
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX + 0x210]
MOV RAX,qword ptr [RBP + -0x20]
MOV R8D,dword ptr [RAX + 0x8]
MOV ESI,0x201
MOV AL,0x0
CALL 0x001136e0
LAB_00131720:
MOV RAX,qword ptr [RBP + -0x28]
ADD RSP,0x30
POP RBP
RET
|
long mysql_local_infile_read(int8 *param_1,int8 param_2,int4 param_3)
{
long lVar1;
int *piVar2;
lVar1 = ma_read(param_2,1,param_3,*param_1);
if (lVar1 == -1) {
piVar2 = __errno_location();
*(int *)(param_1 + 1) = *piVar2;
snprintf((char *)((long)param_1 + 0xc),0x201,(char *)mariadb_client_errors._40_8_,param_1[0x42],
(ulong)*(uint *)(param_1 + 1));
}
return lVar1;
}
| |
26,441 | psi_rwlock_rdlock | eloqsql/mysys/my_thr_init.c | ATTRIBUTE_COLD
int psi_rwlock_rdlock(mysql_rwlock_t *that, const char *file, uint line)
{
PSI_rwlock_locker_state state;
PSI_rwlock_locker *locker= PSI_RWLOCK_CALL(start_rwlock_rdwait)
(&state, that->m_psi, PSI_RWLOCK_READLOCK, file, line);
int result= rw_rdlock(&that->m_rwlock);
if (locker)
PSI_RWLOCK_CALL(end_rwlock_rdwait)(locker, result);
return result;
} | O0 | c | psi_rwlock_rdlock:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x1a6b3e(%rip), %rax # 0x1cda28
movq (%rax), %rax
movq 0x1a0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x90(%rcx), %rsi
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %r8d
leaq -0x48(%rbp), %rdi
xorl %edx, %edx
callq *%rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x274e0
movl %eax, -0x54(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x26f40
leaq 0x1a6afb(%rip), %rax # 0x1cda28
movq (%rax), %rax
movq 0x1a8(%rax), %rax
movq -0x50(%rbp), %rdi
movl -0x54(%rbp), %esi
callq *%rax
movl -0x54(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| psi_rwlock_rdlock:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1A0h]
mov rcx, [rbp+var_8]
mov rsi, [rcx+90h]
mov rcx, [rbp+var_10]
mov r8d, [rbp+var_14]
lea rdi, [rbp+var_48]
xor edx, edx
call rax
mov [rbp+var_50], rax
mov rdi, [rbp+var_8]
call my_rw_rdlock
mov [rbp+var_54], eax
cmp [rbp+var_50], 0
jz short loc_26F40
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1A8h]
mov rdi, [rbp+var_50]
mov esi, [rbp+var_54]
call rax
loc_26F40:
mov eax, [rbp+var_54]
add rsp, 60h
pop rbp
retn
| long long psi_rwlock_rdlock(long long a1, long long a2, unsigned int a3)
{
unsigned int v4; // [rsp+Ch] [rbp-54h]
long long v5; // [rsp+10h] [rbp-50h]
_BYTE v6[52]; // [rsp+18h] [rbp-48h] BYREF
unsigned int v7; // [rsp+4Ch] [rbp-14h]
long long v8; // [rsp+50h] [rbp-10h]
long long v9; // [rsp+58h] [rbp-8h]
v9 = a1;
v8 = a2;
v7 = a3;
v5 = (*((long long ( **)(_BYTE *, _QWORD, _QWORD, long long, _QWORD))PSI_server[0] + 52))(
v6,
*(_QWORD *)(a1 + 144),
0LL,
a2,
a3);
v4 = my_rw_rdlock(v9);
if ( v5 )
(*((void ( **)(long long, _QWORD))PSI_server[0] + 53))(v5, v4);
return v4;
}
| psi_rwlock_rdlock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
LEA RAX,[0x2cda28]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1a0]
MOV RCX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RCX + 0x90]
MOV RCX,qword ptr [RBP + -0x10]
MOV R8D,dword ptr [RBP + -0x14]
LEA RDI,[RBP + -0x48]
XOR EDX,EDX
CALL RAX
MOV qword ptr [RBP + -0x50],RAX
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001274e0
MOV dword ptr [RBP + -0x54],EAX
CMP qword ptr [RBP + -0x50],0x0
JZ 0x00126f40
LEA RAX,[0x2cda28]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1a8]
MOV RDI,qword ptr [RBP + -0x50]
MOV ESI,dword ptr [RBP + -0x54]
CALL RAX
LAB_00126f40:
MOV EAX,dword ptr [RBP + -0x54]
ADD RSP,0x60
POP RBP
RET
|
int4 psi_rwlock_rdlock(long param_1,int8 param_2,int4 param_3)
{
int4 uVar1;
long lVar2;
int1 local_50 [52];
int4 local_1c;
int8 local_18;
long local_10;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
lVar2 = (**(code **)(PSI_server + 0x1a0))
(local_50,*(int8 *)(param_1 + 0x90),0,param_2,param_3);
uVar1 = my_rw_rdlock(local_10);
if (lVar2 != 0) {
(**(code **)(PSI_server + 0x1a8))(lVar2,uVar1);
}
return uVar1;
}
| |
26,442 | reinit_io_cache | eloqsql/mysys/mf_iocache.c | my_bool reinit_io_cache(IO_CACHE *info, enum cache_type type,
my_off_t seek_offset,
my_bool use_async_io __attribute__((unused)),
my_bool clear_cache)
{
DBUG_ENTER("reinit_io_cache");
DBUG_PRINT("enter",("cache:%p type: %d seek_offset: %llu clear_cache: %d",
info, type, (ulonglong) seek_offset,
(int) clear_cache));
DBUG_ASSERT(type == READ_CACHE || type == WRITE_CACHE);
DBUG_ASSERT(info->type == READ_CACHE || info->type == WRITE_CACHE);
/* If the whole file is in memory, avoid flushing to disk */
if (! clear_cache &&
seek_offset >= info->pos_in_file &&
seek_offset <= my_b_tell(info))
{
/* Reuse current buffer without flushing it to disk */
uchar *pos;
if (info->type == WRITE_CACHE && type == READ_CACHE)
{
info->read_end=info->write_pos;
info->end_of_file=my_b_tell(info);
/*
Trigger a new seek only if we have a valid
file handle.
*/
info->seek_not_done= (info->file != -1);
}
else if (type == WRITE_CACHE)
{
if (info->type == READ_CACHE)
{
info->write_end=info->write_buffer+info->buffer_length;
info->seek_not_done=1;
}
info->end_of_file = ~(my_off_t) 0;
}
pos=info->request_pos+(seek_offset-info->pos_in_file);
if (type == WRITE_CACHE)
info->write_pos=pos;
else
info->read_pos= pos;
}
else
{
/*
If we change from WRITE_CACHE to READ_CACHE, assume that everything
after the current positions should be ignored. In other cases we
update end_of_file as it may have changed since last init.
*/
if (type == READ_CACHE)
{
if (info->type == WRITE_CACHE)
info->end_of_file= my_b_tell(info);
else
{
if (!(info->myflags & MY_ENCRYPT))
info->end_of_file= mysql_file_seek(info->file, 0L,
MY_SEEK_END, MYF(0));
}
}
/* flush cache if we want to reuse it */
if (!clear_cache && my_b_flush_io_cache(info,1))
DBUG_RETURN(1);
info->pos_in_file=seek_offset;
/* Better to do always do a seek */
info->seek_not_done=1;
info->request_pos=info->read_pos=info->write_pos=info->buffer;
if (type == READ_CACHE)
{
info->read_end=info->buffer; /* Nothing in cache */
}
else
{
if (info->myflags & MY_ENCRYPT)
{
info->write_end = info->write_buffer + info->buffer_length;
if (seek_offset && info->file != -1)
{
info->read_end= info->buffer;
_my_b_encr_read(info, 0, 0); /* prefill the buffer */
info->write_pos= info->read_pos;
info->seek_not_done=1;
}
}
else
{
info->write_end=(info->buffer + info->buffer_length -
(seek_offset & (IO_SIZE-1)));
}
info->end_of_file= ~(my_off_t) 0;
}
}
info->type=type;
info->error=0;
init_functions(info);
DBUG_RETURN(0);
} | O3 | c | reinit_io_cache:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r8d, %r12d
movq %rdx, %r15
movl %esi, %r14d
movq %rdi, %rbx
testb %r12b, %r12b
jne 0x7b800
movq (%rbx), %rdx
movq %r15, %rax
subq %rdx, %rax
jb 0x7b800
movl 0xb0(%rbx), %esi
leaq 0x10(%rbx), %rdi
leaq 0x40(%rbx), %r8
cmpl $0x2, %esi
movq 0x28(%rbx), %rcx
cmoveq %r8, %rdi
subq %rcx, %rdx
movq (%rdi), %rdi
addq %rdx, %rdi
cmpq %r15, %rdi
jae 0x7b943
cmpl $0x1, %r14d
jne 0x7b866
cmpl $0x2, 0xb0(%rbx)
jne 0x7b81c
movq (%rbx), %rax
subq 0x28(%rbx), %rax
addq 0x40(%rbx), %rax
jmp 0x7b862
testb $0x40, 0xf8(%rbx)
jne 0x7b866
movl 0xd4(%rbx), %r13d
leaq 0x2f47b5(%rip), %rax # 0x36ffe8
movq (%rax), %rax
leaq -0x78(%rbp), %rdi
movl %r13d, %esi
movl $0x8, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x7b9bb
movl %r13d, %edi
xorl %esi, %esi
movl $0x2, %edx
xorl %ecx, %ecx
callq 0x85264
movq %rax, 0x8(%rbx)
testb %r12b, %r12b
je 0x7b8b7
movq %r15, (%rbx)
movl $0x1, 0xe0(%rbx)
movq 0x20(%rbx), %rax
movq %rax, 0x40(%rbx)
movq %rax, 0x10(%rbx)
movq %rax, 0x28(%rbx)
cmpl $0x1, %r14d
jne 0x7b897
movq %rax, 0x18(%rbx)
jmp 0x7b919
testb $0x40, 0xf8(%rbx)
jne 0x7b8ce
addq 0xe8(%rbx), %rax
andl $0xfff, %r15d # imm = 0xFFF
subq %r15, %rax
movq %rax, 0x48(%rbx)
jmp 0x7b911
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7b9d9
movl %eax, %ecx
movb $0x1, %al
testl %ecx, %ecx
jne 0x7b934
jmp 0x7b86b
movq 0x30(%rbx), %rcx
addq 0xe8(%rbx), %rcx
movq %rcx, 0x48(%rbx)
testq %r15, %r15
je 0x7b911
cmpl $-0x1, 0xd4(%rbx)
je 0x7b911
movq %rax, 0x18(%rbx)
leaq 0x375202(%rip), %rax # 0x3f0af8
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq *(%rax)
movq 0x10(%rbx), %rax
movq %rax, 0x40(%rbx)
movl $0x1, 0xe0(%rbx)
movq $-0x1, 0x8(%rbx)
movl %r14d, 0xb0(%rbx)
movl $0x0, 0xe4(%rbx)
movq %rbx, %rdi
callq 0x7b58f
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %esi, %edi
xorl $0x2, %edi
movl %r14d, %r8d
xorl $0x1, %r8d
orl %edi, %r8d
jne 0x7b977
movq 0x40(%rbx), %rsi
movq %rsi, 0x18(%rbx)
addq %rsi, %rdx
movq %rdx, 0x8(%rbx)
xorl %edx, %edx
cmpl $-0x1, 0xd4(%rbx)
setne %dl
movl %edx, 0xe0(%rbx)
jmp 0x7b9af
cmpl $0x2, %r14d
jne 0x7b9af
cmpl $0x1, %esi
jne 0x7b99b
movq 0x30(%rbx), %rdx
addq 0xe8(%rbx), %rdx
movq %rdx, 0x48(%rbx)
movl $0x1, 0xe0(%rbx)
movq $-0x1, 0x8(%rbx)
addq %rax, %rcx
movq %rcx, 0x40(%rbx)
jmp 0x7b919
addq %rax, %rcx
movq %rcx, 0x10(%rbx)
jmp 0x7b919
leaq -0x30(%rbp), %rcx
movq %rax, %rdi
movl %r13d, %esi
movq %rcx, %r13
movq %rcx, %rdx
callq 0x3c9c7
movq (%r13), %rax
jmp 0x7b862
| reinit_io_cache:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov r12d, r8d
mov r15, rdx
mov r14d, esi
mov rbx, rdi
test r12b, r12b
jnz short loc_7B800
mov rdx, [rbx]
mov rax, r15
sub rax, rdx
jb short loc_7B800
mov esi, [rbx+0B0h]
lea rdi, [rbx+10h]
lea r8, [rbx+40h]
cmp esi, 2
mov rcx, [rbx+28h]
cmovz rdi, r8
sub rdx, rcx
mov rdi, [rdi]
add rdi, rdx
cmp rdi, r15
jnb loc_7B943
loc_7B800:
cmp r14d, 1
jnz short loc_7B866
cmp dword ptr [rbx+0B0h], 2
jnz short loc_7B81C
mov rax, [rbx]
sub rax, [rbx+28h]
add rax, [rbx+40h]
jmp short loc_7B862
loc_7B81C:
test byte ptr [rbx+0F8h], 40h
jnz short loc_7B866
mov r13d, [rbx+0D4h]
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_78]
mov esi, r13d
mov edx, 8
call qword ptr [rax+158h]
test rax, rax
jnz loc_7B9BB
mov edi, r13d
xor esi, esi
mov edx, 2
xor ecx, ecx
call my_seek
loc_7B862:
mov [rbx+8], rax
loc_7B866:
test r12b, r12b
jz short loc_7B8B7
loc_7B86B:
mov [rbx], r15
mov dword ptr [rbx+0E0h], 1
mov rax, [rbx+20h]
mov [rbx+40h], rax
mov [rbx+10h], rax
mov [rbx+28h], rax
cmp r14d, 1
jnz short loc_7B897
mov [rbx+18h], rax
jmp loc_7B919
loc_7B897:
test byte ptr [rbx+0F8h], 40h
jnz short loc_7B8CE
add rax, [rbx+0E8h]
and r15d, 0FFFh
sub rax, r15
mov [rbx+48h], rax
jmp short loc_7B911
loc_7B8B7:
mov rdi, rbx
mov esi, 1
call my_b_flush_io_cache
mov ecx, eax
mov al, 1
test ecx, ecx
jnz short loc_7B934
jmp short loc_7B86B
loc_7B8CE:
mov rcx, [rbx+30h]
add rcx, [rbx+0E8h]
mov [rbx+48h], rcx
test r15, r15
jz short loc_7B911
cmp dword ptr [rbx+0D4h], 0FFFFFFFFh
jz short loc_7B911
mov [rbx+18h], rax
lea rax, _my_b_encr_read
mov rdi, rbx
xor esi, esi
xor edx, edx
call qword ptr [rax]
mov rax, [rbx+10h]
mov [rbx+40h], rax
mov dword ptr [rbx+0E0h], 1
loc_7B911:
mov qword ptr [rbx+8], 0FFFFFFFFFFFFFFFFh
loc_7B919:
mov [rbx+0B0h], r14d
mov dword ptr [rbx+0E4h], 0
mov rdi, rbx
call init_functions
xor eax, eax
loc_7B934:
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7B943:
mov edi, esi
xor edi, 2
mov r8d, r14d
xor r8d, 1
or r8d, edi
jnz short loc_7B977
mov rsi, [rbx+40h]
mov [rbx+18h], rsi
add rdx, rsi
mov [rbx+8], rdx
xor edx, edx
cmp dword ptr [rbx+0D4h], 0FFFFFFFFh
setnz dl
mov [rbx+0E0h], edx
jmp short loc_7B9AF
loc_7B977:
cmp r14d, 2
jnz short loc_7B9AF
cmp esi, 1
jnz short loc_7B99B
mov rdx, [rbx+30h]
add rdx, [rbx+0E8h]
mov [rbx+48h], rdx
mov dword ptr [rbx+0E0h], 1
loc_7B99B:
mov qword ptr [rbx+8], 0FFFFFFFFFFFFFFFFh
add rcx, rax
mov [rbx+40h], rcx
jmp loc_7B919
loc_7B9AF:
add rcx, rax
mov [rbx+10h], rcx
jmp loc_7B919
loc_7B9BB:
lea rcx, [rbp+var_30]
mov rdi, rax
mov esi, r13d
mov r13, rcx
mov rdx, rcx
call reinit_io_cache_cold_1
mov rax, [r13+0]
jmp loc_7B862
| char reinit_io_cache(long long a1, int a2, unsigned long long a3, long long a4, char a5)
{
long long v9; // rdx
unsigned long long v10; // rax
int v11; // esi
_QWORD *v12; // rdi
long long v13; // rcx
long long v14; // rdx
long long v15; // rax
unsigned int v16; // r13d
long long v17; // rax
long long v18; // rax
int v19; // ecx
char result; // al
long long v21; // rsi
_BYTE v22[72]; // [rsp+8h] [rbp-78h] BYREF
long long v23[6]; // [rsp+50h] [rbp-30h] BYREF
if ( !a5 )
{
v9 = *(_QWORD *)a1;
v10 = a3 - *(_QWORD *)a1;
if ( a3 >= *(_QWORD *)a1 )
{
v11 = *(_DWORD *)(a1 + 176);
v12 = (_QWORD *)(a1 + 16);
v13 = *(_QWORD *)(a1 + 40);
if ( v11 == 2 )
v12 = (_QWORD *)(a1 + 64);
v14 = v9 - v13;
if ( v14 + *v12 >= a3 )
{
if ( v11 ^ 2 | a2 ^ 1 )
{
if ( a2 == 2 )
{
if ( v11 == 1 )
{
*(_QWORD *)(a1 + 72) = *(_QWORD *)(a1 + 232) + *(_QWORD *)(a1 + 48);
*(_DWORD *)(a1 + 224) = 1;
}
*(_QWORD *)(a1 + 8) = -1LL;
*(_QWORD *)(a1 + 64) = v10 + v13;
goto LABEL_24;
}
}
else
{
v21 = *(_QWORD *)(a1 + 64);
*(_QWORD *)(a1 + 24) = v21;
*(_QWORD *)(a1 + 8) = v21 + v14;
*(_DWORD *)(a1 + 224) = *(_DWORD *)(a1 + 212) != -1;
}
*(_QWORD *)(a1 + 16) = v10 + v13;
LABEL_24:
*(_DWORD *)(a1 + 176) = a2;
*(_DWORD *)(a1 + 228) = 0;
init_functions(a1);
return 0;
}
}
}
if ( a2 == 1 )
{
if ( *(_DWORD *)(a1 + 176) == 2 )
{
v15 = *(_QWORD *)(a1 + 64) + *(_QWORD *)a1 - *(_QWORD *)(a1 + 40);
LABEL_12:
*(_QWORD *)(a1 + 8) = v15;
goto LABEL_13;
}
if ( (*(_BYTE *)(a1 + 248) & 0x40) == 0 )
{
v16 = *(_DWORD *)(a1 + 212);
v17 = (*((long long ( **)(_BYTE *, _QWORD, long long))PSI_server + 43))(v22, v16, 8LL);
if ( v17 )
{
reinit_io_cache_cold_1(v17, v16, v23);
v15 = v23[0];
}
else
{
v15 = my_seek(v16, 0LL, 2LL, 0LL);
}
goto LABEL_12;
}
}
LABEL_13:
if ( a5 || (v19 = my_b_flush_io_cache(a1, 1LL), result = 1, !v19) )
{
*(_QWORD *)a1 = a3;
*(_DWORD *)(a1 + 224) = 1;
v18 = *(_QWORD *)(a1 + 32);
*(_QWORD *)(a1 + 64) = v18;
*(_QWORD *)(a1 + 16) = v18;
*(_QWORD *)(a1 + 40) = v18;
if ( a2 == 1 )
{
*(_QWORD *)(a1 + 24) = v18;
}
else
{
if ( (*(_BYTE *)(a1 + 248) & 0x40) != 0 )
{
*(_QWORD *)(a1 + 72) = *(_QWORD *)(a1 + 232) + *(_QWORD *)(a1 + 48);
if ( a3 )
{
if ( *(_DWORD *)(a1 + 212) != -1 )
{
*(_QWORD *)(a1 + 24) = v18;
my_b_encr_read(a1, 0LL, 0LL);
*(_QWORD *)(a1 + 64) = *(_QWORD *)(a1 + 16);
*(_DWORD *)(a1 + 224) = 1;
}
}
}
else
{
*(_QWORD *)(a1 + 72) = *(_QWORD *)(a1 + 232) + v18 - (a3 & 0xFFF);
}
*(_QWORD *)(a1 + 8) = -1LL;
}
goto LABEL_24;
}
return result;
}
| reinit_io_cache:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R12D,R8D
MOV R15,RDX
MOV R14D,ESI
MOV RBX,RDI
TEST R12B,R12B
JNZ 0x0017b800
MOV RDX,qword ptr [RBX]
MOV RAX,R15
SUB RAX,RDX
JC 0x0017b800
MOV ESI,dword ptr [RBX + 0xb0]
LEA RDI,[RBX + 0x10]
LEA R8,[RBX + 0x40]
CMP ESI,0x2
MOV RCX,qword ptr [RBX + 0x28]
CMOVZ RDI,R8
SUB RDX,RCX
MOV RDI,qword ptr [RDI]
ADD RDI,RDX
CMP RDI,R15
JNC 0x0017b943
LAB_0017b800:
CMP R14D,0x1
JNZ 0x0017b866
CMP dword ptr [RBX + 0xb0],0x2
JNZ 0x0017b81c
MOV RAX,qword ptr [RBX]
SUB RAX,qword ptr [RBX + 0x28]
ADD RAX,qword ptr [RBX + 0x40]
JMP 0x0017b862
LAB_0017b81c:
TEST byte ptr [RBX + 0xf8],0x40
JNZ 0x0017b866
MOV R13D,dword ptr [RBX + 0xd4]
LEA RAX,[0x46ffe8]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x78]
MOV ESI,R13D
MOV EDX,0x8
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x0017b9bb
MOV EDI,R13D
XOR ESI,ESI
MOV EDX,0x2
XOR ECX,ECX
CALL 0x00185264
LAB_0017b862:
MOV qword ptr [RBX + 0x8],RAX
LAB_0017b866:
TEST R12B,R12B
JZ 0x0017b8b7
LAB_0017b86b:
MOV qword ptr [RBX],R15
MOV dword ptr [RBX + 0xe0],0x1
MOV RAX,qword ptr [RBX + 0x20]
MOV qword ptr [RBX + 0x40],RAX
MOV qword ptr [RBX + 0x10],RAX
MOV qword ptr [RBX + 0x28],RAX
CMP R14D,0x1
JNZ 0x0017b897
MOV qword ptr [RBX + 0x18],RAX
JMP 0x0017b919
LAB_0017b897:
TEST byte ptr [RBX + 0xf8],0x40
JNZ 0x0017b8ce
ADD RAX,qword ptr [RBX + 0xe8]
AND R15D,0xfff
SUB RAX,R15
MOV qword ptr [RBX + 0x48],RAX
JMP 0x0017b911
LAB_0017b8b7:
MOV RDI,RBX
MOV ESI,0x1
CALL 0x0017b9d9
MOV ECX,EAX
MOV AL,0x1
TEST ECX,ECX
JNZ 0x0017b934
JMP 0x0017b86b
LAB_0017b8ce:
MOV RCX,qword ptr [RBX + 0x30]
ADD RCX,qword ptr [RBX + 0xe8]
MOV qword ptr [RBX + 0x48],RCX
TEST R15,R15
JZ 0x0017b911
CMP dword ptr [RBX + 0xd4],-0x1
JZ 0x0017b911
MOV qword ptr [RBX + 0x18],RAX
LEA RAX,[0x4f0af8]
MOV RDI,RBX
XOR ESI,ESI
XOR EDX,EDX
CALL qword ptr [RAX]
MOV RAX,qword ptr [RBX + 0x10]
MOV qword ptr [RBX + 0x40],RAX
MOV dword ptr [RBX + 0xe0],0x1
LAB_0017b911:
MOV qword ptr [RBX + 0x8],-0x1
LAB_0017b919:
MOV dword ptr [RBX + 0xb0],R14D
MOV dword ptr [RBX + 0xe4],0x0
MOV RDI,RBX
CALL 0x0017b58f
XOR EAX,EAX
LAB_0017b934:
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017b943:
MOV EDI,ESI
XOR EDI,0x2
MOV R8D,R14D
XOR R8D,0x1
OR R8D,EDI
JNZ 0x0017b977
MOV RSI,qword ptr [RBX + 0x40]
MOV qword ptr [RBX + 0x18],RSI
ADD RDX,RSI
MOV qword ptr [RBX + 0x8],RDX
XOR EDX,EDX
CMP dword ptr [RBX + 0xd4],-0x1
SETNZ DL
MOV dword ptr [RBX + 0xe0],EDX
JMP 0x0017b9af
LAB_0017b977:
CMP R14D,0x2
JNZ 0x0017b9af
CMP ESI,0x1
JNZ 0x0017b99b
MOV RDX,qword ptr [RBX + 0x30]
ADD RDX,qword ptr [RBX + 0xe8]
MOV qword ptr [RBX + 0x48],RDX
MOV dword ptr [RBX + 0xe0],0x1
LAB_0017b99b:
MOV qword ptr [RBX + 0x8],-0x1
ADD RCX,RAX
MOV qword ptr [RBX + 0x40],RCX
JMP 0x0017b919
LAB_0017b9af:
ADD RCX,RAX
MOV qword ptr [RBX + 0x10],RCX
JMP 0x0017b919
LAB_0017b9bb:
LEA RCX,[RBP + -0x30]
MOV RDI,RAX
MOV ESI,R13D
MOV R13,RCX
MOV RDX,RCX
CALL 0x0013c9c7
MOV RAX,qword ptr [R13]
JMP 0x0017b862
|
int8 reinit_io_cache(ulong *param_1,int param_2,ulong param_3,int8 param_4,char param_5)
{
int4 uVar1;
ulong uVar2;
ulong uVar3;
int iVar4;
long lVar5;
ulong *puVar6;
int1 local_80 [72];
ulong local_38;
if (param_5 == '\0') {
uVar2 = *param_1;
if (uVar2 <= param_3) {
iVar4 = (int)param_1[0x16];
uVar3 = param_1[5];
puVar6 = param_1 + 2;
if (iVar4 == 2) {
puVar6 = param_1 + 8;
}
if (param_3 <= *puVar6 + (uVar2 - uVar3)) {
if (param_2 == 1 && iVar4 == 2) {
param_1[3] = param_1[8];
param_1[1] = (uVar2 - uVar3) + param_1[8];
*(uint *)(param_1 + 0x1c) = (uint)(*(int *)((long)param_1 + 0xd4) != -1);
}
else if (param_2 == 2) {
if (iVar4 == 1) {
param_1[9] = param_1[6] + param_1[0x1d];
*(int4 *)(param_1 + 0x1c) = 1;
}
param_1[1] = 0xffffffffffffffff;
param_1[8] = uVar3 + (param_3 - uVar2);
goto LAB_0017b919;
}
param_1[2] = uVar3 + (param_3 - uVar2);
goto LAB_0017b919;
}
}
}
if (param_2 == 1) {
if ((int)param_1[0x16] == 2) {
local_38 = (*param_1 - param_1[5]) + param_1[8];
}
else {
if ((param_1[0x1f] & 0x40) != 0) goto LAB_0017b866;
uVar1 = *(int4 *)((long)param_1 + 0xd4);
lVar5 = (**(code **)(PSI_server + 0x158))(local_80,uVar1,8);
if (lVar5 == 0) {
local_38 = my_seek(uVar1,0,2,0);
}
else {
reinit_io_cache_cold_1(lVar5,uVar1,&local_38);
}
}
param_1[1] = local_38;
}
LAB_0017b866:
if ((param_5 == '\0') && (iVar4 = my_b_flush_io_cache(param_1,1), iVar4 != 0)) {
return 1;
}
*param_1 = param_3;
*(int4 *)(param_1 + 0x1c) = 1;
uVar2 = param_1[4];
param_1[8] = uVar2;
param_1[2] = uVar2;
param_1[5] = uVar2;
if (param_2 == 1) {
param_1[3] = uVar2;
}
else {
if ((param_1[0x1f] & 0x40) == 0) {
param_1[9] = (uVar2 + param_1[0x1d]) - (ulong)((uint)param_3 & 0xfff);
}
else {
param_1[9] = param_1[6] + param_1[0x1d];
if ((param_3 != 0) && (*(int *)((long)param_1 + 0xd4) != -1)) {
param_1[3] = uVar2;
(*_my_b_encr_read)(param_1,0,0);
param_1[8] = param_1[2];
*(int4 *)(param_1 + 0x1c) = 1;
}
}
param_1[1] = 0xffffffffffffffff;
}
LAB_0017b919:
*(int *)(param_1 + 0x16) = param_2;
*(int4 *)((long)param_1 + 0xe4) = 0;
init_functions(param_1);
return 0;
}
| |
26,443 | my_fstat | eloqsql/mysys/my_lib.c | int my_fstat(File Filedes, MY_STAT *stat_area,
myf MyFlags __attribute__((unused)))
{
DBUG_ENTER("my_fstat");
DBUG_PRINT("my",("fd: %d MyFlags: %lu", Filedes, MyFlags));
#ifdef _WIN32
DBUG_RETURN(my_win_fstat(Filedes, stat_area));
#elif defined HAVE_valgrind
{
int s= fstat(Filedes, stat_area);
if (!s)
MSAN_STAT_WORKAROUND(stat_area);
DBUG_RETURN(s);
}
#else
DBUG_RETURN(fstat(Filedes, (struct stat *) stat_area));
#endif
} | O0 | c | my_fstat:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0xfb045
jmp 0xfb047
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x29500
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
| my_fstat:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
jmp short $+2
loc_FB045:
jmp short $+2
loc_FB047:
mov edi, [rbp+var_4]
mov rsi, [rbp+var_10]
call _fstat64
mov [rbp+var_1C], eax
mov eax, [rbp+var_1C]
add rsp, 20h
pop rbp
retn
| long long my_fstat(unsigned int a1, long long a2)
{
return (unsigned int)fstat64(a1, a2);
}
| my_fstat:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
JMP 0x001fb045
LAB_001fb045:
JMP 0x001fb047
LAB_001fb047:
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x00129500
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0x1c]
ADD RSP,0x20
POP RBP
RET
|
int my_fstat(int param_1,stat64 *param_2)
{
int iVar1;
iVar1 = fstat64(param_1,param_2);
return iVar1;
}
| |
26,444 | my_fstat | eloqsql/mysys/my_lib.c | int my_fstat(File Filedes, MY_STAT *stat_area,
myf MyFlags __attribute__((unused)))
{
DBUG_ENTER("my_fstat");
DBUG_PRINT("my",("fd: %d MyFlags: %lu", Filedes, MyFlags));
#ifdef _WIN32
DBUG_RETURN(my_win_fstat(Filedes, stat_area));
#elif defined HAVE_valgrind
{
int s= fstat(Filedes, stat_area);
if (!s)
MSAN_STAT_WORKAROUND(stat_area);
DBUG_RETURN(s);
}
#else
DBUG_RETURN(fstat(Filedes, (struct stat *) stat_area));
#endif
} | O3 | c | my_fstat:
pushq %rbp
movq %rsp, %rbp
popq %rbp
jmp 0x29540
nopl (%rax)
| my_fstat:
push rbp
mov rbp, rsp
pop rbp
jmp _fstat64
| long long my_fstat()
{
return fstat64();
}
| my_fstat:
PUSH RBP
MOV RBP,RSP
POP RBP
JMP 0x00129540
|
void my_fstat(int param_1,stat64 *param_2)
{
fstat64(param_1,param_2);
return;
}
| |
26,445 | minja::Parser::parseConstant() | llama.cpp/common/minja/minja.hpp | std::shared_ptr<Value> parseConstant() {
auto start = it;
consumeSpaces();
if (it == end) return nullptr;
if (*it == '"' || *it == '\'') {
auto str = parseString();
if (str) return std::make_shared<Value>(*str);
}
static std::regex prim_tok(R"(true\b|True\b|false\b|False\b|None\b)");
auto token = consumeToken(prim_tok);
if (!token.empty()) {
if (token == "true" || token == "True") return std::make_shared<Value>(true);
if (token == "false" || token == "False") return std::make_shared<Value>(false);
if (token == "None") return std::make_shared<Value>(nullptr);
throw std::runtime_error("Unknown constant token: " + token);
}
auto number = parseNumber(it, end);
if (!number.is_null()) return std::make_shared<Value>(number);
it = start;
return nullptr;
} | O3 | cpp | minja::Parser::parseConstant():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x20(%rsi), %r14
movq 0x18(%rsi), %r12
movq 0x20(%rsi), %r13
movq %r13, %rbp
cmpq %r12, %r13
je 0xecb05
movq %r13, %rbp
movsbl (%rbp), %edi
callq 0x21d50
testl %eax, %eax
je 0xecb05
incq %rbp
movq %rbp, (%r14)
cmpq %r12, %rbp
jne 0xecaed
cmpq %r12, %rbp
je 0xecb5b
movzbl (%rbp), %eax
cmpl $0x27, %eax
je 0xecb18
cmpl $0x22, %eax
jne 0xecb66
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xede90
movq (%r12), %rdx
testq %rdx, %rdx
je 0xecb66
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0xee482
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0xeccc3
leaq 0x8(%rsp), %rdi
callq 0xee628
jmp 0xeccc3
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0xeccc3
leaq 0x82b5b(%rip), %rax # 0x16f6c8
movb (%rax), %al
testb %al, %al
je 0xeccd5
leaq 0x82b2a(%rip), %rdx # 0x16f6a8
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movl $0x1, %ecx
callq 0xe76bc
cmpq $0x0, 0x8(%r12)
je 0xecc42
leaq 0x32871(%rip), %rsi # 0x11f417
leaq 0x8(%rsp), %rdi
callq 0x21fb0
testl %eax, %eax
je 0xecc2b
leaq 0x3d001(%rip), %rsi # 0x129bbc
leaq 0x8(%rsp), %rdi
callq 0x21fb0
testl %eax, %eax
je 0xecc2b
leaq 0x35774(%rip), %rsi # 0x122344
leaq 0x8(%rsp), %rdi
callq 0x21fb0
testl %eax, %eax
je 0xecc71
leaq 0x3cfd8(%rip), %rsi # 0x129bc1
leaq 0x8(%rsp), %rdi
callq 0x21fb0
testl %eax, %eax
je 0xecc71
leaq 0x3d311(%rip), %rsi # 0x129f0f
leaq 0x8(%rsp), %rdi
callq 0x21fb0
testl %eax, %eax
jne 0xecd2c
leaq 0x28(%rsp), %rdx
movq $0x0, (%rdx)
leaq 0x7(%rsp), %rsi
movq %rbx, %rdi
callq 0xee748
jmp 0xecca8
leaq 0x7(%rsp), %rdx
movb $0x1, (%rdx)
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0xee656
jmp 0xecca8
leaq 0x18(%r15), %rcx
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xedf10
cmpb $0x0, 0x28(%rsp)
je 0xecc88
leaq 0x7(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0xee830
jmp 0xecc91
leaq 0x7(%rsp), %rdx
movb $0x0, (%rdx)
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0xee656
jmp 0xecca8
movq %r13, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
leaq 0x28(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x9524a
movq %r14, %rdi
callq 0x3488a
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xeccc3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21180
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x829ec(%rip), %rdi # 0x16f6c8
callq 0x215a0
testl %eax, %eax
je 0xecb77
leaq 0x829b8(%rip), %rdi # 0x16f6a8
leaq 0x3ead4(%rip), %rsi # 0x12b7cb
movl $0x10, %edx
callq 0x2d298
leaq -0x68ae8(%rip), %rdi # 0x84220
leaq 0x82999(%rip), %rsi # 0x16f6a8
leaq 0x81d82(%rip), %rdx # 0x16ea98
callq 0x21f30
leaq 0x829a6(%rip), %rdi # 0x16f6c8
callq 0x21990
jmp 0xecb77
movl $0x10, %edi
callq 0x21660
movq %rax, %r14
leaq 0x3eab0(%rip), %rsi # 0x12b7f0
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x373d5
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x21480
xorl %ebp, %ebp
movq 0x81258(%rip), %rsi # 0x16dfc0
movq 0x81211(%rip), %rdx # 0x16df80
movq %r14, %rdi
callq 0x21a80
movq %rax, %rbx
leaq 0x82947(%rip), %rdi # 0x16f6c8
callq 0x216e0
jmp 0xece16
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xecda9
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21180
testb %bpl, %bpl
jne 0xecdb3
jmp 0xecde2
movq %rax, %rbx
movq %r14, %rdi
callq 0x21f50
jmp 0xecde2
jmp 0xecddf
jmp 0xecddf
movq %rax, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x9524a
movq %r14, %rdi
callq 0x3488a
jmp 0xecde2
jmp 0xecddf
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xece16
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21180
jmp 0xece16
movq %rax, %rbx
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0xece16
leaq 0x8(%rsp), %rdi
callq 0xee628
movq %rbx, %rdi
callq 0x21b20
| _ZN5minja6Parser13parseConstantEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r15, rsi
mov rbx, rdi
lea r14, [rsi+20h]
mov r12, [rsi+18h]
mov r13, [rsi+20h]
mov rbp, r13
cmp r13, r12
jz short loc_ECB05
mov rbp, r13
loc_ECAED:
movsx edi, byte ptr [rbp+0]
call _isspace
test eax, eax
jz short loc_ECB05
inc rbp
mov [r14], rbp
cmp rbp, r12
jnz short loc_ECAED
loc_ECB05:
cmp rbp, r12
jz short loc_ECB5B
movzx eax, byte ptr [rbp+0]
cmp eax, 27h ; '''
jz short loc_ECB18
cmp eax, 22h ; '"'
jnz short loc_ECB66
loc_ECB18:
lea r12, [rsp+78h+var_70]
mov rdi, r12; int
mov rsi, r15; void *
call _ZN5minja6Parser11parseStringB5cxx11Ev; minja::Parser::parseString(void)
mov rdx, [r12]
test rdx, rdx
jz short loc_ECB66
lea rsi, [rsp+78h+var_50]
mov rdi, rbx
call _ZNSt12__shared_ptrIN5minja5ValueELN9__gnu_cxx12_Lock_policyE2EEC2ISaIvEJRNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEESt20_Sp_alloc_shared_tagIT_EDpOT0_; std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<void>,std::string &>(std::_Sp_alloc_shared_tag<std::allocator<void>>,std::string &)
mov rsi, qword ptr [rsp+78h+var_70]
test rsi, rsi
jz loc_ECCC3
lea rdi, [rsp+78h+var_70]
call _ZNKSt14default_deleteINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEPS5_; std::default_delete<std::string>::operator()(std::string*)
jmp loc_ECCC3
loc_ECB5B:
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
jmp loc_ECCC3
loc_ECB66:
lea rax, _ZGVZN5minja6Parser13parseConstantEvE8prim_tokB5cxx11; `guard variable for'minja::Parser::parseConstant(void)::prim_tok
mov al, [rax]
test al, al
jz loc_ECCD5
loc_ECB77:
lea rdx, _ZZN5minja6Parser13parseConstantEvE8prim_tokB5cxx11; int
lea r12, [rsp+78h+var_70]
mov rdi, r12; int
mov rsi, r15; int
mov ecx, 1; int
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
cmp qword ptr [r12+8], 0
jz loc_ECC42
lea rsi, aTrue; "true"
lea rdi, [rsp+78h+var_70]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_ECC2B
lea rsi, aTrue_0; "True"
lea rdi, [rsp+78h+var_70]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_ECC2B
lea rsi, aAdvancedOption+0ABh; "false"
lea rdi, [rsp+78h+var_70]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz loc_ECC71
lea rsi, aFalse; "False"
lea rdi, [rsp+78h+var_70]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_ECC71
lea rsi, aNone_0; "None"
lea rdi, [rsp+78h+var_70]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jnz loc_ECD2C
lea rdx, [rsp+78h+var_50]
mov qword ptr [rdx], 0
lea rsi, [rsp+78h+var_71]
mov rdi, rbx
call _ZNSt12__shared_ptrIN5minja5ValueELN9__gnu_cxx12_Lock_policyE2EEC2ISaIvEJDnEEESt20_Sp_alloc_shared_tagIT_EDpOT0_; std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<void>,decltype(nullptr)>(std::_Sp_alloc_shared_tag<std::allocator<void>>,decltype(nullptr) &&)
jmp short loc_ECCA8
loc_ECC2B:
lea rdx, [rsp+78h+var_71]
mov byte ptr [rdx], 1
lea rsi, [rsp+78h+var_50]
mov rdi, rbx
call _ZNSt12__shared_ptrIN5minja5ValueELN9__gnu_cxx12_Lock_policyE2EEC2ISaIvEJbEEESt20_Sp_alloc_shared_tagIT_EDpOT0_; std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<void>,bool>(std::_Sp_alloc_shared_tag<std::allocator<void>>,bool &&)
jmp short loc_ECCA8
loc_ECC42:
lea rcx, [r15+18h]
lea rdi, [rsp+78h+var_50]
mov rsi, r15
mov rdx, r14
call _ZN5minja6Parser11parseNumberERN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEERKSB_; minja::Parser::parseNumber(__gnu_cxx::__normal_iterator<char const*,std::string> &,__gnu_cxx::__normal_iterator<char const*,std::string> const&)
cmp [rsp+78h+var_50], 0
jz short loc_ECC88
lea rsi, [rsp+78h+var_71]
lea rdx, [rsp+78h+var_50]
mov rdi, rbx
call _ZNSt12__shared_ptrIN5minja5ValueELN9__gnu_cxx12_Lock_policyE2EEC2ISaIvEJRN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS8_14adl_serializerESB_IhSaIhEEvEEEEESt20_Sp_alloc_shared_tagIT_EDpOT0_; std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<void>,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &>(std::_Sp_alloc_shared_tag<std::allocator<void>>,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)
jmp short loc_ECC91
loc_ECC71:
lea rdx, [rsp+78h+var_71]
mov byte ptr [rdx], 0
lea rsi, [rsp+78h+var_50]
mov rdi, rbx
call _ZNSt12__shared_ptrIN5minja5ValueELN9__gnu_cxx12_Lock_policyE2EEC2ISaIvEJbEEESt20_Sp_alloc_shared_tagIT_EDpOT0_; std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<void>,bool>(std::_Sp_alloc_shared_tag<std::allocator<void>>,bool &&)
jmp short loc_ECCA8
loc_ECC88:
mov [r14], r13
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
loc_ECC91:
lea r14, [rsp+78h+var_50]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_ECCA8:
lea rax, [rsp+78h+var_60]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_ECCC3
mov rsi, [rsp+78h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_ECCC3:
mov rax, rbx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_ECCD5:
lea rdi, _ZGVZN5minja6Parser13parseConstantEvE8prim_tokB5cxx11; __guard *
call ___cxa_guard_acquire
test eax, eax
jz loc_ECB77
lea rdi, _ZZN5minja6Parser13parseConstantEvE8prim_tokB5cxx11; minja::Parser::parseConstant(void)::prim_tok
lea rsi, aTrueBTrueBFals; "true\\b|True\\b|false\\b|False\\b|None"...
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, _ZZN5minja6Parser13parseConstantEvE8prim_tokB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN5minja6Parser13parseConstantEvE8prim_tokB5cxx11; __guard *
call ___cxa_guard_release
jmp loc_ECB77
loc_ECD2C:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aUnknownConstan; "Unknown constant token: "
lea rdi, [rsp+78h+var_50]
lea rdx, [rsp+78h+var_70]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
mov bpl, 1
lea rsi, [rsp+78h+var_50]
mov rdi, r14
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
mov rbx, rax
lea rdi, _ZGVZN5minja6Parser13parseConstantEvE8prim_tokB5cxx11; __guard *
call ___cxa_guard_abort
jmp loc_ECE16
mov rbx, rax
lea rax, [rsp+78h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_ECDA9
mov rsi, [rsp+78h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_ECDA9:
test bpl, bpl
jnz short loc_ECDB3
jmp short loc_ECDE2
mov rbx, rax
loc_ECDB3:
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_ECDE2
jmp short loc_ECDDF
jmp short loc_ECDDF
mov rbx, rax
lea r14, [rsp+78h+var_50]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_ECDE2
jmp short $+2
loc_ECDDF:
mov rbx, rax
loc_ECDE2:
lea rax, [rsp+78h+var_60]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_ECE16
mov rsi, [rsp+78h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_ECE16
mov rbx, rax
mov rsi, qword ptr [rsp+78h+var_70]
test rsi, rsi
jz short loc_ECE16
lea rdi, [rsp+78h+var_70]
call _ZNKSt14default_deleteINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEPS5_; std::default_delete<std::string>::operator()(std::string*)
loc_ECE16:
mov rdi, rbx
call __Unwind_Resume
| minja::Parser * minja::Parser::parseConstant(minja::Parser *this, unsigned __int8 **a2)
{
unsigned __int8 **v2; // r14
char *v3; // r12
unsigned __int8 *v4; // r13
unsigned __int8 *v5; // rbp
int v6; // eax
void *exception; // r14
char v9; // [rsp+7h] [rbp-71h] BYREF
int v10[2]; // [rsp+8h] [rbp-70h] BYREF
long long v11; // [rsp+10h] [rbp-68h]
long long v12; // [rsp+18h] [rbp-60h] BYREF
_QWORD v13[2]; // [rsp+28h] [rbp-50h] BYREF
v2 = a2 + 4;
v3 = (char *)a2[3];
v4 = a2[4];
v5 = v4;
if ( v4 != (unsigned __int8 *)v3 )
{
v5 = a2[4];
do
{
if ( !(unsigned int)isspace((unsigned int)(char)*v5) )
break;
*v2 = ++v5;
}
while ( v5 != (unsigned __int8 *)v3 );
}
if ( v5 == (unsigned __int8 *)v3 )
{
*(_OWORD *)this = 0LL;
}
else
{
v6 = *v5;
if ( (v6 == 39 || v6 == 34) && (minja::Parser::parseString[abi:cxx11]((int)v10, a2), *(_QWORD *)v10) )
{
std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<void>,std::string &>(
this,
v13);
if ( *(_QWORD *)v10 )
std::default_delete<std::string>::operator()(v10);
}
else
{
if ( !(_BYTE)`guard variable for'minja::Parser::parseConstant(void)::prim_tok[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseConstant(void)::prim_tok[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseConstant(void)::prim_tok[abi:cxx11],
(long long)"true\\b|True\\b|false\\b|False\\b|None\\b",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseConstant(void)::prim_tok[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseConstant(void)::prim_tok[abi:cxx11]);
}
minja::Parser::consumeToken(
v10,
(long long)a2,
(long long)&minja::Parser::parseConstant(void)::prim_tok[abi:cxx11],
1u);
if ( v11 )
{
if ( !(unsigned int)std::string::compare(v10, "true") || !(unsigned int)std::string::compare(v10, "True") )
{
v9 = 1;
std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<void>,bool>(
this,
v13,
&v9);
}
else if ( !(unsigned int)std::string::compare(v10, "false") || !(unsigned int)std::string::compare(v10, "False") )
{
v9 = 0;
std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<void>,bool>(
this,
v13,
&v9);
}
else
{
if ( (unsigned int)std::string::compare(v10, "None") )
{
exception = __cxa_allocate_exception(0x10uLL);
std::operator+<char>((long long)v13, (long long)"Unknown constant token: ", v10);
std::runtime_error::runtime_error(exception, v13);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v13[0] = 0LL;
std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<void>,decltype(nullptr)>(
this,
&v9,
v13);
}
}
else
{
minja::Parser::parseNumber(v13, a2, v2, a2 + 3);
if ( LOBYTE(v13[0]) )
{
std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<void>,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> &>(
this,
&v9,
v13);
}
else
{
*v2 = v4;
*(_OWORD *)this = 0LL;
}
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v13);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v13);
}
if ( *(long long **)v10 != &v12 )
operator delete(*(void **)v10, v12 + 1);
}
}
return this;
}
| parseConstant:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R15,RSI
MOV RBX,RDI
LEA R14,[RSI + 0x20]
MOV R12,qword ptr [RSI + 0x18]
MOV R13,qword ptr [RSI + 0x20]
MOV RBP,R13
CMP R13,R12
JZ 0x001ecb05
MOV RBP,R13
LAB_001ecaed:
MOVSX EDI,byte ptr [RBP]
CALL 0x00121d50
TEST EAX,EAX
JZ 0x001ecb05
INC RBP
MOV qword ptr [R14],RBP
CMP RBP,R12
JNZ 0x001ecaed
LAB_001ecb05:
CMP RBP,R12
JZ 0x001ecb5b
MOVZX EAX,byte ptr [RBP]
CMP EAX,0x27
JZ 0x001ecb18
CMP EAX,0x22
JNZ 0x001ecb66
LAB_001ecb18:
LEA R12,[RSP + 0x8]
MOV RDI,R12
MOV RSI,R15
CALL 0x001ede90
MOV RDX,qword ptr [R12]
TEST RDX,RDX
JZ 0x001ecb66
LAB_001ecb31:
LEA RSI,[RSP + 0x28]
MOV RDI,RBX
CALL 0x001ee482
LAB_001ecb3e:
MOV RSI,qword ptr [RSP + 0x8]
TEST RSI,RSI
JZ 0x001eccc3
LEA RDI,[RSP + 0x8]
CALL 0x001ee628
JMP 0x001eccc3
LAB_001ecb5b:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
JMP 0x001eccc3
LAB_001ecb66:
LEA RAX,[0x26f6c8]
MOV AL,byte ptr [RAX]
TEST AL,AL
JZ 0x001eccd5
LAB_001ecb77:
LEA RDX,[0x26f6a8]
LEA R12,[RSP + 0x8]
MOV RDI,R12
MOV RSI,R15
MOV ECX,0x1
CALL 0x001e76bc
CMP qword ptr [R12 + 0x8],0x0
JZ 0x001ecc42
LEA RSI,[0x21f417]
LEA RDI,[RSP + 0x8]
CALL 0x00121fb0
TEST EAX,EAX
JZ 0x001ecc2b
LEA RSI,[0x229bbc]
LEA RDI,[RSP + 0x8]
CALL 0x00121fb0
TEST EAX,EAX
JZ 0x001ecc2b
LEA RSI,[0x222344]
LEA RDI,[RSP + 0x8]
CALL 0x00121fb0
TEST EAX,EAX
JZ 0x001ecc71
LEA RSI,[0x229bc1]
LEA RDI,[RSP + 0x8]
CALL 0x00121fb0
TEST EAX,EAX
JZ 0x001ecc71
LEA RSI,[0x229f0f]
LEA RDI,[RSP + 0x8]
CALL 0x00121fb0
TEST EAX,EAX
JNZ 0x001ecd2c
LEA RDX,[RSP + 0x28]
MOV qword ptr [RDX],0x0
LAB_001ecc1c:
LEA RSI,[RSP + 0x7]
MOV RDI,RBX
CALL 0x001ee748
JMP 0x001ecca8
LAB_001ecc2b:
LEA RDX,[RSP + 0x7]
MOV byte ptr [RDX],0x1
LAB_001ecc33:
LEA RSI,[RSP + 0x28]
MOV RDI,RBX
CALL 0x001ee656
JMP 0x001ecca8
LAB_001ecc42:
LEA RCX,[R15 + 0x18]
LEA RDI,[RSP + 0x28]
MOV RSI,R15
MOV RDX,R14
CALL 0x001edf10
CMP byte ptr [RSP + 0x28],0x0
JZ 0x001ecc88
LAB_001ecc5d:
LEA RSI,[RSP + 0x7]
LEA RDX,[RSP + 0x28]
MOV RDI,RBX
CALL 0x001ee830
JMP 0x001ecc91
LAB_001ecc71:
LEA RDX,[RSP + 0x7]
MOV byte ptr [RDX],0x0
LAB_001ecc79:
LEA RSI,[RSP + 0x28]
MOV RDI,RBX
CALL 0x001ee656
JMP 0x001ecca8
LAB_001ecc88:
MOV qword ptr [R14],R13
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
LAB_001ecc91:
LEA R14,[RSP + 0x28]
MOV RDI,R14
XOR ESI,ESI
CALL 0x0019524a
MOV RDI,R14
CALL 0x0013488a
LAB_001ecca8:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001eccc3
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00121180
LAB_001eccc3:
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001eccd5:
LEA RDI,[0x26f6c8]
CALL 0x001215a0
TEST EAX,EAX
JZ 0x001ecb77
LAB_001ecce9:
LEA RDI,[0x26f6a8]
LEA RSI,[0x22b7cb]
MOV EDX,0x10
CALL 0x0012d298
LAB_001ecd01:
LEA RDI,[0x184220]
LEA RSI,[0x26f6a8]
LEA RDX,[0x26ea98]
CALL 0x00121f30
LEA RDI,[0x26f6c8]
CALL 0x00121990
JMP 0x001ecb77
LAB_001ecd2c:
MOV EDI,0x10
CALL 0x00121660
MOV R14,RAX
LAB_001ecd39:
LEA RSI,[0x22b7f0]
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x8]
CALL 0x001373d5
MOV BPL,0x1
LAB_001ecd52:
LEA RSI,[RSP + 0x28]
MOV RDI,R14
CALL 0x00121480
XOR EBP,EBP
MOV RSI,qword ptr [0x0026dfc0]
MOV RDX,qword ptr [0x0026df80]
MOV RDI,R14
CALL 0x00121a80
|
/* minja::Parser::parseConstant() */
void minja::Parser::parseConstant(void)
{
char *pcVar1;
char *pcVar2;
int iVar3;
runtime_error *this;
char *pcVar4;
__normal_iterator *in_RSI;
int8 *in_RDI;
string *local_70;
long local_68;
long local_60 [2];
int8 local_50 [4];
pcVar1 = *(char **)(in_RSI + 0x18);
pcVar2 = *(char **)(in_RSI + 0x20);
pcVar4 = pcVar2;
while ((pcVar4 != pcVar1 && (iVar3 = isspace((int)*pcVar4), iVar3 != 0))) {
pcVar4 = pcVar4 + 1;
*(char **)(in_RSI + 0x20) = pcVar4;
}
if (pcVar4 == pcVar1) {
*in_RDI = 0;
in_RDI[1] = 0;
}
else if (((*pcVar4 == '\'') || (*pcVar4 == '\"')) &&
(parseString_abi_cxx11_(), local_70 != (string *)0x0)) {
/* try { // try from 001ecb31 to 001ecb3d has its CatchHandler @ 001ecdff */
std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::
__shared_ptr<std::allocator<void>,std::__cxx11::string&>();
if (local_70 != (string *)0x0) {
std::default_delete<std::__cxx11::string>::operator()
((default_delete<std::__cxx11::string> *)&local_70,local_70);
}
}
else {
if ((parseConstant()::prim_tok_abi_cxx11_ == '\0') &&
(iVar3 = __cxa_guard_acquire(&parseConstant()::prim_tok_abi_cxx11_), iVar3 != 0)) {
/* try { // try from 001ecce9 to 001ecd00 has its CatchHandler @ 001ecd77 */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
((basic_regex<char,std::__cxx11::regex_traits<char>> *)
parseConstant()::prim_tok_abi_cxx11_,"true\\b|True\\b|false\\b|False\\b|None\\b",
0x10);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
parseConstant()::prim_tok_abi_cxx11_,&__dso_handle);
__cxa_guard_release(&parseConstant()::prim_tok_abi_cxx11_);
}
consumeToken(&local_70);
if (local_68 == 0) {
/* try { // try from 001ecc42 to 001ecc55 has its CatchHandler @ 001ecddd */
parseNumber((__normal_iterator *)local_50,in_RSI);
if (local_50[0]._0_1_ == (data)0x0) {
*(char **)(in_RSI + 0x20) = pcVar2;
*in_RDI = 0;
in_RDI[1] = 0;
}
else {
/* try { // try from 001ecc5d to 001ecc6e has its CatchHandler @ 001ecdc1 */
std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::
__shared_ptr<std::allocator<void>,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&>
();
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81((data *)local_50,0));
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>
::data::~data((data *)local_50);
}
else {
iVar3 = std::__cxx11::string::compare((char *)&local_70);
if ((iVar3 == 0) || (iVar3 = std::__cxx11::string::compare((char *)&local_70), iVar3 == 0)) {
/* try { // try from 001ecc33 to 001ecc3f has its CatchHandler @ 001ecddf */
std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::
__shared_ptr<std::allocator<void>,bool>();
}
else {
iVar3 = std::__cxx11::string::compare((char *)&local_70);
if ((iVar3 == 0) || (iVar3 = std::__cxx11::string::compare((char *)&local_70), iVar3 == 0))
{
/* try { // try from 001ecc79 to 001ecc85 has its CatchHandler @ 001ecdbf */
std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::
__shared_ptr<std::allocator<void>,bool>();
}
else {
iVar3 = std::__cxx11::string::compare((char *)&local_70);
if (iVar3 != 0) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001ecd39 to 001ecd4e has its CatchHandler @ 001ecdb0 */
std::operator+((char *)local_50,(string *)"Unknown constant token: ");
/* try { // try from 001ecd52 to 001ecd76 has its CatchHandler @ 001ecd8b */
std::runtime_error::runtime_error(this,(string *)local_50);
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_0026dfc0,PTR__runtime_error_0026df80);
}
local_50[0] = 0;
/* try { // try from 001ecc1c to 001ecc28 has its CatchHandler @ 001ecdbd */
std::__shared_ptr<minja::Value,(__gnu_cxx::_Lock_policy)2>::
__shared_ptr<std::allocator<void>,decltype(nullptr)>();
}
}
}
if (local_70 != (string *)local_60) {
operator_delete(local_70,local_60[0] + 1);
}
}
return;
}
| |
26,446 | dtoa_alloc | eloqsql/strings/dtoa.c | static char *dtoa_alloc(int i, Stack_alloc *alloc)
{
char *rv;
int aligned_size= MY_ALIGN(i, SIZEOF_CHARP);
if (alloc->free + aligned_size <= alloc->end)
{
rv= alloc->free;
alloc->free+= aligned_size;
}
else
rv= malloc(i);
return rv;
} | O0 | c | dtoa_alloc:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
addl $0x8, %eax
subl $0x1, %eax
andl $-0x8, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
ja 0xac6ba
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
jmp 0xac6c7
movslq -0x4(%rbp), %rdi
callq 0x26440
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| dtoa_alloc:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov eax, [rbp+var_4]
add eax, 8
sub eax, 1
and eax, 0FFFFFFF8h
mov [rbp+var_1C], eax
mov rax, [rbp+var_10]
mov rax, [rax+8]
movsxd rcx, [rbp+var_1C]
add rax, rcx
mov rcx, [rbp+var_10]
cmp rax, [rcx+10h]
ja short loc_AC6BA
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_18], rax
mov edx, [rbp+var_1C]
mov rax, [rbp+var_10]
mov rcx, [rax+8]
movsxd rdx, edx
add rcx, rdx
mov [rax+8], rcx
jmp short loc_AC6C7
loc_AC6BA:
movsxd rdi, [rbp+var_4]
call _malloc
mov [rbp+var_18], rax
loc_AC6C7:
mov rax, [rbp+var_18]
add rsp, 20h
pop rbp
retn
| long long dtoa_alloc(int a1, long long a2)
{
signed int v3; // [rsp+4h] [rbp-1Ch]
long long v4; // [rsp+8h] [rbp-18h]
v3 = (a1 + 7) & 0xFFFFFFF8;
if ( (unsigned long long)(v3 + *(_QWORD *)(a2 + 8)) > *(_QWORD *)(a2 + 16) )
return malloc(a1);
v4 = *(_QWORD *)(a2 + 8);
*(_QWORD *)(a2 + 8) = v3 + v4;
return v4;
}
| dtoa_alloc:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x8
SUB EAX,0x1
AND EAX,0xfffffff8
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOVSXD RCX,dword ptr [RBP + -0x1c]
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x10]
JA 0x001ac6ba
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV EDX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x8]
MOVSXD RDX,EDX
ADD RCX,RDX
MOV qword ptr [RAX + 0x8],RCX
JMP 0x001ac6c7
LAB_001ac6ba:
MOVSXD RDI,dword ptr [RBP + -0x4]
CALL 0x00126440
MOV qword ptr [RBP + -0x18],RAX
LAB_001ac6c7:
MOV RAX,qword ptr [RBP + -0x18]
ADD RSP,0x20
POP RBP
RET
|
void * dtoa_alloc(int param_1,long param_2)
{
uint uVar1;
int8 local_20;
uVar1 = param_1 + 7U & 0xfffffff8;
if (*(ulong *)(param_2 + 0x10) < (ulong)(*(long *)(param_2 + 8) + (long)(int)uVar1)) {
local_20 = malloc((long)param_1);
}
else {
local_20 = *(void **)(param_2 + 8);
*(long *)(param_2 + 8) = *(long *)(param_2 + 8) + (long)(int)uVar1;
}
return local_20;
}
| |
26,447 | print_aria_log_control | eloqsql/storage/maria/ma_control_file.c | my_bool print_aria_log_control()
{
uchar buffer[CF_MAX_SIZE];
char name[FN_REFLEN], uuid_str[MY_UUID_STRING_LENGTH+1];
const char *errmsg;
uint new_cf_create_time_size, new_cf_changeable_size;
my_off_t file_size;
ulong logno;
ulonglong trid,checkpoint_lsn;
int open_flags= O_BINARY | /*O_DIRECT |*/ O_RDWR | O_CLOEXEC;
int error= CONTROL_FILE_UNKNOWN_ERROR;
uint recovery_fails;
File file;
DBUG_ENTER("ma_control_file_open");
if (fn_format(name, CONTROL_FILE_BASE_NAME,
maria_data_root, "", MYF(MY_WME)) == NullS)
DBUG_RETURN(CONTROL_FILE_UNKNOWN_ERROR);
if ((file= mysql_file_open(key_file_control, name,
open_flags, MYF(MY_WME))) < 0)
{
errmsg= "Can't open file";
goto err;
}
file_size= mysql_file_seek(file, 0, SEEK_END, MYF(MY_WME));
if (file_size == MY_FILEPOS_ERROR)
{
errmsg= "Can't read size";
goto err;
}
if (file_size < CF_MIN_SIZE)
{
/*
Given that normally we write only a sector and it's atomic, the only
possibility for a file to be of too short size is if we crashed at the
very first startup, between file creation and file write. Quite unlikely
(and can be made even more unlikely by doing this: create a temp file,
write it, and then rename it to be the control file).
What's more likely is if someone forgot to restore the control file,
just did a "touch control" to try to get Maria to start, or if the
disk/filesystem has a problem.
So let's be rigid.
*/
error= CONTROL_FILE_TOO_SMALL;
errmsg= "Size of control file is smaller than expected";
goto err;
}
/* Check if control file is unexpectedly big */
if (file_size > CF_MAX_SIZE)
{
error= CONTROL_FILE_TOO_BIG;
errmsg= "File size bigger than expected";
goto err;
}
if (mysql_file_pread(file, buffer, (size_t)file_size, 0, MYF(MY_FNABP)))
{
errmsg= "Can't read file";
goto err;
}
if (memcmp(buffer + CF_MAGIC_STRING_OFFSET,
CF_MAGIC_STRING, CF_MAGIC_STRING_SIZE))
{
error= CONTROL_FILE_BAD_MAGIC_STRING;
errmsg= "Missing valid id at start of file. File is not a valid aria control file";
goto err;
}
printf("Aria file version: %u\n", buffer[CF_VERSION_OFFSET]);
new_cf_create_time_size= uint2korr(buffer + CF_CREATE_TIME_SIZE_OFFSET);
new_cf_changeable_size= uint2korr(buffer + CF_CHANGEABLE_SIZE_OFFSET);
if (new_cf_create_time_size < CF_MIN_CREATE_TIME_TOTAL_SIZE ||
new_cf_changeable_size < CF_MIN_CHANGEABLE_TOTAL_SIZE ||
new_cf_create_time_size + new_cf_changeable_size != file_size)
{
error= CONTROL_FILE_INCONSISTENT_INFORMATION;
errmsg= "Sizes stored in control file are inconsistent";
goto err;
}
checkpoint_lsn= lsn_korr(buffer + new_cf_create_time_size +
CF_LSN_OFFSET);
logno= uint4korr(buffer + new_cf_create_time_size + CF_FILENO_OFFSET);
my_uuid2str(buffer + CF_UUID_OFFSET, uuid_str);
uuid_str[MY_UUID_STRING_LENGTH]= 0;
printf("Block size: %u\n", uint2korr(buffer + CF_BLOCKSIZE_OFFSET));
printf("maria_uuid: %s\n", uuid_str);
printf("last_checkpoint_lsn: " LSN_FMT "\n", LSN_IN_PARTS(checkpoint_lsn));
printf("last_log_number: %lu\n", (ulong) logno);
if (new_cf_changeable_size >= (CF_MAX_TRID_OFFSET + CF_MAX_TRID_SIZE))
{
trid= transid_korr(buffer + new_cf_create_time_size + CF_MAX_TRID_OFFSET);
printf("trid: %llu\n", (ulonglong) trid);
}
if (new_cf_changeable_size >= (CF_RECOV_FAIL_OFFSET + CF_RECOV_FAIL_SIZE))
{
recovery_fails=
(buffer + new_cf_create_time_size + CF_RECOV_FAIL_OFFSET)[0];
printf("recovery_failures: %u\n", recovery_fails);
}
DBUG_RETURN(0);
err:
my_printf_error(HA_ERR_INITIALIZATION,
"Got error '%s' when trying to use aria control file "
"'%s'", 0, errmsg, name);
DBUG_RETURN(error);
} | O3 | c | print_aria_log_control:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x478, %rsp # imm = 0x478
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
leaq 0x3b4d2a(%rip), %rax # 0x3fcf60
movq (%rax), %rdx
leaq 0x917f0(%rip), %rsi # 0xd9a30
leaq 0x97bc9(%rip), %rcx # 0xdfe10
leaq -0x480(%rbp), %rdi
movl $0x10, %r8d
callq 0x949ac
testq %rax, %rax
je 0x48315
leaq 0x3b4eb7(%rip), %rax # 0x3fd120
movl (%rax), %esi
leaq 0x33dd9e(%rip), %r13 # 0x386010
movq (%r13), %rax
leaq -0x280(%rbp), %rdi
leaq -0x480(%rbp), %rcx
leaq -0x80(%rbp), %rbx
movl $0x2, %edx
movq %rbx, %r8
callq *0x148(%rax)
movq %rax, (%rbx)
testq %rax, %rax
jne 0x48567
leaq -0x480(%rbp), %rdi
movl $0x10, %edx
movl $0x80002, %esi # imm = 0x80002
callq 0xa03b8
movl %eax, %r15d
movb $0xb, %bl
testl %r15d, %r15d
js 0x4831c
movq (%r13), %rax
leaq -0x280(%rbp), %rdi
movl %r15d, %esi
movl $0x8, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x4858c
movl $0x10, %ecx
movl %r15d, %edi
xorl %esi, %esi
movl $0x2, %edx
callq 0xa0b78
movq %rax, %r14
cmpq $-0x1, %r14
je 0x48328
cmpq $0x2d, %r14
jae 0x48334
leaq 0x917be(%rip), %rcx # 0xd9acc
movb $0x1, %bl
jmp 0x483b5
movb $0xb, %bl
jmp 0x483d1
leaq 0x91789(%rip), %rcx # 0xd9aac
jmp 0x483b5
leaq 0x9178d(%rip), %rcx # 0xd9abc
jmp 0x483b5
cmpq $0x200, %r14 # imm = 0x200
jbe 0x48348
leaq 0x917b6(%rip), %rcx # 0xd9afa
movb $0x2, %bl
jmp 0x483b5
movq (%r13), %rax
leaq -0x80(%rbp), %rdi
movl %r15d, %esi
movl $0x6, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x485a6
leaq -0x280(%rbp), %rsi
movl $0x2, %r8d
movl %r15d, %edi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xa0638
movq %rax, %r15
testq %r15, %r15
je 0x48392
leaq 0x91789(%rip), %rcx # 0xd9b19
jmp 0x483b5
movl $0xfefe, %eax # imm = 0xFEFE
xorl -0x280(%rbp), %eax
movzbl -0x27e(%rbp), %ecx
xorl $0xc, %ecx
orw %ax, %cx
je 0x483f8
leaq 0x9177a(%rip), %rcx # 0xd9b2d
movb $0x3, %bl
leaq 0x918c7(%rip), %rsi # 0xd9c83
leaq -0x480(%rbp), %r8
movl $0xae, %edi
xorl %edx, %edx
xorl %eax, %eax
callq 0x9e2c9
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x48600
movl %ebx, %eax
addq $0x478, %rsp # imm = 0x478
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzbl -0x27d(%rbp), %edx
leaq 0x9192c(%rip), %rsi # 0xd9d32
movl $0x1, %edi
xorl %eax, %eax
callq 0x29810
movzwl -0x26c(%rbp), %r12d
leaq 0x91793(%rip), %rcx # 0xd9bb4
movb $0x8, %bl
cmpq $0x1e, %r12
jb 0x483b5
movzwl -0x26a(%rbp), %r13d
cmpw $0xf, %r13w
jb 0x483b5
movq %r13, %rax
addq %r12, %rax
cmpq %rax, %r14
jne 0x483b5
movzwl -0x27c(%rbp,%r12), %eax
movzbl -0x27a(%rbp,%r12), %r15d
shll $0x10, %r15d
orl %eax, %r15d
movl -0x279(%rbp,%r12), %eax
movl %eax, -0x484(%rbp)
movl -0x275(%rbp,%r12), %eax
movq %rax, -0x490(%rbp)
leaq -0x27c(%rbp), %rbx
leaq -0x80(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa6502
movb $0x0, 0x24(%r14)
movzwl 0x14(%rbx), %edx
leaq 0x918a4(%rip), %rsi # 0xd9d4b
xorl %ebx, %ebx
movl $0x1, %edi
xorl %eax, %eax
callq 0x29810
leaq 0x918a8(%rip), %rsi # 0xd9d64
movl $0x1, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x29810
leaq 0x918ab(%rip), %rsi # 0xd9d7d
movl $0x1, %edi
movl %r15d, %edx
movl -0x484(%rbp), %ecx
xorl %eax, %eax
callq 0x29810
leaq 0x918af(%rip), %rsi # 0xd9d9d
movl $0x1, %edi
movq -0x490(%rbp), %rdx
xorl %eax, %eax
callq 0x29810
cmpw $0x15, %r13w
jb 0x483d1
movl -0x271(%rbp,%r12), %eax
movzwl -0x26d(%rbp,%r12), %edx
shlq $0x20, %rdx
orq %rax, %rdx
leaq 0x9188c(%rip), %rsi # 0xd9db7
xorl %ebx, %ebx
movl $0x1, %edi
xorl %eax, %eax
callq 0x29810
cmpw $0x15, %r13w
je 0x483d1
movzbl -0x26b(%rbp,%r12), %edx
leaq 0x9187e(%rip), %rsi # 0xd9dd2
xorl %ebx, %ebx
movl $0x1, %edi
xorl %eax, %eax
callq 0x29810
jmp 0x483d1
leaq -0x480(%rbp), %rsi
leaq -0x80(%rbp), %rdx
leaq -0x494(%rbp), %rbx
movq %rax, %rdi
movq %rbx, %rcx
callq 0x2a7f2
movl (%rbx), %r15d
jmp 0x482bb
leaq -0x80(%rbp), %r14
movq %rax, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x2a84e
movq (%r14), %r14
jmp 0x482fb
movq %rax, %r12
movq (%r13), %rax
leaq 0x914af(%rip), %rdx # 0xd9a63
movq %r12, %rdi
movq %r14, %rsi
movl $0x2a6, %ecx # imm = 0x2A6
callq *0x210(%rax)
leaq -0x280(%rbp), %rsi
movl $0x2, %r8d
movl %r15d, %edi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xa0638
movq %rax, %r15
testq %rax, %rax
movl $0x0, %esi
cmoveq %r14, %rsi
movq (%r13), %rax
movq %r12, %rdi
callq *0x218(%rax)
jmp 0x48384
callq 0x29270
nopl (%rax)
| print_aria_log_control:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 478h
mov rax, fs:28h
mov [rbp+var_30], rax
lea rax, maria_data_root
mov rdx, [rax]
lea rsi, aAriaLogControl; "aria_log_control"
lea rcx, asc_DFE0C+4; ""
lea rdi, [rbp+var_480]
mov r8d, 10h
call fn_format
test rax, rax
jz loc_48315
lea rax, key_file_control
mov esi, [rax]
lea r13, PSI_server
mov rax, [r13+0]
lea rdi, [rbp+var_280]
lea rcx, [rbp+var_480]
lea rbx, [rbp+var_80]
mov edx, 2
mov r8, rbx
call qword ptr [rax+148h]
mov [rbx], rax
test rax, rax
jnz loc_48567
lea rdi, [rbp+var_480]
mov edx, 10h
mov esi, offset loc_80002
call my_open
mov r15d, eax
loc_482BB:
mov bl, 0Bh
test r15d, r15d
js short loc_4831C
mov rax, [r13+0]
lea rdi, [rbp+var_280]
mov esi, r15d
mov edx, 8
call qword ptr [rax+158h]
test rax, rax
jnz loc_4858C
mov ecx, 10h
mov edi, r15d
xor esi, esi
mov edx, 2
call my_seek
mov r14, rax
loc_482FB:
cmp r14, 0FFFFFFFFFFFFFFFFh
jz short loc_48328
cmp r14, 2Dh ; '-'
jnb short loc_48334
lea rcx, aSizeOfControlF; "Size of control file is smaller than ex"...
mov bl, 1
jmp loc_483B5
loc_48315:
mov bl, 0Bh
jmp loc_483D1
loc_4831C:
lea rcx, aCanTOpenFile; "Can't open file"
jmp loc_483B5
loc_48328:
lea rcx, aCanTReadSize; "Can't read size"
jmp loc_483B5
loc_48334:
cmp r14, 200h
jbe short loc_48348
lea rcx, aFileSizeBigger; "File size bigger than expected"
mov bl, 2
jmp short loc_483B5
loc_48348:
mov rax, [r13+0]
lea rdi, [rbp+var_80]
mov esi, r15d
mov edx, 6
call qword ptr [rax+158h]
test rax, rax
jnz loc_485A6
lea rsi, [rbp+var_280]
mov r8d, 2
mov edi, r15d
mov rdx, r14
xor ecx, ecx
call my_pread
mov r15, rax
loc_48384:
test r15, r15
jz short loc_48392
lea rcx, aCanTReadFile; "Can't read file"
jmp short loc_483B5
loc_48392:
mov eax, 0FEFEh
xor eax, [rbp+var_280]
movzx ecx, byte ptr [rbp+var_280+2]
xor ecx, 0Ch
or cx, ax
jz short loc_483F8
lea rcx, aMissingValidId; "Missing valid id at start of file. File"...
mov bl, 3
loc_483B5:
lea rsi, aGotErrorSWhenT; "Got error '%s' when trying to use aria "...
lea r8, [rbp+var_480]
mov edi, 0AEh
xor edx, edx
xor eax, eax
call my_printf_error
loc_483D1:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz loc_48600
mov eax, ebx
add rsp, 478h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_483F8:
movzx edx, byte ptr [rbp+var_280+3]
lea rsi, aAriaFileVersio; "Aria file version: %u\n"
mov edi, 1
xor eax, eax
call ___printf_chk
movzx r12d, [rbp+var_26C]
lea rcx, aSizesStoredInC; "Sizes stored in control file are incons"...
mov bl, 8
cmp r12, 1Eh
jb short loc_483B5
movzx r13d, [rbp+var_26A]
cmp r13w, 0Fh
jb loc_483B5
mov rax, r13
add rax, r12
cmp r14, rax
jnz loc_483B5
movzx eax, [rbp+r12+var_27C]
movzx r15d, [rbp+r12+var_27A]
shl r15d, 10h
or r15d, eax
mov eax, [rbp+r12+var_279]
mov [rbp+var_484], eax
mov eax, [rbp+r12+var_275]
mov [rbp+var_490], rax
lea rbx, [rbp+var_27C]
lea r14, [rbp+var_80]
mov rdi, rbx
mov rsi, r14
call my_uuid2str
mov byte ptr [r14+24h], 0
movzx edx, word ptr [rbx+14h]
lea rsi, aBlockSizeU; "Block size: %u\n"
xor ebx, ebx
mov edi, 1
xor eax, eax
call ___printf_chk
lea rsi, aMariaUuidS; "maria_uuid: %s\n"
mov edi, 1
mov rdx, r14
xor eax, eax
call ___printf_chk
lea rsi, aLastCheckpoint; "last_checkpoint_lsn: (%u,0x%x)\n"
mov edi, 1
mov edx, r15d
mov ecx, [rbp+var_484]
xor eax, eax
call ___printf_chk
lea rsi, aLastLogNumberL; "last_log_number: %lu\n"
mov edi, 1
mov rdx, [rbp+var_490]
xor eax, eax
call ___printf_chk
cmp r13w, 15h
jb loc_483D1
mov eax, [rbp+r12+var_271]
movzx edx, word ptr [rbp+r12-26Dh]
shl rdx, 20h
or rdx, rax
lea rsi, aTridLlu; "trid: %llu\n"
xor ebx, ebx
mov edi, 1
xor eax, eax
call ___printf_chk
cmp r13w, 15h
jz loc_483D1
movzx edx, byte ptr [rbp+r12+var_26C+1]
lea rsi, aRecoveryFailur; "recovery_failures: %u\n"
xor ebx, ebx
mov edi, 1
xor eax, eax
call ___printf_chk
jmp loc_483D1
loc_48567:
lea rsi, [rbp+var_480]
lea rdx, [rbp+var_80]
lea rbx, [rbp+var_494]
mov rdi, rax
mov rcx, rbx
call print_aria_log_control_cold_1
mov r15d, [rbx]
jmp loc_482BB
loc_4858C:
lea r14, [rbp+var_80]
mov rdi, rax
mov esi, r15d
mov rdx, r14
call print_aria_log_control_cold_2
mov r14, [r14]
jmp loc_482FB
loc_485A6:
mov r12, rax
mov rax, [r13+0]
lea rdx, aWorkspaceLlm4b_6; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r12
mov rsi, r14
mov ecx, 2A6h
call qword ptr [rax+210h]
lea rsi, [rbp+var_280]
mov r8d, 2
mov edi, r15d
mov rdx, r14
xor ecx, ecx
call my_pread
mov r15, rax
test rax, rax
mov esi, 0
cmovz rsi, r14
mov rax, [r13+0]
mov rdi, r12
call qword ptr [rax+218h]
jmp loc_48384
loc_48600:
call ___stack_chk_fail
| long long print_aria_log_control()
{
unsigned int *v0; // rbx
long long v1; // rax
int v2; // r9d
unsigned int v3; // r15d
long long v4; // rax
unsigned long long v5; // r14
const char *v6; // rcx
long long v7; // rax
long long v8; // r15
long long v10; // rdx
long long v11; // r12
unsigned __int16 v12; // r13
int v13; // r15d
long long v14; // r12
unsigned long long v15; // rsi
unsigned int v16; // [rsp+Ch] [rbp-494h] BYREF
long long v17; // [rsp+10h] [rbp-490h]
int v18; // [rsp+1Ch] [rbp-484h]
_BYTE v19[512]; // [rsp+20h] [rbp-480h] BYREF
unsigned __int16 v20; // [rsp+220h] [rbp-280h] BYREF
unsigned __int8 v21; // [rsp+222h] [rbp-27Eh]
unsigned __int8 v22; // [rsp+223h] [rbp-27Dh]
_WORD v23[8]; // [rsp+224h] [rbp-27Ch] BYREF
unsigned __int16 v24; // [rsp+234h] [rbp-26Ch]
unsigned __int16 v25; // [rsp+236h] [rbp-26Ah]
unsigned __int16 v26; // [rsp+238h] [rbp-268h]
_QWORD v27[4]; // [rsp+420h] [rbp-80h] BYREF
char v28; // [rsp+444h] [rbp-5Ch]
unsigned long long v29; // [rsp+470h] [rbp-30h]
v29 = __readfsqword(0x28u);
if ( fn_format(v19, "aria_log_control", maria_data_root, "", 16LL) )
{
v0 = (unsigned int *)v27;
v1 = ((long long ( *)(unsigned __int16 *, _QWORD, long long, _BYTE *, _QWORD *))PSI_server[41])(
&v20,
key_file_control,
2LL,
v19,
v27);
v27[0] = v1;
if ( v1 )
{
v0 = &v16;
print_aria_log_control_cold_1(v1, (long long)v19, v27, &v16);
v3 = v16;
}
else
{
v3 = my_open(v19, &loc_80002, 16LL);
}
LOBYTE(v0) = 11;
if ( (v3 & 0x80000000) != 0 )
{
v6 = "Can't open file";
goto LABEL_21;
}
v4 = ((long long ( *)(unsigned __int16 *, _QWORD, long long))PSI_server[43])(&v20, v3, 8LL);
if ( v4 )
{
print_aria_log_control_cold_2(v4, v3, v27);
v5 = v27[0];
}
else
{
v5 = my_seek(v3, 0LL, 2LL, 16LL);
}
if ( v5 == -1LL )
{
v6 = "Can't read size";
goto LABEL_21;
}
if ( v5 < 0x2D )
{
v6 = "Size of control file is smaller than expected";
LOBYTE(v0) = 1;
LABEL_21:
my_printf_error(
174,
(unsigned int)"Got error '%s' when trying to use aria control file '%s'",
0,
(_DWORD)v6,
(unsigned int)v19,
v2);
return (unsigned int)v0;
}
if ( v5 > 0x200 )
{
v6 = "File size bigger than expected";
LOBYTE(v0) = 2;
goto LABEL_21;
}
v7 = ((long long ( *)(_QWORD *, _QWORD, long long))PSI_server[43])(v27, v3, 6LL);
if ( v7 )
{
v14 = v7;
((void ( *)(long long, unsigned long long, const char *, long long))PSI_server[66])(
v7,
v5,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_control_file.c",
678LL);
v8 = my_pread(v3, &v20, v5, 0LL, 2LL);
v15 = 0LL;
if ( !v8 )
v15 = v5;
((void ( *)(long long, unsigned long long))PSI_server[67])(v14, v15);
}
else
{
v8 = my_pread(v3, &v20, v5, 0LL, 2LL);
}
if ( v8 )
{
v6 = "Can't read file";
goto LABEL_21;
}
if ( v20 ^ 0xFEFE | v21 ^ 0xC )
{
v6 = "Missing valid id at start of file. File is not a valid aria control file";
LOBYTE(v0) = 3;
goto LABEL_21;
}
__printf_chk(1LL, "Aria file version: %u\n", v22);
v11 = v24;
v6 = "Sizes stored in control file are inconsistent";
LOBYTE(v0) = 8;
if ( v24 < 0x1EuLL )
goto LABEL_21;
v12 = v25;
if ( v25 < 0xFu || v5 != v24 + (unsigned long long)v25 )
goto LABEL_21;
v13 = *(unsigned __int16 *)((char *)v23 + v24) | (*((unsigned __int8 *)&v23[1] + v24) << 16);
v18 = *(_DWORD *)((char *)&v23[1] + v24 + 1);
v17 = *(unsigned int *)((char *)&v23[3] + v24 + 1);
my_uuid2str(v23, v27, v10, "Sizes stored in control file are inconsistent");
v28 = 0;
LODWORD(v0) = 0;
__printf_chk(1LL, "Block size: %u\n", v26);
__printf_chk(1LL, "maria_uuid: %s\n", (const char *)v27);
__printf_chk(1LL, "last_checkpoint_lsn: (%u,0x%x)\n", v13, v18);
__printf_chk(1LL, "last_log_number: %lu\n", v17);
if ( v12 >= 0x15u )
{
LODWORD(v0) = 0;
__printf_chk(
1LL,
"trid: %llu\n",
*(unsigned int *)((char *)&v23[5] + v11 + 1) | ((unsigned long long)*(unsigned __int16 *)((char *)&v23[7] + v11 + 1) << 32));
if ( v12 != 21 )
{
LODWORD(v0) = 0;
__printf_chk(1LL, "recovery_failures: %u\n", *((unsigned __int8 *)&v24 + v11 + 1));
}
}
}
else
{
LOBYTE(v0) = 11;
}
return (unsigned int)v0;
}
| print_aria_log_control:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x478
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
LEA RAX,[0x4fcf60]
MOV RDX,qword ptr [RAX]
LEA RSI,[0x1d9a30]
LEA RCX,[0x1dfe10]
LEA RDI,[RBP + -0x480]
MOV R8D,0x10
CALL 0x001949ac
TEST RAX,RAX
JZ 0x00148315
LEA RAX,[0x4fd120]
MOV ESI,dword ptr [RAX]
LEA R13,[0x486010]
MOV RAX,qword ptr [R13]
LEA RDI,[RBP + -0x280]
LEA RCX,[RBP + -0x480]
LEA RBX,[RBP + -0x80]
MOV EDX,0x2
MOV R8,RBX
CALL qword ptr [RAX + 0x148]
MOV qword ptr [RBX],RAX
TEST RAX,RAX
JNZ 0x00148567
LEA RDI,[RBP + -0x480]
MOV EDX,0x10
MOV ESI,0x80002
CALL 0x001a03b8
MOV R15D,EAX
LAB_001482bb:
MOV BL,0xb
TEST R15D,R15D
JS 0x0014831c
MOV RAX,qword ptr [R13]
LEA RDI,[RBP + -0x280]
MOV ESI,R15D
MOV EDX,0x8
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x0014858c
MOV ECX,0x10
MOV EDI,R15D
XOR ESI,ESI
MOV EDX,0x2
CALL 0x001a0b78
MOV R14,RAX
LAB_001482fb:
CMP R14,-0x1
JZ 0x00148328
CMP R14,0x2d
JNC 0x00148334
LEA RCX,[0x1d9acc]
MOV BL,0x1
JMP 0x001483b5
LAB_00148315:
MOV BL,0xb
JMP 0x001483d1
LAB_0014831c:
LEA RCX,[0x1d9aac]
JMP 0x001483b5
LAB_00148328:
LEA RCX,[0x1d9abc]
JMP 0x001483b5
LAB_00148334:
CMP R14,0x200
JBE 0x00148348
LEA RCX,[0x1d9afa]
MOV BL,0x2
JMP 0x001483b5
LAB_00148348:
MOV RAX,qword ptr [R13]
LEA RDI,[RBP + -0x80]
MOV ESI,R15D
MOV EDX,0x6
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x001485a6
LEA RSI,[RBP + -0x280]
MOV R8D,0x2
MOV EDI,R15D
MOV RDX,R14
XOR ECX,ECX
CALL 0x001a0638
MOV R15,RAX
LAB_00148384:
TEST R15,R15
JZ 0x00148392
LEA RCX,[0x1d9b19]
JMP 0x001483b5
LAB_00148392:
MOV EAX,0xfefe
XOR EAX,dword ptr [RBP + -0x280]
MOVZX ECX,byte ptr [RBP + -0x27e]
XOR ECX,0xc
OR CX,AX
JZ 0x001483f8
LEA RCX,[0x1d9b2d]
MOV BL,0x3
LAB_001483b5:
LEA RSI,[0x1d9c83]
LEA R8,[RBP + -0x480]
MOV EDI,0xae
XOR EDX,EDX
XOR EAX,EAX
CALL 0x0019e2c9
LAB_001483d1:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00148600
MOV EAX,EBX
ADD RSP,0x478
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001483f8:
MOVZX EDX,byte ptr [RBP + -0x27d]
LEA RSI,[0x1d9d32]
MOV EDI,0x1
XOR EAX,EAX
CALL 0x00129810
MOVZX R12D,word ptr [RBP + -0x26c]
LEA RCX,[0x1d9bb4]
MOV BL,0x8
CMP R12,0x1e
JC 0x001483b5
MOVZX R13D,word ptr [RBP + -0x26a]
CMP R13W,0xf
JC 0x001483b5
MOV RAX,R13
ADD RAX,R12
CMP R14,RAX
JNZ 0x001483b5
MOVZX EAX,word ptr [RBP + R12*0x1 + -0x27c]
MOVZX R15D,byte ptr [RBP + R12*0x1 + -0x27a]
SHL R15D,0x10
OR R15D,EAX
MOV EAX,dword ptr [RBP + R12*0x1 + -0x279]
MOV dword ptr [RBP + -0x484],EAX
MOV EAX,dword ptr [RBP + R12*0x1 + -0x275]
MOV qword ptr [RBP + -0x490],RAX
LEA RBX,[RBP + -0x27c]
LEA R14,[RBP + -0x80]
MOV RDI,RBX
MOV RSI,R14
CALL 0x001a6502
MOV byte ptr [R14 + 0x24],0x0
MOVZX EDX,word ptr [RBX + 0x14]
LEA RSI,[0x1d9d4b]
XOR EBX,EBX
MOV EDI,0x1
XOR EAX,EAX
CALL 0x00129810
LEA RSI,[0x1d9d64]
MOV EDI,0x1
MOV RDX,R14
XOR EAX,EAX
CALL 0x00129810
LEA RSI,[0x1d9d7d]
MOV EDI,0x1
MOV EDX,R15D
MOV ECX,dword ptr [RBP + -0x484]
XOR EAX,EAX
CALL 0x00129810
LEA RSI,[0x1d9d9d]
MOV EDI,0x1
MOV RDX,qword ptr [RBP + -0x490]
XOR EAX,EAX
CALL 0x00129810
CMP R13W,0x15
JC 0x001483d1
MOV EAX,dword ptr [RBP + R12*0x1 + -0x271]
MOVZX EDX,word ptr [RBP + R12*0x1 + -0x26d]
SHL RDX,0x20
OR RDX,RAX
LEA RSI,[0x1d9db7]
XOR EBX,EBX
MOV EDI,0x1
XOR EAX,EAX
CALL 0x00129810
CMP R13W,0x15
JZ 0x001483d1
MOVZX EDX,byte ptr [RBP + R12*0x1 + -0x26b]
LEA RSI,[0x1d9dd2]
XOR EBX,EBX
MOV EDI,0x1
XOR EAX,EAX
CALL 0x00129810
JMP 0x001483d1
LAB_00148567:
LEA RSI,[RBP + -0x480]
LEA RDX,[RBP + -0x80]
LEA RBX,[RBP + -0x494]
MOV RDI,RAX
MOV RCX,RBX
CALL 0x0012a7f2
MOV R15D,dword ptr [RBX]
JMP 0x001482bb
LAB_0014858c:
LEA R14,[RBP + -0x80]
MOV RDI,RAX
MOV ESI,R15D
MOV RDX,R14
CALL 0x0012a84e
MOV R14,qword ptr [R14]
JMP 0x001482fb
LAB_001485a6:
MOV R12,RAX
MOV RAX,qword ptr [R13]
LEA RDX,[0x1d9a63]
MOV RDI,R12
MOV RSI,R14
MOV ECX,0x2a6
CALL qword ptr [RAX + 0x210]
LEA RSI,[RBP + -0x280]
MOV R8D,0x2
MOV EDI,R15D
MOV RDX,R14
XOR ECX,ECX
CALL 0x001a0638
MOV R15,RAX
TEST RAX,RAX
MOV ESI,0x0
CMOVZ RSI,R14
MOV RAX,qword ptr [R13]
MOV RDI,R12
CALL qword ptr [RAX + 0x218]
JMP 0x00148384
LAB_00148600:
CALL 0x00129270
|
ulong print_aria_log_control(void)
{
int1 uVar1;
int2 uVar2;
int iVar3;
long lVar4;
ulong uVar5;
long lVar6;
char *pcVar7;
int8 extraout_RDX;
int8 unaff_RBX;
ulong uVar8;
ulong uVar11;
long in_FS_OFFSET;
int local_49c;
ulong local_498;
int4 local_48c;
int1 local_488 [512];
int1 local_288 [2];
char cStack_286;
int1 uStack_285;
int2 local_284;
int1 uStack_282;
uint auStack_281 [3];
int1 auStack_275 [2];
int1 uStack_273;
ushort local_272;
int2 local_270;
ulong local_88 [4];
int1 local_64;
long local_38;
ulong *puVar9;
int7 uVar10;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
lVar4 = fn_format(local_488,"aria_log_control",maria_data_root,&DAT_001dfe10,0x10);
if (lVar4 == 0) {
uVar8 = CONCAT71((int7)((ulong)unaff_RBX >> 8),0xb);
}
else {
puVar9 = local_88;
local_88[0] = (**(code **)(PSI_server + 0x148))(local_288,key_file_control,2,local_488,puVar9);
if (local_88[0] == 0) {
iVar3 = my_open(local_488,0x80002,0x10);
}
else {
puVar9 = (ulong *)&local_49c;
print_aria_log_control_cold_1(local_88[0],local_488,local_88,puVar9);
iVar3 = local_49c;
}
uVar10 = (int7)((ulong)puVar9 >> 8);
uVar8 = CONCAT71(uVar10,0xb);
if (iVar3 < 0) {
pcVar7 = "Can\'t open file";
}
else {
lVar4 = (**(code **)(PSI_server + 0x158))(local_288,iVar3,8);
if (lVar4 == 0) {
uVar5 = my_seek(iVar3,0,2,0x10);
}
else {
print_aria_log_control_cold_2(lVar4,iVar3,local_88);
uVar5 = local_88[0];
}
if (uVar5 == 0xffffffffffffffff) {
pcVar7 = "Can\'t read size";
}
else if (uVar5 < 0x2d) {
pcVar7 = "Size of control file is smaller than expected";
uVar8 = CONCAT71(uVar10,1);
}
else if (uVar5 < 0x201) {
lVar4 = (**(code **)(PSI_server + 0x158))(local_88,iVar3,6);
if (lVar4 == 0) {
lVar6 = my_pread(iVar3,local_288,uVar5,0,2);
}
else {
(**(code **)(PSI_server + 0x210))
(lVar4,uVar5,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_control_file.c",
0x2a6);
lVar6 = my_pread(iVar3,local_288,uVar5,0,2);
uVar11 = 0;
if (lVar6 == 0) {
uVar11 = uVar5;
}
(**(code **)(PSI_server + 0x218))(lVar4,uVar11);
}
if (lVar6 == 0) {
if (cStack_286 == '\f' && (short)_local_288 == -0x102) {
__printf_chk(1,"Aria file version: %u\n",uStack_285);
uVar11 = (ulong)stack0xfffffffffffffd8c;
pcVar7 = "Sizes stored in control file are inconsistent";
uVar8 = CONCAT71(uVar10,8);
if (0x1d < uVar11) {
if ((0xe < local_272) && (uVar5 == local_272 + uVar11)) {
uVar2 = *(int2 *)((long)&local_284 + uVar11);
uVar1 = *(int1 *)((long)auStack_281 + (uVar11 - 1));
local_48c = *(int4 *)((long)auStack_281 + uVar11);
local_498 = (ulong)*(uint *)((long)auStack_281 + uVar11 + 4);
my_uuid2str(&local_284,local_88,extraout_RDX,
"Sizes stored in control file are inconsistent");
local_64 = 0;
uVar8 = 0;
__printf_chk(1,"Block size: %u\n",local_270);
__printf_chk(1,"maria_uuid: %s\n",local_88);
__printf_chk(1,"last_checkpoint_lsn: (%u,0x%x)\n",(ulong)CONCAT12(uVar1,uVar2),
local_48c);
__printf_chk(1,"last_log_number: %lu\n",local_498);
if (0x14 < local_272) {
uVar8 = 0;
__printf_chk(1,"trid: %llu\n",
(ulong)CONCAT24(*(int2 *)(auStack_275 + uVar11),
*(int4 *)((long)auStack_281 + uVar11 + 8)));
if (local_272 != 0x15) {
uVar8 = 0;
__printf_chk(1,"recovery_failures: %u\n",(&uStack_273)[uVar11]);
}
}
goto LAB_001483d1;
}
}
}
else {
pcVar7 = "Missing valid id at start of file. File is not a valid aria control file";
uVar8 = CONCAT71(uVar10,3);
}
}
else {
pcVar7 = "Can\'t read file";
}
}
else {
pcVar7 = "File size bigger than expected";
uVar8 = CONCAT71(uVar10,2);
}
}
my_printf_error(0xae,"Got error \'%s\' when trying to use aria control file \'%s\'",0,pcVar7,
local_488);
}
LAB_001483d1:
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return uVar8 & 0xffffffff;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
26,448 | initialize_tables_for_help_command(THD*, TABLE_LIST*) | eloqsql/sql/sql_help.cc | static void initialize_tables_for_help_command(THD *thd, TABLE_LIST *tables)
{
LEX_CSTRING MYSQL_HELP_TOPIC_NAME= {STRING_WITH_LEN("help_topic") };
LEX_CSTRING MYSQL_HELP_CATEGORY_NAME= {STRING_WITH_LEN("help_category") };
LEX_CSTRING MYSQL_HELP_RELATION_NAME= {STRING_WITH_LEN("help_relation") };
LEX_CSTRING MYSQL_HELP_KEYWORD_NAME= {STRING_WITH_LEN("help_keyword") };
tables[0].init_one_table(&MYSQL_SCHEMA_NAME, &MYSQL_HELP_TOPIC_NAME, 0,
TL_READ);
tables[1].init_one_table(&MYSQL_SCHEMA_NAME, &MYSQL_HELP_CATEGORY_NAME, 0,
TL_READ);
tables[2].init_one_table(&MYSQL_SCHEMA_NAME, &MYSQL_HELP_RELATION_NAME, 0,
TL_READ);
tables[3].init_one_table(&MYSQL_SCHEMA_NAME, &MYSQL_HELP_KEYWORD_NAME, 0,
TL_READ);
tables[0].next_global= tables[0].next_local=
tables[0].next_name_resolution_table= &tables[1];
tables[1].next_global= tables[1].next_local=
tables[1].next_name_resolution_table= &tables[2];
tables[2].next_global= tables[2].next_local=
tables[2].next_name_resolution_table= &tables[3];
} | O0 | cpp | initialize_tables_for_help_command(THD*, TABLE_LIST*):
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0xcd61c9(%rip), %rax # 0x1a9e810
movq %rax, -0x20(%rbp)
movq 0xcd61c6(%rip), %rax # 0x1a9e818
movq %rax, -0x18(%rbp)
movq 0xcd61c3(%rip), %rax # 0x1a9e820
movq %rax, -0x30(%rbp)
movq 0xcd61c0(%rip), %rax # 0x1a9e828
movq %rax, -0x28(%rbp)
movq 0xcd61bd(%rip), %rax # 0x1a9e830
movq %rax, -0x40(%rbp)
movq 0xcd61ba(%rip), %rax # 0x1a9e838
movq %rax, -0x38(%rbp)
movq 0xcd61b7(%rip), %rax # 0x1a9e840
movq %rax, -0x50(%rbp)
movq 0xcd61b4(%rip), %rax # 0x1a9e848
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xd1550d(%rip), %rsi # 0x1addbb0
leaq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movl $0x2, %r8d
callq 0x827990
movq -0x10(%rbp), %rdi
addq $0x6e0, %rdi # imm = 0x6E0
leaq 0xd154e8(%rip), %rsi # 0x1addbb0
leaq -0x30(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movl $0x2, %r8d
callq 0x827990
movq -0x10(%rbp), %rdi
addq $0xdc0, %rdi # imm = 0xDC0
leaq 0xd154c3(%rip), %rsi # 0x1addbb0
leaq -0x40(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movl $0x2, %r8d
callq 0x827990
movq -0x10(%rbp), %rdi
addq $0x14a0, %rdi # imm = 0x14A0
leaq 0xd1549e(%rip), %rsi # 0x1addbb0
leaq -0x50(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movl $0x2, %r8d
callq 0x827990
movq -0x10(%rbp), %rcx
addq $0x6e0, %rcx # imm = 0x6E0
movq -0x10(%rbp), %rax
movq %rcx, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
addq $0xdc0, %rcx # imm = 0xDC0
movq -0x10(%rbp), %rax
movq %rcx, 0x7d0(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0x6e0(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0x6e8(%rax)
movq -0x10(%rbp), %rcx
addq $0x14a0, %rcx # imm = 0x14A0
movq -0x10(%rbp), %rax
movq %rcx, 0xeb0(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0xdc0(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0xdc8(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ZL34initialize_tables_for_help_commandP3THDP10TABLE_LIST:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, cs:off_1A9E810; "help_topic"
mov [rbp+var_20], rax
mov rax, cs:qword_1A9E818
mov [rbp+var_18], rax
mov rax, cs:off_1A9E820; "help_category"
mov [rbp+var_30], rax
mov rax, cs:qword_1A9E828
mov [rbp+var_28], rax
mov rax, cs:off_1A9E830; "help_relation"
mov [rbp+var_40], rax
mov rax, cs:qword_1A9E838
mov [rbp+var_38], rax
mov rax, cs:off_1A9E840; "help_keyword"
mov [rbp+var_50], rax
mov rax, cs:qword_1A9E848
mov [rbp+var_48], rax
mov rdi, [rbp+var_10]
lea rsi, MYSQL_SCHEMA_NAME
lea rdx, [rbp+var_20]
xor eax, eax
mov ecx, eax
mov r8d, 2
call _ZN10TABLE_LIST14init_one_tableEPK25st_mysql_const_lex_stringS2_S2_13thr_lock_type; TABLE_LIST::init_one_table(st_mysql_const_lex_string const*,st_mysql_const_lex_string const*,st_mysql_const_lex_string const*,thr_lock_type)
mov rdi, [rbp+var_10]
add rdi, 6E0h
lea rsi, MYSQL_SCHEMA_NAME
lea rdx, [rbp+var_30]
xor eax, eax
mov ecx, eax
mov r8d, 2
call _ZN10TABLE_LIST14init_one_tableEPK25st_mysql_const_lex_stringS2_S2_13thr_lock_type; TABLE_LIST::init_one_table(st_mysql_const_lex_string const*,st_mysql_const_lex_string const*,st_mysql_const_lex_string const*,thr_lock_type)
mov rdi, [rbp+var_10]
add rdi, 0DC0h
lea rsi, MYSQL_SCHEMA_NAME
lea rdx, [rbp+var_40]
xor eax, eax
mov ecx, eax
mov r8d, 2
call _ZN10TABLE_LIST14init_one_tableEPK25st_mysql_const_lex_stringS2_S2_13thr_lock_type; TABLE_LIST::init_one_table(st_mysql_const_lex_string const*,st_mysql_const_lex_string const*,st_mysql_const_lex_string const*,thr_lock_type)
mov rdi, [rbp+var_10]
add rdi, 14A0h
lea rsi, MYSQL_SCHEMA_NAME
lea rdx, [rbp+var_50]
xor eax, eax
mov ecx, eax
mov r8d, 2
call _ZN10TABLE_LIST14init_one_tableEPK25st_mysql_const_lex_stringS2_S2_13thr_lock_type; TABLE_LIST::init_one_table(st_mysql_const_lex_string const*,st_mysql_const_lex_string const*,st_mysql_const_lex_string const*,thr_lock_type)
mov rcx, [rbp+var_10]
add rcx, 6E0h
mov rax, [rbp+var_10]
mov [rax+0F0h], rcx
mov rax, [rbp+var_10]
mov [rax], rcx
mov rax, [rbp+var_10]
mov [rax+8], rcx
mov rcx, [rbp+var_10]
add rcx, 0DC0h
mov rax, [rbp+var_10]
mov [rax+7D0h], rcx
mov rax, [rbp+var_10]
mov [rax+6E0h], rcx
mov rax, [rbp+var_10]
mov [rax+6E8h], rcx
mov rcx, [rbp+var_10]
add rcx, 14A0h
mov rax, [rbp+var_10]
mov [rax+0EB0h], rcx
mov rax, [rbp+var_10]
mov [rax+0DC0h], rcx
mov rax, [rbp+var_10]
mov [rax+0DC8h], rcx
add rsp, 50h
pop rbp
retn
| TABLE_LIST * initialize_tables_for_help_command(THD *a1, TABLE_LIST *a2)
{
char *v2; // rcx
char *v3; // rcx
char *v4; // rcx
TABLE_LIST *result; // rax
_QWORD v6[2]; // [rsp+0h] [rbp-50h] BYREF
_QWORD v7[2]; // [rsp+10h] [rbp-40h] BYREF
_QWORD v8[2]; // [rsp+20h] [rbp-30h] BYREF
_QWORD v9[2]; // [rsp+30h] [rbp-20h] BYREF
TABLE_LIST *v10; // [rsp+40h] [rbp-10h]
THD *v11; // [rsp+48h] [rbp-8h]
v11 = a1;
v10 = a2;
v9[0] = "help_topic";
v9[1] = &byte_9[1];
v8[0] = "help_category";
v8[1] = &byte_9[4];
v7[0] = "help_relation";
v7[1] = &byte_9[4];
v6[0] = "help_keyword";
v6[1] = &byte_9[3];
TABLE_LIST::init_one_table((long long)a2, &MYSQL_SCHEMA_NAME, v9, 0LL, 2);
TABLE_LIST::init_one_table((long long)v10 + 1760, &MYSQL_SCHEMA_NAME, v8, 0LL, 2);
TABLE_LIST::init_one_table((long long)v10 + 3520, &MYSQL_SCHEMA_NAME, v7, 0LL, 2);
TABLE_LIST::init_one_table((long long)v10 + 5280, &MYSQL_SCHEMA_NAME, v6, 0LL, 2);
v2 = (char *)v10 + 1760;
*((_QWORD *)v10 + 30) = (char *)v10 + 1760;
*(_QWORD *)v10 = v2;
*((_QWORD *)v10 + 1) = v2;
v3 = (char *)v10 + 3520;
*((_QWORD *)v10 + 250) = (char *)v10 + 3520;
*((_QWORD *)v10 + 220) = v3;
*((_QWORD *)v10 + 221) = v3;
v4 = (char *)v10 + 5280;
*((_QWORD *)v10 + 470) = (char *)v10 + 5280;
*((_QWORD *)v10 + 440) = v4;
result = v10;
*((_QWORD *)v10 + 441) = v4;
return result;
}
| ~Create_func_numinteriorring:
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 0x00dc2600
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x8
CALL 0x008581c0
ADD RSP,0x10
POP RBP
RET
|
/* Create_func_numinteriorring::~Create_func_numinteriorring() */
void __thiscall
Create_func_numinteriorring::~Create_func_numinteriorring(Create_func_numinteriorring *this)
{
~Create_func_numinteriorring(this);
::operator_delete(this,8);
return;
}
| |
26,449 | Decoder::get_num_tensors() | 7CodeWizard[P]stablediffusion/vae.hpp | size_t get_num_tensors() {
int num_tensors = 8;
// mid
num_tensors += 10 * 3;
int len_mults = sizeof(ch_mult) / sizeof(int);
for (int i = len_mults - 1; i >= 0; i--) {
for (int j = 0; j < num_res_blocks + 1; j++) {
num_tensors += 10;
}
if (i != 0) {
num_tensors += 2;
}
}
return num_tensors;
} | O0 | cpp | Decoder::get_num_tensors():
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movl $0x8, -0xc(%rsp)
movl -0xc(%rsp), %eax
addl $0x1e, %eax
movl %eax, -0xc(%rsp)
movl $0x4, -0x10(%rsp)
movl -0x10(%rsp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rsp)
cmpl $0x0, -0x14(%rsp)
jl 0x4a230
movl $0x0, -0x18(%rsp)
movq -0x20(%rsp), %rcx
movl -0x18(%rsp), %eax
movl 0x10(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x4a20f
movl -0xc(%rsp), %eax
addl $0xa, %eax
movl %eax, -0xc(%rsp)
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x4a1e4
cmpl $0x0, -0x14(%rsp)
je 0x4a221
movl -0xc(%rsp), %eax
addl $0x2, %eax
movl %eax, -0xc(%rsp)
jmp 0x4a223
movl -0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x4a1d5
movslq -0xc(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
| _ZN7Decoder15get_num_tensorsEv:
mov [rsp+var_8], rdi
mov rax, [rsp+var_8]
mov [rsp+var_20], rax
mov [rsp+var_C], 8
mov eax, [rsp+var_C]
add eax, 1Eh
mov [rsp+var_C], eax
mov [rsp+var_10], 4
mov eax, [rsp+var_10]
sub eax, 1
mov [rsp+var_14], eax
loc_4A1D5:
cmp [rsp+var_14], 0
jl short loc_4A230
mov [rsp+var_18], 0
loc_4A1E4:
mov rcx, [rsp+var_20]
mov eax, [rsp+var_18]
mov ecx, [rcx+10h]
add ecx, 1
cmp eax, ecx
jge short loc_4A20F
mov eax, [rsp+var_C]
add eax, 0Ah
mov [rsp+var_C], eax
mov eax, [rsp+var_18]
add eax, 1
mov [rsp+var_18], eax
jmp short loc_4A1E4
loc_4A20F:
cmp [rsp+var_14], 0
jz short loc_4A221
mov eax, [rsp+var_C]
add eax, 2
mov [rsp+var_C], eax
loc_4A221:
jmp short $+2
loc_4A223:
mov eax, [rsp+var_14]
add eax, 0FFFFFFFFh
mov [rsp+var_14], eax
jmp short loc_4A1D5
loc_4A230:
movsxd rax, [rsp+var_C]
retn
| long long Decoder::get_num_tensors(Decoder *this)
{
int j; // [rsp+8h] [rbp-18h]
int i; // [rsp+Ch] [rbp-14h]
int v4; // [rsp+14h] [rbp-Ch]
v4 = 38;
for ( i = 3; i >= 0; --i )
{
for ( j = 0; j < *((_DWORD *)this + 4) + 1; ++j )
v4 += 10;
if ( i )
v4 += 2;
}
return v4;
}
| get_num_tensors:
MOV qword ptr [RSP + -0x8],RDI
MOV RAX,qword ptr [RSP + -0x8]
MOV qword ptr [RSP + -0x20],RAX
MOV dword ptr [RSP + -0xc],0x8
MOV EAX,dword ptr [RSP + -0xc]
ADD EAX,0x1e
MOV dword ptr [RSP + -0xc],EAX
MOV dword ptr [RSP + -0x10],0x4
MOV EAX,dword ptr [RSP + -0x10]
SUB EAX,0x1
MOV dword ptr [RSP + -0x14],EAX
LAB_0014a1d5:
CMP dword ptr [RSP + -0x14],0x0
JL 0x0014a230
MOV dword ptr [RSP + -0x18],0x0
LAB_0014a1e4:
MOV RCX,qword ptr [RSP + -0x20]
MOV EAX,dword ptr [RSP + -0x18]
MOV ECX,dword ptr [RCX + 0x10]
ADD ECX,0x1
CMP EAX,ECX
JGE 0x0014a20f
MOV EAX,dword ptr [RSP + -0xc]
ADD EAX,0xa
MOV dword ptr [RSP + -0xc],EAX
MOV EAX,dword ptr [RSP + -0x18]
ADD EAX,0x1
MOV dword ptr [RSP + -0x18],EAX
JMP 0x0014a1e4
LAB_0014a20f:
CMP dword ptr [RSP + -0x14],0x0
JZ 0x0014a221
MOV EAX,dword ptr [RSP + -0xc]
ADD EAX,0x2
MOV dword ptr [RSP + -0xc],EAX
LAB_0014a221:
JMP 0x0014a223
LAB_0014a223:
MOV EAX,dword ptr [RSP + -0x14]
ADD EAX,-0x1
MOV dword ptr [RSP + -0x14],EAX
JMP 0x0014a1d5
LAB_0014a230:
MOVSXD RAX,dword ptr [RSP + -0xc]
RET
|
/* Decoder::get_num_tensors() */
long __thiscall Decoder::get_num_tensors(Decoder *this)
{
int local_18;
int local_14;
int local_c;
local_c = 0x26;
for (local_14 = 3; -1 < local_14; local_14 = local_14 + -1) {
for (local_18 = 0; local_18 < *(int *)(this + 0x10) + 1; local_18 = local_18 + 1) {
local_c = local_c + 10;
}
if (local_14 != 0) {
local_c = local_c + 2;
}
}
return (long)local_c;
}
| |
26,450 | Decoder::get_num_tensors() | 7CodeWizard[P]stablediffusion/vae.hpp | size_t get_num_tensors() {
int num_tensors = 8;
// mid
num_tensors += 10 * 3;
int len_mults = sizeof(ch_mult) / sizeof(int);
for (int i = len_mults - 1; i >= 0; i--) {
for (int j = 0; j < num_res_blocks + 1; j++) {
num_tensors += 10;
}
if (i != 0) {
num_tensors += 2;
}
}
return num_tensors;
} | O2 | cpp | Decoder::get_num_tensors():
movl 0x10(%rdi), %eax
testl %eax, %eax
pushq $-0x1
popq %rcx
cmovnsl %eax, %ecx
imull $0xa, %ecx, %eax
addl $0xa, %eax
pushq $0x3
popq %rdx
pushq $0x26
popq %rcx
testl %edx, %edx
js 0x241f4
leal (%rax,%rcx), %esi
subl $0x1, %edx
leal 0x2(%rax,%rcx), %ecx
cmovbl %esi, %ecx
jmp 0x241e1
movslq %ecx, %rax
retq
| _ZN7Decoder15get_num_tensorsEv:
mov eax, [rdi+10h]
test eax, eax
push 0FFFFFFFFFFFFFFFFh
pop rcx
cmovns ecx, eax
imul eax, ecx, 0Ah
add eax, 0Ah
push 3
pop rdx
push 26h ; '&'
pop rcx
loc_241E1:
test edx, edx
js short loc_241F4
lea esi, [rax+rcx]
sub edx, 1
lea ecx, [rax+rcx+2]
cmovb ecx, esi
jmp short loc_241E1
loc_241F4:
movsxd rax, ecx
retn
| long long Decoder::get_num_tensors(Decoder *this)
{
int v1; // ecx
int v2; // eax
int v3; // edx
int v4; // ecx
int v5; // esi
bool v6; // cf
v1 = -1;
if ( *((int *)this + 4) >= 0 )
v1 = *((_DWORD *)this + 4);
v2 = 10 * v1 + 10;
v3 = 3;
v4 = 38;
while ( v3 >= 0 )
{
v5 = v2 + v4;
v6 = v3-- == 0;
v4 += v2 + 2;
if ( v6 )
v4 = v5;
}
return v4;
}
| get_num_tensors:
MOV EAX,dword ptr [RDI + 0x10]
TEST EAX,EAX
PUSH -0x1
POP RCX
CMOVNS ECX,EAX
IMUL EAX,ECX,0xa
ADD EAX,0xa
PUSH 0x3
POP RDX
PUSH 0x26
POP RCX
LAB_001241e1:
TEST EDX,EDX
JS 0x001241f4
LEA ESI,[RAX + RCX*0x1]
SUB EDX,0x1
LEA ECX,[RAX + RCX*0x1 + 0x2]
CMOVC ECX,ESI
JMP 0x001241e1
LAB_001241f4:
MOVSXD RAX,ECX
RET
|
/* Decoder::get_num_tensors() */
long __thiscall Decoder::get_num_tensors(Decoder *this)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
bool bVar5;
iVar2 = -1;
if (-1 < *(int *)(this + 0x10)) {
iVar2 = *(int *)(this + 0x10);
}
iVar4 = 3;
iVar3 = 0x26;
while (-1 < iVar4) {
bVar5 = iVar4 == 0;
iVar4 = iVar4 + -1;
iVar1 = iVar2 * 10 + 0xc;
if (bVar5) {
iVar1 = iVar2 * 10 + 10;
}
iVar3 = iVar1 + iVar3;
}
return (long)iVar3;
}
| |
26,451 | Item_func_floor::int_op() | eloqsql/sql/item_func.cc | longlong Item_func_floor::int_op()
{
switch (args[0]->result_type()) {
case STRING_RESULT: // hex hybrid
case INT_RESULT:
return val_int_from_item(args[0]);
case DECIMAL_RESULT:
{
my_decimal dec_buf, *dec;
return (!(dec= Item_func_floor::decimal_op(&dec_buf))) ? 0 :
dec->to_longlong(unsigned_flag);
}
default:
break;
}
return (longlong) Item_func_floor::real_op();
} | O0 | cpp | Item_func_floor::int_op():
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x78(%rbp)
movq 0x70(%rax), %rax
movq (%rax), %rdi
callq 0x4c24f0
movl %eax, %ecx
movl %ecx, -0x70(%rbp)
testl %eax, %eax
je 0x95b8e2
jmp 0x95b8cb
movl -0x70(%rbp), %eax
subl $0x2, %eax
je 0x95b8e2
jmp 0x95b8d5
movl -0x70(%rbp), %eax
subl $0x4, %eax
je 0x95b8fb
jmp 0x95b994
movq -0x78(%rbp), %rdi
movq 0x70(%rdi), %rax
movq (%rax), %rsi
callq 0x64d0d0
movq %rax, -0x50(%rbp)
jmp 0x95b9a8
leaq -0x48(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x4a2fa0
movq -0x78(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x95ba10
movq %rax, -0x80(%rbp)
jmp 0x95b921
movq -0x80(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
jne 0x95b93a
xorl %eax, %eax
movq %rax, -0x90(%rbp)
jmp 0x95b967
movq -0x78(%rbp), %rax
movq -0x60(%rbp), %rdi
movzbl 0xe(%rax), %esi
andl $0x1, %esi
callq 0xa370d0
movq %rax, -0x98(%rbp)
jmp 0x95b957
movq -0x98(%rbp), %rax
movq %rax, -0x90(%rbp)
jmp 0x95b967
movq -0x90(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4a2fc0
jmp 0x95b9a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4a2fc0
jmp 0x95b9d5
jmp 0x95b996
movq -0x78(%rbp), %rdi
callq 0x95bb60
cvttsd2si %xmm0, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x95b9fe
movq -0xa0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x95b9fe
movq -0xa8(%rbp), %rdi
callq 0x433ff0
callq 0x433650
nopw %cs:(%rax,%rax)
| _ZN15Item_func_floor6int_opEv:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_58], rdi
mov rax, [rbp+var_58]
mov [rbp+var_78], rax
mov rax, [rax+70h]
mov rdi, [rax]; this
call _ZNK4Item11result_typeEv; Item::result_type(void)
mov ecx, eax
mov [rbp+var_70], ecx
test eax, eax
jz short loc_95B8E2
jmp short $+2
loc_95B8CB:
mov eax, [rbp+var_70]
sub eax, 2
jz short loc_95B8E2
jmp short $+2
loc_95B8D5:
mov eax, [rbp+var_70]
sub eax, 4
jz short loc_95B8FB
jmp loc_95B994
loc_95B8E2:
mov rdi, [rbp+var_78]; this
mov rax, [rdi+70h]
mov rsi, [rax]; Item *
call _ZN4Item17val_int_from_itemEPS_; Item::val_int_from_item(Item*)
mov [rbp+var_50], rax
jmp loc_95B9A8
loc_95B8FB:
lea rdi, [rbp+var_48]; this
mov [rbp+var_88], rdi
call _ZN10my_decimalC2Ev; my_decimal::my_decimal(void)
mov rdi, [rbp+var_78]; this
mov rsi, [rbp+var_88]; my_decimal *
call _ZN15Item_func_floor10decimal_opEP10my_decimal; Item_func_floor::decimal_op(my_decimal *)
mov [rbp+var_80], rax
jmp short $+2
loc_95B921:
mov rax, [rbp+var_80]
mov [rbp+var_60], rax
cmp rax, 0
jnz short loc_95B93A
xor eax, eax
mov [rbp+var_90], rax
jmp short loc_95B967
loc_95B93A:
mov rax, [rbp+var_78]
mov rdi, [rbp+var_60]; this
movzx esi, byte ptr [rax+0Eh]
and esi, 1; bool
call _ZNK10my_decimal11to_longlongEb; my_decimal::to_longlong(bool)
mov [rbp+var_98], rax
jmp short $+2
loc_95B957:
mov rax, [rbp+var_98]
mov [rbp+var_90], rax
jmp short $+2
loc_95B967:
mov rax, [rbp+var_90]
mov [rbp+var_50], rax
lea rdi, [rbp+var_48]; void *
call _ZN10my_decimalD2Ev; my_decimal::~my_decimal()
jmp short loc_95B9A8
mov rcx, rax
mov eax, edx
mov [rbp+var_68], rcx
mov [rbp+var_6C], eax
lea rdi, [rbp+var_48]; void *
call _ZN10my_decimalD2Ev; my_decimal::~my_decimal()
jmp short loc_95B9D5
loc_95B994:
jmp short $+2
loc_95B996:
mov rdi, [rbp+var_78]; this
call _ZN15Item_func_floor7real_opEv; Item_func_floor::real_op(void)
cvttsd2si rax, xmm0
mov [rbp+var_50], rax
loc_95B9A8:
mov rax, [rbp+var_50]
mov [rbp+var_A0], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_95B9FE
mov rax, [rbp+var_A0]
add rsp, 0B0h
pop rbp
retn
loc_95B9D5:
mov rax, [rbp+var_68]
mov [rbp+var_A8], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_95B9FE
mov rdi, [rbp+var_A8]
call __Unwind_Resume
loc_95B9FE:
call ___stack_chk_fail
| long long Item_func_floor::int_op(Item ***this, double a2)
{
long long v3; // [rsp+20h] [rbp-90h]
int v4; // [rsp+40h] [rbp-70h]
my_decimal *v5; // [rsp+50h] [rbp-60h]
long long v6; // [rsp+60h] [rbp-50h]
_BYTE v7[64]; // [rsp+68h] [rbp-48h] BYREF
unsigned long long v8; // [rsp+A8h] [rbp-8h]
v8 = __readfsqword(0x28u);
v4 = Item::result_type(*this[14]);
if ( !v4 || v4 == 2 )
return Item::val_int_from_item((Item *)this, *this[14]);
if ( v4 == 4 )
{
my_decimal::my_decimal((my_decimal *)v7);
v5 = (my_decimal *)Item_func_floor::decimal_op((Item_func_floor *)this, (my_decimal *)v7);
if ( v5 )
v3 = my_decimal::to_longlong(v5, *((_BYTE *)this + 14) & 1);
else
v3 = 0LL;
v6 = v3;
my_decimal::~my_decimal((my_decimal *)v7);
}
else
{
Item_func_floor::real_op((Item_func_floor *)this);
return (unsigned int)(int)a2;
}
return v6;
}
| select_export:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RDI
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x00961df0
MOV RAX,qword ptr [RBP + -0x20]
LEA RCX,[0x1386538]
ADD RCX,0x10
MOV qword ptr [RAX],RCX
ADD RSP,0x20
POP RBP
RET
|
/* select_export::select_export(THD*, sql_exchange*) */
void __thiscall select_export::select_export(select_export *this,THD *param_1,sql_exchange *param_2)
{
select_to_file::select_to_file((select_to_file *)this,param_1,param_2);
*(int ***)this = &PTR_send_data_01386548;
return;
}
| |
26,452 | SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/json-schema-to-grammar.cpp | void resolve_refs(json & schema, const std::string & url) {
/*
* Resolves all $ref fields in the given schema, fetching any remote schemas,
* replacing each $ref with absolute reference URL and populates _refs with the
* respective referenced (sub)schema dictionaries.
*/
std::function<void(json &)> visit_refs = [&](json & n) {
if (n.is_array()) {
for (auto & x : n) {
visit_refs(x);
}
} else if (n.is_object()) {
if (n.contains("$ref")) {
std::string ref = n["$ref"];
if (_refs.find(ref) == _refs.end()) {
json target;
if (ref.find("https://") == 0) {
std::string base_url = ref.substr(0, ref.find('#'));
auto it = _refs.find(base_url);
if (it != _refs.end()) {
target = it->second;
} else {
// Fetch the referenced schema and resolve its refs
auto referenced = _fetch_json(ref);
resolve_refs(referenced, base_url);
_refs[base_url] = referenced;
}
if (ref.find('#') == std::string::npos || ref.substr(ref.find('#') + 1).empty()) {
return;
}
} else if (ref.find("#/") == 0) {
target = schema;
n["$ref"] = url + ref;
ref = url + ref;
} else {
_errors.push_back("Unsupported ref: " + ref);
return;
}
std::string pointer = ref.substr(ref.find('#') + 1);
std::vector<std::string> tokens = string_split(pointer, "/");
for (size_t i = 1; i < tokens.size(); ++i) {
std::string sel = tokens[i];
if (target.is_null() || !target.contains(sel)) {
_errors.push_back("Error resolving ref " + ref + ": " + sel + " not in " + target.dump());
return;
}
target = target[sel];
}
_refs[ref] = target;
}
} else {
for (auto & kv : n.items()) {
visit_refs(kv.value());
}
}
}
};
visit_refs(schema);
} | O3 | cpp | SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movq $0x0, 0x8(%r12)
movl $0x20, %edi
callq 0x1dc20
movq %r12, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq %rax, (%r12)
leaq 0x70(%rip), %rcx # 0xee2ce
movq %rcx, 0x18(%r12)
leaq 0x6c(%rip), %rcx # 0xee2d6
movq %rcx, 0x10(%r12)
movq %rax, %rdi
movq %r14, %rsi
callq 0xee2fe
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xee293
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xee2c5
movq %rax, %rbx
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xee2bd
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x1e660
movq %rax, %rdi
callq 0x25c6b
nop
| _ZN15SchemaConverter12resolve_refsERN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEERKSA_:
push r15
push r14
push r12
push rbx
sub rsp, 28h
mov rbx, rdx
mov r14, rsi
mov r15, rdi
lea r12, [rsp+48h+var_40]
mov qword ptr [r12+8], 0
mov edi, 20h ; ' '; unsigned __int64
call __Znwm; operator new(ulong)
mov [rax], r12
mov [rax+8], r15
mov [rax+10h], r14
mov [rax+18h], rbx
mov [r12], rax
lea rcx, _ZNSt17_Function_handlerIFvRN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEZN15SchemaConverter12resolve_refsESF_RKSA_EUlSF_E_E9_M_invokeERKSt9_Any_dataSF_; std::_Function_handler<void ()(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &),SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,std::string const&)::{lambda(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> &)#1}>::_M_invoke(std::_Any_data const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)
mov [r12+18h], rcx
lea rcx, _ZNSt17_Function_handlerIFvRN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEZN15SchemaConverter12resolve_refsESF_RKSA_EUlSF_E_E10_M_managerERSt9_Any_dataRKSM_St18_Manager_operation; std::_Function_handler<void ()(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &),SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,std::string const&)::{lambda(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> &)#1}>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [r12+10h], rcx
mov rdi, rax
mov rsi, r14
call _ZZN15SchemaConverter12resolve_refsERN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEERKSA_ENKUlSF_E_clESF_; SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,std::string const&)::{lambda(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> &)#1}::operator()(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)
mov rax, [rsp+48h+var_30]
test rax, rax
jz short loc_EE293
lea rdi, [rsp+48h+var_40]
mov rsi, rdi
mov edx, 3
call rax
loc_EE293:
add rsp, 28h
pop rbx
pop r12
pop r14
pop r15
retn
jmp short loc_EE2C5
mov rbx, rax
mov rax, [rsp+48h+var_30]
test rax, rax
jz short loc_EE2BD
lea rdi, [rsp+48h+var_40]
mov rsi, rdi
mov edx, 3
call rax
loc_EE2BD:
mov rdi, rbx
call __Unwind_Resume
loc_EE2C5:
mov rdi, rax
call __clang_call_terminate
| long long SchemaConverter::resolve_refs(long long a1, long long a2, long long a3)
{
_QWORD *v4; // rax
long long result; // rax
_QWORD v6[2]; // [rsp+8h] [rbp-40h] BYREF
long long ( *v7)(); // [rsp+18h] [rbp-30h]
long long ( *v8)(); // [rsp+20h] [rbp-28h]
v6[1] = 0LL;
v4 = (_QWORD *)operator new(0x20uLL);
*v4 = v6;
v4[1] = a1;
v4[2] = a2;
v4[3] = a3;
v6[0] = v4;
v8 = std::_Function_handler<void ()(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> &),SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &,std::string const&)::{lambda(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> &)#1}>::_M_invoke;
v7 = std::_Function_handler<void ()(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> &),SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &,std::string const&)::{lambda(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> &)#1}>::_M_manager;
SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &,std::string const&)::{lambda(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> &)#1}::operator()(
v4,
a2);
result = (long long)v7;
if ( v7 )
return ((long long ( *)(_QWORD *, _QWORD *, long long))v7)(v6, v6, 3LL);
return result;
}
| resolve_refs:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
LEA R12,[RSP + 0x8]
MOV qword ptr [R12 + 0x8],0x0
MOV EDI,0x20
CALL 0x0011dc20
MOV qword ptr [RAX],R12
MOV qword ptr [RAX + 0x8],R15
MOV qword ptr [RAX + 0x10],R14
MOV qword ptr [RAX + 0x18],RBX
MOV qword ptr [R12],RAX
LEA RCX,[0x1ee2ce]
MOV qword ptr [R12 + 0x18],RCX
LEA RCX,[0x1ee2d6]
MOV qword ptr [R12 + 0x10],RCX
LAB_001ee26f:
MOV RDI,RAX
MOV RSI,R14
CALL 0x001ee2fe
MOV RAX,qword ptr [RSP + 0x18]
TEST RAX,RAX
JZ 0x001ee293
LAB_001ee284:
LEA RDI,[RSP + 0x8]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_001ee293:
ADD RSP,0x28
POP RBX
POP R12
POP R14
POP R15
RET
|
/* SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>&, std::__cxx11::string const&) */
void __thiscall
SchemaConverter::resolve_refs(SchemaConverter *this,basic_json *param_1,string *param_2)
{
_lambda_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>___1_
*local_40;
int8 local_38;
code *local_30;
code *local_28;
local_38 = 0;
local_40 = (_lambda_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>___1_
*)operator_new(0x20);
*(_lambda_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>___1_
***)local_40 = &local_40;
*(SchemaConverter **)(local_40 + 8) = this;
*(basic_json **)(local_40 + 0x10) = param_1;
*(string **)(local_40 + 0x18) = param_2;
local_28 = std::
_Function_handler<void(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&),SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&,std::__cxx11::string_const&)::{lambda(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>&)#1}>
::_M_invoke;
local_30 = std::
_Function_handler<void(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&),SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&,std::__cxx11::string_const&)::{lambda(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>&)#1}>
::_M_manager;
/* try { // try from 001ee26f to 001ee279 has its CatchHandler @ 001ee2a1 */
resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&,std::__cxx11::string_const&)
::
{lambda(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>&)#1}
::operator()(local_40,param_1);
if (local_30 != (code *)0x0) {
/* try { // try from 001ee284 to 001ee292 has its CatchHandler @ 001ee29f */
(*local_30)(&local_40,&local_40,3);
}
return;
}
| |
26,453 | LefDefParser::convert_name2num(char const*) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefrReader.cpp | double
convert_name2num(const char *versionName)
{
char majorNm[80];
char minorNm[80];
char *subMinorNm = NULL;
char *versionNm = strdup(versionName);
double major = 0, minor = 0, subMinor = 0;
double version, versionNumber;
char finalVersion[80];
sscanf(versionNm, "%[^.].%s", majorNm, minorNm);
char *p1 = strchr(minorNm, '.');
if (p1) {
subMinorNm = p1 + 1;
*p1 = '\0';
}
major = atof(majorNm);
minor = atof(minorNm);
if (subMinorNm)
subMinor = atof(subMinorNm);
version = major;
if (minor > 0)
version = major + minor / 10;
if (subMinor > 0)
version = version + subMinor / 1000;
lefFree(versionNm);
sprintf(finalVersion, "%.4f", version);
versionNumber = atof(finalVersion);
return versionNumber;
} | O0 | cpp | LefDefParser::convert_name2num(char const*):
subq $0x148, %rsp # imm = 0x148
movq %rdi, 0x140(%rsp)
movq $0x0, 0x98(%rsp)
movq 0x140(%rsp), %rdi
callq 0x2470
movq %rax, 0x90(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x88(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x80(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x78(%rsp)
movq 0x90(%rsp), %rdi
leaq 0xf0(%rsp), %rdx
leaq 0xa0(%rsp), %rcx
leaq 0x4c0c8(%rip), %rsi # 0x96be8
movb $0x0, %al
callq 0x20c0
leaq 0xa0(%rsp), %rdi
movl $0x2e, %esi
callq 0x2090
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x4ab5f
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x98(%rsp)
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
leaq 0xf0(%rsp), %rdi
callq 0x2310
movsd %xmm0, 0x88(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x2310
movsd %xmm0, 0x80(%rsp)
cmpq $0x0, 0x98(%rsp)
je 0x4aba9
movq 0x98(%rsp), %rdi
callq 0x2310
movsd %xmm0, 0x78(%rsp)
movsd 0x88(%rsp), %xmm0
movsd %xmm0, 0x70(%rsp)
movsd 0x80(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x4abf2
movsd 0x88(%rsp), %xmm0
movsd 0x80(%rsp), %xmm1
movsd 0x58044(%rip), %xmm2 # 0xa2c28
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x70(%rsp)
movsd 0x78(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x4ac23
movsd 0x70(%rsp), %xmm0
movsd 0x78(%rsp), %xmm1
movsd 0x58043(%rip), %xmm2 # 0xa2c58
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x70(%rsp)
movq 0x90(%rsp), %rdi
callq 0x52810
leaq 0x10(%rsp), %rdi
movsd 0x70(%rsp), %xmm0
leaq 0x4bfaf(%rip), %rsi # 0x96bf1
movb $0x1, %al
callq 0x2050
leaq 0x10(%rsp), %rdi
callq 0x2310
movsd %xmm0, 0x68(%rsp)
movsd 0x68(%rsp), %xmm0
addq $0x148, %rsp # imm = 0x148
retq
nopw (%rax,%rax)
| _ZN12LefDefParser16convert_name2numEPKc:
sub rsp, 148h
mov [rsp+148h+var_8], rdi
mov [rsp+148h+var_B0], 0
mov rdi, [rsp+148h+var_8]
call _strdup
mov [rsp+148h+var_B8], rax
xorps xmm0, xmm0
movsd [rsp+148h+var_C0], xmm0
xorps xmm0, xmm0
movsd [rsp+148h+var_C8], xmm0
xorps xmm0, xmm0
movsd [rsp+148h+var_D0], xmm0
mov rdi, [rsp+148h+var_B8]
lea rdx, [rsp+148h+var_58]
lea rcx, [rsp+148h+var_A8]
lea rsi, aS_2; "%[^.].%s"
mov al, 0
call ___isoc23_sscanf
lea rdi, [rsp+148h+var_A8]
mov esi, (offset qword_28+6); void *
call _strchr
mov [rsp+148h+var_140], rax
cmp [rsp+148h+var_140], 0
jz short loc_4AB5F
mov rax, [rsp+148h+var_140]
add rax, 1
mov [rsp+148h+var_B0], rax
mov rax, [rsp+148h+var_140]
mov byte ptr [rax], 0
loc_4AB5F:
lea rdi, [rsp+148h+var_58]
call _atof
movsd [rsp+148h+var_C0], xmm0
lea rdi, [rsp+148h+var_A8]
call _atof
movsd [rsp+148h+var_C8], xmm0
cmp [rsp+148h+var_B0], 0
jz short loc_4ABA9
mov rdi, [rsp+148h+var_B0]
call _atof
movsd [rsp+148h+var_D0], xmm0
loc_4ABA9:
movsd xmm0, [rsp+148h+var_C0]
movsd [rsp+148h+var_D8], xmm0
movsd xmm0, [rsp+148h+var_C8]
xorps xmm1, xmm1
ucomisd xmm0, xmm1
jbe short loc_4ABF2
movsd xmm0, [rsp+148h+var_C0]
movsd xmm1, [rsp+148h+var_C8]
movsd xmm2, cs:qword_A2C28
divsd xmm1, xmm2
addsd xmm0, xmm1
movsd [rsp+148h+var_D8], xmm0
loc_4ABF2:
movsd xmm0, [rsp+148h+var_D0]
xorps xmm1, xmm1
ucomisd xmm0, xmm1
jbe short loc_4AC23
movsd xmm0, [rsp+148h+var_D8]
movsd xmm1, [rsp+148h+var_D0]
movsd xmm2, cs:qword_A2C58
divsd xmm1, xmm2
addsd xmm0, xmm1
movsd [rsp+148h+var_D8], xmm0
loc_4AC23:
mov rdi, [rsp+148h+var_B8]; this
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
lea rdi, [rsp+148h+var_138]
movsd xmm0, [rsp+148h+var_D8]
lea rsi, a4f; "%.4f"
mov al, 1
call _sprintf
lea rdi, [rsp+148h+var_138]
call _atof
movsd [rsp+148h+var_E0], xmm0
movsd xmm0, [rsp+148h+var_E0]
add rsp, 148h
retn
| void LefDefParser::convert_name2num(LefDefParser *this, const char *a2, long long a3)
{
_BYTE *v3; // [rsp+8h] [rbp-140h]
_BYTE v4[88]; // [rsp+10h] [rbp-138h] BYREF
double v5; // [rsp+70h] [rbp-D8h]
double v6; // [rsp+78h] [rbp-D0h]
double v7; // [rsp+80h] [rbp-C8h]
double v8; // [rsp+88h] [rbp-C0h]
LefDefParser *v9; // [rsp+90h] [rbp-B8h]
_BYTE *v10; // [rsp+98h] [rbp-B0h]
_BYTE v11[80]; // [rsp+A0h] [rbp-A8h] BYREF
_BYTE v12[80]; // [rsp+F0h] [rbp-58h] BYREF
LefDefParser *v13; // [rsp+140h] [rbp-8h]
v13 = this;
v10 = 0LL;
v9 = (LefDefParser *)strdup(this, a2, a3);
v8 = 0.0;
v7 = 0.0;
v6 = 0.0;
__isoc23_sscanf(v9, "%[^.].%s", v12, v11);
v3 = (_BYTE *)strchr(v11, (char *)&qword_28 + 6);
if ( v3 )
{
v10 = v3 + 1;
*v3 = 0;
}
v8 = atof(v12);
v7 = atof(v11);
if ( v10 )
v6 = atof(v10);
v5 = v8;
if ( v7 > 0.0 )
v5 = v8 + v7 / 10.0;
if ( v6 > 0.0 )
v5 = v5 + v6 / 1000.0;
LefDefParser::lefFree(v9, (char *)&qword_28 + 6);
sprintf(v4, "%.4f", v5);
atof(v4);
}
| convert_name2num:
SUB RSP,0x148
MOV qword ptr [RSP + 0x140],RDI
MOV qword ptr [RSP + 0x98],0x0
MOV RDI,qword ptr [RSP + 0x140]
CALL 0x00102470
MOV qword ptr [RSP + 0x90],RAX
XORPS XMM0,XMM0
MOVSD qword ptr [RSP + 0x88],XMM0
XORPS XMM0,XMM0
MOVSD qword ptr [RSP + 0x80],XMM0
XORPS XMM0,XMM0
MOVSD qword ptr [RSP + 0x78],XMM0
MOV RDI,qword ptr [RSP + 0x90]
LEA RDX,[RSP + 0xf0]
LEA RCX,[RSP + 0xa0]
LEA RSI,[0x196be8]
MOV AL,0x0
CALL 0x001020c0
LEA RDI,[RSP + 0xa0]
MOV ESI,0x2e
CALL 0x00102090
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
JZ 0x0014ab5f
MOV RAX,qword ptr [RSP + 0x8]
ADD RAX,0x1
MOV qword ptr [RSP + 0x98],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV byte ptr [RAX],0x0
LAB_0014ab5f:
LEA RDI,[RSP + 0xf0]
CALL 0x00102310
MOVSD qword ptr [RSP + 0x88],XMM0
LEA RDI,[RSP + 0xa0]
CALL 0x00102310
MOVSD qword ptr [RSP + 0x80],XMM0
CMP qword ptr [RSP + 0x98],0x0
JZ 0x0014aba9
MOV RDI,qword ptr [RSP + 0x98]
CALL 0x00102310
MOVSD qword ptr [RSP + 0x78],XMM0
LAB_0014aba9:
MOVSD XMM0,qword ptr [RSP + 0x88]
MOVSD qword ptr [RSP + 0x70],XMM0
MOVSD XMM0,qword ptr [RSP + 0x80]
XORPS XMM1,XMM1
UCOMISD XMM0,XMM1
JBE 0x0014abf2
MOVSD XMM0,qword ptr [RSP + 0x88]
MOVSD XMM1,qword ptr [RSP + 0x80]
MOVSD XMM2,qword ptr [0x001a2c28]
DIVSD XMM1,XMM2
ADDSD XMM0,XMM1
MOVSD qword ptr [RSP + 0x70],XMM0
LAB_0014abf2:
MOVSD XMM0,qword ptr [RSP + 0x78]
XORPS XMM1,XMM1
UCOMISD XMM0,XMM1
JBE 0x0014ac23
MOVSD XMM0,qword ptr [RSP + 0x70]
MOVSD XMM1,qword ptr [RSP + 0x78]
MOVSD XMM2,qword ptr [0x001a2c58]
DIVSD XMM1,XMM2
ADDSD XMM0,XMM1
MOVSD qword ptr [RSP + 0x70],XMM0
LAB_0014ac23:
MOV RDI,qword ptr [RSP + 0x90]
CALL 0x00152810
LEA RDI,[RSP + 0x10]
MOVSD XMM0,qword ptr [RSP + 0x70]
LEA RSI,[0x196bf1]
MOV AL,0x1
CALL 0x00102050
LEA RDI,[RSP + 0x10]
CALL 0x00102310
MOVSD qword ptr [RSP + 0x68],XMM0
MOVSD XMM0,qword ptr [RSP + 0x68]
ADD RSP,0x148
RET
|
/* LefDefParser::convert_name2num(char const*) */
double LefDefParser::convert_name2num(char *param_1)
{
char *pcVar1;
double dVar2;
char local_138 [96];
double local_d8;
double local_d0;
double local_c8;
double local_c0;
char *local_b8;
char *local_b0;
char local_a8 [80];
char local_58 [80];
char *local_8;
local_b0 = (char *)0x0;
local_8 = param_1;
local_b8 = strdup(param_1);
local_c0 = 0.0;
local_c8 = 0.0;
local_d0 = 0.0;
__isoc23_sscanf(local_b8,"%[^.].%s",local_58,local_a8);
pcVar1 = strchr(local_a8,0x2e);
if (pcVar1 != (char *)0x0) {
local_b0 = pcVar1 + 1;
*pcVar1 = '\0';
}
local_c0 = atof(local_58);
local_c8 = atof(local_a8);
if (local_b0 != (char *)0x0) {
local_d0 = atof(local_b0);
}
local_d8 = local_c0;
if (0.0 < local_c8) {
local_d8 = local_c0 + local_c8 / DAT_001a2c28;
}
if (0.0 < local_d0) {
local_d8 = local_d8 + local_d0 / DAT_001a2c58;
}
lefFree(local_b8);
sprintf(local_138,"%.4f",local_d8);
dVar2 = atof(local_138);
return dVar2;
}
| |
26,454 | fmt::v10::appender fmt::v10::detail::write_significand<fmt::v10::appender, char, char const*, fmt::v10::detail::digit_grouping<char>>(fmt::v10::appender, char const*, int, int, char, fmt::v10::detail::digit_grouping<char> const&) | aimrt_mujoco_sim/_deps/fmt-src/include/fmt/format.h | FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand,
int significand_size, int integral_size,
Char decimal_point,
const Grouping& grouping) -> OutputIt {
if (!grouping.has_separator()) {
return write_significand(out, significand, significand_size, integral_size,
decimal_point);
}
auto buffer = basic_memory_buffer<Char>();
write_significand(buffer_appender<Char>(buffer), significand,
significand_size, integral_size, decimal_point);
grouping.apply(
out, basic_string_view<Char>(buffer.data(), to_unsigned(integral_size)));
return detail::copy_str_noinline<Char>(buffer.data() + integral_size,
buffer.end(), out);
} | O3 | c | fmt::v10::appender fmt::v10::detail::write_significand<fmt::v10::appender, char, char const*, fmt::v10::detail::digit_grouping<char>>(fmt::v10::appender, char const*, int, int, char, fmt::v10::detail::digit_grouping<char> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movl %ecx, %ebp
movq %rdi, %rbx
cmpq $0x0, 0x28(%r9)
je 0x2e843
movq %r9, %r14
leaq 0x20(%rsp), %r15
movq $0x0, -0x10(%r15)
leaq 0x7fca5(%rip), %rax # 0xae478
movq %rax, -0x20(%r15)
movq %r15, -0x18(%r15)
movq $0x1f4, -0x8(%r15) # imm = 0x1F4
movsbl %r8b, %r8d
movq %rsp, %rdi
movl %ebp, %ecx
callq 0x2e3b6
movq 0x8(%rsp), %rdx
movl %ebp, %ecx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2843c
movq 0x8(%rsp), %rsi
movslq %ebp, %rdi
addq %rsi, %rdi
addq 0x10(%rsp), %rsi
movq %rbx, %rdx
callq 0x25736
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2e832
movq 0x18(%rsp), %rsi
callq 0x1f250
movq %rbx, %rax
addq $0x218, %rsp # imm = 0x218
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movsbl %r8b, %r8d
movq %rbx, %rdi
movl %ebp, %ecx
addq $0x218, %rsp # imm = 0x218
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2e3b6
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2e875
movq 0x18(%rsp), %rsi
callq 0x1f250
movq %rbx, %rdi
callq 0x1ffd0
| _ZN3fmt3v106detail17write_significandINS0_8appenderEcPKcNS1_14digit_groupingIcEEEET_S8_T1_iiT0_RKT2_:
push rbp
push r15
push r14
push rbx
sub rsp, 218h
mov ebp, ecx
mov rbx, rdi
cmp qword ptr [r9+28h], 0
jz loc_2E843
mov r14, r9
lea r15, [rsp+238h+var_218]
mov qword ptr [r15-10h], 0
lea rax, off_AE478
mov [r15-20h], rax
mov [r15-18h], r15
mov qword ptr [r15-8], 1F4h
movsx r8d, r8b
mov rdi, rsp
mov ecx, ebp
call _ZN3fmt3v106detail17write_significandINS0_8appenderEcEET_S4_PKciiT0_; fmt::v10::detail::write_significand<fmt::v10::appender,char>(fmt::v10::appender,char const*,int,int,char)
mov rdx, [rsp+238h+var_230]; int
mov ecx, ebp; int
mov rdi, r14; int
mov rsi, rbx; int
call _ZNK3fmt3v106detail14digit_groupingIcE5applyINS0_8appenderEcEET_S6_NS0_17basic_string_viewIT0_EE; fmt::v10::detail::digit_grouping<char>::apply<fmt::v10::appender,char>(fmt::v10::appender,fmt::v10::basic_string_view<char>)
mov rsi, [rsp+238h+var_230]
movsxd rdi, ebp
add rdi, rsi
add rsi, [rsp+238h+var_228]
mov rdx, rbx
call _ZN3fmt3v106detail17copy_str_noinlineIcPcNS0_8appenderEEET1_T0_S6_S5_; fmt::v10::detail::copy_str_noinline<char,char *,fmt::v10::appender>(char *,char *,fmt::v10::appender)
mov rbx, rax
mov rdi, [rsp+238h+var_230]; void *
cmp rdi, r15
jz short loc_2E832
mov rsi, [rsp+238h+var_220]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2E832:
mov rax, rbx
add rsp, 218h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_2E843:
movsx r8d, r8b
mov rdi, rbx
mov ecx, ebp
add rsp, 218h
pop rbx
pop r14
pop r15
pop rbp
jmp _ZN3fmt3v106detail17write_significandINS0_8appenderEcEET_S4_PKciiT0_; fmt::v10::detail::write_significand<fmt::v10::appender,char>(fmt::v10::appender,char const*,int,int,char)
mov rbx, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, r15
jz short loc_2E875
mov rsi, [rsp+arg_10]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2E875:
mov rdi, rbx
call __Unwind_Resume
| long long fmt::v10::detail::write_significand<fmt::v10::appender,char,char const*,fmt::v10::detail::digit_grouping<char>>(
long long a1,
long long a2,
int a3,
int a4,
char a5,
long long a6)
{
long long v8; // rbx
_UNKNOWN **v10; // [rsp+0h] [rbp-238h] BYREF
void *v11; // [rsp+8h] [rbp-230h]
long long v12; // [rsp+10h] [rbp-228h]
unsigned long long v13; // [rsp+18h] [rbp-220h]
_BYTE v14[536]; // [rsp+20h] [rbp-218h] BYREF
if ( !*(_QWORD *)(a6 + 40) )
return fmt::v10::detail::write_significand<fmt::v10::appender,char>(a1, a2, a3, a4, a5);
v12 = 0LL;
v10 = &off_AE478;
v11 = v14;
v13 = 500LL;
fmt::v10::detail::write_significand<fmt::v10::appender,char>((long long)&v10, a2, a3, a4, a5);
fmt::v10::detail::digit_grouping<char>::apply<fmt::v10::appender,char>(a6, a1, (long long)v11, a4);
v8 = fmt::v10::detail::copy_str_noinline<char,char *,fmt::v10::appender>((long long)v11 + a4, (long long)v11 + v12, a1);
if ( v11 != v14 )
operator delete(v11, v13);
return v8;
}
| write_significand<fmt::v10::appender,char,char_const*,fmt::v10::detail::digit_grouping<char>>:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x218
MOV EBP,ECX
MOV RBX,RDI
CMP qword ptr [R9 + 0x28],0x0
JZ 0x0012e843
MOV R14,R9
LEA R15,[RSP + 0x20]
MOV qword ptr [R15 + -0x10],0x0
LEA RAX,[0x1ae478]
MOV qword ptr [R15 + -0x20],RAX
MOV qword ptr [R15 + -0x18],R15
MOV qword ptr [R15 + -0x8],0x1f4
LAB_0012e7e3:
MOVSX R8D,R8B
MOV RDI,RSP
MOV ECX,EBP
CALL 0x0012e3b6
MOV RDX,qword ptr [RSP + 0x8]
MOV ECX,EBP
MOV RDI,R14
MOV RSI,RBX
CALL 0x0012843c
MOV RSI,qword ptr [RSP + 0x8]
MOVSXD RDI,EBP
ADD RDI,RSI
ADD RSI,qword ptr [RSP + 0x10]
MOV RDX,RBX
CALL 0x00125736
LAB_0012e81b:
MOV RBX,RAX
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R15
JZ 0x0012e832
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x0011f250
LAB_0012e832:
MOV RAX,RBX
ADD RSP,0x218
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0012e843:
MOVSX R8D,R8B
MOV RDI,RBX
MOV ECX,EBP
ADD RSP,0x218
POP RBX
POP R14
POP R15
POP RBP
JMP 0x0012e3b6
|
/* fmt::v10::appender fmt::v10::detail::write_significand<fmt::v10::appender, char, char const*,
fmt::v10::detail::digit_grouping<char> >(fmt::v10::appender, char const*, int, int, char,
fmt::v10::detail::digit_grouping<char> const&) */
int8
fmt::v10::detail::
write_significand<fmt::v10::appender,char,char_const*,fmt::v10::detail::digit_grouping<char>>
(int8 param_1,int8 param_2,int8 param_3,int param_4,char param_5,
long param_6)
{
int8 uVar1;
int **local_238;
int1 *local_230;
long local_228;
ulong local_220;
int1 local_218 [504];
if (*(long *)(param_6 + 0x28) != 0) {
local_228 = 0;
local_238 = &PTR_grow_001ae478;
local_220 = 500;
/* try { // try from 0012e7e3 to 0012e81a has its CatchHandler @ 0012e85e */
local_230 = local_218;
write_significand<fmt::v10::appender,char>(&local_238,param_2,param_3,param_4,(int)param_5);
digit_grouping<char>::apply<fmt::v10::appender,char>(param_6,param_1,local_230,param_4);
uVar1 = copy_str_noinline<char,char*,fmt::v10::appender>
(local_230 + param_4,local_230 + local_228,param_1);
if (local_230 != local_218) {
operator_delete(local_230,local_220);
}
return uVar1;
}
uVar1 = write_significand<fmt::v10::appender,char>(param_1,param_2,param_3,param_4,(int)param_5);
return uVar1;
}
| |
26,455 | Mem_root_array<SEL_ARG*, true>::reserve(unsigned long) | eloqsql/sql/mem_root_array.h | bool reserve(size_t n)
{
if (n <= m_capacity)
return false;
void *mem= alloc_root(m_root, n * element_size());
if (!mem)
return true;
Element_type *array= static_cast<Element_type*>(mem);
// Copy all the existing elements into the new array.
for (size_t ix= 0; ix < m_size; ++ix)
{
Element_type *new_p= &array[ix];
Element_type *old_p= &m_array[ix];
new (new_p) Element_type(*old_p); // Copy into new location.
if (!has_trivial_destructor)
old_p->~Element_type(); // Destroy the old element.
}
// Forget the old array.
m_array= array;
m_capacity= n;
return false;
} | O0 | c | Mem_root_array<SEL_ARG*, true>::reserve(unsigned long):
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq -0x18(%rbp), %rax
cmpq 0x18(%rcx), %rax
ja 0x8d149b
movb $0x0, -0x1(%rbp)
jmp 0x8d1551
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x8d1620
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdi
imulq %rax, %rsi
callq 0x1319160
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x8d14d5
movb $0x1, -0x1(%rbp)
jmp 0x8d1551
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x48(%rbp), %rcx
movq -0x30(%rbp), %rax
cmpq 0x10(%rcx), %rax
jae 0x8d1539
movq -0x48(%rbp), %rax
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x8d14e5
movq -0x48(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| _ZN14Mem_root_arrayIP7SEL_ARGLb1EE7reserveEm:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rcx, [rbp+var_10]
mov [rbp+var_48], rcx
mov rax, [rbp+var_18]
cmp rax, [rcx+18h]
ja short loc_8D149B
mov [rbp+var_1], 0
jmp loc_8D1551
loc_8D149B:
mov rdi, [rbp+var_48]
mov rax, [rdi]
mov [rbp+var_50], rax
mov rax, [rbp+var_18]
mov [rbp+var_58], rax
call _ZNK14Mem_root_arrayIP7SEL_ARGLb1EE12element_sizeEv; Mem_root_array<SEL_ARG *,true>::element_size(void)
mov rsi, [rbp+var_58]
mov rdi, [rbp+var_50]
imul rsi, rax
call alloc_root
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jnz short loc_8D14D5
mov [rbp+var_1], 1
jmp short loc_8D1551
loc_8D14D5:
mov rax, [rbp+var_20]
mov [rbp+var_28], rax
mov [rbp+var_30], 0
loc_8D14E5:
mov rcx, [rbp+var_48]
mov rax, [rbp+var_30]
cmp rax, [rcx+10h]
jnb short loc_8D1539
mov rax, [rbp+var_48]
mov rcx, [rbp+var_28]
mov rdx, [rbp+var_30]
shl rdx, 3
add rcx, rdx
mov [rbp+var_38], rcx
mov rax, [rax+8]
mov rcx, [rbp+var_30]
shl rcx, 3
add rax, rcx
mov [rbp+var_40], rax
mov rax, [rbp+var_38]
mov rcx, [rbp+var_40]
mov rcx, [rcx]
mov [rax], rcx
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
jmp short loc_8D14E5
loc_8D1539:
mov rax, [rbp+var_48]
mov rcx, [rbp+var_28]
mov [rax+8], rcx
mov rcx, [rbp+var_18]
mov [rax+18h], rcx
mov [rbp+var_1], 0
loc_8D1551:
mov al, [rbp+var_1]
and al, 1
add rsp, 60h
pop rbp
retn
| char Mem_root_array<SEL_ARG *,true>::reserve(long long *a1, unsigned long long a2)
{
long long v2; // rax
long long v4; // [rsp+10h] [rbp-50h]
unsigned long long i; // [rsp+30h] [rbp-30h]
long long v6; // [rsp+40h] [rbp-20h]
if ( a2 <= a1[3] )
return 0;
v4 = *a1;
v2 = Mem_root_array<SEL_ARG *,true>::element_size();
v6 = alloc_root(v4, v2 * a2);
if ( !v6 )
return 1;
for ( i = 0LL; i < a1[2]; ++i )
*(_QWORD *)(8 * i + v6) = *(_QWORD *)(8 * i + a1[1]);
a1[1] = v6;
a1[3] = a2;
return 0;
}
| __cxx_global_var_init.6:
PUSH RBP
MOV RBP,RSP
LEA RDI,[0x26cfda0]
MOV ESI,0x1000000
CALL 0x008fd530
POP RBP
RET
|
void __cxx_global_var_init_6(void)
{
date_conv_mode_t::date_conv_mode_t((date_conv_mode_t *)&TIME_NO_ZERO_DATE,0x1000000);
return;
}
| |
26,456 | Mem_root_array<SEL_ARG*, true>::reserve(unsigned long) | eloqsql/sql/mem_root_array.h | bool reserve(size_t n)
{
if (n <= m_capacity)
return false;
void *mem= alloc_root(m_root, n * element_size());
if (!mem)
return true;
Element_type *array= static_cast<Element_type*>(mem);
// Copy all the existing elements into the new array.
for (size_t ix= 0; ix < m_size; ++ix)
{
Element_type *new_p= &array[ix];
Element_type *old_p= &m_array[ix];
new (new_p) Element_type(*old_p); // Copy into new location.
if (!has_trivial_destructor)
old_p->~Element_type(); // Destroy the old element.
}
// Forget the old array.
m_array= array;
m_capacity= n;
return false;
} | O3 | c | Mem_root_array<SEL_ARG*, true>::reserve(unsigned long):
cmpq %rsi, 0x18(%rdi)
jae 0x86da54
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
shlq $0x4, %rsi
callq 0xcf03ef
testq %rax, %rax
je 0x86da57
cmpq $0x0, 0x10(%r14)
je 0x86da48
xorl %ecx, %ecx
xorl %edx, %edx
movq 0x8(%r14), %rsi
movups (%rsi,%rcx), %xmm0
movups %xmm0, (%rax,%rcx)
incq %rdx
addq $0x10, %rcx
cmpq 0x10(%r14), %rdx
jb 0x86da2f
movq %rax, 0x8(%r14)
movq %rbx, 0x18(%r14)
xorl %eax, %eax
jmp 0x86da59
xorl %eax, %eax
retq
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
| _ZN14Mem_root_arrayIN18Alter_inplace_info15Rename_key_pairELb1EE7reserveEm:
cmp [rdi+18h], rsi
jnb short loc_86DA54
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rsi
mov r14, rdi
mov rdi, [rdi]
shl rsi, 4
call alloc_root
test rax, rax
jz short loc_86DA57
cmp qword ptr [r14+10h], 0
jz short loc_86DA48
xor ecx, ecx
xor edx, edx
loc_86DA2F:
mov rsi, [r14+8]
movups xmm0, xmmword ptr [rsi+rcx]
movups xmmword ptr [rax+rcx], xmm0
inc rdx
add rcx, 10h
cmp rdx, [r14+10h]
jb short loc_86DA2F
loc_86DA48:
mov [r14+8], rax
mov [r14+18h], rbx
xor eax, eax
jmp short loc_86DA59
loc_86DA54:
xor eax, eax
retn
loc_86DA57:
mov al, 1
loc_86DA59:
pop rbx
pop r14
pop rbp
retn
| long long Mem_root_array<Alter_inplace_info::Rename_key_pair,true>::reserve(_QWORD *a1, unsigned long long a2)
{
long long v2; // rax
long long v3; // rcx
unsigned long long v4; // rdx
if ( a1[3] >= a2 )
return 0LL;
v2 = alloc_root(*a1, 16 * a2);
if ( !v2 )
return 1LL;
if ( a1[2] )
{
v3 = 0LL;
v4 = 0LL;
do
{
*(_OWORD *)(v2 + v3) = *(_OWORD *)(a1[1] + v3);
++v4;
v3 += 16LL;
}
while ( v4 < a1[2] );
}
a1[1] = v2;
a1[3] = a2;
return 0LL;
}
| |||
26,457 | js_get_radix | bluesky950520[P]quickjs/quickjs.c | static int js_get_radix(JSContext *ctx, JSValue val)
{
int radix;
if (JS_ToInt32Sat(ctx, &radix, val))
return -1;
if (radix < 2 || radix > 36) {
JS_ThrowRangeError(ctx, "toString() radix argument must be between 2 and 36");
return -1;
}
return radix;
} | O1 | c | js_get_radix:
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
cmpl $-0x9, %ecx
jb 0x6f9a0
movq 0x8(%rsp), %rax
incl (%rax)
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x276c3
movl %eax, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x6f9da
movl 0x4(%rsp), %eax
leal -0x25(%rax), %ecx
cmpl $-0x24, %ecx
ja 0x6f9da
leaq 0x31e4a(%rip), %rsi # 0xa1815
movq %rbx, %rdi
xorl %eax, %eax
callq 0x20add
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
retq
| js_get_radix:
push rbx
sub rsp, 10h
mov rcx, rdx
mov rdx, rsi
mov rbx, rdi
mov [rsp+18h+var_10], rsi
cmp ecx, 0FFFFFFF7h
jb short loc_6F9A0
mov rax, [rsp+18h+var_10]
inc dword ptr [rax]
loc_6F9A0:
lea rsi, [rsp+18h+var_14]
mov rdi, rbx
call JS_ToInt32SatFree
mov ecx, eax
mov eax, 0FFFFFFFFh
test ecx, ecx
jnz short loc_6F9DA
mov eax, [rsp+18h+var_14]
lea ecx, [rax-25h]
cmp ecx, 0FFFFFFDCh
ja short loc_6F9DA
lea rsi, aTostringRadixA; "toString() radix argument must be betwe"...
mov rdi, rbx
xor eax, eax
call JS_ThrowRangeError
mov eax, 0FFFFFFFFh
loc_6F9DA:
add rsp, 10h
pop rbx
retn
| long long js_get_radix(
long long a1,
long long a2,
long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
long long v11; // rdx
int v12; // ecx
long long v13; // r8
long long v14; // r9
__m128 v15; // xmm4
__m128 v16; // xmm5
long long result; // rax
long long v18; // rcx
char v19; // [rsp+0h] [rbp-18h]
unsigned int v20; // [rsp+4h] [rbp-14h] BYREF
_DWORD *v21; // [rsp+8h] [rbp-10h]
v21 = (_DWORD *)a2;
if ( (unsigned int)a3 >= 0xFFFFFFF7 )
++*v21;
v12 = JS_ToInt32SatFree(a1, (int *)&v20, a2, a3);
result = 0xFFFFFFFFLL;
if ( !v12 )
{
result = v20;
v18 = v20 - 37;
if ( (unsigned int)v18 <= 0xFFFFFFDC )
{
JS_ThrowRangeError(
a1,
(long long)"toString() radix argument must be between 2 and 36",
v11,
v18,
v13,
v14,
a4,
a5,
a6,
a7,
v15,
v16,
a10,
a11,
v19);
return 0xFFFFFFFFLL;
}
}
return result;
}
| js_get_radix:
PUSH RBX
SUB RSP,0x10
MOV RCX,RDX
MOV RDX,RSI
MOV RBX,RDI
MOV qword ptr [RSP + 0x8],RSI
CMP ECX,-0x9
JC 0x0016f9a0
MOV RAX,qword ptr [RSP + 0x8]
INC dword ptr [RAX]
LAB_0016f9a0:
LEA RSI,[RSP + 0x4]
MOV RDI,RBX
CALL 0x001276c3
MOV ECX,EAX
MOV EAX,0xffffffff
TEST ECX,ECX
JNZ 0x0016f9da
MOV EAX,dword ptr [RSP + 0x4]
LEA ECX,[RAX + -0x25]
CMP ECX,-0x24
JA 0x0016f9da
LEA RSI,[0x1a1815]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x00120add
MOV EAX,0xffffffff
LAB_0016f9da:
ADD RSP,0x10
POP RBX
RET
|
int js_get_radix(int8 param_1,int *param_2,uint param_3)
{
int iVar1;
int iVar2;
int local_14;
int *local_10;
if (0xfffffff6 < param_3) {
*param_2 = *param_2 + 1;
}
local_10 = param_2;
iVar1 = JS_ToInt32SatFree(param_1,&local_14,param_2);
iVar2 = -1;
if (iVar1 == 0) {
iVar2 = local_14;
if (local_14 - 0x25U < 0xffffffdd) {
JS_ThrowRangeError(param_1,"toString() radix argument must be between 2 and 36");
iVar2 = -1;
}
}
return iVar2;
}
| |
26,458 | js_get_radix | bluesky950520[P]quickjs/quickjs.c | static int js_get_radix(JSContext *ctx, JSValue val)
{
int radix;
if (JS_ToInt32Sat(ctx, &radix, val))
return -1;
if (radix < 2 || radix > 36) {
JS_ThrowRangeError(ctx, "toString() radix argument must be between 2 and 36");
return -1;
}
return radix;
} | O2 | c | js_get_radix:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x4(%rsp), %rsi
callq 0x2133d
pushq $-0x1
popq %rbp
testl %eax, %eax
jne 0x5ddf5
movl 0x4(%rsp), %eax
leal -0x25(%rax), %ecx
cmpl $-0x24, %ecx
ja 0x5ddf7
leaq 0x2a964(%rip), %rsi # 0x8874f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1acb3
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| js_get_radix:
push rbp
push rbx
push rax
mov rcx, rdx
mov rdx, rsi
mov rbx, rdi
lea rsi, [rsp+18h+var_14]
call JS_ToInt32Sat
push 0FFFFFFFFFFFFFFFFh
pop rbp
test eax, eax
jnz short loc_5DDF5
mov eax, [rsp+18h+var_14]
lea ecx, [rax-25h]
cmp ecx, 0FFFFFFDCh
ja short loc_5DDF7
lea rsi, aTostringRadixA; "toString() radix argument must be betwe"...
mov rdi, rbx
xor eax, eax
call JS_ThrowRangeError
loc_5DDF5:
mov eax, ebp
loc_5DDF7:
add rsp, 8
pop rbx
pop rbp
retn
| long long js_get_radix(
long long a1,
_DWORD *a2,
unsigned int a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
long long v11; // rax
long long v12; // rdx
long long v13; // r8
long long v14; // r9
__m128 v15; // xmm4
__m128 v16; // xmm5
long long result; // rax
long long v18; // rcx
long long v19; // [rsp-4h] [rbp-18h] BYREF
v19 = v11;
if ( !(unsigned int)JS_ToInt32Sat(a1, (long long)&v19 + 4, a2, a3) )
{
result = HIDWORD(v19);
v18 = (unsigned int)(HIDWORD(v19) - 37);
if ( (unsigned int)v18 > 0xFFFFFFDC )
return result;
JS_ThrowRangeError(
a1,
(long long)"toString() radix argument must be between 2 and 36",
v12,
v18,
v13,
v14,
a4,
a5,
a6,
a7,
v15,
v16,
a10,
a11,
v19);
}
return 0xFFFFFFFFLL;
}
| js_get_radix:
PUSH RBP
PUSH RBX
PUSH RAX
MOV RCX,RDX
MOV RDX,RSI
MOV RBX,RDI
LEA RSI,[RSP + 0x4]
CALL 0x0012133d
PUSH -0x1
POP RBP
TEST EAX,EAX
JNZ 0x0015ddf5
MOV EAX,dword ptr [RSP + 0x4]
LEA ECX,[RAX + -0x25]
CMP ECX,-0x24
JA 0x0015ddf7
LEA RSI,[0x18874f]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x0011acb3
LAB_0015ddf5:
MOV EAX,EBP
LAB_0015ddf7:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
int js_get_radix(int8 param_1,int8 param_2,int8 param_3)
{
int iVar1;
int8 in_RAX;
int local_14;
local_14 = (int)((ulong)in_RAX >> 0x20);
iVar1 = JS_ToInt32Sat(param_1,&local_14,param_2,param_3);
if (iVar1 == 0) {
if (0xffffffdc < local_14 - 0x25U) {
return local_14;
}
JS_ThrowRangeError(param_1,"toString() radix argument must be between 2 and 36");
}
return -1;
}
| |
26,459 | pfs_start_file_wait_v1 | eloqsql/storage/perfschema/pfs.cc | void pfs_start_file_wait_v1(PSI_file_locker *locker,
size_t count,
const char *src_file,
uint src_line)
{
ulonglong timer_start= 0;
PSI_file_locker_state *state= reinterpret_cast<PSI_file_locker_state*> (locker);
assert(state != NULL);
uint flags= state->m_flags;
if (flags & STATE_FLAG_TIMED)
{
timer_start= get_timer_raw_value_and_function(wait_timer, & state->m_timer);
state->m_timer_start= timer_start;
}
if (flags & STATE_FLAG_EVENT)
{
PFS_events_waits *wait= reinterpret_cast<PFS_events_waits*> (state->m_wait);
assert(wait != NULL);
wait->m_timer_start= timer_start;
wait->m_source_file= src_file;
wait->m_source_line= src_line;
wait->m_number_of_bytes= count;
}
} | O0 | cpp | pfs_start_file_wait_v1:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x51bb1
leaq 0x1c581a(%rip), %rax # 0x2173ac
movl (%rax), %edi
movq -0x30(%rbp), %rsi
addq $0x38, %rsi
callq 0x4b340
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x30(%rax)
movl -0x34(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x51bf9
movq -0x30(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x48(%rax)
movl -0x1c(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x50(%rax)
movq -0x10(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x98(%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
| pfs_start_file_wait_v1:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov [rbp+var_28], 0
mov rax, [rbp+var_8]
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
mov eax, [rax]
mov [rbp+var_34], eax
mov eax, [rbp+var_34]
and eax, 1
cmp eax, 0
jz short loc_51BB1
lea rax, wait_timer
mov edi, [rax]
mov rsi, [rbp+var_30]
add rsi, 38h ; '8'
call _Z32get_timer_raw_value_and_function15enum_timer_namePPFyvE; get_timer_raw_value_and_function(enum_timer_name,ulong long (**)(void))
mov [rbp+var_28], rax
mov rcx, [rbp+var_28]
mov rax, [rbp+var_30]
mov [rax+30h], rcx
loc_51BB1:
mov eax, [rbp+var_34]
and eax, 4
cmp eax, 0
jz short loc_51BF9
mov rax, [rbp+var_30]
mov rax, [rax+40h]
mov [rbp+var_40], rax
mov rcx, [rbp+var_28]
mov rax, [rbp+var_40]
mov [rax+38h], rcx
mov rcx, [rbp+var_18]
mov rax, [rbp+var_40]
mov [rax+48h], rcx
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_40]
mov [rax+50h], ecx
mov rcx, [rbp+var_10]
mov rax, [rbp+var_40]
mov [rax+98h], rcx
loc_51BF9:
add rsp, 40h
pop rbp
retn
| long long pfs_start_file_wait_v1(int *a1, long long a2, long long a3, int a4)
{
long long result; // rax
long long v5; // [rsp+0h] [rbp-40h]
int v6; // [rsp+Ch] [rbp-34h]
unsigned long long timer_raw_value_and_function; // [rsp+18h] [rbp-28h]
timer_raw_value_and_function = 0LL;
v6 = *a1;
if ( (*a1 & 1) != 0 )
{
timer_raw_value_and_function = get_timer_raw_value_and_function(
(unsigned int)wait_timer,
(unsigned long long (**)(void))a1 + 7);
*((_QWORD *)a1 + 6) = timer_raw_value_and_function;
}
result = v6 & 4;
if ( (v6 & 4) != 0 )
{
v5 = *((_QWORD *)a1 + 8);
*(_QWORD *)(v5 + 56) = timer_raw_value_and_function;
*(_QWORD *)(v5 + 72) = a3;
*(_DWORD *)(v5 + 80) = a4;
result = v5;
*(_QWORD *)(v5 + 152) = a2;
}
return result;
}
| pfs_start_file_wait_v1:
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 dword ptr [RBP + -0x1c],ECX
MOV qword ptr [RBP + -0x28],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x34],EAX
MOV EAX,dword ptr [RBP + -0x34]
AND EAX,0x1
CMP EAX,0x0
JZ 0x00151bb1
LEA RAX,[0x3173ac]
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x30]
ADD RSI,0x38
CALL 0x0014b340
MOV qword ptr [RBP + -0x28],RAX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x30],RCX
LAB_00151bb1:
MOV EAX,dword ptr [RBP + -0x34]
AND EAX,0x4
CMP EAX,0x0
JZ 0x00151bf9
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x40]
MOV qword ptr [RBP + -0x40],RAX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX + 0x38],RCX
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX + 0x48],RCX
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x40]
MOV dword ptr [RAX + 0x50],ECX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX + 0x98],RCX
LAB_00151bf9:
ADD RSP,0x40
POP RBP
RET
|
void pfs_start_file_wait_v1(uint *param_1,int8 param_2,int8 param_3,int4 param_4)
{
uint uVar1;
long lVar2;
int8 local_30;
local_30 = 0;
uVar1 = *param_1;
if ((uVar1 & 1) != 0) {
local_30 = get_timer_raw_value_and_function(wait_timer,param_1 + 0xe);
*(int8 *)(param_1 + 0xc) = local_30;
}
if ((uVar1 & 4) != 0) {
lVar2 = *(long *)(param_1 + 0x10);
*(int8 *)(lVar2 + 0x38) = local_30;
*(int8 *)(lVar2 + 0x48) = param_3;
*(int4 *)(lVar2 + 0x50) = param_4;
*(int8 *)(lVar2 + 0x98) = param_2;
}
return;
}
| |
26,460 | httplib::detail::bind_ip_address(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | hkr04[P]cpp-mcp/common/httplib.h | inline bool bind_ip_address(socket_t sock, const std::string &host) {
struct addrinfo hints;
struct addrinfo *result;
memset(&hints, 0, sizeof(struct addrinfo));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = 0;
if (getaddrinfo(host.c_str(), "0", &hints, &result)) { return false; }
auto se = detail::scope_exit([&] { freeaddrinfo(result); });
auto ret = false;
for (auto rp = result; rp; rp = rp->ai_next) {
const auto &ai = *rp;
if (!::bind(sock, ai.ai_addr, static_cast<socklen_t>(ai.ai_addrlen))) {
ret = true;
break;
}
}
return ret;
} | O0 | c | httplib::detail::bind_ip_address(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
subq $0xc8, %rsp
movl %edi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
leaq 0x88(%rsp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0xb420
movl $0x0, 0x8c(%rsp)
movl $0x1, 0x90(%rsp)
movl $0x0, 0x94(%rsp)
movq 0xb8(%rsp), %rdi
callq 0xb2c0
movq %rax, %rdi
leaq 0x64440(%rip), %rsi # 0xcde82
leaq 0x88(%rsp), %rdx
leaq 0x80(%rsp), %rcx
callq 0xba20
cmpl $0x0, %eax
je 0x69a69
movb $0x0, 0xc7(%rsp)
jmp 0x69b35
leaq 0x80(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x30(%rsp), %rsi
callq 0x6a290
movq 0x8(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x69410
jmp 0x69a9b
leaq 0x38(%rsp), %rdi
callq 0x27140
movb $0x0, 0x23(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x69b1e
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0xc0(%rsp), %edi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x10(%rsp), %rax
movl 0x10(%rax), %edx
callq 0xb0e0
cmpl $0x0, %eax
jne 0x69b0c
movb $0x1, 0x23(%rsp)
jmp 0x69b1e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x27140
jmp 0x69b46
jmp 0x69b0e
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x69ab7
movb 0x23(%rsp), %al
andb $0x1, %al
movb %al, 0xc7(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x69480
movb 0xc7(%rsp), %al
andb $0x1, %al
addq $0xc8, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xbe10
| _ZN7httplib6detail15bind_ip_addressEiRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
sub rsp, 0C8h
mov [rsp+0C8h+var_8], edi
mov [rsp+0C8h+var_10], rsi
lea rdi, [rsp+0C8h+var_40]
xor esi, esi
mov edx, 30h ; '0'
call _memset
mov [rsp+0C8h+var_3C], 0
mov [rsp+0C8h+var_38], 1
mov [rsp+0C8h+var_34], 0
mov rdi, [rsp+0C8h+var_10]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rdi, rax
lea rsi, aHttp10+7; "0"
lea rdx, [rsp+0C8h+var_40]
lea rcx, [rsp+0C8h+var_48]
call _getaddrinfo
cmp eax, 0
jz short loc_69A69
mov [rsp+0C8h+var_1], 0
jmp loc_69B35
loc_69A69:
lea rax, [rsp+0C8h+var_48]
mov [rsp+0C8h+var_98], rax
lea rdi, [rsp+0C8h+var_90]
mov [rsp+0C8h+var_C0], rdi
lea rsi, [rsp+0C8h+var_98]
call _ZNSt8functionIFvvEEC2IZN7httplib6detail15bind_ip_addressEiRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEUlvE_vEEOT_; std::function<void ()(void)>::function<httplib::detail::bind_ip_address(int,std::string const&)::{lambda(void)#1},void>(httplib::detail::bind_ip_address(int,std::string const&)::{lambda(void)#1} &&)
mov rsi, [rsp+0C8h+var_C0]
lea rdi, [rsp+0C8h+var_70]
call _ZN7httplib6detail10scope_exitC2EOSt8functionIFvvEE; httplib::detail::scope_exit::scope_exit(std::function<void ()(void)> &&)
jmp short $+2
loc_69A9B:
lea rdi, [rsp+0C8h+var_90]
call _ZNSt8functionIFvvEED2Ev; std::function<void ()(void)>::~function()
mov [rsp+0C8h+var_A5], 0
mov rax, [rsp+0C8h+var_48]
mov [rsp+0C8h+var_B0], rax
loc_69AB7:
cmp [rsp+0C8h+var_B0], 0
jz short loc_69B1E
mov rax, [rsp+0C8h+var_B0]
mov [rsp+0C8h+var_B8], rax
mov edi, [rsp+0C8h+var_8]
mov rax, [rsp+0C8h+var_B8]
mov rsi, [rax+18h]
mov rax, [rsp+0C8h+var_B8]
mov edx, [rax+10h]
call _bind
cmp eax, 0
jnz short loc_69B0C
mov [rsp+0C8h+var_A5], 1
jmp short loc_69B1E
mov rcx, rax
mov eax, edx
mov [rsp+arg_20], rcx
mov [rsp+arg_1C], eax
lea rdi, [rsp+arg_30]
call _ZNSt8functionIFvvEED2Ev; std::function<void ()(void)>::~function()
jmp short loc_69B46
loc_69B0C:
jmp short $+2
loc_69B0E:
mov rax, [rsp+0C8h+var_B0]
mov rax, [rax+28h]
mov [rsp+0C8h+var_B0], rax
jmp short loc_69AB7
loc_69B1E:
mov al, [rsp+0C8h+var_A5]
and al, 1
mov [rsp+0C8h+var_1], al
lea rdi, [rsp+0C8h+var_70]; this
call _ZN7httplib6detail10scope_exitD2Ev; httplib::detail::scope_exit::~scope_exit()
loc_69B35:
mov al, [rsp+0C8h+var_1]
and al, 1
add rsp, 0C8h
retn
loc_69B46:
mov rdi, [rsp+arg_20]
call __Unwind_Resume
| char httplib::detail::bind_ip_address(unsigned int a1, long long a2)
{
long long v2; // rax
long long i; // [rsp+18h] [rbp-B0h]
char v5; // [rsp+23h] [rbp-A5h]
long long *v6; // [rsp+30h] [rbp-98h] BYREF
_BYTE v7[32]; // [rsp+38h] [rbp-90h] BYREF
_BYTE v8[40]; // [rsp+58h] [rbp-70h] BYREF
long long v9; // [rsp+80h] [rbp-48h] BYREF
_BYTE v10[4]; // [rsp+88h] [rbp-40h] BYREF
int v11; // [rsp+8Ch] [rbp-3Ch]
int v12; // [rsp+90h] [rbp-38h]
int v13; // [rsp+94h] [rbp-34h]
long long v14; // [rsp+B8h] [rbp-10h]
unsigned int v15; // [rsp+C0h] [rbp-8h]
char v16; // [rsp+C7h] [rbp-1h]
v15 = a1;
v14 = a2;
memset(v10, 0LL, 48LL);
v11 = 0;
v12 = 1;
v13 = 0;
v2 = std::string::c_str(v14);
if ( (unsigned int)getaddrinfo(v2, "0", v10, &v9) )
{
v16 = 0;
}
else
{
v6 = &v9;
std::function<void ()(void)>::function<httplib::detail::bind_ip_address(int,std::string const&)::{lambda(void)#1},void>(
v7,
&v6);
httplib::detail::scope_exit::scope_exit((long long)v8, (long long)v7);
std::function<void ()(void)>::~function((std::_Function_base *)v7);
v5 = 0;
for ( i = v9; i; i = *(_QWORD *)(i + 40) )
{
if ( !(unsigned int)bind(v15, *(_QWORD *)(i + 24), *(unsigned int *)(i + 16)) )
{
v5 = 1;
break;
}
}
v16 = v5;
httplib::detail::scope_exit::~scope_exit((httplib::detail::scope_exit *)v8);
}
return v16 & 1;
}
| bind_ip_address:
SUB RSP,0xc8
MOV dword ptr [RSP + 0xc0],EDI
MOV qword ptr [RSP + 0xb8],RSI
LEA RDI,[RSP + 0x88]
XOR ESI,ESI
MOV EDX,0x30
CALL 0x0010b420
MOV dword ptr [RSP + 0x8c],0x0
MOV dword ptr [RSP + 0x90],0x1
MOV dword ptr [RSP + 0x94],0x0
MOV RDI,qword ptr [RSP + 0xb8]
CALL 0x0010b2c0
MOV RDI,RAX
LEA RSI,[0x1cde82]
LEA RDX,[RSP + 0x88]
LEA RCX,[RSP + 0x80]
CALL 0x0010ba20
CMP EAX,0x0
JZ 0x00169a69
MOV byte ptr [RSP + 0xc7],0x0
JMP 0x00169b35
LAB_00169a69:
LEA RAX,[RSP + 0x80]
MOV qword ptr [RSP + 0x30],RAX
LEA RDI,[RSP + 0x38]
MOV qword ptr [RSP + 0x8],RDI
LEA RSI,[RSP + 0x30]
CALL 0x0016a290
MOV RSI,qword ptr [RSP + 0x8]
LAB_00169a8f:
LEA RDI,[RSP + 0x58]
CALL 0x00169410
LAB_00169a99:
JMP 0x00169a9b
LAB_00169a9b:
LEA RDI,[RSP + 0x38]
CALL 0x00127140
MOV byte ptr [RSP + 0x23],0x0
MOV RAX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0x18],RAX
LAB_00169ab7:
CMP qword ptr [RSP + 0x18],0x0
JZ 0x00169b1e
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x10],RAX
MOV EDI,dword ptr [RSP + 0xc0]
MOV RAX,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RSP + 0x10]
MOV EDX,dword ptr [RAX + 0x10]
CALL 0x0010b0e0
CMP EAX,0x0
JNZ 0x00169b0c
MOV byte ptr [RSP + 0x23],0x1
JMP 0x00169b1e
LAB_00169b0c:
JMP 0x00169b0e
LAB_00169b0e:
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RSP + 0x18],RAX
JMP 0x00169ab7
LAB_00169b1e:
MOV AL,byte ptr [RSP + 0x23]
AND AL,0x1
MOV byte ptr [RSP + 0xc7],AL
LEA RDI,[RSP + 0x58]
CALL 0x00169480
LAB_00169b35:
MOV AL,byte ptr [RSP + 0xc7]
AND AL,0x1
ADD RSP,0xc8
RET
|
/* httplib::detail::bind_ip_address(int, std::__cxx11::string const&) */
ulong httplib::detail::bind_ip_address(int param_1,string *param_2)
{
int iVar1;
char *__name;
int4 extraout_var;
int8 uVar2;
addrinfo *local_b0;
int1 local_a5;
addrinfo **local_98;
function<void()> local_90 [32];
scope_exit local_70 [40];
addrinfo *local_48;
addrinfo local_40;
string *local_10;
int local_8;
int1 local_1;
local_10 = param_2;
local_8 = param_1;
memset(&local_40,0,0x30);
local_40.ai_family = 0;
local_40.ai_socktype = 1;
local_40.ai_protocol = 0;
__name = (char *)std::__cxx11::string::c_str();
iVar1 = getaddrinfo(__name,"0",&local_40,&local_48);
uVar2 = CONCAT44(extraout_var,iVar1);
if (iVar1 == 0) {
local_98 = &local_48;
std::function<void()>::
function<httplib::detail::bind_ip_address(int,std::__cxx11::string_const&)::_lambda()_1_,void>
(local_90,(_lambda___1_ *)&local_98);
/* try { // try from 00169a8f to 00169a98 has its CatchHandler @ 00169af2 */
scope_exit::scope_exit(local_70,(function *)local_90);
std::function<void()>::~function(local_90);
local_a5 = 0;
for (local_b0 = local_48; local_b0 != (addrinfo *)0x0; local_b0 = local_b0->ai_next) {
iVar1 = bind(local_8,local_b0->ai_addr,local_b0->ai_addrlen);
if (iVar1 == 0) {
local_a5 = 1;
break;
}
}
local_1 = local_a5;
uVar2 = scope_exit::~scope_exit(local_70);
}
else {
local_1 = 0;
}
return CONCAT71((int7)((ulong)uVar2 >> 8),local_1) & 0xffffffffffffff01;
}
| |
26,461 | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(char*, int&, int&, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp) | monkey531[P]llama/common/json.hpp | inline void grisu2(char* buf, int& len, int& decimal_exponent,
diyfp m_minus, diyfp v, diyfp m_plus)
{
JSON_ASSERT(m_plus.e == m_minus.e);
JSON_ASSERT(m_plus.e == v.e);
// --------(-----------------------+-----------------------)-------- (A)
// m- v m+
//
// --------------------(-----------+-----------------------)-------- (B)
// m- v m+
//
// First scale v (and m- and m+) such that the exponent is in the range
// [alpha, gamma].
const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k
// The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma]
const diyfp w = diyfp::mul(v, c_minus_k);
const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
const diyfp w_plus = diyfp::mul(m_plus, c_minus_k);
// ----(---+---)---------------(---+---)---------------(---+---)----
// w- w w+
// = c*m- = c*v = c*m+
//
// diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and
// w+ are now off by a small amount.
// In fact:
//
// w - v * 10^k < 1 ulp
//
// To account for this inaccuracy, add resp. subtract 1 ulp.
//
// --------+---[---------------(---+---)---------------]---+--------
// w- M- w M+ w+
//
// Now any number in [M-, M+] (bounds included) will round to w when input,
// regardless of how the input rounding algorithm breaks ties.
//
// And digit_gen generates the shortest possible such number in [M-, M+].
// Note that this does not mean that Grisu2 always generates the shortest
// possible number in the interval (m-, m+).
const diyfp M_minus(w_minus.f + 1, w_minus.e);
const diyfp M_plus (w_plus.f - 1, w_plus.e );
decimal_exponent = -cached.k; // = -(-k) = k
grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
} | O2 | cpp | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(char*, int&, int&, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, 0x58(%rsp)
movl %r8d, 0x60(%rsp)
cmpl %r8d, 0xc8(%rsp)
jne 0x88960
movq %rdi, 0x20(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
leaq 0xb0(%rsp), %r13
cmpl %r8d, 0x8(%r13)
jne 0x8897c
movl %r8d, %edi
callq 0x88a35
movq %rdx, %r12
leaq 0x68(%rsp), %r14
movq %rax, (%r14)
movl %r12d, 0x8(%r14)
movq %r13, %rdi
movq %r14, %rsi
callq 0x88b6a
movq %rax, %r15
movl %edx, %ebx
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
callq 0x88b6a
movq %rax, %r13
movl %edx, %ebp
leaq 0xc0(%rsp), %rdi
movq %r14, %rsi
callq 0x88b6a
incq %r13
decq %rax
shrq $0x20, %r12
negl %r12d
movq 0x30(%rsp), %rcx
movl %r12d, (%rcx)
movq %r15, 0x48(%rsp)
movl %ebx, 0x50(%rsp)
movq %rax, 0x38(%rsp)
movl %edx, 0x40(%rsp)
movups 0x38(%rsp), %xmm0
movups %xmm0, 0x10(%rsp)
movups 0x48(%rsp), %xmm0
movups %xmm0, (%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq %rcx, %rdx
movq %r13, %rcx
movl %ebp, %r8d
callq 0x88bc6
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x292d5(%rip), %rdi # 0xb1c3c
leaq 0x29318(%rip), %rdx # 0xb1c86
leaq 0x2eb00(%rip), %rcx # 0xb7475
movl $0x454b, %esi # imm = 0x454B
jmp 0x88996
leaq 0x292b9(%rip), %rdi # 0xb1c3c
leaq 0x292fc(%rip), %rdx # 0xb1c86
leaq 0x2eafa(%rip), %rcx # 0xb748b
movl $0x454c, %esi # imm = 0x454C
xorl %eax, %eax
callq 0x24ea0
nop
| _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl6grisu2EPcRiS4_NS2_5diyfpES5_S5_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov [rsp+0A8h+var_50], rcx
mov [rsp+0A8h+var_48], r8d
cmp [rsp+0A8h+arg_18], r8d
jnz loc_88960
mov [rsp+0A8h+var_88], rdi
mov [rsp+0A8h+var_80], rsi
mov [rsp+0A8h+var_78], rdx
lea r13, [rsp+0A8h+arg_0]
cmp [r13+8], r8d
jnz loc_8897C
mov edi, r8d; this
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl36get_cached_power_for_binary_exponentEi; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::get_cached_power_for_binary_exponent(int)
mov r12, rdx
lea r14, [rsp+0A8h+var_40]
mov [r14], rax
mov [r14+8], r12d
mov rdi, r13
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp3mulERKS3_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&)
mov r15, rax
mov ebx, edx
lea rdi, [rsp+0A8h+var_50]
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp3mulERKS3_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&)
mov r13, rax
mov ebp, edx
lea rdi, [rsp+0A8h+arg_10]
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp3mulERKS3_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&)
inc r13
dec rax
shr r12, 20h
neg r12d
mov rcx, [rsp+0A8h+var_78]
mov [rcx], r12d
mov qword ptr [rsp+0A8h+var_60], r15
mov dword ptr [rsp+0A8h+var_60+8], ebx
mov qword ptr [rsp+0A8h+var_70], rax
mov dword ptr [rsp+0A8h+var_70+8], edx
movups xmm0, [rsp+0A8h+var_70]
movups [rsp+0A8h+var_98], xmm0
movups xmm0, [rsp+0A8h+var_60]
movups [rsp+0A8h+var_A8], xmm0
mov rdi, [rsp+0A8h+var_88]
mov rsi, [rsp+0A8h+var_80]
mov rdx, rcx
mov rcx, r13
mov r8d, ebp
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl16grisu2_digit_genEPcRiS4_NS2_5diyfpES5_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen(char *,int &,int &,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp)
add rsp, 78h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_88960:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aMPlusEMMinusE; "m_plus.e == m_minus.e"
mov esi, 454Bh
jmp short loc_88996
loc_8897C:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aMPlusEVE; "m_plus.e == v.e"
mov esi, 454Ch
loc_88996:
xor eax, eax
call _ggml_abort
nop
| long long nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(
int a1,
int a2,
_DWORD *a3,
long long a4,
unsigned int a5,
long long a6,
char a7,
int a8,
char a9,
int a10)
{
long long cached_power_for_binary_exponent; // rax
int v11; // rdx^4
int v12; // r12^4
int v13; // edx
char v14; // r15
int v15; // edx
int v16; // ebx
int v17; // r13d
int v18; // edx
int v19; // ebp
char v20; // al
int v21; // edx
int v22; // r9d
long long v25; // [rsp+58h] [rbp-50h] BYREF
unsigned int v26; // [rsp+60h] [rbp-48h]
long long v27; // [rsp+68h] [rbp-40h] BYREF
int v28; // [rsp+70h] [rbp-38h]
v25 = a4;
v26 = a5;
if ( a10 == a5 )
{
if ( a8 == a5 )
{
cached_power_for_binary_exponent = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::get_cached_power_for_binary_exponent(
(nlohmann::json_abi_v3_11_3::detail::dtoa_impl *)a5,
a2);
v12 = v11;
v27 = cached_power_for_binary_exponent;
v28 = v13;
v14 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(&a7, &v27);
v16 = v15;
v17 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(&v25, &v27);
v19 = v18;
v20 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(&a9, &v27);
*a3 = -v12;
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen(
a1,
a2,
(_DWORD)a3,
v17 + 1,
v19,
v22,
v14,
v16,
v20 - 1,
v21);
}
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17740LL,
"GGML_ASSERT(%s) failed",
"m_plus.e == v.e");
}
else
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17739LL,
"GGML_ASSERT(%s) failed",
"m_plus.e == m_minus.e");
}
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp");
}
| grisu2:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV qword ptr [RSP + 0x58],RCX
MOV dword ptr [RSP + 0x60],R8D
CMP dword ptr [RSP + 0xc8],R8D
JNZ 0x00188960
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x30],RDX
LEA R13,[RSP + 0xb0]
CMP dword ptr [R13 + 0x8],R8D
JNZ 0x0018897c
MOV EDI,R8D
CALL 0x00188a35
MOV R12,RDX
LEA R14,[RSP + 0x68]
MOV qword ptr [R14],RAX
MOV dword ptr [R14 + 0x8],R12D
MOV RDI,R13
MOV RSI,R14
CALL 0x00188b6a
MOV R15,RAX
MOV EBX,EDX
LEA RDI,[RSP + 0x58]
MOV RSI,R14
CALL 0x00188b6a
MOV R13,RAX
MOV EBP,EDX
LEA RDI,[RSP + 0xc0]
MOV RSI,R14
CALL 0x00188b6a
INC R13
DEC RAX
SHR R12,0x20
NEG R12D
MOV RCX,qword ptr [RSP + 0x30]
MOV dword ptr [RCX],R12D
MOV qword ptr [RSP + 0x48],R15
MOV dword ptr [RSP + 0x50],EBX
MOV qword ptr [RSP + 0x38],RAX
MOV dword ptr [RSP + 0x40],EDX
MOVUPS XMM0,xmmword ptr [RSP + 0x38]
MOVUPS xmmword ptr [RSP + 0x10],XMM0
MOVUPS XMM0,xmmword ptr [RSP + 0x48]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,RCX
MOV RCX,R13
MOV R8D,EBP
CALL 0x00188bc6
ADD RSP,0x78
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00188960:
LEA RDI,[0x1b1c3c]
LEA RDX,[0x1b1c86]
LEA RCX,[0x1b7475]
MOV ESI,0x454b
JMP 0x00188996
LAB_0018897c:
LEA RDI,[0x1b1c3c]
LEA RDX,[0x1b1c86]
LEA RCX,[0x1b748b]
MOV ESI,0x454c
LAB_00188996:
XOR EAX,EAX
CALL 0x00124ea0
|
/* nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(char*, int&, int&,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp) */
void nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2
(int8 param_1,int8 param_2,int *param_3,int8 param_4,int param_5,
int8 param_6,int8 param_7,int param_8,int8 param_9,int param_10)
{
int4 uVar1;
char *pcVar2;
int4 extraout_EDX;
int8 uVar3;
int1 auVar4 [16];
int1 auVar5 [12];
int1 auVar6 [12];
int4 uStack_64;
int8 local_50;
int local_48;
int8 local_40;
int4 local_38;
local_50 = param_4;
local_48 = param_5;
if (param_10 == param_5) {
if (param_8 == param_5) {
auVar4 = get_cached_power_for_binary_exponent(param_5);
local_40 = auVar4._0_8_;
local_38 = auVar4._8_4_;
uVar1 = diyfp::mul((diyfp *)¶m_7,(diyfp *)&local_40);
auVar5 = diyfp::mul((diyfp *)&local_50,(diyfp *)&local_40);
auVar6 = diyfp::mul((diyfp *)¶m_9,(diyfp *)&local_40);
*param_3 = -auVar4._12_4_;
grisu2_digit_gen(param_1,param_2,param_3,auVar5._0_8_ + 1,auVar5._8_4_,param_6,uVar1,
extraout_EDX,auVar6._0_8_ + -1,CONCAT44(uStack_64,auVar6._8_4_));
return;
}
pcVar2 = "m_plus.e == v.e";
uVar3 = 0x454c;
}
else {
pcVar2 = "m_plus.e == m_minus.e";
uVar3 = 0x454b;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",uVar3,
"GGML_ASSERT(%s) failed",pcVar2);
}
| |
26,462 | ma_ft_cmp | eloqsql/storage/maria/ma_ft_update.c | int _ma_ft_cmp(MARIA_HA *info, uint keynr, const uchar *rec1, const uchar *rec2)
{
FT_SEG_ITERATOR ftsi1, ftsi2;
CHARSET_INFO *cs=info->s->keyinfo[keynr].seg->charset;
DBUG_ENTER("_ma_ft_cmp");
_ma_ft_segiterator_init(info, keynr, rec1, &ftsi1);
_ma_ft_segiterator_init(info, keynr, rec2, &ftsi2);
while (_ma_ft_segiterator(&ftsi1) && _ma_ft_segiterator(&ftsi2))
{
if ((ftsi1.pos != ftsi2.pos) &&
(!ftsi1.pos || !ftsi2.pos ||
ha_compare_text(cs, ftsi1.pos,ftsi1.len,
ftsi2.pos,ftsi2.len,0)))
DBUG_RETURN(THOSE_TWO_DAMN_KEYS_ARE_REALLY_DIFFERENT);
}
DBUG_RETURN(GEE_THEY_ARE_ABSOLUTELY_IDENTICAL);
} | O0 | c | ma_ft_cmp:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x570(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x118, %rcx, %rcx # imm = 0x118
addq %rcx, %rax
movq 0xc0(%rax), %rax
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
leaq -0x48(%rbp), %rcx
callq 0x791f0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x28(%rbp), %rdx
leaq -0x68(%rbp), %rcx
callq 0x791f0
leaq -0x48(%rbp), %rdi
callq 0x792c0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x71(%rbp)
je 0x796b2
leaq -0x68(%rbp), %rdi
callq 0x792c0
cmpl $0x0, %eax
setne %al
movb %al, -0x71(%rbp)
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x796bb
jmp 0x79704
movq -0x30(%rbp), %rax
cmpq -0x50(%rbp), %rax
je 0x79702
cmpq $0x0, -0x30(%rbp)
je 0x796f7
cmpq $0x0, -0x50(%rbp)
je 0x796f7
movq -0x70(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x44(%rbp), %eax
movl %eax, %edx
movq -0x50(%rbp), %rcx
movl -0x64(%rbp), %eax
movl %eax, %r8d
xorl %r9d, %r9d
callq 0xff060
cmpl $0x0, %eax
je 0x79702
jmp 0x796f9
movl $0x1, -0x4(%rbp)
jmp 0x7970d
jmp 0x7968b
jmp 0x79706
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
| _ma_ft_cmp:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+570h]
mov ecx, [rbp+var_14]
imul rcx, 118h
add rax, rcx
mov rax, [rax+0C0h]
mov rax, [rax]
mov [rbp+var_70], rax
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
mov rdx, [rbp+var_20]
lea rcx, [rbp+var_48]
call _ma_ft_segiterator_init
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
mov rdx, [rbp+var_28]
lea rcx, [rbp+var_68]
call _ma_ft_segiterator_init
loc_7968B:
lea rdi, [rbp+var_48]
call _ma_ft_segiterator
mov ecx, eax
xor eax, eax
cmp ecx, 0
mov [rbp+var_71], al
jz short loc_796B2
lea rdi, [rbp+var_68]
call _ma_ft_segiterator
cmp eax, 0
setnz al
mov [rbp+var_71], al
loc_796B2:
mov al, [rbp+var_71]
test al, 1
jnz short loc_796BB
jmp short loc_79704
loc_796BB:
mov rax, [rbp+var_30]
cmp rax, [rbp+var_50]
jz short loc_79702
cmp [rbp+var_30], 0
jz short loc_796F7
cmp [rbp+var_50], 0
jz short loc_796F7
mov rdi, [rbp+var_70]
mov rsi, [rbp+var_30]
mov eax, [rbp+var_44]
mov edx, eax
mov rcx, [rbp+var_50]
mov eax, [rbp+var_64]
mov r8d, eax
xor r9d, r9d
call ha_compare_text
cmp eax, 0
jz short loc_79702
loc_796F7:
jmp short $+2
loc_796F9:
mov [rbp+var_4], 1
jmp short loc_7970D
loc_79702:
jmp short loc_7968B
loc_79704:
jmp short $+2
loc_79706:
mov [rbp+var_4], 0
loc_7970D:
mov eax, [rbp+var_4]
add rsp, 80h
pop rbp
retn
| long long ma_ft_cmp(long long a1, unsigned int a2, long long a3, long long a4)
{
bool v5; // [rsp+Fh] [rbp-71h]
long long v6; // [rsp+10h] [rbp-70h]
_BYTE v7[4]; // [rsp+18h] [rbp-68h] BYREF
unsigned int v8; // [rsp+1Ch] [rbp-64h]
long long v9; // [rsp+30h] [rbp-50h]
_BYTE v10[4]; // [rsp+38h] [rbp-48h] BYREF
unsigned int v11; // [rsp+3Ch] [rbp-44h]
long long v12; // [rsp+50h] [rbp-30h]
long long v13; // [rsp+58h] [rbp-28h]
long long v14; // [rsp+60h] [rbp-20h]
unsigned int v15; // [rsp+6Ch] [rbp-14h]
long long v16; // [rsp+70h] [rbp-10h]
v16 = a1;
v15 = a2;
v14 = a3;
v13 = a4;
v6 = **(_QWORD **)(280LL * a2 + *(_QWORD *)(*(_QWORD *)a1 + 1392LL) + 192);
ma_ft_segiterator_init(a1, a2, a3, (long long)v10);
ma_ft_segiterator_init(v16, v15, v13, (long long)v7);
while ( 1 )
{
v5 = 0;
if ( (unsigned int)ma_ft_segiterator((long long)v10) )
v5 = (unsigned int)ma_ft_segiterator((long long)v7) != 0;
if ( !v5 )
break;
if ( v12 != v9 && (!v12 || !v9 || (unsigned int)ha_compare_text(v6, v12, v11, v9, v8, 0LL)) )
return 1;
}
return 0;
}
| _ma_ft_cmp:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x570]
MOV ECX,dword ptr [RBP + -0x14]
IMUL RCX,RCX,0x118
ADD RAX,RCX
MOV RAX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x70],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
MOV RDX,qword ptr [RBP + -0x20]
LEA RCX,[RBP + -0x48]
CALL 0x001791f0
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
MOV RDX,qword ptr [RBP + -0x28]
LEA RCX,[RBP + -0x68]
CALL 0x001791f0
LAB_0017968b:
LEA RDI,[RBP + -0x48]
CALL 0x001792c0
MOV ECX,EAX
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x71],AL
JZ 0x001796b2
LEA RDI,[RBP + -0x68]
CALL 0x001792c0
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x71],AL
LAB_001796b2:
MOV AL,byte ptr [RBP + -0x71]
TEST AL,0x1
JNZ 0x001796bb
JMP 0x00179704
LAB_001796bb:
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x50]
JZ 0x00179702
CMP qword ptr [RBP + -0x30],0x0
JZ 0x001796f7
CMP qword ptr [RBP + -0x50],0x0
JZ 0x001796f7
MOV RDI,qword ptr [RBP + -0x70]
MOV RSI,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RBP + -0x44]
MOV EDX,EAX
MOV RCX,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RBP + -0x64]
MOV R8D,EAX
XOR R9D,R9D
CALL 0x001ff060
CMP EAX,0x0
JZ 0x00179702
LAB_001796f7:
JMP 0x001796f9
LAB_001796f9:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0017970d
LAB_00179702:
JMP 0x0017968b
LAB_00179704:
JMP 0x00179706
LAB_00179706:
MOV dword ptr [RBP + -0x4],0x0
LAB_0017970d:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x80
POP RBP
RET
|
int4 _ma_ft_cmp(long *param_1,uint param_2,int8 param_3,int8 param_4)
{
int8 uVar1;
int iVar2;
bool bVar3;
int1 local_70 [4];
int4 local_6c;
long local_58;
int1 local_50 [4];
int4 local_4c;
long local_38;
int8 local_30;
int8 local_28;
uint local_1c;
long *local_18;
uVar1 = **(int8 **)(*(long *)(*param_1 + 0x570) + (ulong)param_2 * 0x118 + 0xc0);
local_30 = param_4;
local_28 = param_3;
local_1c = param_2;
local_18 = param_1;
_ma_ft_segiterator_init(param_1,param_2,param_3,local_50);
_ma_ft_segiterator_init(local_18,local_1c,local_30,local_70);
while( true ) {
iVar2 = _ma_ft_segiterator(local_50);
bVar3 = false;
if (iVar2 != 0) {
iVar2 = _ma_ft_segiterator(local_70);
bVar3 = iVar2 != 0;
}
if (!bVar3) break;
if ((local_38 != local_58) &&
(((local_38 == 0 || (local_58 == 0)) ||
(iVar2 = ha_compare_text(uVar1,local_38,local_4c,local_58,local_6c,0), iVar2 != 0)))) {
return 1;
}
}
return 0;
}
| |
26,463 | bool minja::Value::get<bool>() const | llama.cpp/common/minja/minja.hpp | T get() const {
if (is_primitive()) return primitive_.get<T>();
throw std::runtime_error("get<T> not defined for this value type: " + dump());
} | O3 | cpp | bool minja::Value::get<bool>() const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
jne 0xe4276
cmpq $0x0, 0x20(%r14)
jne 0xe4276
cmpq $0x0, 0x30(%r14)
jne 0xe4276
addq $0x40, %r14
leaq 0x20(%rsp), %rbx
movb $0x0, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe45ff
movb (%rbx), %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x23850
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0xdb44c
leaq 0x62aed(%rip), %rsi # 0x146d89
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xd4cec
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x23590
xorl %ebp, %ebp
movq 0xaacfe(%rip), %rsi # 0x18efc0
movq 0xaacb7(%rip), %rdx # 0x18ef80
movq %rbx, %rdi
callq 0x23e00
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe42ef
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x231f0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe430a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x231f0
testb %bpl, %bpl
jne 0xe4334
jmp 0xe433c
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe4334
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x231f0
jmp 0xe4334
movq %rax, %r14
movq %rbx, %rdi
callq 0x24440
movq %r14, %rdi
callq 0x23ee0
| _ZNK5minja5Value3getIbEET_v:
push rbp
push r14
push rbx
sub rsp, 40h
mov r14, rdi
cmp qword ptr [rdi+10h], 0
jnz short loc_E4276
cmp qword ptr [r14+20h], 0
jnz short loc_E4276
cmp qword ptr [r14+30h], 0
jnz short loc_E4276
add r14, 40h ; '@'
lea rbx, [rsp+58h+var_38]
mov byte ptr [rbx], 0
mov rdi, r14
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEEvRKT_RNSG_9boolean_tE; nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::boolean_t &)
mov al, [rbx]
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
loc_E4276:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, rsp
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aGetTNotDefined; "get<T> not defined for this value type:"...
lea rdi, [rsp+58h+var_38]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+58h+var_38]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+58h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_E42EF
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_E42EF:
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_E430A
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_E430A:
test bpl, bpl
jnz short loc_E4334
jmp short loc_E433C
mov r14, rax
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_E4334
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_E4334
mov r14, rax
loc_E4334:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_E433C:
mov rdi, r14
call __Unwind_Resume
| char minja::Value::get<bool>(_QWORD *a1)
{
void *exception; // rbx
_BYTE v3[16]; // [rsp+0h] [rbp-58h] BYREF
_QWORD v4[2]; // [rsp+20h] [rbp-38h] BYREF
if ( a1[2] || a1[4] || a1[6] )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v3, (long long)a1, 0xFFFFFFFF, 0);
std::operator+<char>(v4, (long long)"get<T> not defined for this value type: ", (long long)v3);
std::runtime_error::runtime_error(exception, v4);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
LOBYTE(v4[0]) = 0;
nlohmann::json_abi_v3_11_3::detail::from_json<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>>(
a1 + 8,
v4);
return v4[0];
}
| get<bool>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
CMP qword ptr [RDI + 0x10],0x0
JNZ 0x001e4276
CMP qword ptr [R14 + 0x20],0x0
JNZ 0x001e4276
CMP qword ptr [R14 + 0x30],0x0
JNZ 0x001e4276
ADD R14,0x40
LEA RBX,[RSP + 0x20]
MOV byte ptr [RBX],0x0
MOV RDI,R14
MOV RSI,RBX
CALL 0x001e45ff
MOV AL,byte ptr [RBX]
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
LAB_001e4276:
MOV EDI,0x10
CALL 0x00123850
MOV RBX,RAX
LAB_001e4283:
MOV RDI,RSP
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x001db44c
LAB_001e4295:
LEA RSI,[0x246d89]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x001d4cec
MOV BPL,0x1
LAB_001e42ac:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x00123590
XOR EBP,EBP
MOV RSI,qword ptr [0x0028efc0]
MOV RDX,qword ptr [0x0028ef80]
MOV RDI,RBX
CALL 0x00123e00
|
/* bool minja::Value::get<bool>() const */
bool __thiscall minja::Value::get<bool>(Value *this)
{
runtime_error *this_00;
int1 auStack_58 [32];
string local_38 [32];
if (((*(long *)(this + 0x10) == 0) && (*(long *)(this + 0x20) == 0)) &&
(*(long *)(this + 0x30) == 0)) {
local_38[0] = (string)0x0;
nlohmann::json_abi_v3_11_3::detail::
from_json<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>>
((basic_json *)(this + 0x40),local_38);
return (bool)local_38[0];
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001e4283 to 001e4294 has its CatchHandler @ 001e4331 */
dump_abi_cxx11_((int)auStack_58,SUB81(this,0));
/* try { // try from 001e4295 to 001e42a8 has its CatchHandler @ 001e4311 */
std::operator+((char *)local_38,(string *)"get<T> not defined for this value type: ");
/* try { // try from 001e42ac to 001e42d0 has its CatchHandler @ 001e42d1 */
std::runtime_error::runtime_error(this_00,local_38);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_0028efc0,PTR__runtime_error_0028ef80);
}
| |
26,464 | ma_checksum | eloqsql/storage/maria/ma_checksum.c | ha_checksum _ma_checksum(MARIA_HA *info, const uchar *record)
{
ha_checksum crc=0;
uint i,end;
MARIA_COLUMNDEF *base_column= info->s->columndef;
uint16 *column_nr= info->s->column_nr;
if (info->s->base.null_bytes)
crc= my_checksum(crc, record, info->s->base.null_bytes);
for (i= 0, end= info->s->base.fields ; i < end ; i++)
{
MARIA_COLUMNDEF *column= base_column + column_nr[i];
const uchar *pos;
ulong length;
if (record[column->null_pos] & column->null_bit)
continue; /* Null field */
pos= record + column->offset;
switch (column->type) {
case FIELD_BLOB:
{
uint blob_size_length= column->length- portable_sizeof_char_ptr;
length= _ma_calc_blob_length(blob_size_length, pos);
if (length)
{
memcpy((char**) &pos, pos + blob_size_length, sizeof(char*));
crc= my_checksum(crc, pos, length);
}
continue;
}
case FIELD_VARCHAR:
{
uint pack_length= column->fill_length;
if (pack_length == 1)
length= (ulong) *pos;
else
length= uint2korr(pos);
pos+= pack_length; /* Skip length information */
break;
}
default:
length= column->length;
break;
}
crc= my_checksum(crc, pos, length);
}
return crc;
} | O3 | c | ma_checksum:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq (%rdi), %rax
movq 0x588(%rax), %r13
movq 0x5a8(%rax), %r12
movl 0x3fc(%rax), %edx
testq %rdx, %rdx
je 0x69edc
movq %rdi, %r15
xorl %edi, %edi
movq %rbx, %rsi
callq 0xa7fe0
movl %eax, %edi
movq (%r15), %rax
jmp 0x69ede
xorl %edi, %edi
movl 0x3c8(%rax), %esi
testq %rsi, %rsi
je 0x69f9f
xorl %r14d, %r14d
movq %rsi, -0x38(%rbp)
movq %r12, -0x40(%rbp)
movzwl (%r12,%r14,2), %eax
imulq $0x38, %rax, %rax
movzwl 0xe(%r13,%rax), %ecx
movb 0x12(%r13,%rax), %dl
testb %dl, (%rbx,%rcx)
jne 0x69f88
addq %r13, %rax
movl (%rax), %ecx
movl 0x4(%rax), %r15d
addq %rbx, %r15
cmpl $0x8, %ecx
je 0x69f5d
cmpl $0x4, %ecx
jne 0x69f6d
movl %edi, -0x2c(%rbp)
movzwl 0x8(%rax), %r12d
addl $-0x8, %r12d
movl %r12d, %edi
movq %r15, %rsi
callq 0x3e2cf
testq %rax, %rax
je 0x69f96
movl %r12d, %ecx
movq (%r15,%rcx), %rsi
movl -0x2c(%rbp), %edi
movq %rax, %rdx
callq 0xa7fe0
movl %eax, %edi
movq -0x40(%rbp), %r12
jmp 0x69f84
movzwl 0xc(%rax), %eax
cmpq $0x1, %rax
jne 0x69f73
movzbl (%r15), %edx
jmp 0x69f77
movzwl 0x8(%rax), %edx
jmp 0x69f7a
movzwl (%r15), %edx
addq %rax, %r15
movq %r15, %rsi
callq 0xa7fe0
movl %eax, %edi
movq -0x38(%rbp), %rsi
incq %r14
cmpq %r14, %rsi
jne 0x69ef8
jmp 0x69f9f
movq -0x40(%rbp), %r12
movl -0x2c(%rbp), %edi
jmp 0x69f84
movl %edi, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ma_checksum:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rsi
mov rax, [rdi]
mov r13, [rax+588h]
mov r12, [rax+5A8h]
mov edx, [rax+3FCh]
test rdx, rdx
jz short loc_69EDC
mov r15, rdi
xor edi, edi
mov rsi, rbx
call my_checksum
mov edi, eax
mov rax, [r15]
jmp short loc_69EDE
loc_69EDC:
xor edi, edi
loc_69EDE:
mov esi, [rax+3C8h]
test rsi, rsi
jz loc_69F9F
xor r14d, r14d
mov [rbp+var_38], rsi
mov [rbp+var_40], r12
loc_69EF8:
movzx eax, word ptr [r12+r14*2]
imul rax, 38h ; '8'
movzx ecx, word ptr [r13+rax+0Eh]
mov dl, [r13+rax+12h]
test [rbx+rcx], dl
jnz short loc_69F88
add rax, r13
mov ecx, [rax]
mov r15d, [rax+4]
add r15, rbx
cmp ecx, 8
jz short loc_69F5D
cmp ecx, 4
jnz short loc_69F6D
mov [rbp+var_2C], edi
movzx r12d, word ptr [rax+8]
add r12d, 0FFFFFFF8h
mov edi, r12d
mov rsi, r15
call _ma_calc_blob_length
test rax, rax
jz short loc_69F96
mov ecx, r12d
mov rsi, [r15+rcx]
mov edi, [rbp+var_2C]
mov rdx, rax
call my_checksum
mov edi, eax
mov r12, [rbp+var_40]
jmp short loc_69F84
loc_69F5D:
movzx eax, word ptr [rax+0Ch]
cmp rax, 1
jnz short loc_69F73
movzx edx, byte ptr [r15]
jmp short loc_69F77
loc_69F6D:
movzx edx, word ptr [rax+8]
jmp short loc_69F7A
loc_69F73:
movzx edx, word ptr [r15]
loc_69F77:
add r15, rax
loc_69F7A:
mov rsi, r15
call my_checksum
mov edi, eax
loc_69F84:
mov rsi, [rbp+var_38]
loc_69F88:
inc r14
cmp rsi, r14
jnz loc_69EF8
jmp short loc_69F9F
loc_69F96:
mov r12, [rbp+var_40]
mov edi, [rbp+var_2C]
jmp short loc_69F84
loc_69F9F:
mov eax, edi
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ma_checksum(long long *a1, long long a2)
{
long long v3; // rax
long long v4; // r13
long long v5; // r12
long long v7; // rdi
long long v8; // rsi
long long v9; // r14
long long v10; // rax
long long v11; // rax
unsigned __int8 *v12; // r15
unsigned int v13; // r12d
unsigned long long v14; // rax
long long v15; // rax
long long v16; // rdx
long long v18; // [rsp+0h] [rbp-40h]
long long v19; // [rsp+8h] [rbp-38h]
v3 = *a1;
v4 = *(_QWORD *)(*a1 + 1416);
v5 = *(_QWORD *)(*a1 + 1448);
if ( *(_DWORD *)(*a1 + 1020) )
{
v7 = (unsigned int)my_checksum(0LL, a2, *(unsigned int *)(*a1 + 1020));
v3 = *a1;
}
else
{
v7 = 0LL;
}
v8 = *(unsigned int *)(v3 + 968);
if ( *(_DWORD *)(v3 + 968) )
{
v9 = 0LL;
v19 = *(unsigned int *)(v3 + 968);
v18 = v5;
while ( 1 )
{
v10 = 56LL * *(unsigned __int16 *)(v5 + 2 * v9);
if ( (*(_BYTE *)(v4 + v10 + 18) & *(_BYTE *)(a2 + *(unsigned __int16 *)(v4 + v10 + 14))) == 0 )
break;
LABEL_18:
if ( v8 == ++v9 )
return (unsigned int)v7;
}
v11 = v4 + v10;
v12 = (unsigned __int8 *)(a2 + *(unsigned int *)(v11 + 4));
if ( *(_DWORD *)v11 == 8 )
{
v15 = *(unsigned __int16 *)(v11 + 12);
if ( v15 == 1 )
v16 = *v12;
else
v16 = *(unsigned __int16 *)v12;
v12 += v15;
}
else
{
if ( *(_DWORD *)v11 == 4 )
{
v13 = *(unsigned __int16 *)(v11 + 8) - 8;
v14 = ma_calc_blob_length(v13, v12);
if ( v14 )
{
v7 = (unsigned int)my_checksum((unsigned int)v7, *(_QWORD *)&v12[v13], v14);
v5 = v18;
}
else
{
v5 = v18;
v7 = (unsigned int)v7;
}
goto LABEL_17;
}
v16 = *(unsigned __int16 *)(v11 + 8);
}
LODWORD(v7) = my_checksum(v7, v12, v16);
LABEL_17:
v8 = v19;
goto LABEL_18;
}
return (unsigned int)v7;
}
| _ma_checksum:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RSI
MOV RAX,qword ptr [RDI]
MOV R13,qword ptr [RAX + 0x588]
MOV R12,qword ptr [RAX + 0x5a8]
MOV EDX,dword ptr [RAX + 0x3fc]
TEST RDX,RDX
JZ 0x00169edc
MOV R15,RDI
XOR EDI,EDI
MOV RSI,RBX
CALL 0x001a7fe0
MOV EDI,EAX
MOV RAX,qword ptr [R15]
JMP 0x00169ede
LAB_00169edc:
XOR EDI,EDI
LAB_00169ede:
MOV ESI,dword ptr [RAX + 0x3c8]
TEST RSI,RSI
JZ 0x00169f9f
XOR R14D,R14D
MOV qword ptr [RBP + -0x38],RSI
MOV qword ptr [RBP + -0x40],R12
LAB_00169ef8:
MOVZX EAX,word ptr [R12 + R14*0x2]
IMUL RAX,RAX,0x38
MOVZX ECX,word ptr [R13 + RAX*0x1 + 0xe]
MOV DL,byte ptr [R13 + RAX*0x1 + 0x12]
TEST byte ptr [RBX + RCX*0x1],DL
JNZ 0x00169f88
ADD RAX,R13
MOV ECX,dword ptr [RAX]
MOV R15D,dword ptr [RAX + 0x4]
ADD R15,RBX
CMP ECX,0x8
JZ 0x00169f5d
CMP ECX,0x4
JNZ 0x00169f6d
MOV dword ptr [RBP + -0x2c],EDI
MOVZX R12D,word ptr [RAX + 0x8]
ADD R12D,-0x8
MOV EDI,R12D
MOV RSI,R15
CALL 0x0013e2cf
TEST RAX,RAX
JZ 0x00169f96
MOV ECX,R12D
MOV RSI,qword ptr [R15 + RCX*0x1]
MOV EDI,dword ptr [RBP + -0x2c]
MOV RDX,RAX
CALL 0x001a7fe0
MOV EDI,EAX
MOV R12,qword ptr [RBP + -0x40]
JMP 0x00169f84
LAB_00169f5d:
MOVZX EAX,word ptr [RAX + 0xc]
CMP RAX,0x1
JNZ 0x00169f73
MOVZX EDX,byte ptr [R15]
JMP 0x00169f77
LAB_00169f6d:
MOVZX EDX,word ptr [RAX + 0x8]
JMP 0x00169f7a
LAB_00169f73:
MOVZX EDX,word ptr [R15]
LAB_00169f77:
ADD R15,RAX
LAB_00169f7a:
MOV RSI,R15
CALL 0x001a7fe0
MOV EDI,EAX
LAB_00169f84:
MOV RSI,qword ptr [RBP + -0x38]
LAB_00169f88:
INC R14
CMP RSI,R14
JNZ 0x00169ef8
JMP 0x00169f9f
LAB_00169f96:
MOV R12,qword ptr [RBP + -0x40]
MOV EDI,dword ptr [RBP + -0x2c]
JMP 0x00169f84
LAB_00169f9f:
MOV EAX,EDI
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int4 _ma_checksum(long *param_1,long param_2)
{
uint uVar1;
long lVar2;
long lVar3;
int4 uVar4;
long lVar5;
int *piVar6;
ushort uVar7;
ulong uVar8;
ushort *puVar9;
lVar5 = *param_1;
lVar2 = *(long *)(lVar5 + 0x588);
lVar3 = *(long *)(lVar5 + 0x5a8);
if (*(int *)(lVar5 + 0x3fc) == 0) {
uVar4 = 0;
}
else {
uVar4 = my_checksum(0,param_2);
lVar5 = *param_1;
}
uVar1 = *(uint *)(lVar5 + 0x3c8);
if ((ulong)uVar1 != 0) {
uVar8 = 0;
do {
lVar5 = (ulong)*(ushort *)(lVar3 + uVar8 * 2) * 0x38;
if ((*(byte *)(param_2 + (ulong)*(ushort *)(lVar2 + 0xe + lVar5)) &
*(byte *)(lVar2 + 0x12 + lVar5)) == 0) {
piVar6 = (int *)(lVar5 + lVar2);
puVar9 = (ushort *)((ulong)(uint)piVar6[1] + param_2);
if (*piVar6 == 8) {
if ((ulong)*(ushort *)(piVar6 + 3) == 1) {
uVar7 = (ushort)(byte)*puVar9;
}
else {
uVar7 = *puVar9;
}
puVar9 = (ushort *)((long)puVar9 + (ulong)*(ushort *)(piVar6 + 3));
}
else {
if (*piVar6 == 4) {
uVar7 = *(ushort *)(piVar6 + 2);
lVar5 = _ma_calc_blob_length(uVar7 - 8,puVar9);
if (lVar5 != 0) {
uVar4 = my_checksum(uVar4,*(int8 *)((long)puVar9 + (ulong)(uVar7 - 8)),lVar5);
}
goto LAB_00169f88;
}
uVar7 = *(ushort *)(piVar6 + 2);
}
uVar4 = my_checksum(uVar4,puVar9,uVar7);
}
LAB_00169f88:
uVar8 = uVar8 + 1;
} while (uVar1 != uVar8);
}
return uVar4;
}
| |
26,465 | minja::Value::operator<(minja::Value const&) const | monkey531[P]llama/common/minja.hpp | bool operator<(const Value & other) const {
if (is_null())
throw std::runtime_error("Undefined value or reference");
if (is_number() && other.is_number()) return get<double>() < other.get<double>();
if (is_string() && other.is_string()) return get<std::string>() < other.get<std::string>();
throw std::runtime_error("Cannot compare values: " + dump() + " < " + other.dump());
} | O3 | cpp | minja::Value::operator<(minja::Value const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, 0x20(%rdi)
movb 0x40(%rdi), %al
jne 0xbae59
cmpq $0x0, 0x10(%r15)
jne 0xbae59
testb %al, %al
jne 0xbae59
cmpq $0x0, 0x30(%r15)
je 0xbaf5c
leal -0x5(%rax), %ecx
cmpb $0x2, %cl
ja 0xbae93
movb 0x40(%r14), %al
addb $-0x5, %al
cmpb $0x2, %al
ja 0xbaf8e
movq %r15, %rdi
callq 0xa9ec0
movsd %xmm0, 0x48(%rsp)
movq %r14, %rdi
callq 0xa9ec0
ucomisd 0x48(%rsp), %xmm0
seta %bl
jmp 0xbaf4a
cmpb $0x3, %al
jne 0xbaf8e
cmpb $0x3, 0x40(%r14)
jne 0xbaf8e
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0xaae5a
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xaae5a
movq 0x30(%rsp), %r15
movq 0x8(%rsp), %r14
movq 0x10(%rsp), %r12
cmpq %r15, %r12
movq %r15, %rdx
cmovbq %r12, %rdx
testq %rdx, %rdx
je 0xbaef1
movq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x1d530
movl %eax, %ebx
testl %eax, %eax
jne 0xbaf12
subq %r12, %r15
cmpq $-0x7fffffff, %r15 # imm = 0x80000001
movq $-0x80000000, %rbx # imm = 0x80000000
cmovgeq %r15, %rbx
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
cmpq %rax, %rbx
cmovgeq %rax, %rbx
leaq 0x18(%rsp), %rax
cmpq %rax, %r14
je 0xbaf2c
movq 0x18(%rsp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x1dc50
shrl $0x1f, %ebx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbaf4a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1dc50
movl %ebx, %eax
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x1d5b0
movq %rax, %rbx
leaq 0x5a376(%rip), %rsi # 0x1152e6
movq %rax, %rdi
callq 0x1d410
movq 0x9b069(%rip), %rsi # 0x155fe8
movq 0x9afd2(%rip), %rdx # 0x155f58
movq %rbx, %rdi
callq 0x1e5b0
movl $0x10, %edi
callq 0x1d5b0
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
movq %r15, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0xaa00c
leaq 0x5af20(%rip), %rsi # 0x115ed6
leaq 0x90(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x9c765
leaq 0x5af1f(%rip), %rsi # 0x115eee
leaq 0x90(%rsp), %rdi
callq 0x1e870
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xbaffd
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0xbb00a
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x70(%rsp), %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0xaa00c
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x9c7d5
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x1e430
xorl %ebp, %ebp
movq 0x9af85(%rip), %rsi # 0x155fe8
movq 0x9aeee(%rip), %rdx # 0x155f58
movq %rbx, %rdi
callq 0x1e5b0
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbb098
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1dc50
jmp 0xbb098
movq %rax, %r14
movb $0x1, %bpl
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbb0c1
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x1dc50
jmp 0xbb0c1
movq %rax, %r14
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xbb0e0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1dc50
jmp 0xbb0e0
movq %rax, %r14
movb $0x1, %bpl
leaq 0xa0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbb101
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x1dc50
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbb11c
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1dc50
testb %bpl, %bpl
jne 0xbb168
jmp 0xbb170
movq %rax, %r14
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbb168
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1dc50
jmp 0xbb168
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbb170
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1dc50
jmp 0xbb170
jmp 0xbb165
movq %rax, %r14
movq %rbx, %rdi
callq 0x1d8c0
movq %r14, %rdi
callq 0x1e660
| _ZNK5minja5ValueltERKS0_:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 0B0h
mov r14, rsi
mov r15, rdi
cmp qword ptr [rdi+20h], 0
mov al, [rdi+40h]
jnz short loc_BAE59
cmp qword ptr [r15+10h], 0
jnz short loc_BAE59
test al, al
jnz short loc_BAE59
cmp qword ptr [r15+30h], 0
jz loc_BAF5C
loc_BAE59:
lea ecx, [rax-5]
cmp cl, 2
ja short loc_BAE93
mov al, [r14+40h]
add al, 0FBh
cmp al, 2
ja loc_BAF8E
mov rdi, r15
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
movsd [rsp+0D8h+var_90], xmm0
mov rdi, r14
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
ucomisd xmm0, [rsp+0D8h+var_90]
setnbe bl
jmp loc_BAF4A
loc_BAE93:
cmp al, 3
jnz loc_BAF8E
cmp byte ptr [r14+40h], 3
jnz loc_BAF8E
lea rdi, [rsp+0D8h+var_B0]
mov rsi, r15
call _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v; minja::Value::get<std::string>(void)
lea rdi, [rsp+0D8h+var_D0]
mov rsi, r14
call _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v; minja::Value::get<std::string>(void)
mov r15, [rsp+0D8h+var_A8]
mov r14, [rsp+0D8h+var_D0]
mov r12, [rsp+0D8h+var_C8]
cmp r12, r15
mov rdx, r15
cmovb rdx, r12
test rdx, rdx
jz short loc_BAEF1
mov rdi, [rsp+0D8h+var_B0]
mov rsi, r14
call _memcmp
mov ebx, eax
test eax, eax
jnz short loc_BAF12
loc_BAEF1:
sub r15, r12
cmp r15, 0FFFFFFFF80000001h
mov rbx, 0FFFFFFFF80000000h
cmovge rbx, r15
mov eax, 7FFFFFFFh
cmp rbx, rax
cmovge rbx, rax
loc_BAF12:
lea rax, [rsp+0D8h+var_C0]
cmp r14, rax
jz short loc_BAF2C
mov rsi, [rsp+0D8h+var_C0]
inc rsi; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_BAF2C:
shr ebx, 1Fh
lea rax, [rsp+0D8h+var_A0]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BAF4A
mov rsi, [rsp+0D8h+var_A0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_BAF4A:
mov eax, ebx
add rsp, 0B0h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_BAF5C:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aUndefinedValue; "Undefined value or reference"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_BAF8E:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+0D8h+var_88]
mov rsi, r15
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aCannotCompareV; "Cannot compare values: "
lea rdi, [rsp+0D8h+var_48]
lea rdx, [rsp+0D8h+var_88]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
lea rsi, asc_115EEE; " < "
lea rdi, [rsp+0D8h+var_48]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea r15, [rsp+0D8h+var_C0]
mov [r15-10h], r15
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jnz short loc_BAFFD
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r15], xmm0
jmp short loc_BB00A
loc_BAFFD:
mov [rsp+0D8h+var_D0], rdx
mov rdx, [rcx]
mov [rsp+0D8h+var_C0], rdx
loc_BB00A:
mov rdx, [rax+8]
mov [rsp+0D8h+var_C8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
lea rdi, [rsp+0D8h+var_68]
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rdi, [rsp+0D8h+var_B0]
lea rsi, [rsp+0D8h+var_D0]
lea rdx, [rsp+0D8h+var_68]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
mov bpl, 1
lea rsi, [rsp+0D8h+var_B0]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+0D8h+var_A0]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BB098
mov rsi, [rsp+0D8h+var_A0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_BB098
mov r14, rax
mov bpl, 1
loc_BB098:
lea rax, [rsp+0D8h+var_58]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BB0C1
mov rsi, [rsp+0D8h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_BB0C1
mov r14, rax
mov bpl, 1
loc_BB0C1:
mov rdi, [rsp+0D8h+var_D0]; void *
cmp rdi, r15
jz short loc_BB0E0
mov rsi, [rsp+0D8h+var_C0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_BB0E0
mov r14, rax
mov bpl, 1
loc_BB0E0:
lea rax, [rsp+0D8h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BB101
mov rsi, [rsp+0D8h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_BB101:
lea rax, [rsp+0D8h+var_78]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BB11C
mov rsi, [rsp+0D8h+var_78]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_BB11C:
test bpl, bpl
jnz short loc_BB168
jmp short loc_BB170
mov r14, rax
lea rax, [rsp+0D8h+var_78]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BB168
mov rsi, [rsp+0D8h+var_78]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_BB168
mov r14, rax
lea rax, [rsp+0D8h+var_A0]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BB170
mov rsi, [rsp+0D8h+var_A0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_BB170
jmp short $+2
loc_BB165:
mov r14, rax
loc_BB168:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_BB170:
mov rdi, r14
call __Unwind_Resume
| long long minja::Value::operator<(long long a1, long long a2)
{
unsigned int v2; // ebx
char v3; // al
unsigned long long v4; // r15
__int128 *v5; // r14
unsigned long long v6; // r12
unsigned long long v7; // rdx
long long v8; // rbx
long long v9; // r15
std::runtime_error *exception; // rbx
void *v12; // rbx
long long v13; // rax
__int128 *v14; // rcx
void *v15; // [rsp+8h] [rbp-D0h] BYREF
unsigned long long v16; // [rsp+10h] [rbp-C8h]
__int128 v17; // [rsp+18h] [rbp-C0h] BYREF
long long *v18; // [rsp+28h] [rbp-B0h] BYREF
unsigned long long v19; // [rsp+30h] [rbp-A8h]
long long v20; // [rsp+38h] [rbp-A0h] BYREF
double v21; // [rsp+48h] [rbp-90h]
_BYTE v22[16]; // [rsp+50h] [rbp-88h] BYREF
_QWORD v23[2]; // [rsp+70h] [rbp-68h] BYREF
_BYTE v24[16]; // [rsp+90h] [rbp-48h] BYREF
v3 = *(_BYTE *)(a1 + 64);
if ( !*(_QWORD *)(a1 + 32) && !*(_QWORD *)(a1 + 16) && !v3 && !*(_QWORD *)(a1 + 48) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Undefined value or reference");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( (unsigned __int8)(v3 - 5) <= 2u )
{
if ( (unsigned __int8)(*(_BYTE *)(a2 + 64) - 5) <= 2u )
{
v21 = minja::Value::get<double>(a1);
LOBYTE(v2) = minja::Value::get<double>(a2) > v21;
return v2;
}
LABEL_24:
v12 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v22, a1, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v24, (long long)"Cannot compare values: ", (long long)v22);
v13 = std::string::append(v24, " < ");
v15 = &v17;
v14 = (__int128 *)(v13 + 16);
if ( *(_QWORD *)v13 == v13 + 16 )
{
v17 = *v14;
}
else
{
v15 = *(void **)v13;
*(_QWORD *)&v17 = *(_QWORD *)v14;
}
v16 = *(_QWORD *)(v13 + 8);
*(_QWORD *)v13 = v14;
*(_QWORD *)(v13 + 8) = 0LL;
*(_BYTE *)(v13 + 16) = 0;
minja::Value::dump[abi:cxx11]((long long)v23, a2, 0xFFFFFFFF, 0);
std::operator+<char>((long long)&v18, &v15, v23);
std::runtime_error::runtime_error(v12, &v18);
__cxa_throw(
v12,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( v3 != 3 || *(_BYTE *)(a2 + 64) != 3 )
goto LABEL_24;
minja::Value::get<std::string>((long long)&v18, (_QWORD *)a1);
minja::Value::get<std::string>((long long)&v15, (_QWORD *)a2);
v4 = v19;
v5 = (__int128 *)v15;
v6 = v16;
v7 = v19;
if ( v16 < v19 )
v7 = v16;
if ( !v7 || (LODWORD(v8) = memcmp(v18, v15), !(_DWORD)v8) )
{
v9 = v4 - v6;
v8 = 0xFFFFFFFF80000000LL;
if ( v9 >= -2147483647 )
v8 = v9;
if ( v8 >= 0x7FFFFFFF )
LODWORD(v8) = 0x7FFFFFFF;
}
if ( v5 != &v17 )
operator delete(v5, v17 + 1);
v2 = (unsigned int)v8 >> 31;
if ( v18 != &v20 )
operator delete(v18, v20 + 1);
return v2;
}
| operator<:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0xb0
MOV R14,RSI
MOV R15,RDI
CMP qword ptr [RDI + 0x20],0x0
MOV AL,byte ptr [RDI + 0x40]
JNZ 0x001bae59
CMP qword ptr [R15 + 0x10],0x0
JNZ 0x001bae59
TEST AL,AL
JNZ 0x001bae59
CMP qword ptr [R15 + 0x30],0x0
JZ 0x001baf5c
LAB_001bae59:
LEA ECX,[RAX + -0x5]
CMP CL,0x2
JA 0x001bae93
MOV AL,byte ptr [R14 + 0x40]
ADD AL,0xfb
CMP AL,0x2
JA 0x001baf8e
MOV RDI,R15
CALL 0x001a9ec0
MOVSD qword ptr [RSP + 0x48],XMM0
MOV RDI,R14
CALL 0x001a9ec0
UCOMISD XMM0,qword ptr [RSP + 0x48]
SETA BL
JMP 0x001baf4a
LAB_001bae93:
CMP AL,0x3
JNZ 0x001baf8e
CMP byte ptr [R14 + 0x40],0x3
JNZ 0x001baf8e
LEA RDI,[RSP + 0x28]
MOV RSI,R15
CALL 0x001aae5a
LAB_001baeb3:
LEA RDI,[RSP + 0x8]
MOV RSI,R14
CALL 0x001aae5a
LAB_001baec0:
MOV R15,qword ptr [RSP + 0x30]
MOV R14,qword ptr [RSP + 0x8]
MOV R12,qword ptr [RSP + 0x10]
CMP R12,R15
MOV RDX,R15
CMOVC RDX,R12
TEST RDX,RDX
JZ 0x001baef1
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,R14
CALL 0x0011d530
MOV EBX,EAX
TEST EAX,EAX
JNZ 0x001baf12
LAB_001baef1:
SUB R15,R12
CMP R15,-0x7fffffff
MOV RBX,-0x80000000
CMOVGE RBX,R15
MOV EAX,0x7fffffff
CMP RBX,RAX
CMOVGE RBX,RAX
LAB_001baf12:
LEA RAX,[RSP + 0x18]
CMP R14,RAX
JZ 0x001baf2c
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
MOV RDI,R14
CALL 0x0011dc50
LAB_001baf2c:
SHR EBX,0x1f
LEA RAX,[RSP + 0x38]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001baf4a
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x0011dc50
LAB_001baf4a:
MOV EAX,EBX
ADD RSP,0xb0
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001baf5c:
MOV EDI,0x10
CALL 0x0011d5b0
MOV RBX,RAX
LAB_001baf69:
LEA RSI,[0x2152e6]
MOV RDI,RAX
CALL 0x0011d410
LAB_001baf78:
MOV RSI,qword ptr [0x00255fe8]
MOV RDX,qword ptr [0x00255f58]
MOV RDI,RBX
CALL 0x0011e5b0
LAB_001baf8e:
MOV EDI,0x10
CALL 0x0011d5b0
MOV RBX,RAX
LAB_001baf9b:
LEA RDI,[RSP + 0x50]
MOV RSI,R15
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x001aa00c
LAB_001bafaf:
LEA RSI,[0x215ed6]
LEA RDI,[RSP + 0x90]
LEA RDX,[RSP + 0x50]
CALL 0x0019c765
LAB_001bafc8:
LEA RSI,[0x215eee]
LEA RDI,[RSP + 0x90]
CALL 0x0011e870
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JNZ 0x001baffd
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R15],XMM0
JMP 0x001bb00a
LAB_001baffd:
MOV qword ptr [RSP + 0x8],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x18],RDX
LAB_001bb00a:
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LAB_001bb022:
LEA RDI,[RSP + 0x70]
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x001aa00c
LAB_001bb036:
LEA RDI,[RSP + 0x28]
LEA RSI,[RSP + 0x8]
LEA RDX,[RSP + 0x70]
CALL 0x0019c7d5
MOV BPL,0x1
LAB_001bb04d:
LEA RSI,[RSP + 0x28]
MOV RDI,RBX
CALL 0x0011e430
XOR EBP,EBP
MOV RSI,qword ptr [0x00255fe8]
MOV RDX,qword ptr [0x00255f58]
MOV RDI,RBX
CALL 0x0011e5b0
|
/* minja::Value::TEMPNAMEPLACEHOLDERVALUE(minja::Value const&) const */
ulong __thiscall minja::Value::operator<(Value *this,Value *param_1)
{
Value VVar1;
double dVar2;
uint uVar3;
runtime_error *prVar4;
long *plVar5;
long *plVar6;
ulong uVar7;
int8 unaff_RBX;
long *local_d0;
ulong local_c8;
long local_c0;
long lStack_b8;
long *local_b0;
ulong local_a8;
long local_a0 [2];
double local_90;
int1 local_88 [32];
int1 local_68 [32];
char local_48 [32];
VVar1 = this[0x40];
if ((((*(long *)(this + 0x20) == 0) && (*(long *)(this + 0x10) == 0)) && (VVar1 == (Value)0x0)) &&
(*(long *)(this + 0x30) == 0)) {
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001baf69 to 001baf77 has its CatchHandler @ 001bb165 */
std::runtime_error::runtime_error(prVar4,"Undefined value or reference");
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_00255fe8,PTR__runtime_error_00255f58);
}
if ((byte)((char)VVar1 - 5U) < 3) {
if (2 < (byte)((char)param_1[0x40] - 5U)) {
LAB_001baf8e:
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001baf9b to 001bafae has its CatchHandler @ 001bb163 */
dump_abi_cxx11_((int)local_88,SUB81(this,0));
/* try { // try from 001bafaf to 001bafc7 has its CatchHandler @ 001bb123 */
std::operator+(local_48,(string *)"Cannot compare values: ");
/* try { // try from 001bafc8 to 001bafdb has its CatchHandler @ 001bb0da */
plVar5 = (long *)std::__cxx11::string::append(local_48);
local_d0 = (long *)*plVar5;
plVar6 = plVar5 + 2;
if (local_d0 == plVar6) {
local_c0 = *plVar6;
lStack_b8 = plVar5[3];
local_d0 = &local_c0;
}
else {
local_c0 = *plVar6;
}
local_c8 = plVar5[1];
*plVar5 = (long)plVar6;
plVar5[1] = 0;
*(int1 *)(plVar5 + 2) = 0;
/* try { // try from 001bb022 to 001bb035 has its CatchHandler @ 001bb0bb */
dump_abi_cxx11_((int)local_68,SUB81(param_1,0));
/* try { // try from 001bb036 to 001bb049 has its CatchHandler @ 001bb092 */
std::operator+((string *)&local_b0,(string *)&local_d0);
/* try { // try from 001bb04d to 001bb071 has its CatchHandler @ 001bb072 */
std::runtime_error::runtime_error(prVar4,(string *)&local_b0);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_00255fe8,PTR__runtime_error_00255f58);
}
local_90 = get<double>(this);
dVar2 = get<double>(param_1);
uVar7 = CONCAT71((int7)((ulong)unaff_RBX >> 8),local_90 < dVar2);
goto LAB_001baf4a;
}
if ((VVar1 != (Value)0x3) || (param_1[0x40] != (Value)0x3)) goto LAB_001baf8e;
get<std::__cxx11::string>();
/* try { // try from 001baeb3 to 001baebf has its CatchHandler @ 001bb143 */
get<std::__cxx11::string>();
uVar7 = local_a8;
if (local_c8 < local_a8) {
uVar7 = local_c8;
}
if (uVar7 == 0) {
LAB_001baef1:
uVar7 = 0xffffffff80000000;
if (-0x80000000 < (long)(local_a8 - local_c8)) {
uVar7 = local_a8 - local_c8;
}
if (0x7ffffffe < (long)uVar7) {
uVar7 = 0;
}
}
else {
uVar3 = memcmp(local_b0,local_d0,uVar7);
uVar7 = (ulong)uVar3;
if (uVar3 == 0) goto LAB_001baef1;
}
if (local_d0 != &local_c0) {
operator_delete(local_d0,local_c0 + 1);
}
uVar7 = uVar7 >> 0x1f & 1;
if (local_b0 != local_a0) {
operator_delete(local_b0,local_a0[0] + 1);
}
LAB_001baf4a:
return uVar7 & 0xffffffff;
}
| |
26,466 | intx_init | corpus-core[P]colibri-stateless/build_O2/_deps/intx-src/include/intx/intx.hpp | inline void store(uint8_t* dst, const uint256& x) noexcept
{
// Store byte-swapped words in primitive temporaries. This helps with memory aliasing
// and GCC bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=107837
// TODO: Use std::byte instead of uint8_t.
const auto v0 = to_big_endian(x[0]);
const auto v1 = to_big_endian(x[1]);
const auto v2 = to_big_endian(x[2]);
const auto v3 = to_big_endian(x[3]);
// Store words in reverse (big-endian) order, write addresses are ascending.
std::memcpy(dst, &v3, sizeof(v3));
std::memcpy(dst + 8, &v2, sizeof(v2));
std::memcpy(dst + 16, &v1, sizeof(v1));
std::memcpy(dst + 24, &v0, sizeof(v0));
} | O2 | cpp | intx_init:
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
retq
| intx_init:
xorps xmm0, xmm0
movups xmmword ptr [rdi+10h], xmm0
movups xmmword ptr [rdi], xmm0
retn
| void intx_init(_OWORD *a1)
{
a1[1] = 0LL;
*a1 = 0LL;
}
| intx_init:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOVUPS xmmword ptr [RDI],XMM0
RET
|
void intx_init(int8 *param_1)
{
param_1[2] = 0;
param_1[3] = 0;
*param_1 = 0;
param_1[1] = 0;
return;
}
| |
26,467 | stbi__resample_row_h_2(unsigned char*, unsigned char*, unsigned char*, int, int) | monkey531[P]llama/examples/llava/../../common/stb_image.h | static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
{
// need to generate two samples horizontally for every one in input
int i;
stbi_uc *input = in_near;
if (w == 1) {
// if only one sample, can't do any interpolation
out[0] = out[1] = input[0];
return out;
}
out[0] = input[0];
out[1] = stbi__div4(input[0]*3 + input[1] + 2);
for (i=1; i < w-1; ++i) {
int n = 3*input[i]+2;
out[i*2+0] = stbi__div4(n+input[i-1]);
out[i*2+1] = stbi__div4(n+input[i+1]);
}
out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2);
out[i*2+1] = input[w-1];
STBI_NOTUSED(in_far);
STBI_NOTUSED(hs);
return out;
} | O2 | c | stbi__resample_row_h_2(unsigned char*, unsigned char*, unsigned char*, int, int):
movq %rdi, %rax
movb (%rsi), %dl
cmpl $0x1, %ecx
jne 0x40b8a
movb %dl, 0x1(%rax)
movb %dl, (%rax)
retq
movzbl %dl, %edx
movb %dl, (%rax)
movzwl %dx, %edx
leal (%rdx,%rdx,2), %edx
movzbl 0x1(%rsi), %edi
addl %edi, %edx
addl $0x2, %edx
shrl $0x2, %edx
movb %dl, 0x1(%rax)
movslq %ecx, %rdi
leaq -0x1(%rdi), %rcx
pushq $0x1
popq %rdx
cmpq %rcx, %rdx
jge 0x40bec
movzbl (%rsi,%rdx), %r8d
leal (%r8,%r8,2), %r8d
movzbl -0x1(%rsi,%rdx), %r9d
addl %r8d, %r9d
addl $0x2, %r9d
shrl $0x2, %r9d
movb %r9b, (%rax,%rdx,2)
movzbl 0x1(%rsi,%rdx), %r9d
addl %r9d, %r8d
addl $0x2, %r8d
shrl $0x2, %r8d
movb %r8b, 0x1(%rax,%rdx,2)
incq %rdx
jmp 0x40bae
movzbl -0x2(%rsi,%rdi), %edi
leal (%rdi,%rdi,2), %edi
movzbl (%rsi,%rcx), %r8d
addl %r8d, %edi
addl $0x2, %edi
shrl $0x2, %edi
movb %dil, (%rax,%rdx,2)
movb (%rsi,%rcx), %cl
movb %cl, 0x1(%rax,%rdx,2)
retq
| _ZL22stbi__resample_row_h_2PhS_S_ii:
mov rax, rdi
mov dl, [rsi]
cmp ecx, 1
jnz short loc_40B8A
mov [rax+1], dl
mov [rax], dl
retn
loc_40B8A:
movzx edx, dl
mov [rax], dl
movzx edx, dx
lea edx, [rdx+rdx*2]
movzx edi, byte ptr [rsi+1]
add edx, edi
add edx, 2
shr edx, 2
mov [rax+1], dl
movsxd rdi, ecx
lea rcx, [rdi-1]
push 1
pop rdx
loc_40BAE:
cmp rdx, rcx
jge short loc_40BEC
movzx r8d, byte ptr [rsi+rdx]
lea r8d, [r8+r8*2]
movzx r9d, byte ptr [rsi+rdx-1]
add r9d, r8d
add r9d, 2
shr r9d, 2
mov [rax+rdx*2], r9b
movzx r9d, byte ptr [rsi+rdx+1]
add r8d, r9d
add r8d, 2
shr r8d, 2
mov [rax+rdx*2+1], r8b
inc rdx
jmp short loc_40BAE
loc_40BEC:
movzx edi, byte ptr [rsi+rdi-2]
lea edi, [rdi+rdi*2]
movzx r8d, byte ptr [rsi+rcx]
add edi, r8d
add edi, 2
shr edi, 2
mov [rax+rdx*2], dil
mov cl, [rsi+rcx]
mov [rax+rdx*2+1], cl
retn
| unsigned __int8 * stbi__resample_row_h_2(
unsigned __int8 *a1,
unsigned __int8 *a2,
unsigned __int8 *a3,
int a4)
{
unsigned __int8 *result; // rax
unsigned __int8 v5; // dl
long long v6; // rdi
long long v7; // rcx
long long i; // rdx
int v9; // r8d
result = a1;
v5 = *a2;
if ( a4 == 1 )
{
a1[1] = v5;
*a1 = v5;
}
else
{
*a1 = v5;
a1[1] = (a2[1] + 3 * (unsigned int)v5 + 2) >> 2;
v6 = a4;
v7 = a4 - 1LL;
for ( i = 1LL; i < v7; ++i )
{
v9 = 3 * a2[i];
result[2 * i] = (v9 + (unsigned int)a2[i - 1] + 2) >> 2;
result[2 * i + 1] = ((unsigned int)a2[i + 1] + v9 + 2) >> 2;
}
result[2 * i] = (a2[v7] + 3 * (unsigned int)a2[v6 - 2] + 2) >> 2;
result[2 * i + 1] = a2[v7];
}
return result;
}
| stbi__resample_row_h_2:
MOV RAX,RDI
MOV DL,byte ptr [RSI]
CMP ECX,0x1
JNZ 0x00140b8a
MOV byte ptr [RAX + 0x1],DL
MOV byte ptr [RAX],DL
RET
LAB_00140b8a:
MOVZX EDX,DL
MOV byte ptr [RAX],DL
MOVZX EDX,DX
LEA EDX,[RDX + RDX*0x2]
MOVZX EDI,byte ptr [RSI + 0x1]
ADD EDX,EDI
ADD EDX,0x2
SHR EDX,0x2
MOV byte ptr [RAX + 0x1],DL
MOVSXD RDI,ECX
LEA RCX,[RDI + -0x1]
PUSH 0x1
POP RDX
LAB_00140bae:
CMP RDX,RCX
JGE 0x00140bec
MOVZX R8D,byte ptr [RSI + RDX*0x1]
LEA R8D,[R8 + R8*0x2]
MOVZX R9D,byte ptr [RSI + RDX*0x1 + -0x1]
ADD R9D,R8D
ADD R9D,0x2
SHR R9D,0x2
MOV byte ptr [RAX + RDX*0x2],R9B
MOVZX R9D,byte ptr [RSI + RDX*0x1 + 0x1]
ADD R8D,R9D
ADD R8D,0x2
SHR R8D,0x2
MOV byte ptr [RAX + RDX*0x2 + 0x1],R8B
INC RDX
JMP 0x00140bae
LAB_00140bec:
MOVZX EDI,byte ptr [RSI + RDI*0x1 + -0x2]
LEA EDI,[RDI + RDI*0x2]
MOVZX R8D,byte ptr [RSI + RCX*0x1]
ADD EDI,R8D
ADD EDI,0x2
SHR EDI,0x2
MOV byte ptr [RAX + RDX*0x2],DIL
MOV CL,byte ptr [RSI + RCX*0x1]
MOV byte ptr [RAX + RDX*0x2 + 0x1],CL
RET
|
/* stbi__resample_row_h_2(unsigned char*, unsigned char*, unsigned char*, int, int) */
void stbi__resample_row_h_2(uchar *param_1,uchar *param_2,uchar *param_3,int param_4,int param_5)
{
long lVar1;
byte bVar2;
long lVar3;
int iVar4;
bVar2 = *param_2;
if (param_4 == 1) {
param_1[1] = bVar2;
*param_1 = bVar2;
return;
}
*param_1 = bVar2;
param_1[1] = (uchar)((uint)(ushort)bVar2 + (uint)(ushort)bVar2 * 2 + (uint)param_2[1] + 2 >> 2);
lVar1 = (long)param_4 + -1;
for (lVar3 = 1; lVar3 < lVar1; lVar3 = lVar3 + 1) {
iVar4 = (uint)param_2[lVar3] + (uint)param_2[lVar3] * 2;
param_1[lVar3 * 2] = (uchar)((uint)param_2[lVar3 + -1] + iVar4 + 2 >> 2);
param_1[lVar3 * 2 + 1] = (uchar)(iVar4 + (uint)param_2[lVar3 + 1] + 2 >> 2);
}
param_1[lVar3 * 2] =
(uchar)((uint)param_2[(long)param_4 + -2] + (uint)param_2[(long)param_4 + -2] * 2 +
(uint)param_2[lVar1] + 2 >> 2);
param_1[lVar3 * 2 + 1] = param_2[lVar1];
return;
}
| |
26,468 | JS_ThrowTypeErrorReadOnly | bluesky950520[P]quickjs/quickjs.c | static int JS_ThrowTypeErrorReadOnly(JSContext *ctx, int flags, JSAtom atom)
{
if ((flags & JS_PROP_THROW) ||
((flags & JS_PROP_THROW_STRICT) && is_strict_mode(ctx))) {
JS_ThrowTypeErrorAtom(ctx, "'%s' is read-only", atom);
return -1;
} else {
return FALSE;
}
} | O0 | c | JS_ThrowTypeErrorReadOnly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movl 0x14(%rsp), %eax
andl $0x4000, %eax # imm = 0x4000
cmpl $0x0, %eax
jne 0x672fc
movl 0x14(%rsp), %eax
andl $0x8000, %eax # imm = 0x8000
cmpl $0x0, %eax
je 0x6732d
movq 0x18(%rsp), %rdi
callq 0x3e230
cmpl $0x0, %eax
je 0x6732d
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %esi
leaq 0xad08b(%rip), %rdx # 0x114397
leaq 0xa849c(%rip), %rcx # 0x10f7af
movb $0x0, %al
callq 0x666d0
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x67335
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
| JS_ThrowTypeErrorReadOnly:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_14], esi
mov [rsp+28h+var_18], edx
mov eax, [rsp+28h+var_14]
and eax, 4000h
cmp eax, 0
jnz short loc_672FC
mov eax, [rsp+28h+var_14]
and eax, 8000h
cmp eax, 0
jz short loc_6732D
mov rdi, [rsp+28h+var_10]
call is_strict_mode
cmp eax, 0
jz short loc_6732D
loc_672FC:
mov rdi, [rsp+28h+var_10]
mov esi, [rsp+28h+var_18]
lea rdx, aSIsReadOnly; "'%s' is read-only"
lea rcx, aMaximumMemoryS+24h; ""
mov al, 0
call __JS_ThrowTypeErrorAtom
mov [rsp+28h+var_28], rax
mov [rsp+28h+var_20], rdx
mov [rsp+28h+var_4], 0FFFFFFFFh
jmp short loc_67335
loc_6732D:
mov [rsp+28h+var_4], 0
loc_67335:
mov eax, [rsp+28h+var_4]
add rsp, 28h
retn
| long long JS_ThrowTypeErrorReadOnly(
long long a1,
__int16 a2,
unsigned int a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
if ( (a2 & 0x4000) != 0 || a2 < 0 && is_strict_mode(a1) )
{
_JS_ThrowTypeErrorAtom(a1, a3, "'%s' is read-only", a4, a5, a6, a7, a8, a9, a10, a11);
return (unsigned int)-1;
}
else
{
return 0;
}
}
| JS_ThrowTypeErrorReadOnly:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV dword ptr [RSP + 0x14],ESI
MOV dword ptr [RSP + 0x10],EDX
MOV EAX,dword ptr [RSP + 0x14]
AND EAX,0x4000
CMP EAX,0x0
JNZ 0x001672fc
MOV EAX,dword ptr [RSP + 0x14]
AND EAX,0x8000
CMP EAX,0x0
JZ 0x0016732d
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x0013e230
CMP EAX,0x0
JZ 0x0016732d
LAB_001672fc:
MOV RDI,qword ptr [RSP + 0x18]
MOV ESI,dword ptr [RSP + 0x10]
LEA RDX,[0x214397]
LEA RCX,[0x20f7af]
MOV AL,0x0
CALL 0x001666d0
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],RDX
MOV dword ptr [RSP + 0x24],0xffffffff
JMP 0x00167335
LAB_0016732d:
MOV dword ptr [RSP + 0x24],0x0
LAB_00167335:
MOV EAX,dword ptr [RSP + 0x24]
ADD RSP,0x28
RET
|
int4 JS_ThrowTypeErrorReadOnly(int8 param_1,uint param_2,int4 param_3)
{
int iVar1;
int4 local_4;
if ((param_2 & 0x4000) == 0) {
if ((param_2 & 0x8000) != 0) {
iVar1 = is_strict_mode(param_1);
if (iVar1 != 0) goto LAB_001672fc;
}
local_4 = 0;
}
else {
LAB_001672fc:
__JS_ThrowTypeErrorAtom(param_1,param_3,"\'%s\' is read-only","");
local_4 = 0xffffffff;
}
return local_4;
}
| |
26,469 | JS_ThrowTypeErrorReadOnly | bluesky950520[P]quickjs/quickjs.c | static int JS_ThrowTypeErrorReadOnly(JSContext *ctx, int flags, JSAtom atom)
{
if ((flags & JS_PROP_THROW) ||
((flags & JS_PROP_THROW_STRICT) && is_strict_mode(ctx))) {
JS_ThrowTypeErrorAtom(ctx, "'%s' is read-only", atom);
return -1;
} else {
return FALSE;
}
} | O1 | c | JS_ThrowTypeErrorReadOnly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
btl $0xe, %esi
jb 0x41be9
xorl %eax, %eax
testw %si, %si
jns 0x41c0e
movq 0x18(%rbx), %rcx
movq 0x108(%rcx), %rcx
testq %rcx, %rcx
je 0x41c0e
cmpl $0x0, 0x40(%rcx)
jns 0x41c0e
movq 0x18(%rbx), %rdi
movq %rsp, %rsi
callq 0x2624c
leaq 0x617af(%rip), %rsi # 0xa33ab
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x265c3
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x40, %rsp
popq %rbx
retq
| JS_ThrowTypeErrorReadOnly:
push rbx
sub rsp, 40h
mov rbx, rdi
bt esi, 0Eh
jb short loc_41BE9
xor eax, eax
test si, si
jns short loc_41C0E
mov rcx, [rbx+18h]
mov rcx, [rcx+108h]
test rcx, rcx
jz short loc_41C0E
cmp dword ptr [rcx+40h], 0
jns short loc_41C0E
loc_41BE9:
mov rdi, [rbx+18h]
mov rsi, rsp
call JS_AtomGetStrRT
lea rsi, aSIsReadOnly; "'%s' is read-only"
mov rdi, rbx
mov rdx, rax
xor eax, eax
call JS_ThrowTypeError
mov eax, 0FFFFFFFFh
loc_41C0E:
add rsp, 40h
pop rbx
retn
| long long JS_ThrowTypeErrorReadOnly(
long long a1,
__int16 a2,
int a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
long long result; // rax
long long v12; // rcx
unsigned long long StrRT; // rax
long long v14; // rcx
long long v15; // r8
long long v16; // r9
__m128 v17; // xmm4
__m128 v18; // xmm5
char v19[72]; // [rsp+0h] [rbp-48h] BYREF
if ( (a2 & 0x4000) != 0
|| (result = 0LL, a2 < 0) && (v12 = *(_QWORD *)(*(_QWORD *)(a1 + 24) + 264LL)) != 0 && *(int *)(v12 + 64) < 0 )
{
StrRT = JS_AtomGetStrRT(*(_QWORD *)(a1 + 24), v19, a3);
JS_ThrowTypeError(
a1,
(long long)"'%s' is read-only",
StrRT,
v14,
v15,
v16,
a4,
a5,
a6,
a7,
v17,
v18,
a10,
a11,
v19[0]);
return 0xFFFFFFFFLL;
}
return result;
}
| JS_ThrowTypeErrorReadOnly:
PUSH RBX
SUB RSP,0x40
MOV RBX,RDI
BT ESI,0xe
JC 0x00141be9
XOR EAX,EAX
TEST SI,SI
JNS 0x00141c0e
MOV RCX,qword ptr [RBX + 0x18]
MOV RCX,qword ptr [RCX + 0x108]
TEST RCX,RCX
JZ 0x00141c0e
CMP dword ptr [RCX + 0x40],0x0
JNS 0x00141c0e
LAB_00141be9:
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,RSP
CALL 0x0012624c
LEA RSI,[0x1a33ab]
MOV RDI,RBX
MOV RDX,RAX
XOR EAX,EAX
CALL 0x001265c3
MOV EAX,0xffffffff
LAB_00141c0e:
ADD RSP,0x40
POP RBX
RET
|
int8 JS_ThrowTypeErrorReadOnly(long param_1,uint param_2)
{
long lVar1;
int8 uVar2;
int1 auStack_48 [64];
if (((param_2 >> 0xe & 1) != 0) ||
(((uVar2 = 0, (short)param_2 < 0 &&
(lVar1 = *(long *)(*(long *)(param_1 + 0x18) + 0x108), lVar1 != 0)) &&
(*(int *)(lVar1 + 0x40) < 0)))) {
uVar2 = JS_AtomGetStrRT(*(int8 *)(param_1 + 0x18),auStack_48);
JS_ThrowTypeError(param_1,"\'%s\' is read-only",uVar2);
uVar2 = 0xffffffff;
}
return uVar2;
}
| |
26,470 | JS_ThrowTypeErrorReadOnly | bluesky950520[P]quickjs/quickjs.c | static int JS_ThrowTypeErrorReadOnly(JSContext *ctx, int flags, JSAtom atom)
{
if ((flags & JS_PROP_THROW) ||
((flags & JS_PROP_THROW_STRICT) && is_strict_mode(ctx))) {
JS_ThrowTypeErrorAtom(ctx, "'%s' is read-only", atom);
return -1;
} else {
return FALSE;
}
} | O2 | c | JS_ThrowTypeErrorReadOnly:
btl $0xe, %esi
jb 0x39f3b
xorl %eax, %eax
testw %si, %si
jns 0x39f3a
movq 0x18(%rdi), %rcx
movq 0x108(%rcx), %rcx
testq %rcx, %rcx
je 0x39f3a
cmpl $0x0, 0x40(%rcx)
js 0x39f3b
retq
pushq %rax
leaq 0x4f3b8(%rip), %rax # 0x892fb
movl %edx, %esi
movq %rax, %rdx
callq 0x39a1d
pushq $-0x1
popq %rax
addq $0x8, %rsp
retq
| JS_ThrowTypeErrorReadOnly:
bt esi, 0Eh
jb short loc_39F3B
xor eax, eax
test si, si
jns short locret_39F3A
mov rcx, [rdi+18h]
mov rcx, [rcx+108h]
test rcx, rcx
jz short locret_39F3A
cmp dword ptr [rcx+40h], 0
js short loc_39F3B
locret_39F3A:
retn
loc_39F3B:
push rax
lea rax, aSIsReadOnly; "'%s' is read-only"
mov esi, edx
mov rdx, rax
call __JS_ThrowTypeErrorAtom
push 0FFFFFFFFFFFFFFFFh
pop rax
add rsp, 8
retn
| long long JS_ThrowTypeErrorReadOnly(
long long a1,
__int16 a2,
int a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
long long result; // rax
long long v12; // rcx
if ( (a2 & 0x4000) != 0
|| (result = 0LL, a2 < 0) && (v12 = *(_QWORD *)(*(_QWORD *)(a1 + 24) + 264LL)) != 0 && *(int *)(v12 + 64) < 0 )
{
_JS_ThrowTypeErrorAtom(a1, a3, "'%s' is read-only", a4, a5, a6, a7, a8, a9, a10, a11);
return -1LL;
}
return result;
}
| JS_ThrowTypeErrorReadOnly:
BT ESI,0xe
JC 0x00139f3b
XOR EAX,EAX
TEST SI,SI
JNS 0x00139f3a
MOV RCX,qword ptr [RDI + 0x18]
MOV RCX,qword ptr [RCX + 0x108]
TEST RCX,RCX
JZ 0x00139f3a
CMP dword ptr [RCX + 0x40],0x0
JS 0x00139f3b
LAB_00139f3a:
RET
LAB_00139f3b:
PUSH RAX
LEA RAX,[0x1892fb]
MOV ESI,EDX
MOV RDX,RAX
CALL 0x00139a1d
PUSH -0x1
POP RAX
ADD RSP,0x8
RET
|
int8 JS_ThrowTypeErrorReadOnly(long param_1,uint param_2,int4 param_3)
{
long lVar1;
if ((param_2 >> 0xe & 1) == 0) {
if (((-1 < (short)param_2) || (lVar1 = *(long *)(*(long *)(param_1 + 0x18) + 0x108), lVar1 == 0)
) || (-1 < *(int *)(lVar1 + 0x40))) {
return 0;
}
}
__JS_ThrowTypeErrorAtom(param_1,param_3,"\'%s\' is read-only");
return 0xffffffffffffffff;
}
| |
26,471 | void google::protobuf::io::Printer::Annotate<google::protobuf::EnumValueDescriptor>(char const*, char const*, google::protobuf::EnumValueDescriptor const*) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/printer.h | void Annotate(const char* begin_varname, const char* end_varname,
const SomeDescriptor* descriptor) {
if (annotation_collector_ == NULL) {
// Annotations aren't turned on for this Printer, so don't pay the cost
// of building the location path.
return;
}
std::vector<int> path;
descriptor->GetLocationPath(&path);
Annotate(begin_varname, end_varname, descriptor->file()->name(), path);
} | O0 | c | void google::protobuf::io::Printer::Annotate<google::protobuf::EnumValueDescriptor>(char const*, char const*, google::protobuf::EnumValueDescriptor const*):
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x98(%rax)
jne 0x19e64e
jmp 0x19e6c5
leaq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xe5e70
movq 0x20(%rsp), %rsi
movq 0x58(%rsp), %rdi
callq 0x258d30
jmp 0x19e66e
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rdi
callq 0x17e540
movq %rax, 0x18(%rsp)
jmp 0x19e693
movq 0x18(%rsp), %rdi
callq 0x28990
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
leaq 0x40(%rsp), %r8
callq 0x323430
jmp 0x19e6bb
leaq 0x40(%rsp), %rdi
callq 0xe5f70
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xe5f70
movq 0x38(%rsp), %rdi
callq 0x21700
nopl (%rax)
| _ZN6google8protobuf2io7Printer8AnnotateINS0_19EnumValueDescriptorEEEvPKcS6_PKT_:
sub rsp, 78h
mov [rsp+78h+var_8], rdi
mov [rsp+78h+var_10], rsi
mov [rsp+78h+var_18], rdx
mov [rsp+78h+var_20], rcx
mov rax, [rsp+78h+var_8]
mov [rsp+78h+var_50], rax
cmp qword ptr [rax+98h], 0
jnz short loc_19E64E
jmp short loc_19E6C5
loc_19E64E:
lea rdi, [rsp+78h+var_38]
mov [rsp+78h+var_58], rdi
call _ZNSt6vectorIiSaIiEEC2Ev; std::vector<int>::vector(void)
mov rsi, [rsp+78h+var_58]
mov rdi, [rsp+78h+var_20]
call _ZNK6google8protobuf19EnumValueDescriptor15GetLocationPathEPSt6vectorIiSaIiEE; google::protobuf::EnumValueDescriptor::GetLocationPath(std::vector<int> *)
jmp short $+2
loc_19E66E:
mov rax, [rsp+78h+var_10]
mov [rsp+78h+var_70], rax
mov rax, [rsp+78h+var_18]
mov [rsp+78h+var_68], rax
mov rdi, [rsp+78h+var_20]; this
call _ZNK6google8protobuf19EnumValueDescriptor4fileEv; google::protobuf::EnumValueDescriptor::file(void)
mov [rsp+78h+var_60], rax
jmp short $+2
loc_19E693:
mov rdi, [rsp+78h+var_60]
call _ZNK6google8protobuf14FileDescriptor4nameB5cxx11Ev; google::protobuf::FileDescriptor::name(void)
mov rdi, [rsp+78h+var_50]
mov rsi, [rsp+78h+var_70]
mov rdx, [rsp+78h+var_68]
mov rcx, rax
lea r8, [rsp+78h+var_38]
call _ZN6google8protobuf2io7Printer8AnnotateEPKcS4_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorIiSaIiEE; google::protobuf::io::Printer::Annotate(char const*,char const*,std::string const&,std::vector<int> const&)
jmp short $+2
loc_19E6BB:
lea rdi, [rsp+78h+var_38]
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
loc_19E6C5:
add rsp, 78h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_30], rcx
mov [rsp+arg_2C], eax
lea rdi, [rsp+arg_38]
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rdi, [rsp+arg_30]
call __Unwind_Resume
| long long google::protobuf::io::Printer::Annotate<google::protobuf::EnumValueDescriptor>(
long long a1,
long long a2,
long long a3,
google::protobuf::EnumValueDescriptor *a4)
{
long long result; // rax
int v5; // eax
int v6; // r9d
int v7; // [rsp+0h] [rbp-78h]
int v8; // [rsp+8h] [rbp-70h]
int v9; // [rsp+10h] [rbp-68h]
long long v10; // [rsp+18h] [rbp-60h]
long long v11[3]; // [rsp+40h] [rbp-38h] BYREF
google::protobuf::EnumValueDescriptor *v12; // [rsp+58h] [rbp-20h]
long long v13; // [rsp+60h] [rbp-18h]
long long v14; // [rsp+68h] [rbp-10h]
long long v15; // [rsp+70h] [rbp-8h]
v15 = a1;
v14 = a2;
v13 = a3;
v12 = a4;
result = a1;
if ( *(_QWORD *)(a1 + 152) )
{
std::vector<int>::vector((long long)v11);
google::protobuf::EnumValueDescriptor::GetLocationPath(v12, v11);
v8 = v14;
v9 = v13;
v10 = google::protobuf::EnumValueDescriptor::file(v12);
v5 = google::protobuf::FileDescriptor::name[abi:cxx11](v10);
google::protobuf::io::Printer::Annotate(a1, v8, v9, v5, (unsigned int)v11, v6, v7, v8);
return std::vector<int>::~vector(v11);
}
return result;
}
| |||
26,472 | void google::protobuf::io::Printer::Annotate<google::protobuf::EnumValueDescriptor>(char const*, char const*, google::protobuf::EnumValueDescriptor const*) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/printer.h | void Annotate(const char* begin_varname, const char* end_varname,
const SomeDescriptor* descriptor) {
if (annotation_collector_ == NULL) {
// Annotations aren't turned on for this Printer, so don't pay the cost
// of building the location path.
return;
}
std::vector<int> path;
descriptor->GetLocationPath(&path);
Annotate(begin_varname, end_varname, descriptor->file()->name(), path);
} | O3 | c | void google::protobuf::io::Printer::Annotate<google::protobuf::EnumValueDescriptor>(char const*, char const*, google::protobuf::EnumValueDescriptor const*):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpq $0x0, 0x98(%rdi)
je 0xafce0
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq %rcx, %rdi
callq 0x12526e
movq 0x10(%r12), %rax
movq 0x8(%rax), %rcx
movq %rsp, %r8
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x16cc22
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xafce0
callq 0x1f4a0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xafcfd
callq 0x1f4a0
movq %rbx, %rdi
callq 0x1f860
| _ZN6google8protobuf2io7Printer8AnnotateINS0_15FieldDescriptorEEEvPKcS6_PKT_:
push r15
push r14
push r12
push rbx
sub rsp, 18h
cmp qword ptr [rdi+98h], 0
jz short loc_AFCE0
mov r12, rcx
mov rbx, rdx
mov r14, rsi
mov r15, rdi
xorps xmm0, xmm0
mov rsi, rsp
movaps xmmword ptr [rsi], xmm0
mov qword ptr [rsi+10h], 0
mov rdi, rcx
call _ZNK6google8protobuf15FieldDescriptor15GetLocationPathEPSt6vectorIiSaIiEE; google::protobuf::FieldDescriptor::GetLocationPath(std::vector<int> *)
mov rax, [r12+10h]
mov rcx, [rax+8]
mov r8, rsp
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call _ZN6google8protobuf2io7Printer8AnnotateEPKcS4_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorIiSaIiEE; google::protobuf::io::Printer::Annotate(char const*,char const*,std::string const&,std::vector<int> const&)
mov rdi, [rsp+38h+var_38]; void *
test rdi, rdi
jz short loc_AFCE0
call __ZdlPv; operator delete(void *)
loc_AFCE0:
add rsp, 18h
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
mov rdi, [rsp+0]; void *
test rdi, rdi
jz short loc_AFCFD
call __ZdlPv; operator delete(void *)
loc_AFCFD:
mov rdi, rbx
call __Unwind_Resume
| void google::protobuf::io::Printer::Annotate<google::protobuf::FieldDescriptor>(
long long a1,
int a2,
int a3,
long long a4)
{
int v6; // r9d
__int128 v7; // [rsp+0h] [rbp-38h] BYREF
long long v8; // [rsp+10h] [rbp-28h]
int v9; // [rsp+18h] [rbp-20h]
int v10; // [rsp+20h] [rbp-18h]
int v11; // [rsp+28h] [rbp-10h]
char v12; // [rsp+30h] [rbp-8h]
if ( *(_QWORD *)(a1 + 152) )
{
v7 = 0LL;
v8 = 0LL;
google::protobuf::FieldDescriptor::GetLocationPath(a4, &v7);
google::protobuf::io::Printer::Annotate(
a1,
a2,
a3,
*(_QWORD *)(*(_QWORD *)(a4 + 16) + 8LL),
(unsigned int)&v7,
v6,
v7,
DWORD2(v7),
v8,
v9,
v10,
v11,
v12);
if ( (_QWORD)v7 )
operator delete((void *)v7);
}
}
| Annotate<google::protobuf::FieldDescriptor>:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x18
CMP qword ptr [RDI + 0x98],0x0
JZ 0x001afce0
MOV R12,RCX
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
XORPS XMM0,XMM0
MOV RSI,RSP
MOVAPS xmmword ptr [RSI],XMM0
MOV qword ptr [RSI + 0x10],0x0
LAB_001afcb0:
MOV RDI,RCX
CALL 0x0022526e
MOV RAX,qword ptr [R12 + 0x10]
MOV RCX,qword ptr [RAX + 0x8]
MOV R8,RSP
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x0026cc22
LAB_001afcd2:
MOV RDI,qword ptr [RSP]
TEST RDI,RDI
JZ 0x001afce0
CALL 0x0011f4a0
LAB_001afce0:
ADD RSP,0x18
POP RBX
POP R12
POP R14
POP R15
RET
|
/* void google::protobuf::io::Printer::Annotate<google::protobuf::FieldDescriptor>(char const*, char
const*, google::protobuf::FieldDescriptor const*) */
void __thiscall
google::protobuf::io::Printer::Annotate<google::protobuf::FieldDescriptor>
(Printer *this,char *param_1,char *param_2,FieldDescriptor *param_3)
{
void *local_38;
int8 uStack_30;
int8 local_28;
if (*(long *)(this + 0x98) != 0) {
local_38 = (void *)0x0;
uStack_30 = 0;
local_28 = 0;
/* try { // try from 001afcb0 to 001afcd1 has its CatchHandler @ 001afcec */
FieldDescriptor::GetLocationPath(param_3,(vector *)&local_38);
Annotate((char *)this,param_1,(string *)param_2,*(vector **)(*(long *)(param_3 + 0x10) + 8));
if (local_38 != (void *)0x0) {
operator_delete(local_38);
}
}
return;
}
| |
26,473 | verify_col_data | eloqsql/libmariadb/unittest/libmariadb/my_test.h | int verify_col_data(MYSQL *mysql, const char *table, const char *col,
const char *exp_data)
{
static char query[MAX_TEST_QUERY_LENGTH];
MYSQL_RES *result;
MYSQL_ROW row;
int rc;
if (table && col)
{
sprintf(query, "SELECT %s FROM %s LIMIT 1", col, table);
rc= mysql_query(mysql, query);
check_mysql_rc(rc, mysql);
}
result= mysql_use_result(mysql);
FAIL_IF(!result, "Invalid result set");
if (!(row= mysql_fetch_row(result)) || !row[0]) {
diag("Failed to get the result");
goto error;
}
if(strcmp(row[0], exp_data)) {
diag("Expected %s, got %s", exp_data, row[0]);
goto error;
}
mysql_free_result(result);
return OK;
error:
mysql_free_result(result);
return FAIL;
} | O0 | c | verify_col_data:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x14dc4
cmpq $0x0, -0x20(%rbp)
je 0x14dc4
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x6c483(%rip), %rdi # 0x811d0
leaq 0x50967(%rip), %rsi # 0x656bb
movb $0x0, %al
callq 0x140f0
movq -0x10(%rbp), %rdi
leaq 0x6c46a(%rip), %rsi # 0x811d0
callq 0x38a70
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x14dc0
movl -0x3c(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c3f0
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c3c0
movl -0x4c(%rbp), %esi
movq -0x48(%rbp), %rdx
movl %eax, %ecx
leaq 0x50935(%rip), %rdi # 0x656d5
leaq 0x50811(%rip), %r8 # 0x655b8
movl $0x17f, %r9d # imm = 0x17F
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x14e86
jmp 0x14dc2
jmp 0x14dc4
movq -0x10(%rbp), %rdi
callq 0x378e0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x14e05
leaq 0x507b1(%rip), %rdi # 0x65590
leaq 0x50911(%rip), %rsi # 0x656f7
leaq 0x507cb(%rip), %rdx # 0x655b8
movl $0x182, %ecx # imm = 0x182
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x14e86
jmp 0x14e07
movq -0x30(%rbp), %rdi
callq 0x3a400
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x14e24
movq -0x38(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x14e34
leaq 0x508df(%rip), %rdi # 0x6570a
movb $0x0, %al
callq 0x2fc40
jmp 0x14e76
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x14600
cmpl $0x0, %eax
je 0x14e64
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rax
movq (%rax), %rdx
leaq 0x508c8(%rip), %rdi # 0x65723
movb $0x0, %al
callq 0x2fc40
jmp 0x14e76
movq -0x30(%rbp), %rdi
callq 0x31900
movl $0x0, -0x4(%rbp)
jmp 0x14e86
movq -0x30(%rbp), %rdi
callq 0x31900
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
| verify_col_data:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
cmp [rbp+var_18], 0
jz loc_14DC4
cmp [rbp+var_20], 0
jz loc_14DC4
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_18]
lea rdi, verify_col_data_query
lea rsi, aSelectSFromSLi; "SELECT %s FROM %s LIMIT 1"
mov al, 0
call _sprintf
mov rdi, [rbp+var_10]
lea rsi, verify_col_data_query
call mysql_query
mov [rbp+var_3C], eax
cmp [rbp+var_3C], 0
jz short loc_14DC0
mov eax, [rbp+var_3C]
mov [rbp+var_4C], eax
mov rdi, [rbp+var_10]
call mysql_error
mov [rbp+var_48], rax
mov rdi, [rbp+var_10]
call mysql_errno
mov esi, [rbp+var_4C]
mov rdx, [rbp+var_48]
mov ecx, eax
lea rdi, aErrorDSDInSLin; "Error (%d): %s (%d) in %s line %d"
lea r8, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eloqsq"...
mov r9d, 17Fh
mov al, 0
call diag
mov [rbp+var_4], 1
jmp loc_14E86
loc_14DC0:
jmp short $+2
loc_14DC2:
jmp short $+2
loc_14DC4:
mov rdi, [rbp+var_10]
call mysql_use_result
mov [rbp+var_30], rax
cmp [rbp+var_30], 0
jnz short loc_14E05
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rsi, aInvalidResultS; "Invalid result set"
lea rdx, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 182h
mov al, 0
call diag
mov [rbp+var_4], 1
jmp loc_14E86
loc_14E05:
jmp short $+2
loc_14E07:
mov rdi, [rbp+var_30]
call mysql_fetch_row
mov [rbp+var_38], rax
cmp rax, 0
jz short loc_14E24
mov rax, [rbp+var_38]
cmp qword ptr [rax], 0
jnz short loc_14E34
loc_14E24:
lea rdi, aFailedToGetThe; "Failed to get the result"
mov al, 0
call diag
jmp short loc_14E76
loc_14E34:
mov rax, [rbp+var_38]
mov rdi, [rax]
mov rsi, [rbp+var_28]
call _strcmp
cmp eax, 0
jz short loc_14E64
mov rsi, [rbp+var_28]
mov rax, [rbp+var_38]
mov rdx, [rax]
lea rdi, aExpectedSGotS; "Expected %s, got %s"
mov al, 0
call diag
jmp short loc_14E76
loc_14E64:
mov rdi, [rbp+var_30]
call mysql_free_result
mov [rbp+var_4], 0
jmp short loc_14E86
loc_14E76:
mov rdi, [rbp+var_30]
call mysql_free_result
mov [rbp+var_4], 1
loc_14E86:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
| long long verify_col_data(long long a1, const char *a2, const char *a3, long long a4)
{
int v4; // eax
int v5; // r8d
int v6; // r9d
int v7; // edx
int v8; // ecx
int v9; // r8d
int v10; // r9d
int v11; // ecx
int v12; // r8d
int v13; // r9d
int v15; // [rsp+8h] [rbp-48h]
int v16; // [rsp+14h] [rbp-3Ch]
_QWORD *row; // [rsp+18h] [rbp-38h]
long long v18; // [rsp+20h] [rbp-30h]
if ( a2
&& a3
&& (sprintf(&verify_col_data_query, "SELECT %s FROM %s LIMIT 1", a3, a2),
a2 = (const char *)&verify_col_data_query,
(v16 = mysql_query(a1, &verify_col_data_query)) != 0) )
{
v15 = mysql_error(a1);
v4 = mysql_errno(a1);
diag(
(unsigned int)"Error (%d): %s (%d) in %s line %d",
v16,
v15,
v4,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/my_test.h",
383);
return 1;
}
else
{
v18 = mysql_use_result(a1);
if ( v18 )
{
row = (_QWORD *)mysql_fetch_row(v18);
if ( row && *row )
{
if ( !(unsigned int)strcmp(*row, a4) )
{
mysql_free_result(v18);
return 0;
}
diag((unsigned int)"Expected %s, got %s", a4, *row, v11, v12, v13);
}
else
{
diag((unsigned int)"Failed to get the result", (_DWORD)a2, v7, v8, v9, v10);
}
mysql_free_result(v18);
return 1;
}
diag(
(unsigned int)"Error: %s (%s: %d)",
(unsigned int)"Invalid result set",
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/my_test.h",
386,
v5,
v6);
return 1;
}
}
| verify_col_data:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00114dc4
CMP qword ptr [RBP + -0x20],0x0
JZ 0x00114dc4
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
LEA RDI,[0x1811d0]
LEA RSI,[0x1656bb]
MOV AL,0x0
CALL 0x001140f0
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x1811d0]
CALL 0x00138a70
MOV dword ptr [RBP + -0x3c],EAX
CMP dword ptr [RBP + -0x3c],0x0
JZ 0x00114dc0
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x4c],EAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013c3f0
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013c3c0
MOV ESI,dword ptr [RBP + -0x4c]
MOV RDX,qword ptr [RBP + -0x48]
MOV ECX,EAX
LEA RDI,[0x1656d5]
LEA R8,[0x1655b8]
MOV R9D,0x17f
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00114e86
LAB_00114dc0:
JMP 0x00114dc2
LAB_00114dc2:
JMP 0x00114dc4
LAB_00114dc4:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001378e0
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x00114e05
LEA RDI,[0x165590]
LEA RSI,[0x1656f7]
LEA RDX,[0x1655b8]
MOV ECX,0x182
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00114e86
LAB_00114e05:
JMP 0x00114e07
LAB_00114e07:
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x0013a400
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JZ 0x00114e24
MOV RAX,qword ptr [RBP + -0x38]
CMP qword ptr [RAX],0x0
JNZ 0x00114e34
LAB_00114e24:
LEA RDI,[0x16570a]
MOV AL,0x0
CALL 0x0012fc40
JMP 0x00114e76
LAB_00114e34:
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x00114600
CMP EAX,0x0
JZ 0x00114e64
MOV RSI,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RAX]
LEA RDI,[0x165723]
MOV AL,0x0
CALL 0x0012fc40
JMP 0x00114e76
LAB_00114e64:
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00131900
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00114e86
LAB_00114e76:
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00131900
MOV dword ptr [RBP + -0x4],0x1
LAB_00114e86:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
int4 verify_col_data(int8 param_1,long param_2,long param_3,char *param_4)
{
int iVar1;
int4 uVar2;
int8 uVar3;
long lVar4;
long *plVar5;
if ((param_2 != 0) && (param_3 != 0)) {
sprintf(verify_col_data_query,"SELECT %s FROM %s LIMIT 1",param_3,param_2);
iVar1 = mysql_query(param_1,verify_col_data_query);
if (iVar1 != 0) {
uVar3 = mysql_error(param_1);
uVar2 = mysql_errno(param_1);
diag("Error (%d): %s (%d) in %s line %d",iVar1,uVar3,uVar2,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/my_test.h",0x17f
);
return 1;
}
}
lVar4 = mysql_use_result(param_1);
if (lVar4 == 0) {
diag("Error: %s (%s: %d)","Invalid result set",
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/my_test.h",0x182);
}
else {
plVar5 = (long *)mysql_fetch_row(lVar4);
if ((plVar5 == (long *)0x0) || (*plVar5 == 0)) {
diag("Failed to get the result");
}
else {
iVar1 = strcmp((char *)*plVar5,param_4);
if (iVar1 == 0) {
mysql_free_result(lVar4);
return 0;
}
diag("Expected %s, got %s",param_4,*plVar5);
}
mysql_free_result(lVar4);
}
return 1;
}
| |
26,474 | cxxopts::exceptions::incorrect_argument_type::incorrect_argument_type(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | zkingston[P]unknot/build_O1/_deps/cxxopts-src/include/cxxopts.hpp | explicit incorrect_argument_type
(
const std::string& arg
)
: parsing(
"Argument " + LQUOTE + arg + RQUOTE + " failed to parse"
)
{
} | O1 | cpp | cxxopts::exceptions::incorrect_argument_type::incorrect_argument_type(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x260f2c(%rip), %rsi # 0x2902a3
leaq 0x307772(%rip), %rdx # 0x336af0
leaq 0x68(%rsp), %r15
movq %r15, %rdi
callq 0x261ec
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0xf2b0
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2f3c1
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x2f3ca
vmovups (%rcx), %xmm0
vmovups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x307723(%rip), %rsi # 0x336b10
movq 0x307724(%rip), %rdx # 0x336b18
callq 0xf2b0
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2f420
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x2f429
vmovups (%rcx), %xmm0
vmovups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x261032(%rip), %rsi # 0x29047e
callq 0x10310
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2f479
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
jmp 0x2f483
vmovups (%rcx), %xmm0
vmovups %xmm0, (%r12)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
callq 0x28f42
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x2f4be
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xfa70
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x2f4d5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xfa70
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2f4ec
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xfa70
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f507
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xfa70
leaq 0x30419a(%rip), %rax # 0x3336a8
movq %rax, (%rbx)
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x2f53f
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xfa70
jmp 0x2f53f
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x2f55b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xfa70
jmp 0x2f55b
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2f577
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xfa70
jmp 0x2f577
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f592
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xfa70
movq %rbx, %rdi
callq 0x101c0
| _ZN7cxxopts10exceptions23incorrect_argument_typeC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push r12
push rbx
sub rsp, 88h
mov r14, rsi
mov rbx, rdi
lea rsi, aArgument; "Argument "
lea rdx, _ZN7cxxopts12_GLOBAL__N_16LQUOTEB5cxx11E; cxxopts::`anonymous namespace'::LQUOTE
lea r15, [rsp+0A8h+var_40]
mov rdi, r15
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
mov rsi, [r14]
mov rdx, [r14+8]
mov rdi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
lea r14, [rsp+0A8h+var_90]
mov [r14-10h], r14
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_2F3C1
mov [rsp+0A8h+var_A0], rdx
mov rdx, [rcx]
mov [rsp+0A8h+var_90], rdx
jmp short loc_2F3CA
loc_2F3C1:
vmovups xmm0, xmmword ptr [rcx]
vmovups xmmword ptr [r14], xmm0
loc_2F3CA:
mov rdx, [rax+8]
lea rdi, [rsp+0A8h+var_A0]
mov [rdi+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rsi, cs:_ZN7cxxopts12_GLOBAL__N_16RQUOTEB5cxx11E; cxxopts::`anonymous namespace'::RQUOTE
mov rdx, cs:qword_336B18
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
lea r15, [rsp+0A8h+var_70]
mov [r15-10h], r15
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_2F420
mov [rsp+0A8h+var_80], rdx
mov rdx, [rcx]
mov [rsp+0A8h+var_70], rdx
jmp short loc_2F429
loc_2F420:
vmovups xmm0, xmmword ptr [rcx]
vmovups xmmword ptr [r15], xmm0
loc_2F429:
mov rdx, [rax+8]
lea rdi, [rsp+0A8h+var_80]
mov [rdi+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
lea rsi, aFailedToParse; " failed to parse"
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea r12, [rsp+0A8h+var_50]
mov [r12-10h], r12
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_2F479
mov [rsp+0A8h+var_60], rdx
mov rdx, [rcx]
mov [rsp+0A8h+var_50], rdx
jmp short loc_2F483
loc_2F479:
vmovups xmm0, xmmword ptr [rcx]
vmovups xmmword ptr [r12], xmm0
loc_2F483:
mov rdx, [rax+8]
lea rsi, [rsp+0A8h+var_60]
mov [rsi+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rdi, rbx
call _ZN7cxxopts10exceptions7parsingC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; cxxopts::exceptions::parsing::parsing(std::string const&)
mov rdi, [rsp+0A8h+var_60]; void *
cmp rdi, r12
jz short loc_2F4BE
mov rsi, [rsp+0A8h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2F4BE:
mov rdi, [rsp+0A8h+var_80]; void *
cmp rdi, r15
jz short loc_2F4D5
mov rsi, [rsp+0A8h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2F4D5:
mov rdi, [rsp+0A8h+var_A0]; void *
cmp rdi, r14
jz short loc_2F4EC
mov rsi, [rsp+0A8h+var_90]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2F4EC:
lea rax, [rsp+0A8h+var_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_2F507
mov rsi, [rsp+0A8h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2F507:
lea rax, off_3336A8
mov [rbx], rax
add rsp, 88h
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
mov rdi, [rsp+arg_40]; void *
cmp rdi, r12
jz short loc_2F53F
mov rsi, [rsp+arg_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_2F53F
mov rbx, rax
loc_2F53F:
mov rdi, [rsp+arg_20]; void *
cmp rdi, r15
jz short loc_2F55B
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_2F55B
mov rbx, rax
loc_2F55B:
mov rdi, [rsp+arg_0]; void *
cmp rdi, r14
jz short loc_2F577
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_2F577
mov rbx, rax
loc_2F577:
lea rax, [rsp+arg_70]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_2F592
mov rsi, [rsp+arg_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2F592:
mov rdi, rbx
call __Unwind_Resume
| void ( ** cxxopts::exceptions::incorrect_argument_type::incorrect_argument_type(
_QWORD *a1,
_QWORD *a2))(cxxopts::exceptions::exception *__hidden this)
{
long long v2; // rax
long long v6; // rax
long long v10; // rax
void ( **result)(cxxopts::exceptions::exception *__hidden); // rax
void *v15[2]; // [rsp+8h] [rbp-A0h] BYREF
_QWORD v16[2]; // [rsp+18h] [rbp-90h] BYREF
void *v17[2]; // [rsp+28h] [rbp-80h] BYREF
_QWORD v18[2]; // [rsp+38h] [rbp-70h] BYREF
void *v19[2]; // [rsp+48h] [rbp-60h] BYREF
_QWORD v20[2]; // [rsp+58h] [rbp-50h] BYREF
void *v21[2]; // [rsp+68h] [rbp-40h] BYREF
long long v22; // [rsp+78h] [rbp-30h] BYREF
std::operator+<char>((long long)v21, (long long)"Argument ", &cxxopts::`anonymous namespace'::LQUOTE[abi:cxx11]);
v2 = std::string::_M_append(v21, *a2, a2[1]);
_R14 = v16;
v15[0] = v16;
_RCX = (_QWORD *)(v2 + 16);
if ( *(_QWORD *)v2 == v2 + 16 )
{
__asm
{
vmovups xmm0, xmmword ptr [rcx]
vmovups xmmword ptr [r14], xmm0
}
}
else
{
v15[0] = *(void **)v2;
v16[0] = *_RCX;
}
v15[1] = *(void **)(v2 + 8);
*(_QWORD *)v2 = _RCX;
*(_QWORD *)(v2 + 8) = 0LL;
*(_BYTE *)(v2 + 16) = 0;
v6 = std::string::_M_append(v15, cxxopts::`anonymous namespace'::RQUOTE[abi:cxx11], qword_336B18);
_R15 = v18;
v17[0] = v18;
_RCX = (_QWORD *)(v6 + 16);
if ( *(_QWORD *)v6 == v6 + 16 )
{
__asm
{
vmovups xmm0, xmmword ptr [rcx]
vmovups xmmword ptr [r15], xmm0
}
}
else
{
v17[0] = *(void **)v6;
v18[0] = *_RCX;
}
v17[1] = *(void **)(v6 + 8);
*(_QWORD *)v6 = _RCX;
*(_QWORD *)(v6 + 8) = 0LL;
*(_BYTE *)(v6 + 16) = 0;
v10 = std::string::append(v17, " failed to parse");
_R12 = v20;
v19[0] = v20;
_RCX = (_QWORD *)(v10 + 16);
if ( *(_QWORD *)v10 == v10 + 16 )
{
__asm
{
vmovups xmm0, xmmword ptr [rcx]
vmovups xmmword ptr [r12], xmm0
}
}
else
{
v19[0] = *(void **)v10;
v20[0] = *_RCX;
}
v19[1] = *(void **)(v10 + 8);
*(_QWORD *)v10 = _RCX;
*(_QWORD *)(v10 + 8) = 0LL;
*(_BYTE *)(v10 + 16) = 0;
cxxopts::exceptions::parsing::parsing(a1, (long long)v19);
if ( v19[0] != v20 )
operator delete(v19[0], v20[0] + 1LL);
if ( v17[0] != v18 )
operator delete(v17[0], v18[0] + 1LL);
if ( v15[0] != v16 )
operator delete(v15[0], v16[0] + 1LL);
if ( v21[0] != &v22 )
operator delete(v21[0], v22 + 1);
result = off_3336A8;
*a1 = off_3336A8;
return result;
}
| incorrect_argument_type:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV R14,RSI
MOV RBX,RDI
LEA RSI,[0x3902a3]
LEA RDX,[0x436af0]
LEA R15,[RSP + 0x68]
MOV RDI,R15
CALL 0x001261ec
MOV RSI,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
LAB_0012f392:
MOV RDI,R15
CALL 0x0010f2b0
LEA R14,[RSP + 0x18]
MOV qword ptr [R14 + -0x10],R14
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x0012f3c1
MOV qword ptr [RSP + 0x8],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x18],RDX
JMP 0x0012f3ca
LAB_0012f3c1:
VMOVUPS XMM0,xmmword ptr [RCX]
VMOVUPS xmmword ptr [R14],XMM0
LAB_0012f3ca:
MOV RDX,qword ptr [RAX + 0x8]
LEA RDI,[RSP + 0x8]
MOV qword ptr [RDI + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
MOV RSI,qword ptr [0x00436b10]
MOV RDX,qword ptr [0x00436b18]
LAB_0012f3f4:
CALL 0x0010f2b0
LEA R15,[RSP + 0x38]
MOV qword ptr [R15 + -0x10],R15
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x0012f420
MOV qword ptr [RSP + 0x28],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x38],RDX
JMP 0x0012f429
LAB_0012f420:
VMOVUPS XMM0,xmmword ptr [RCX]
VMOVUPS xmmword ptr [R15],XMM0
LAB_0012f429:
MOV RDX,qword ptr [RAX + 0x8]
LEA RDI,[RSP + 0x28]
MOV qword ptr [RDI + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LAB_0012f445:
LEA RSI,[0x39047e]
CALL 0x00110310
LEA R12,[RSP + 0x58]
MOV qword ptr [R12 + -0x10],R12
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x0012f479
MOV qword ptr [RSP + 0x48],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x58],RDX
JMP 0x0012f483
LAB_0012f479:
VMOVUPS XMM0,xmmword ptr [RCX]
VMOVUPS xmmword ptr [R12],XMM0
LAB_0012f483:
MOV RDX,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x48]
MOV qword ptr [RSI + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LAB_0012f49f:
MOV RDI,RBX
CALL 0x00128f42
LAB_0012f4a7:
MOV RDI,qword ptr [RSP + 0x48]
CMP RDI,R12
JZ 0x0012f4be
MOV RSI,qword ptr [RSP + 0x58]
INC RSI
CALL 0x0010fa70
LAB_0012f4be:
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,R15
JZ 0x0012f4d5
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x0010fa70
LAB_0012f4d5:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R14
JZ 0x0012f4ec
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0010fa70
LAB_0012f4ec:
LEA RAX,[RSP + 0x78]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0012f507
MOV RSI,qword ptr [RSP + 0x78]
INC RSI
CALL 0x0010fa70
LAB_0012f507:
LEA RAX,[0x4336a8]
MOV qword ptr [RBX],RAX
ADD RSP,0x88
POP RBX
POP R12
POP R14
POP R15
RET
|
/* cxxopts::exceptions::incorrect_argument_type::incorrect_argument_type(std::__cxx11::string
const&) */
void __thiscall
cxxopts::exceptions::incorrect_argument_type::incorrect_argument_type
(incorrect_argument_type *this,string *param_1)
{
long *plVar1;
long *plVar2;
long *local_a0;
long local_98;
long local_90;
long lStack_88;
long *local_80;
long local_78;
long local_70;
long lStack_68;
long *local_60;
long local_58;
long local_50;
long lStack_48;
long *local_40 [2];
long local_30 [2];
std::operator+((char *)local_40,(string *)"Argument ");
/* try { // try from 0012f392 to 0012f399 has its CatchHandler @ 0012f574 */
plVar1 = (long *)std::__cxx11::string::_M_append((char *)local_40,*(ulong *)param_1);
plVar2 = plVar1 + 2;
if ((long *)*plVar1 == plVar2) {
local_90 = *plVar2;
lStack_88 = plVar1[3];
local_a0 = &local_90;
}
else {
local_90 = *plVar2;
local_a0 = (long *)*plVar1;
}
local_98 = plVar1[1];
*plVar1 = (long)plVar2;
plVar1[1] = 0;
*(int1 *)(plVar1 + 2) = 0;
/* try { // try from 0012f3f4 to 0012f3f8 has its CatchHandler @ 0012f558 */
plVar1 = (long *)std::__cxx11::string::_M_append
((char *)&local_a0,(anonymous_namespace)::RQUOTE_abi_cxx11_);
plVar2 = plVar1 + 2;
if ((long *)*plVar1 == plVar2) {
local_70 = *plVar2;
lStack_68 = plVar1[3];
local_80 = &local_70;
}
else {
local_70 = *plVar2;
local_80 = (long *)*plVar1;
}
local_78 = plVar1[1];
*plVar1 = (long)plVar2;
plVar1[1] = 0;
*(int1 *)(plVar1 + 2) = 0;
/* try { // try from 0012f445 to 0012f450 has its CatchHandler @ 0012f53c */
plVar1 = (long *)std::__cxx11::string::append((char *)&local_80);
plVar2 = plVar1 + 2;
if ((long *)*plVar1 == plVar2) {
local_50 = *plVar2;
lStack_48 = plVar1[3];
local_60 = &local_50;
}
else {
local_50 = *plVar2;
local_60 = (long *)*plVar1;
}
local_58 = plVar1[1];
*plVar1 = (long)plVar2;
plVar1[1] = 0;
*(int1 *)(plVar1 + 2) = 0;
/* try { // try from 0012f49f to 0012f4a6 has its CatchHandler @ 0012f520 */
parsing::parsing((parsing *)this,(string *)&local_60);
if (local_60 != &local_50) {
operator_delete(local_60,local_50 + 1);
}
if (local_80 != &local_70) {
operator_delete(local_80,local_70 + 1);
}
if (local_a0 != &local_90) {
operator_delete(local_a0,local_90 + 1);
}
if (local_40[0] != local_30) {
operator_delete(local_40[0],local_30[0] + 1);
}
*(int ***)this = &PTR__exception_004336a8;
return;
}
| |
26,475 | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::scan_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<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::scan_string():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x2705a
cmpl $0x22, 0x14(%rbx)
jne 0x26b2d
leaq 0x50(%rbx), %r14
leaq 0x35a60(%rip), %r12 # 0x5c183
leaq 0x349b6(%rip), %r13 # 0x5b0e0
movq %rbx, %rdi
callq 0x17cf0
incl %eax
cmpl $0xf5, %eax
ja 0x26afc
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 0x267ca
movaps 0x34939(%rip), %xmm0 # 0x5b0a0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movl $0x4, %edx
jmp 0x267ca
movb 0x14(%rbx), %r15b
movsbl %r15b, %esi
movq %r14, %rdi
callq 0x17c70
jmp 0x2672a
movups 0x3906f(%rip), %xmm0 # 0x5f7fc
jmp 0x267b1
movaps 0x348fa(%rip), %xmm0 # 0x5b090
jmp 0x26767
movaps 0x34911(%rip), %xmm0 # 0x5b0b0
jmp 0x26767
movups 0x3906c(%rip), %xmm0 # 0x5f814
jmp 0x267b1
movups 0x39033(%rip), %xmm0 # 0x5f7e4
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movabsq $0xbf00000080, %rax # imm = 0xBF00000080
movq %rax, 0x10(%rsi)
movl $0x6, %edx
movq %rbx, %rdi
callq 0x270de
testb %al, %al
jne 0x2672a
jmp 0x26b07
movq %rbx, %rdi
callq 0x17cf0
leaq 0x35918(%rip), %rbp # 0x5c106
cmpl $0x61, %eax
jle 0x26919
leal -0x6e(%rax), %ecx
cmpl $0x7, %ecx
ja 0x26934
leaq 0x34cae(%rip), %rax # 0x5b4b8
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %rbx, %rdi
callq 0x27098
leaq 0x357f3(%rip), %rbp # 0x5c015
cmpl $-0x1, %eax
je 0x26b03
movl %eax, %r15d
andl $0xfffffc00, %eax # imm = 0xFFFFFC00
cmpl $0xd800, %eax # imm = 0xD800
jne 0x268e4
movq %rbx, %rdi
callq 0x17cf0
cmpl $0x5c, %eax
jne 0x26b1b
movq %rbx, %rdi
callq 0x17cf0
cmpl $0x75, %eax
jne 0x26b1b
movq %rbx, %rdi
callq 0x27098
cmpl $-0x1, %eax
je 0x26b03
movl %eax, %ecx
andl $0xfffffc00, %ecx # imm = 0xFFFFFC00
leaq 0x357cb(%rip), %rbp # 0x5c04b
cmpl $0xdc00, %ecx # imm = 0xDC00
jne 0x26b03
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 0x17c70
movl %r15d, %eax
shrl $0xc, %eax
andb $0x3f, %al
orb $-0x80, %al
movsbl %al, %esi
movq %r14, %rdi
callq 0x17c70
movl %r15d, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movsbl %al, %esi
movq %r14, %rdi
callq 0x17c70
andb $0x3f, %r15b
orb $-0x80, %r15b
jmp 0x26778
cmpl $0xdc00, %eax # imm = 0xDC00
je 0x26b24
cmpl $0x110000, %r15d # imm = 0x110000
jae 0x26b49
cmpl $0x7f, %r15d
jbe 0x26778
cmpl $0x7ff, %r15d # imm = 0x7FF
ja 0x2694a
movl %r15d, %eax
shrl $0x6, %eax
orb $-0x40, %al
jmp 0x268cc
cmpl $0x22, %eax
je 0x2696c
cmpl $0x2f, %eax
je 0x26964
cmpl $0x5c, %eax
jne 0x26b03
movb $0x5c, %r15b
jmp 0x26778
cmpl $0x62, %eax
je 0x2698c
cmpl $0x66, %eax
jne 0x26b03
movb $0xc, %r15b
jmp 0x26778
cmpl $0xffff, %r15d # imm = 0xFFFF
ja 0x2689a
movl %r15d, %eax
shrl $0xc, %eax
orb $-0x20, %al
jmp 0x268b7
movb $0x2f, %r15b
jmp 0x26778
movb $0x22, %r15b
jmp 0x26778
movb $0x9, %r15b
jmp 0x26778
movb $0xa, %r15b
jmp 0x26778
movb $0xd, %r15b
jmp 0x26778
movb $0x8, %r15b
jmp 0x26778
movl $0x4, %eax
jmp 0x26b0c
leaq 0x3607e(%rip), %rbp # 0x5ca23
jmp 0x26b03
leaq 0x35ec0(%rip), %rbp # 0x5c871
jmp 0x26b03
leaq 0x3601e(%rip), %rbp # 0x5c9db
jmp 0x26b03
leaq 0x35aeb(%rip), %rbp # 0x5c4b4
jmp 0x26b03
leaq 0x35f76(%rip), %rbp # 0x5c94b
jmp 0x26b03
leaq 0x35e47(%rip), %rbp # 0x5c828
jmp 0x26b03
leaq 0x35871(%rip), %rbp # 0x5c25e
jmp 0x26b03
leaq 0x35989(%rip), %rbp # 0x5c382
jmp 0x26b03
leaq 0x35810(%rip), %rbp # 0x5c215
jmp 0x26b03
leaq 0x358df(%rip), %rbp # 0x5c2f0
jmp 0x26b03
leaq 0x3591c(%rip), %rbp # 0x5c339
jmp 0x26b03
movq %r12, %rbp
jmp 0x26b03
leaq 0x35baf(%rip), %rbp # 0x5c5e0
jmp 0x26b03
leaq 0x35b13(%rip), %rbp # 0x5c550
jmp 0x26b03
leaq 0x355a6(%rip), %rbp # 0x5bfef
jmp 0x26b03
leaq 0x35852(%rip), %rbp # 0x5c2a7
jmp 0x26b03
leaq 0x35bc8(%rip), %rbp # 0x5c629
jmp 0x26b03
leaq 0x356cd(%rip), %rbp # 0x5c13a
jmp 0x26b03
leaq 0x35753(%rip), %rbp # 0x5c1cc
jmp 0x26b03
leaq 0x35c36(%rip), %rbp # 0x5c6bb
jmp 0x26b03
leaq 0x35c76(%rip), %rbp # 0x5c704
jmp 0x26b03
leaq 0x35e6b(%rip), %rbp # 0x5c902
jmp 0x26b03
leaq 0x35930(%rip), %rbp # 0x5c3d0
jmp 0x26b03
leaq 0x35ca4(%rip), %rbp # 0x5c74d
jmp 0x26b03
leaq 0x35a50(%rip), %rbp # 0x5c502
jmp 0x26b03
leaq 0x35dfe(%rip), %rbp # 0x5c8b9
jmp 0x26b03
leaq 0x3595a(%rip), %rbp # 0x5c41e
jmp 0x26b03
leaq 0x3599f(%rip), %rbp # 0x5c46c
jmp 0x26b03
leaq 0x35b9c(%rip), %rbp # 0x5c672
jmp 0x26b03
leaq 0x35ab9(%rip), %rbp # 0x5c598
jmp 0x26b03
leaq 0x35eab(%rip), %rbp # 0x5c993
jmp 0x26b03
leaq 0x35ca5(%rip), %rbp # 0x5c796
jmp 0x26b03
leaq 0x35ce5(%rip), %rbp # 0x5c7df
jmp 0x26b03
leaq 0x35f68(%rip), %rbp # 0x5ca6b
movq %rbp, 0x70(%rbx)
movl $0xe, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x35529(%rip), %rbp # 0x5c04b
jmp 0x26b03
leaq 0x3556c(%rip), %rbp # 0x5c097
jmp 0x26b03
leaq 0x35221(%rip), %rdi # 0x5bd55
leaq 0x35257(%rip), %rdx # 0x5bd92
leaq 0x3549d(%rip), %rcx # 0x5bfdf
movl $0x1dd1, %esi # imm = 0x1DD1
jmp 0x26b63
leaq 0x35205(%rip), %rdi # 0x5bd55
leaq 0x3523b(%rip), %rdx # 0x5bd92
leaq 0x3557d(%rip), %rcx # 0x5c0db
movl $0x1e49, %esi # imm = 0x1E49
xorl %eax, %eax
callq 0x17950
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE11scan_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_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5resetEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::reset(void)
cmp dword ptr [rbx+14h], 22h ; '"'
jnz loc_26B2D
lea r14, [rbx+50h]
lea r12, aInvalidStringC; "invalid string: control character U+000"...
lea r13, jpt_26747
loc_2672A:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
inc eax; switch 246 cases
cmp eax, 0F5h
ja def_26747; jumptable 0000000000026747 default case, cases 128-193
movsxd rax, ds:(jpt_26747 - 5B0E0h)[r13+rax*4]
add rax, r13
jmp rax; switch jump
loc_26749:
mov rax, 0BF00000080h; jumptable 0000000000026747 cases 194-223
mov rsi, rsp
mov [rsi], rax
mov edx, 2
jmp short loc_267CA
loc_26760:
movaps xmm0, cs:xmmword_5B0A0; jumptable 0000000000026747 cases 225-236,238,239
loc_26767:
mov rsi, rsp
movaps xmmword ptr [rsi], xmm0
mov edx, 4
jmp short loc_267CA
loc_26774:
mov r15b, [rbx+14h]; jumptable 0000000000026747 cases 32,33,35-91,93-127
loc_26778:
movsx esi, r15b
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
jmp short loc_2672A
loc_26786:
movups xmm0, cs:xmmword_5F7FC; jumptable 0000000000026747 cases 241-243
jmp short loc_267B1
loc_2678F:
movaps xmm0, cs:xmmword_5B090; jumptable 0000000000026747 case 237
jmp short loc_26767
loc_26798:
movaps xmm0, cs:xmmword_5B0B0; jumptable 0000000000026747 case 224
jmp short loc_26767
loc_267A1:
movups xmm0, cs:xmmword_5F814; jumptable 0000000000026747 case 244
jmp short loc_267B1
loc_267AA:
movups xmm0, cs:xmmword_5F7E4; jumptable 0000000000026747 case 240
loc_267B1:
mov rsi, rsp
movaps xmmword ptr [rsi], xmm0
mov rax, 0BF00000080h
mov [rsi+10h], rax
mov edx, 6
loc_267CA:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE18next_byte_in_rangeESt16initializer_listIiE; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::next_byte_in_range(std::initializer_list<int>)
test al, al
jnz loc_2672A
jmp loc_26B07
loc_267DF:
mov rdi, rbx; jumptable 0000000000026747 case 92
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
lea rbp, aInvalidStringF; "invalid string: forbidden character aft"...
cmp eax, 61h ; 'a'
jle loc_26919
lea ecx, [rax-6Eh]; switch 8 cases
cmp ecx, 7
ja def_26811; jumptable 0000000000026811 default case
lea rax, jpt_26811
movsxd rcx, ds:(jpt_26811 - 5B4B8h)[rax+rcx*4]
add rcx, rax
jmp rcx; switch jump
loc_26813:
mov rdi, rbx; jumptable 0000000000026811 case 117
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE13get_codepointEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get_codepoint(void)
lea rbp, aInvalidStringU; "invalid string: '\\u' must be followed "...
cmp eax, 0FFFFFFFFh
jz loc_26B03; jumptable 0000000000026811 cases 111-113,115
mov r15d, eax
and eax, 0FFFFFC00h
cmp eax, 0D800h
jnz loc_268E4
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
cmp eax, 5Ch ; '\'
jnz loc_26B1B
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
cmp eax, 75h ; 'u'
jnz loc_26B1B
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE13get_codepointEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get_codepoint(void)
cmp eax, 0FFFFFFFFh
jz loc_26B03; jumptable 0000000000026811 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_26B03; jumptable 0000000000026811 cases 111-113,115
shl r15d, 0Ah
add r15d, eax
add r15d, 0FCA02400h
loc_2689A:
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_268B7:
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_268CC:
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_26778
loc_268E4:
cmp eax, 0DC00h
jz loc_26B24
cmp r15d, 110000h
jnb loc_26B49
cmp r15d, 7Fh
jbe loc_26778
cmp r15d, 7FFh
ja short loc_2694A
mov eax, r15d
shr eax, 6
or al, 0C0h
jmp short loc_268CC
loc_26919:
cmp eax, 22h ; '"'
jz short loc_2696C
cmp eax, 2Fh ; '/'
jz short loc_26964
cmp eax, 5Ch ; '\'
jnz loc_26B03; jumptable 0000000000026811 cases 111-113,115
mov r15b, 5Ch ; '\'
jmp loc_26778
def_26811:
cmp eax, 62h ; 'b'; jumptable 0000000000026811 default case
jz short loc_2698C
cmp eax, 66h ; 'f'
jnz loc_26B03; jumptable 0000000000026811 cases 111-113,115
mov r15b, 0Ch
jmp loc_26778
loc_2694A:
cmp r15d, 0FFFFh
ja loc_2689A
mov eax, r15d
shr eax, 0Ch
or al, 0E0h
jmp loc_268B7
loc_26964:
mov r15b, 2Fh ; '/'
jmp loc_26778
loc_2696C:
mov r15b, 22h ; '"'
jmp loc_26778
loc_26974:
mov r15b, 9; jumptable 0000000000026811 case 116
jmp loc_26778
loc_2697C:
mov r15b, 0Ah; jumptable 0000000000026811 case 110
jmp loc_26778
loc_26984:
mov r15b, 0Dh; jumptable 0000000000026811 case 114
jmp loc_26778
loc_2698C:
mov r15b, 8
jmp loc_26778
loc_26994:
mov eax, 4; jumptable 0000000000026747 case 34
jmp loc_26B0C
loc_2699E:
lea rbp, aInvalidStringC_0; jumptable 0000000000026747 case 31
jmp loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_269AA:
lea rbp, aInvalidStringC_1; jumptable 0000000000026747 case 25
jmp loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_269B6:
lea rbp, aInvalidStringC_2; jumptable 0000000000026747 case 30
jmp loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_269C2:
lea rbp, aInvalidStringC_3; jumptable 0000000000026747 case 12
jmp loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_269CE:
lea rbp, aInvalidStringC_4; jumptable 0000000000026747 case 28
jmp loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_269DA:
lea rbp, aInvalidStringC_5; jumptable 0000000000026747 case 24
jmp loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_269E6:
lea rbp, aInvalidStringC_6; jumptable 0000000000026747 case 4
jmp loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_269F2:
lea rbp, aInvalidStringC_7; jumptable 0000000000026747 case 8
jmp loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_269FE:
lea rbp, aInvalidStringC_8; jumptable 0000000000026747 case 3
jmp loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_26A0A:
lea rbp, aInvalidStringC_9; jumptable 0000000000026747 case 6
jmp loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_26A16:
lea rbp, aInvalidStringC_10; jumptable 0000000000026747 case 7
jmp loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_26A22:
mov rbp, r12; jumptable 0000000000026747 case 1
jmp loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_26A2A:
lea rbp, aInvalidStringC_11; jumptable 0000000000026747 case 16
jmp loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_26A36:
lea rbp, aInvalidStringC_12; jumptable 0000000000026747 case 14
jmp loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_26A42:
lea rbp, aInvalidStringM; jumptable 0000000000026747 case -1
jmp loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_26A4E:
lea rbp, aInvalidStringC_13; jumptable 0000000000026747 case 5
jmp loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_26A5A:
lea rbp, aInvalidStringC_14; jumptable 0000000000026747 case 17
jmp loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_26A66:
lea rbp, aInvalidStringC_15; jumptable 0000000000026747 case 0
jmp loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_26A72:
lea rbp, aInvalidStringC_16; jumptable 0000000000026747 case 2
jmp loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_26A7E:
lea rbp, aInvalidStringC_17; jumptable 0000000000026747 case 19
jmp short loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_26A87:
lea rbp, aInvalidStringC_18; jumptable 0000000000026747 case 20
jmp short loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_26A90:
lea rbp, aInvalidStringC_19; jumptable 0000000000026747 case 27
jmp short loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_26A99:
lea rbp, aInvalidStringC_20; jumptable 0000000000026747 case 9
jmp short loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_26AA2:
lea rbp, aInvalidStringC_21; jumptable 0000000000026747 case 21
jmp short loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_26AAB:
lea rbp, aInvalidStringC_22; jumptable 0000000000026747 case 13
jmp short loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_26AB4:
lea rbp, aInvalidStringC_23; jumptable 0000000000026747 case 26
jmp short loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_26ABD:
lea rbp, aInvalidStringC_24; jumptable 0000000000026747 case 10
jmp short loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_26AC6:
lea rbp, aInvalidStringC_25; jumptable 0000000000026747 case 11
jmp short loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_26ACF:
lea rbp, aInvalidStringC_26; jumptable 0000000000026747 case 18
jmp short loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_26AD8:
lea rbp, aInvalidStringC_27; jumptable 0000000000026747 case 15
jmp short loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_26AE1:
lea rbp, aInvalidStringC_28; jumptable 0000000000026747 case 29
jmp short loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_26AEA:
lea rbp, aInvalidStringC_29; jumptable 0000000000026747 case 22
jmp short loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_26AF3:
lea rbp, aInvalidStringC_30; jumptable 0000000000026747 case 23
jmp short loc_26B03; jumptable 0000000000026811 cases 111-113,115
def_26747:
lea rbp, aInvalidStringI; jumptable 0000000000026747 default case, cases 128-193
loc_26B03:
mov [rbx+70h], rbp; jumptable 0000000000026811 cases 111-113,115
loc_26B07:
mov eax, 0Eh
loc_26B0C:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_26B1B:
lea rbp, aInvalidStringS; "invalid string: surrogate U+D800..U+DBF"...
jmp short loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_26B24:
lea rbp, aInvalidStringS_0; "invalid string: surrogate U+DC00..U+DFF"...
jmp short loc_26B03; jumptable 0000000000026811 cases 111-113,115
loc_26B2D:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCurrent; "current == '\\\"'"
mov esi, 1DD1h
jmp short loc_26B63
loc_26B49:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, a0x00CodepointC; "0x00 <= codepoint && codepoint <= 0x10F"...
mov esi, 1E49h
loc_26B63:
xor eax, eax
call _ggml_abort
| long long nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::scan_string(
__m128i *a1)
{
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<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::reset();
if ( a1[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<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::scan_number("/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<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1) )
{
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) = a1[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<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1);
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_5B0B0;
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_5B0A0;
goto LABEL_5;
case 0xEDu:
v5 = xmmword_5B090;
LABEL_5:
v16 = v5;
v4 = 4LL;
goto LABEL_14;
case 0xF0u:
v7 = xmmword_5F7E4;
goto LABEL_13;
case 0xF1u:
case 0xF2u:
case 0xF3u:
v7 = xmmword_5F7FC;
goto LABEL_13;
case 0xF4u:
v7 = xmmword_5F814;
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<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::next_byte_in_range(
a1,
&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<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get_codepoint(a1);
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<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1) != 92
|| (unsigned int)nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1) != 117 )
{
v9 = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
LABEL_83:
a1[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<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get_codepoint(a1);
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 < 0x110000 )
{
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(&a1[5], (unsigned int)(char)((v6 >> 18) | 0xF0));
v13 = (v6 >> 12) & 0x3F | 0x80;
LABEL_26:
std::string::push_back(&a1[5], (unsigned int)v13);
v14 = (v6 >> 6) & 0x3F | 0x80;
LABEL_27:
std::string::push_back(&a1[5], (unsigned int)v14);
LOBYTE(v6) = v6 & 0x3F | 0x80;
}
LABEL_7:
std::string::push_back(&a1[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<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::scan_number("/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 0x0012705a
CMP dword ptr [RBX + 0x14],0x22
JNZ 0x00126b2d
LEA R14,[RBX + 0x50]
LEA R12,[0x15c183]
LEA R13,[0x15b0e0]
LAB_0012672a:
MOV RDI,RBX
CALL 0x00117cf0
INC EAX
CMP EAX,0xf5
JA 0x00126afc
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 0x001267ca
caseD_e1:
MOVAPS XMM0,xmmword ptr [0x0015b0a0]
LAB_00126767:
MOV RSI,RSP
MOVAPS xmmword ptr [RSI],XMM0
MOV EDX,0x4
JMP 0x001267ca
caseD_20:
MOV R15B,byte ptr [RBX + 0x14]
LAB_00126778:
MOVSX ESI,R15B
MOV RDI,R14
CALL 0x00117c70
JMP 0x0012672a
caseD_f1:
MOVUPS XMM0,xmmword ptr [0x0015f7fc]
JMP 0x001267b1
caseD_ed:
MOVAPS XMM0,xmmword ptr [0x0015b090]
JMP 0x00126767
caseD_e0:
MOVAPS XMM0,xmmword ptr [0x0015b0b0]
JMP 0x00126767
caseD_f4:
MOVUPS XMM0,xmmword ptr [0x0015f814]
JMP 0x001267b1
caseD_f0:
MOVUPS XMM0,xmmword ptr [0x0015f7e4]
LAB_001267b1:
MOV RSI,RSP
MOVAPS xmmword ptr [RSI],XMM0
MOV RAX,0xbf00000080
MOV qword ptr [RSI + 0x10],RAX
MOV EDX,0x6
LAB_001267ca:
MOV RDI,RBX
CALL 0x001270de
TEST AL,AL
JNZ 0x0012672a
JMP 0x00126b07
caseD_5c:
MOV RDI,RBX
CALL 0x00117cf0
LEA RBP,[0x15c106]
CMP EAX,0x61
JLE 0x00126919
LEA ECX,[RAX + -0x6e]
CMP ECX,0x7
JA 0x00126934
LEA RAX,[0x15b4b8]
MOVSXD RCX,dword ptr [RAX + RCX*0x4]
ADD RCX,RAX
switchD:
JMP RCX
caseD_75:
MOV RDI,RBX
CALL 0x00127098
LEA RBP,[0x15c015]
CMP EAX,-0x1
JZ 0x00126b03
MOV R15D,EAX
AND EAX,0xfffffc00
CMP EAX,0xd800
JNZ 0x001268e4
MOV RDI,RBX
CALL 0x00117cf0
CMP EAX,0x5c
JNZ 0x00126b1b
MOV RDI,RBX
CALL 0x00117cf0
CMP EAX,0x75
JNZ 0x00126b1b
MOV RDI,RBX
CALL 0x00127098
CMP EAX,-0x1
JZ 0x00126b03
MOV ECX,EAX
AND ECX,0xfffffc00
LEA RBP,[0x15c04b]
CMP ECX,0xdc00
JNZ 0x00126b03
SHL R15D,0xa
ADD R15D,EAX
ADD R15D,0xfca02400
LAB_0012689a:
MOV EAX,R15D
SHR EAX,0x12
OR AL,0xf0
MOVSX ESI,AL
MOV RDI,R14
CALL 0x00117c70
MOV EAX,R15D
SHR EAX,0xc
AND AL,0x3f
OR AL,0x80
LAB_001268b7:
MOVSX ESI,AL
MOV RDI,R14
CALL 0x00117c70
MOV EAX,R15D
SHR EAX,0x6
AND AL,0x3f
OR AL,0x80
LAB_001268cc:
MOVSX ESI,AL
MOV RDI,R14
CALL 0x00117c70
AND R15B,0x3f
OR R15B,0x80
JMP 0x00126778
LAB_001268e4:
CMP EAX,0xdc00
JZ 0x00126b24
CMP R15D,0x110000
JNC 0x00126b49
CMP R15D,0x7f
JBE 0x00126778
CMP R15D,0x7ff
JA 0x0012694a
MOV EAX,R15D
SHR EAX,0x6
OR AL,0xc0
JMP 0x001268cc
LAB_00126919:
CMP EAX,0x22
JZ 0x0012696c
CMP EAX,0x2f
JZ 0x00126964
CMP EAX,0x5c
JNZ 0x00126b03
MOV R15B,0x5c
JMP 0x00126778
default:
CMP EAX,0x62
JZ 0x0012698c
CMP EAX,0x66
JNZ 0x00126b03
MOV R15B,0xc
JMP 0x00126778
LAB_0012694a:
CMP R15D,0xffff
JA 0x0012689a
MOV EAX,R15D
SHR EAX,0xc
OR AL,0xe0
JMP 0x001268b7
LAB_00126964:
MOV R15B,0x2f
JMP 0x00126778
LAB_0012696c:
MOV R15B,0x22
JMP 0x00126778
caseD_74:
MOV R15B,0x9
JMP 0x00126778
caseD_6e:
MOV R15B,0xa
JMP 0x00126778
caseD_72:
MOV R15B,0xd
JMP 0x00126778
LAB_0012698c:
MOV R15B,0x8
JMP 0x00126778
caseD_22:
MOV EAX,0x4
JMP 0x00126b0c
caseD_1f:
LEA RBP,[0x15ca23]
JMP 0x00126b03
caseD_19:
LEA RBP,[0x15c871]
JMP 0x00126b03
caseD_1e:
LEA RBP,[0x15c9db]
JMP 0x00126b03
caseD_c:
LEA RBP,[0x15c4b4]
JMP 0x00126b03
caseD_1c:
LEA RBP,[0x15c94b]
JMP 0x00126b03
caseD_18:
LEA RBP,[0x15c828]
JMP 0x00126b03
caseD_4:
LEA RBP,[0x15c25e]
JMP 0x00126b03
caseD_8:
LEA RBP,[0x15c382]
JMP 0x00126b03
caseD_3:
LEA RBP,[0x15c215]
JMP 0x00126b03
caseD_6:
LEA RBP,[0x15c2f0]
JMP 0x00126b03
caseD_7:
LEA RBP,[0x15c339]
JMP 0x00126b03
caseD_1:
MOV RBP,R12
JMP 0x00126b03
caseD_10:
LEA RBP,[0x15c5e0]
JMP 0x00126b03
caseD_e:
LEA RBP,[0x15c550]
JMP 0x00126b03
caseD_ffffffff:
LEA RBP,[0x15bfef]
JMP 0x00126b03
caseD_5:
LEA RBP,[0x15c2a7]
JMP 0x00126b03
caseD_11:
LEA RBP,[0x15c629]
JMP 0x00126b03
caseD_0:
LEA RBP,[0x15c13a]
JMP 0x00126b03
caseD_2:
LEA RBP,[0x15c1cc]
JMP 0x00126b03
caseD_13:
LEA RBP,[0x15c6bb]
JMP 0x00126b03
caseD_14:
LEA RBP,[0x15c704]
JMP 0x00126b03
caseD_1b:
LEA RBP,[0x15c902]
JMP 0x00126b03
caseD_9:
LEA RBP,[0x15c3d0]
JMP 0x00126b03
caseD_15:
LEA RBP,[0x15c74d]
JMP 0x00126b03
caseD_d:
LEA RBP,[0x15c502]
JMP 0x00126b03
caseD_1a:
LEA RBP,[0x15c8b9]
JMP 0x00126b03
caseD_a:
LEA RBP,[0x15c41e]
JMP 0x00126b03
caseD_b:
LEA RBP,[0x15c46c]
JMP 0x00126b03
caseD_12:
LEA RBP,[0x15c672]
JMP 0x00126b03
caseD_f:
LEA RBP,[0x15c598]
JMP 0x00126b03
caseD_1d:
LEA RBP,[0x15c993]
JMP 0x00126b03
caseD_16:
LEA RBP,[0x15c796]
JMP 0x00126b03
caseD_17:
LEA RBP,[0x15c7df]
JMP 0x00126b03
caseD_80:
LEA RBP,[0x15ca6b]
caseD_6f:
MOV qword ptr [RBX + 0x70],RBP
LAB_00126b07:
MOV EAX,0xe
LAB_00126b0c:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00126b1b:
LEA RBP,[0x15c04b]
JMP 0x00126b03
LAB_00126b24:
LEA RBP,[0x15c097]
JMP 0x00126b03
LAB_00126b2d:
LEA RDI,[0x15bd55]
LEA RDX,[0x15bd92]
LEA RCX,[0x15bfdf]
MOV ESI,0x1dd1
JMP 0x00126b63
LAB_00126b49:
LEA RDI,[0x15bd55]
LEA RDX,[0x15bd92]
LEA RCX,[0x15c0db]
MOV ESI,0x1e49
LAB_00126b63:
XOR EAX,EAX
CALL 0x00117950
|
/* 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<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::scan_string() */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::scan_string(lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this)
{
char cVar1;
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_00126b63:
/* 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_0012672a:
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_00126778;
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_00126811_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_00126811_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_00126811_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_00126811_caseD_6f;
LAB_0012689a:
std::__cxx11::string::push_back(cVar7);
LAB_001268b7:
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_00126811_caseD_6f;
}
if (0x10ffff < uVar4) {
pcVar5 = "0x00 <= codepoint && codepoint <= 0x10FFFF";
uVar6 = 0x1e49;
goto LAB_00126b63;
}
if (uVar4 < 0x80) break;
if (0x7ff < uVar4) {
if (0xffff < uVar4) goto LAB_0012689a;
goto LAB_001268b7;
}
}
std::__cxx11::string::push_back(cVar7);
break;
default:
if ((iVar3 != 0x62) && (iVar3 != 0x66)) goto switchD_00126811_caseD_6f;
}
}
LAB_00126778:
std::__cxx11::string::push_back(cVar7);
goto LAB_0012672a;
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_001267ca;
case 0xe0:
uVar2 = _DAT_0015b0b0;
uVar8 = _UNK_0015b0b4;
uStack_40 = _UNK_0015b0b8;
uStack_3c = _UNK_0015b0bc;
goto LAB_00126767;
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_0015b0a0;
uVar8 = _UNK_0015b0a4;
uStack_40 = _UNK_0015b0a8;
uStack_3c = _UNK_0015b0ac;
goto LAB_00126767;
case 0xed:
uVar2 = _DAT_0015b090;
uVar8 = _UNK_0015b094;
uStack_40 = _UNK_0015b098;
uStack_3c = _UNK_0015b09c;
LAB_00126767:
local_48 = CONCAT44(uVar8,uVar2);
uVar6 = 4;
LAB_001267ca:
cVar1 = next_byte_in_range(this,&local_48,uVar6);
if (cVar1 == '\0') {
return 0xe;
}
goto LAB_0012672a;
case 0xf0:
uVar2 = _DAT_0015f7e4;
uVar8 = _UNK_0015f7e8;
uStack_40 = _UNK_0015f7ec;
uStack_3c = _UNK_0015f7f0;
goto LAB_001267b1;
case 0xf1:
case 0xf2:
case 0xf3:
uVar2 = _DAT_0015f7fc;
uVar8 = _UNK_0015f800;
uStack_40 = _UNK_0015f804;
uStack_3c = _UNK_0015f808;
goto LAB_001267b1;
case 0xf4:
uVar2 = _DAT_0015f814;
uVar8 = _UNK_0015f818;
uStack_40 = _UNK_0015f81c;
uStack_3c = _UNK_0015f820;
LAB_001267b1:
local_48 = CONCAT44(uVar8,uVar2);
local_38 = 0xbf00000080;
uVar6 = 6;
goto LAB_001267ca;
case 0xffffffff:
pcVar5 = "invalid string: missing closing quote";
}
switchD_00126811_caseD_6f:
*(char **)(this + 0x70) = pcVar5;
return 0xe;
}
| |
26,476 | ma_apply_redo_bitmap_new_page | eloqsql/storage/maria/ma_bitmap.c | my_bool _ma_apply_redo_bitmap_new_page(MARIA_HA *info,
LSN lsn __attribute__ ((unused)),
const uchar *header)
{
MARIA_SHARE *share= info->s;
MARIA_FILE_BITMAP *bitmap= &share->bitmap;
my_bool error;
pgcache_page_no_t from, to, min_from;
DBUG_ENTER("_ma_apply_redo_bitmap_new_page");
from= page_korr(header);
to= page_korr(header + PAGE_STORE_SIZE);
DBUG_PRINT("info", ("from: %lu to: %lu", (ulong)from, (ulong)to));
if ((from > to) ||
(from % bitmap->pages_covered) != 0 ||
(to % bitmap->pages_covered) != 0)
{
error= TRUE; /* corrupted log record */
goto err;
}
min_from= (share->state.state.data_file_length / bitmap->block_size - 1) /
bitmap->pages_covered + 1;
min_from*= bitmap->pages_covered;
if (from < min_from)
{
DBUG_PRINT("info", ("overwrite bitmap pages from %lu", (ulong)min_from));
/*
We have to overwrite. It could be that there was a bitmap page in
memory, covering a data page which went to disk, then crash: the
bitmap page is now full of zeros and is ==min_from, we have to overwrite
it with correct checksum.
*/
}
share->state.changed|= STATE_CHANGED;
bzero(info->buff, bitmap->block_size);
if (!(error=
_ma_bitmap_create_missing_into_pagecache(share, bitmap, from, to,
info->buff)))
share->state.state.data_file_length= (to + 1) * bitmap->block_size;
err:
DBUG_RETURN(error);
} | O0 | c | ma_apply_redo_bitmap_new_page:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0xa10, %rax # imm = 0xA10
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x609b0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
addq $0x5, %rdi
callq 0x609b0
movq %rax, -0x40(%rbp)
jmp 0x60e6d
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
ja 0x60ea5
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
xorl %edx, %edx
divq 0x138(%rcx)
cmpq $0x0, %rdx
jne 0x60ea5
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
xorl %edx, %edx
divq 0x138(%rcx)
cmpq $0x0, %rdx
je 0x60eae
movb $0x1, -0x29(%rbp)
jmp 0x60f7a
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x28(%rbp), %rcx
movl 0x134(%rcx), %ecx
xorl %edx, %edx
divq %rcx
subq $0x1, %rax
movq -0x28(%rbp), %rcx
xorl %edx, %edx
divq 0x138(%rcx)
addq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq 0x138(%rax), %rax
imulq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x48(%rbp), %rax
jae 0x60f02
jmp 0x60efe
jmp 0x60f00
jmp 0x60f02
movq -0x20(%rbp), %rax
movl 0x170(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x170(%rax)
movq -0x8(%rbp), %rax
movq 0x378(%rax), %rdi
movq -0x28(%rbp), %rax
movl 0x134(%rax), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x292a0
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x378(%rax), %r8
callq 0x60f90
movb %al, -0x29(%rbp)
cmpb $0x0, %al
jne 0x60f78
movq -0x40(%rbp), %rcx
addq $0x1, %rcx
movq -0x28(%rbp), %rax
movl 0x134(%rax), %eax
imulq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x40(%rax)
jmp 0x60f7a
jmp 0x60f7c
movb -0x29(%rbp), %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ma_apply_redo_bitmap_new_page:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
add rax, 0A10h
mov [rbp+var_28], rax
mov rdi, [rbp+var_18]
call uint5korr_1
mov [rbp+var_38], rax
mov rdi, [rbp+var_18]
add rdi, 5
call uint5korr_1
mov [rbp+var_40], rax
jmp short $+2
loc_60E6D:
mov rax, [rbp+var_38]
cmp rax, [rbp+var_40]
ja short loc_60EA5
mov rax, [rbp+var_38]
mov rcx, [rbp+var_28]
xor edx, edx
div qword ptr [rcx+138h]
cmp rdx, 0
jnz short loc_60EA5
mov rax, [rbp+var_40]
mov rcx, [rbp+var_28]
xor edx, edx
div qword ptr [rcx+138h]
cmp rdx, 0
jz short loc_60EAE
loc_60EA5:
mov [rbp+var_29], 1
jmp loc_60F7A
loc_60EAE:
mov rax, [rbp+var_20]
mov rax, [rax+40h]
mov rcx, [rbp+var_28]
mov ecx, [rcx+134h]
xor edx, edx
div rcx
sub rax, 1
mov rcx, [rbp+var_28]
xor edx, edx
div qword ptr [rcx+138h]
add rax, 1
mov [rbp+var_48], rax
mov rax, [rbp+var_28]
mov rax, [rax+138h]
imul rax, [rbp+var_48]
mov [rbp+var_48], rax
mov rax, [rbp+var_38]
cmp rax, [rbp+var_48]
jnb short loc_60F02
jmp short $+2
loc_60EFE:
jmp short $+2
loc_60F00:
jmp short $+2
loc_60F02:
mov rax, [rbp+var_20]
mov ecx, [rax+170h]
or ecx, 1
mov [rax+170h], ecx
mov rax, [rbp+var_8]
mov rdi, [rax+378h]
mov rax, [rbp+var_28]
mov eax, [rax+134h]
mov edx, eax
xor esi, esi
call _memset
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_38]
mov rcx, [rbp+var_40]
mov rax, [rbp+var_8]
mov r8, [rax+378h]
call _ma_bitmap_create_missing_into_pagecache
mov [rbp+var_29], al
cmp al, 0
jnz short loc_60F78
mov rcx, [rbp+var_40]
add rcx, 1
mov rax, [rbp+var_28]
mov eax, [rax+134h]
imul rcx, rax
mov rax, [rbp+var_20]
mov [rax+40h], rcx
loc_60F78:
jmp short $+2
loc_60F7A:
jmp short $+2
loc_60F7C:
mov al, [rbp+var_29]
mov [rbp+var_49], al
mov al, [rbp+var_49]
add rsp, 50h
pop rbp
retn
| char ma_apply_redo_bitmap_new_page(long long *a1, long long a2, unsigned int *a3)
{
unsigned long long v4; // [rsp+10h] [rbp-40h]
unsigned long long v5; // [rsp+18h] [rbp-38h]
char missing_into_pagecache; // [rsp+27h] [rbp-29h]
long long v7; // [rsp+28h] [rbp-28h]
long long v8; // [rsp+30h] [rbp-20h]
v8 = *a1;
v7 = *a1 + 2576;
v5 = uint5korr_1(a3);
v4 = uint5korr_1((unsigned int *)((char *)a3 + 5));
if ( v5 > v4 || v5 % *(_QWORD *)(v7 + 312) || v4 % *(_QWORD *)(v7 + 312) )
return 1;
*(_DWORD *)(v8 + 368) |= 1u;
memset(a1[111], 0LL, *(unsigned int *)(v7 + 308));
missing_into_pagecache = ma_bitmap_create_missing_into_pagecache(v8, v7, v5, v4, a1[111]);
if ( !missing_into_pagecache )
*(_QWORD *)(v8 + 64) = *(unsigned int *)(v7 + 308) * (v4 + 1);
return missing_into_pagecache;
}
| _ma_apply_redo_bitmap_new_page:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0xa10
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001609b0
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x5
CALL 0x001609b0
MOV qword ptr [RBP + -0x40],RAX
JMP 0x00160e6d
LAB_00160e6d:
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x40]
JA 0x00160ea5
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x28]
XOR EDX,EDX
DIV qword ptr [RCX + 0x138]
CMP RDX,0x0
JNZ 0x00160ea5
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x28]
XOR EDX,EDX
DIV qword ptr [RCX + 0x138]
CMP RDX,0x0
JZ 0x00160eae
LAB_00160ea5:
MOV byte ptr [RBP + -0x29],0x1
JMP 0x00160f7a
LAB_00160eae:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RCX + 0x134]
XOR EDX,EDX
DIV RCX
SUB RAX,0x1
MOV RCX,qword ptr [RBP + -0x28]
XOR EDX,EDX
DIV qword ptr [RCX + 0x138]
ADD RAX,0x1
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x138]
IMUL RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x48]
JNC 0x00160f02
JMP 0x00160efe
LAB_00160efe:
JMP 0x00160f00
LAB_00160f00:
JMP 0x00160f02
LAB_00160f02:
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x170]
OR ECX,0x1
MOV dword ptr [RAX + 0x170],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x378]
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX + 0x134]
MOV EDX,EAX
XOR ESI,ESI
CALL 0x001292a0
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x8]
MOV R8,qword ptr [RAX + 0x378]
CALL 0x00160f90
MOV byte ptr [RBP + -0x29],AL
CMP AL,0x0
JNZ 0x00160f78
MOV RCX,qword ptr [RBP + -0x40]
ADD RCX,0x1
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX + 0x134]
IMUL RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x40],RCX
LAB_00160f78:
JMP 0x00160f7a
LAB_00160f7a:
JMP 0x00160f7c
LAB_00160f7c:
MOV AL,byte ptr [RBP + -0x29]
MOV byte ptr [RBP + -0x49],AL
MOV AL,byte ptr [RBP + -0x49]
ADD RSP,0x50
POP RBP
RET
|
char _ma_apply_redo_bitmap_new_page(long *param_1,int8 param_2,long param_3)
{
long lVar1;
ulong uVar2;
ulong uVar3;
char local_31;
lVar1 = *param_1;
uVar2 = uint5korr(param_3);
uVar3 = uint5korr(param_3 + 5);
if (((uVar3 < uVar2) || (uVar2 % *(ulong *)(lVar1 + 0xb48) != 0)) ||
(uVar3 % *(ulong *)(lVar1 + 0xb48) != 0)) {
local_31 = '\x01';
}
else {
*(uint *)(lVar1 + 0x170) = *(uint *)(lVar1 + 0x170) | 1;
memset((void *)param_1[0x6f],0,(ulong)*(uint *)(lVar1 + 0xb44));
local_31 = _ma_bitmap_create_missing_into_pagecache
(lVar1,lVar1 + 0xa10,uVar2,uVar3,param_1[0x6f]);
if (local_31 == '\0') {
*(ulong *)(lVar1 + 0x40) = (uVar3 + 1) * (ulong)*(uint *)(lVar1 + 0xb44);
}
}
return local_31;
}
| |
26,477 | gguf_set_val_i16 | ngxson[P]ggml-easy/ggml/src/gguf.cpp | void gguf_set_val_i16(struct gguf_context * ctx, const char * key, int16_t val) {
gguf_check_reserved_keys(key, val);
gguf_remove_key(ctx, key);
ctx->kv.emplace_back(key, val);
} | O2 | cpp | gguf_set_val_i16:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movw %dx, 0x4(%rsp)
leaq 0x10(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
callq 0x1e820
leaq 0x1a9d9(%rip), %rsi # 0x5a982
movq %r15, %rdi
callq 0x1efa0
testb %al, %al
jne 0x3ffea
leaq 0x10(%rsp), %rdi
callq 0x1c9a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1def0
addq $0x8, %rbx
leaq 0x8(%rsp), %rsi
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
callq 0x1d800
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1a924(%rip), %rdi # 0x5a915
leaq 0x1b17e(%rip), %rdx # 0x5b176
movl $0x3a8, %esi # imm = 0x3A8
xorl %eax, %eax
callq 0x1e770
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1c9a0
movq %rbx, %rdi
callq 0x1e9b0
| gguf_set_val_i16:
push r15
push r14
push rbx
sub rsp, 30h
mov r14, rsi
mov rbx, rdi
mov [rsp+48h+var_40], rsi
mov [rsp+48h+var_44], dx
lea r15, [rsp+48h+var_38]
lea rdx, [rsp+48h+var_41]
mov rdi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rsi, aGeneralAlignme; "general.alignment"
mov rdi, r15
call __ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jnz short loc_3FFEA
lea rdi, [rsp+48h+var_38]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
mov rsi, r14
call _gguf_remove_key
add rbx, 8
lea rsi, [rsp+48h+var_40]
lea rdx, [rsp+48h+var_44]
mov rdi, rbx
call __ZNSt6vectorI7gguf_kvSaIS0_EE12emplace_backIJRPKcRsEEERS0_DpOT_; std::vector<gguf_kv>::emplace_back<char const*&,short &>(char const*&,short &)
add rsp, 30h
pop rbx
pop r14
pop r15
retn
loc_3FFEA:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGeneralAlignme_0; "general.alignment must be type u32"
mov esi, 3A8h
xor eax, eax
call _ggml_abort
mov rbx, rax
lea rdi, [rsp+48h+var_38]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __Unwind_Resume
| long long gguf_set_val_i16(
long long a1,
long long a2,
__int16 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
long long v11; // rcx
long long v12; // r8
long long v13; // r9
__m128 v14; // xmm4
__m128 v15; // xmm5
long long v16; // rdx
char v18; // [rsp+0h] [rbp-48h]
__int16 v19; // [rsp+4h] [rbp-44h] BYREF
char v20; // [rsp+7h] [rbp-41h] BYREF
long long v21; // [rsp+8h] [rbp-40h] BYREF
_BYTE v22[56]; // [rsp+10h] [rbp-38h] BYREF
v21 = a2;
v19 = a3;
std::string::basic_string<std::allocator<char>>(v22, a2, &v20);
if ( (unsigned __int8)std::operator==<char>(v22, "general.alignment") )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/gguf.cpp",
936,
(long long)"general.alignment must be type u32",
v11,
v12,
v13,
a4,
a5,
a6,
a7,
v14,
v15,
a10,
a11,
v18);
std::string::~string(v22);
gguf_remove_key(a1, a2, v16);
return std::vector<gguf_kv>::emplace_back<char const*&,short &>(a1 + 8, &v21, &v19);
}
| gguf_set_val_i16:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RSI
MOV RBX,RDI
MOV qword ptr [RSP + 0x8],RSI
MOV word ptr [RSP + 0x4],DX
LEA R15,[RSP + 0x10]
LEA RDX,[RSP + 0x7]
MOV RDI,R15
CALL 0x0011e820
LEA RSI,[0x15a982]
MOV RDI,R15
CALL 0x0011efa0
TEST AL,AL
JNZ 0x0013ffea
LEA RDI,[RSP + 0x10]
CALL 0x0011c9a0
MOV RDI,RBX
MOV RSI,R14
CALL 0x0011def0
ADD RBX,0x8
LEA RSI,[RSP + 0x8]
LEA RDX,[RSP + 0x4]
MOV RDI,RBX
CALL 0x0011d800
ADD RSP,0x30
POP RBX
POP R14
POP R15
RET
LAB_0013ffea:
LEA RDI,[0x15a915]
LEA RDX,[0x15b176]
MOV ESI,0x3a8
XOR EAX,EAX
CALL 0x0011e770
|
void gguf_set_val_i16(long param_1,char *param_2,short param_3)
{
bool bVar1;
short local_44;
allocator local_41;
char *local_40;
string local_38 [32];
local_44 = param_3;
local_40 = param_2;
std::__cxx11::string::string<std::allocator<char>>(local_38,param_2,&local_41);
bVar1 = std::operator==(local_38,"general.alignment");
if (!bVar1) {
std::__cxx11::string::~string(local_38);
gguf_remove_key(param_1,param_2);
std::vector<gguf_kv,std::allocator<gguf_kv>>::emplace_back<char_const*&,short&>
((vector<gguf_kv,std::allocator<gguf_kv>> *)(param_1 + 8),&local_40,&local_44);
return;
}
/* try { // try from 0013ffea to 00140003 has its CatchHandler @ 00140004 */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/gguf.cpp",0x3a8,
"general.alignment must be type u32");
}
| |
26,478 | translog_disable_purge | eloqsql/storage/maria/ma_loghandler.c | void translog_disable_purge()
{
mysql_mutex_lock(&log_descriptor.purger_lock);
log_purge_disabled++;
mysql_mutex_unlock(&log_descriptor.purger_lock);
} | O3 | c | translog_disable_purge:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0xb9dcbe(%rip) # 0xc0b770
jne 0x6dadf
leaq 0xb9dc75(%rip), %rdi # 0xc0b730
callq 0x2a1f0
incl 0x39bbba(%rip) # 0x409680
movq 0xb9dca3(%rip), %rdi # 0xc0b770
testq %rdi, %rdi
jne 0x6dae6
leaq 0xb9dc57(%rip), %rdi # 0xc0b730
popq %rbp
jmp 0x2a1c0
callq 0x2e26e
jmp 0x6dac0
leaq 0x3233eb(%rip), %rax # 0x390ed8
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x6dad2
| translog_disable_purge:
push rbp
mov rbp, rsp
cmp cs:qword_C0B770, 0
jnz short loc_6DADF
lea rdi, unk_C0B730
call _pthread_mutex_lock
loc_6DAC0:
inc cs:log_purge_disabled
mov rdi, cs:qword_C0B770
test rdi, rdi
jnz short loc_6DAE6
loc_6DAD2:
lea rdi, unk_C0B730
pop rbp
jmp _pthread_mutex_unlock
loc_6DADF:
call translog_disable_purge_cold_1
jmp short loc_6DAC0
loc_6DAE6:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_6DAD2
| long long translog_disable_purge()
{
if ( qword_C0B770 )
translog_disable_purge_cold_1();
else
pthread_mutex_lock(&unk_C0B730);
++log_purge_disabled;
if ( qword_C0B770 )
PSI_server[44]();
return pthread_mutex_unlock(&unk_C0B730);
}
| translog_disable_purge:
PUSH RBP
MOV RBP,RSP
CMP qword ptr [0x00d0b770],0x0
JNZ 0x0016dadf
LEA RDI,[0xd0b730]
CALL 0x0012a1f0
LAB_0016dac0:
INC dword ptr [0x00509680]
MOV RDI,qword ptr [0x00d0b770]
TEST RDI,RDI
JNZ 0x0016dae6
LAB_0016dad2:
LEA RDI,[0xd0b730]
POP RBP
JMP 0x0012a1c0
LAB_0016dadf:
CALL 0x0012e26e
JMP 0x0016dac0
LAB_0016dae6:
LEA RAX,[0x490ed8]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0016dad2
|
void translog_disable_purge(void)
{
if (DAT_00d0b770 == 0) {
pthread_mutex_lock((pthread_mutex_t *)&DAT_00d0b730);
}
else {
translog_disable_purge_cold_1();
}
log_purge_disabled = log_purge_disabled + 1;
if (DAT_00d0b770 != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)&DAT_00d0b730);
return;
}
| |
26,479 | my_charpos_utf16 | eloqsql/strings/ctype-ucs2.c | static size_t
my_charpos_utf16(CHARSET_INFO *cs,
const char *b, const char *e, size_t pos)
{
const char *b0= b;
uint charlen;
for ( ; pos; b+= charlen, pos--)
{
if (!(charlen= my_ismbchar(cs, b, e)))
return (e + 2 - b0); /* Error, return pos outside the string */
}
return (size_t) (pos ? (e + 2 - b0) : (b - b0));
} | O0 | c | my_charpos_utf16:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x57395
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x5aa30
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jne 0x57375
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x573c8
jmp 0x57377
movl -0x34(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x57340
cmpq $0x0, -0x28(%rbp)
je 0x573b1
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
jmp 0x573c0
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_charpos_utf16:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
loc_57340:
cmp [rbp+var_28], 0
jz short loc_57395
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call my_ismbchar_1
mov [rbp+var_34], eax
cmp eax, 0
jnz short loc_57375
mov rax, [rbp+var_20]
add rax, 2
mov rcx, [rbp+var_30]
sub rax, rcx
mov [rbp+var_8], rax
jmp short loc_573C8
loc_57375:
jmp short $+2
loc_57377:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_18]
mov ecx, ecx
add rax, rcx
mov [rbp+var_18], rax
mov rax, [rbp+var_28]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_28], rax
jmp short loc_57340
loc_57395:
cmp [rbp+var_28], 0
jz short loc_573B1
mov rax, [rbp+var_20]
add rax, 2
mov rcx, [rbp+var_30]
sub rax, rcx
mov [rbp+var_40], rax
jmp short loc_573C0
loc_573B1:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_30]
sub rax, rcx
mov [rbp+var_40], rax
loc_573C0:
mov rax, [rbp+var_40]
mov [rbp+var_8], rax
loc_573C8:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| long long my_charpos_utf16(long long a1, long long a2, long long a3, long long a4)
{
unsigned int v5; // [rsp+Ch] [rbp-34h]
long long v8; // [rsp+28h] [rbp-18h]
v8 = a2;
while ( a4 )
{
v5 = my_ismbchar_1(a1, v8, a3);
if ( !v5 )
return a3 + 2 - a2;
v8 += v5;
--a4;
}
return v8 - a2;
}
| my_charpos_utf16:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
LAB_00157340:
CMP qword ptr [RBP + -0x28],0x0
JZ 0x00157395
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0015aa30
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
JNZ 0x00157375
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
MOV RCX,qword ptr [RBP + -0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001573c8
LAB_00157375:
JMP 0x00157377
LAB_00157377:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00157340
LAB_00157395:
CMP qword ptr [RBP + -0x28],0x0
JZ 0x001573b1
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
MOV RCX,qword ptr [RBP + -0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
JMP 0x001573c0
LAB_001573b1:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
LAB_001573c0:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x8],RAX
LAB_001573c8:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
/* WARNING: Removing unreachable block (ram,0x0015739c) */
long my_charpos_utf16(int8 param_1,long param_2,long param_3,long param_4)
{
uint uVar1;
long local_30;
long local_20;
local_30 = param_4;
local_20 = param_2;
while( true ) {
if (local_30 == 0) {
return local_20 - param_2;
}
uVar1 = my_ismbchar(param_1,local_20,param_3);
if (uVar1 == 0) break;
local_20 = local_20 + (ulong)uVar1;
local_30 = local_30 + -1;
}
return (param_3 + 2) - param_2;
}
| |
26,480 | httpserver_read_all_content_ex | qoraal-tictactoe/build_O0/_deps/qoraal_http-src/src/httpserver.c | int32_t
httpserver_read_all_content_ex (HTTP_USER_T* user, uint32_t timeout, char** request)
{
int32_t recvlen ;
uint32_t total = 0 ;
char* buffer ;
uint32_t content_length = user->content_length ;
if (content_length) {
*request = user->content = HTTP_SERVER_MALLOC (content_length+1) ;
if (*request) {
(*request)[content_length] = 0 ;
while (total < content_length) {
if ((recvlen = httpserver_read_content_ex (user, timeout, &buffer)) <= 0) {
break ;
}
if (total + recvlen > content_length) recvlen = content_length - total ;
memcpy (&user->content[total], buffer, recvlen) ;
total += recvlen ;
}
} else {
DBG_MESSAGE_HTTP_SERVER (DBG_MESSAGE_SEVERITY_WARNING,
"HTTPD :W: no memory for %d content bytes!",
content_length);
}
} else {
*request = 0 ;
}
return total ;
} | O0 | c | httpserver_read_all_content_ex:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0xc4(%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x2a01d
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
movl $0x1, %edi
callq 0x1b9b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xc8(%rax)
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2a003
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl -0x2c(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movl -0x20(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jae 0x2a001
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x28(%rbp), %rdx
callq 0x29e00
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jg 0x29fc4
jmp 0x2a001
movl -0x20(%rbp), %eax
addl -0x1c(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jbe 0x29fd8
movl -0x2c(%rbp), %eax
subl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rdi
movl -0x20(%rbp), %eax
addq %rax, %rdi
movq -0x28(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x6350
movl -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x29fa2
jmp 0x2a01b
movl -0x2c(%rbp), %ecx
movl $0x3, %edi
xorl %esi, %esi
leaq 0x16c12(%rip), %rdx # 0x40c26
movb $0x0, %al
callq 0x1e560
jmp 0x2a028
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| httpserver_read_all_content_ex:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_20], 0
mov rax, [rbp+var_8]
mov eax, [rax+0C4h]
mov [rbp+var_2C], eax
cmp [rbp+var_2C], 0
jz loc_2A01D
mov eax, [rbp+var_2C]
add eax, 1
mov eax, eax
mov esi, eax
mov edi, 1
call qoraal_malloc
mov rcx, rax
mov rax, [rbp+var_8]
mov [rax+0C8h], rcx
mov rax, [rbp+var_18]
mov [rax], rcx
mov rax, [rbp+var_18]
cmp qword ptr [rax], 0
jz short loc_2A003
mov rax, [rbp+var_18]
mov rax, [rax]
mov ecx, [rbp+var_2C]
mov byte ptr [rax+rcx], 0
loc_29FA2:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_2C]
jnb short loc_2A001
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
lea rdx, [rbp+var_28]
call httpserver_read_content_ex
mov [rbp+var_1C], eax
cmp eax, 0
jg short loc_29FC4
jmp short loc_2A001
loc_29FC4:
mov eax, [rbp+var_20]
add eax, [rbp+var_1C]
cmp eax, [rbp+var_2C]
jbe short loc_29FD8
mov eax, [rbp+var_2C]
sub eax, [rbp+var_20]
mov [rbp+var_1C], eax
loc_29FD8:
mov rax, [rbp+var_8]
mov rdi, [rax+0C8h]
mov eax, [rbp+var_20]
add rdi, rax
mov rsi, [rbp+var_28]
movsxd rdx, [rbp+var_1C]
call _memcpy
mov eax, [rbp+var_1C]
add eax, [rbp+var_20]
mov [rbp+var_20], eax
jmp short loc_29FA2
loc_2A001:
jmp short loc_2A01B
loc_2A003:
mov ecx, [rbp+var_2C]
mov edi, 3
xor esi, esi
lea rdx, aHttpdWNoMemory; "HTTPD :W: no memory for %d content byte"...
mov al, 0
call svc_logger_type_log
loc_2A01B:
jmp short loc_2A028
loc_2A01D:
mov rax, [rbp+var_18]
mov qword ptr [rax], 0
loc_2A028:
mov eax, [rbp+var_20]
add rsp, 30h
pop rbp
retn
| long long httpserver_read_all_content_ex(long long a1, unsigned int a2, long long *a3)
{
long long v3; // rax
unsigned int v5; // [rsp+4h] [rbp-2Ch]
long long v6; // [rsp+8h] [rbp-28h] BYREF
unsigned int v7; // [rsp+10h] [rbp-20h]
int v8; // [rsp+14h] [rbp-1Ch]
long long *v9; // [rsp+18h] [rbp-18h]
unsigned int v10; // [rsp+24h] [rbp-Ch]
long long v11; // [rsp+28h] [rbp-8h]
v11 = a1;
v10 = a2;
v9 = a3;
v7 = 0;
v5 = *(_DWORD *)(a1 + 196);
if ( v5 )
{
v3 = qoraal_malloc(1u, v5 + 1);
*(_QWORD *)(v11 + 200) = v3;
*v9 = v3;
if ( *v9 )
{
*(_BYTE *)(*v9 + v5) = 0;
while ( v7 < v5 )
{
v8 = httpserver_read_content_ex(v11, v10, &v6);
if ( v8 <= 0 )
break;
if ( v8 + v7 > v5 )
v8 = v5 - v7;
memcpy(v7 + *(_QWORD *)(v11 + 200), v6, v8);
v7 += v8;
}
}
else
{
svc_logger_type_log(3u, 0, (long long)"HTTPD :W: no memory for %d content bytes!", v5);
}
}
else
{
*v9 = 0LL;
}
return v7;
}
| httpserver_read_all_content_ex:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x20],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0xc4]
MOV dword ptr [RBP + -0x2c],EAX
CMP dword ptr [RBP + -0x2c],0x0
JZ 0x0012a01d
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,0x1
MOV EAX,EAX
MOV ESI,EAX
MOV EDI,0x1
CALL 0x0011b9b0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xc8],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX],0x0
JZ 0x0012a003
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x2c]
MOV byte ptr [RAX + RCX*0x1],0x0
LAB_00129fa2:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x2c]
JNC 0x0012a001
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
LEA RDX,[RBP + -0x28]
CALL 0x00129e00
MOV dword ptr [RBP + -0x1c],EAX
CMP EAX,0x0
JG 0x00129fc4
JMP 0x0012a001
LAB_00129fc4:
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x2c]
JBE 0x00129fd8
MOV EAX,dword ptr [RBP + -0x2c]
SUB EAX,dword ptr [RBP + -0x20]
MOV dword ptr [RBP + -0x1c],EAX
LAB_00129fd8:
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0xc8]
MOV EAX,dword ptr [RBP + -0x20]
ADD RDI,RAX
MOV RSI,qword ptr [RBP + -0x28]
MOVSXD RDX,dword ptr [RBP + -0x1c]
CALL 0x00106350
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,dword ptr [RBP + -0x20]
MOV dword ptr [RBP + -0x20],EAX
JMP 0x00129fa2
LAB_0012a001:
JMP 0x0012a01b
LAB_0012a003:
MOV ECX,dword ptr [RBP + -0x2c]
MOV EDI,0x3
XOR ESI,ESI
LEA RDX,[0x140c26]
MOV AL,0x0
CALL 0x0011e560
LAB_0012a01b:
JMP 0x0012a028
LAB_0012a01d:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],0x0
LAB_0012a028:
MOV EAX,dword ptr [RBP + -0x20]
ADD RSP,0x30
POP RBP
RET
|
uint httpserver_read_all_content_ex(long param_1,int4 param_2,long *param_3)
{
uint uVar1;
long lVar2;
void *local_30;
uint local_28;
int local_24;
long *local_20;
int4 local_14;
long local_10;
local_28 = 0;
uVar1 = *(uint *)(param_1 + 0xc4);
if (uVar1 == 0) {
*param_3 = 0;
}
else {
local_20 = param_3;
local_14 = param_2;
local_10 = param_1;
lVar2 = qoraal_malloc(1,uVar1 + 1);
*(long *)(local_10 + 200) = lVar2;
*local_20 = lVar2;
if (*local_20 == 0) {
svc_logger_type_log(3,0,s_HTTPD__W__no_memory_for__d_conte_00140c26,uVar1);
}
else {
*(int1 *)(*local_20 + (ulong)uVar1) = 0;
while ((local_28 < uVar1 &&
(local_24 = httpserver_read_content_ex(local_10,local_14,&local_30), 0 < local_24))) {
if (uVar1 < local_28 + local_24) {
local_24 = uVar1 - local_28;
}
memcpy((void *)(*(long *)(local_10 + 200) + (ulong)local_28),local_30,(long)local_24);
local_28 = local_24 + local_28;
}
}
}
return local_28;
}
| |
26,481 | deflatePending | 3fs/build_O3/src/apache-arrow-cpp/cpp/zlib_ep-prefix/src/zlib_ep/deflate.c | int ZEXPORT deflatePending(strm, pending, bits)
unsigned *pending;
int *bits;
z_streamp strm;
{
if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
if (pending != Z_NULL)
*pending = strm->state->pending;
if (bits != Z_NULL)
*bits = strm->state->bi_valid;
return Z_OK;
} | O3 | c | deflatePending:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x4452
movl %eax, %ecx
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
testl %ecx, %ecx
jne 0x4868
testq %r15, %r15
je 0x4855
movq 0x38(%r14), %rax
movl 0x28(%rax), %eax
movl %eax, (%r15)
xorl %eax, %eax
testq %rbx, %rbx
je 0x4868
movq 0x38(%r14), %rcx
movl 0x1734(%rcx), %ecx
movl %ecx, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
| deflatePending:
push r15
push r14
push rbx
mov rbx, rdx
mov r15, rsi
mov r14, rdi
call deflateStateCheck
mov ecx, eax
mov eax, 0FFFFFFFEh
test ecx, ecx
jnz short loc_4868
test r15, r15
jz short loc_4855
mov rax, [r14+38h]
mov eax, [rax+28h]
mov [r15], eax
loc_4855:
xor eax, eax
test rbx, rbx
jz short loc_4868
mov rcx, [r14+38h]
mov ecx, [rcx+1734h]
mov [rbx], ecx
loc_4868:
pop rbx
pop r14
pop r15
retn
| long long deflatePending(_QWORD *a1, _DWORD *a2, _DWORD *a3)
{
int v4; // ecx
long long result; // rax
v4 = deflateStateCheck(a1);
result = 4294967294LL;
if ( !v4 )
{
if ( a2 )
*a2 = *(_DWORD *)(a1[7] + 40LL);
result = 0LL;
if ( a3 )
*a3 = *(_DWORD *)(a1[7] + 5940LL);
}
return result;
}
| deflatePending:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDX
MOV R15,RSI
MOV R14,RDI
CALL 0x00104452
MOV ECX,EAX
MOV EAX,0xfffffffe
TEST ECX,ECX
JNZ 0x00104868
TEST R15,R15
JZ 0x00104855
MOV RAX,qword ptr [R14 + 0x38]
MOV EAX,dword ptr [RAX + 0x28]
MOV dword ptr [R15],EAX
LAB_00104855:
XOR EAX,EAX
TEST RBX,RBX
JZ 0x00104868
MOV RCX,qword ptr [R14 + 0x38]
MOV ECX,dword ptr [RCX + 0x1734]
MOV dword ptr [RBX],ECX
LAB_00104868:
POP RBX
POP R14
POP R15
RET
|
int8 deflatePending(long param_1,int4 *param_2,int4 *param_3)
{
int iVar1;
int8 uVar2;
iVar1 = deflateStateCheck();
uVar2 = 0xfffffffe;
if (iVar1 == 0) {
if (param_2 != (int4 *)0x0) {
*param_2 = *(int4 *)(*(long *)(param_1 + 0x38) + 0x28);
}
uVar2 = 0;
if (param_3 != (int4 *)0x0) {
*param_3 = *(int4 *)(*(long *)(param_1 + 0x38) + 0x1734);
}
}
return uVar2;
}
| |
26,482 | translog_write_variable_record_1group_code_len | eloqsql/storage/maria/ma_loghandler.c | static void
translog_write_variable_record_1group_code_len(uchar *dst,
translog_size_t length,
uint16 header_len)
{
switch (header_len) {
case 6: /* (5 + 1) */
DBUG_ASSERT(length <= 250);
*dst= (uint8) length;
return;
case 8: /* (5 + 3) */
DBUG_ASSERT(length <= 0xFFFF);
*dst= 251;
int2store(dst + 1, length);
return;
case 9: /* (5 + 4) */
DBUG_ASSERT(length <= (ulong) 0xFFFFFF);
*dst= 252;
int3store(dst + 1, length);
return;
case 10: /* (5 + 5) */
*dst= 253;
int4store(dst + 1, length);
return;
default:
DBUG_ASSERT(0);
}
return;
} | O0 | c | translog_write_variable_record_1group_code_len:
pushq %rbp
movq %rsp, %rbp
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movw %ax, -0xe(%rbp)
movzwl -0xe(%rbp), %eax
addl $-0x6, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x4, %eax
ja 0x9842b
movq -0x28(%rbp), %rax
leaq 0xc8cb1(%rip), %rcx # 0x161044
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x9839e
jmp 0x983a0
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
jmp 0x98433
jmp 0x983b2
jmp 0x983b4
movq -0x8(%rbp), %rax
movb $-0x5, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, (%rax)
jmp 0x98433
jmp 0x983d8
jmp 0x983da
movq -0x8(%rbp), %rax
movb $-0x4, (%rax)
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0xc(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0xc(%rbp), %eax
shrl $0x10, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x3(%rax)
jmp 0x98433
movq -0x8(%rbp), %rax
movb $-0x3, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x98433
jmp 0x9842d
jmp 0x9842f
jmp 0x98431
jmp 0x98433
popq %rbp
retq
nopw %cs:(%rax,%rax)
| translog_write_variable_record_1group_code_len:
push rbp
mov rbp, rsp
mov ax, dx
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_E], ax
movzx eax, [rbp+var_E]
add eax, 0FFFFFFFAh; switch 5 cases
mov ecx, eax
mov [rbp+var_28], rcx
sub eax, 4
ja def_9839A; jumptable 000000000009839A default case, case 7
mov rax, [rbp+var_28]
lea rcx, jpt_9839A
movsxd rax, ds:(jpt_9839A - 161044h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_9839C:
jmp short $+2; jumptable 000000000009839A case 6
loc_9839E:
jmp short $+2
loc_983A0:
mov eax, [rbp+var_C]
mov cl, al
mov rax, [rbp+var_8]
mov [rax], cl
jmp loc_98433
loc_983B0:
jmp short $+2; jumptable 000000000009839A case 8
loc_983B2:
jmp short $+2
loc_983B4:
mov rax, [rbp+var_8]
mov byte ptr [rax], 0FBh
mov rax, [rbp+var_8]
add rax, 1
mov [rbp+var_18], rax
mov eax, [rbp+var_C]
mov cx, ax
mov rax, [rbp+var_18]
mov [rax], cx
jmp short loc_98433
loc_983D6:
jmp short $+2; jumptable 000000000009839A case 9
loc_983D8:
jmp short $+2
loc_983DA:
mov rax, [rbp+var_8]
mov byte ptr [rax], 0FCh
mov eax, [rbp+var_C]
mov cl, al
mov rax, [rbp+var_8]
mov [rax+1], cl
mov eax, [rbp+var_C]
shr eax, 8
mov cl, al
mov rax, [rbp+var_8]
mov [rax+2], cl
mov eax, [rbp+var_C]
shr eax, 10h
mov cl, al
mov rax, [rbp+var_8]
mov [rax+3], cl
jmp short loc_98433
loc_9840D:
mov rax, [rbp+var_8]; jumptable 000000000009839A case 10
mov byte ptr [rax], 0FDh
mov rax, [rbp+var_8]
add rax, 1
mov [rbp+var_20], rax
mov ecx, [rbp+var_C]
mov rax, [rbp+var_20]
mov [rax], ecx
jmp short loc_98433
def_9839A:
jmp short $+2; jumptable 000000000009839A default case, case 7
loc_9842D:
jmp short $+2
loc_9842F:
jmp short $+2
loc_98431:
jmp short $+2
loc_98433:
pop rbp
retn
| long long translog_write_variable_record_1group_code_len(long long a1, int a2, unsigned __int16 a3)
{
long long result; // rax
result = (unsigned int)a3 - 6;
switch ( a3 )
{
case 6u:
result = a1;
*(_BYTE *)a1 = a2;
break;
case 8u:
*(_BYTE *)a1 = -5;
result = a1 + 1;
*(_WORD *)(a1 + 1) = a2;
break;
case 9u:
*(_BYTE *)a1 = -4;
*(_WORD *)(a1 + 1) = a2;
result = a1;
*(_BYTE *)(a1 + 3) = BYTE2(a2);
break;
case 0xAu:
*(_BYTE *)a1 = -3;
result = a1 + 1;
*(_DWORD *)(a1 + 1) = a2;
break;
default:
return result;
}
return result;
}
| translog_write_variable_record_1group_code_len:
PUSH RBP
MOV RBP,RSP
MOV AX,DX
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV word ptr [RBP + -0xe],AX
MOVZX EAX,word ptr [RBP + -0xe]
ADD EAX,-0x6
MOV ECX,EAX
MOV qword ptr [RBP + -0x28],RCX
SUB EAX,0x4
JA 0x0019842b
MOV RAX,qword ptr [RBP + -0x28]
LEA RCX,[0x261044]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_6:
JMP 0x0019839e
LAB_0019839e:
JMP 0x001983a0
LAB_001983a0:
MOV EAX,dword ptr [RBP + -0xc]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX],CL
JMP 0x00198433
caseD_8:
JMP 0x001983b2
LAB_001983b2:
JMP 0x001983b4
LAB_001983b4:
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX],0xfb
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
MOV EAX,dword ptr [RBP + -0xc]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x18]
MOV word ptr [RAX],CX
JMP 0x00198433
caseD_9:
JMP 0x001983d8
LAB_001983d8:
JMP 0x001983da
LAB_001983da:
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX],0xfc
MOV EAX,dword ptr [RBP + -0xc]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x1],CL
MOV EAX,dword ptr [RBP + -0xc]
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x2],CL
MOV EAX,dword ptr [RBP + -0xc]
SHR EAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x3],CL
JMP 0x00198433
caseD_a:
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX],0xfd
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
MOV ECX,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],ECX
JMP 0x00198433
caseD_7:
JMP 0x0019842d
LAB_0019842d:
JMP 0x0019842f
LAB_0019842f:
JMP 0x00198431
LAB_00198431:
JMP 0x00198433
LAB_00198433:
POP RBP
RET
|
void translog_write_variable_record_1group_code_len
(int1 *param_1,int4 param_2,int2 param_3)
{
switch(param_3) {
case 6:
*param_1 = (char)param_2;
break;
default:
break;
case 8:
*param_1 = 0xfb;
*(short *)(param_1 + 1) = (short)param_2;
break;
case 9:
*param_1 = 0xfc;
param_1[1] = (char)param_2;
param_1[2] = (char)((uint)param_2 >> 8);
param_1[3] = (char)((uint)param_2 >> 0x10);
break;
case 10:
*param_1 = 0xfd;
*(int4 *)(param_1 + 1) = param_2;
}
return;
}
| |
26,483 | ma_net_real_write | eloqsql/libmariadb/libmariadb/ma_net.c | int ma_net_real_write(NET *net, const char *packet, size_t len)
{
ssize_t length;
char *pos,*end;
if (net->error == 2)
return(-1); /* socket can't be used */
net->reading_or_writing=2;
#ifdef HAVE_COMPRESS
if (net->compress)
{
size_t complen;
uchar *b;
uint header_length=NET_HEADER_SIZE+COMP_HEADER_SIZE;
if (!(b=(uchar*) malloc(len + NET_HEADER_SIZE + COMP_HEADER_SIZE + 1)))
{
net->pvio->set_error(net->pvio->mysql, CR_OUT_OF_MEMORY, SQLSTATE_UNKNOWN, 0);
net->error=2;
net->reading_or_writing=0;
return(1);
}
memcpy(b+header_length,packet,len);
if (_mariadb_compress(net, (unsigned char*) b+header_length,&len,&complen))
{
complen=0;
}
int3store(&b[NET_HEADER_SIZE],complen);
int3store(b,len);
b[3]=(uchar) (net->compress_pkt_nr++);
len+= header_length;
packet= (char*) b;
}
#endif /* HAVE_COMPRESS */
pos=(char*) packet; end=pos+len;
while (pos != end)
{
if ((length=ma_pvio_write(net->pvio,(uchar *)pos,(size_t) (end-pos))) <= 0)
{
int save_errno= errno;
char errmsg[100];
net->error=2; /* Close socket */
strerror_r(save_errno, errmsg, 100);
net->pvio->set_error(net->pvio->mysql, CR_ERR_NET_WRITE, SQLSTATE_UNKNOWN, 0,
errmsg, save_errno);
net->reading_or_writing=0;
#ifdef HAVE_COMPRESS
if (net->compress)
free((char*) packet);
#endif
return(1);
}
pos+=length;
}
#ifdef HAVE_COMPRESS
if (net->compress)
free((char*) packet);
#endif
net->reading_or_writing=0;
return(((int) (pos != end)));
} | O0 | c | ma_net_real_write:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x80(%rbp)
movq %rsi, -0x88(%rbp)
movq %rdx, -0x90(%rbp)
movq -0x80(%rbp), %rax
movzbl 0x94(%rax), %eax
cmpl $0x2, %eax
jne 0x1e346
movl $0xffffffff, -0x74(%rbp) # imm = 0xFFFFFFFF
jmp 0x1e651
movq -0x80(%rbp), %rax
movb $0x2, 0x80(%rax)
movq -0x80(%rbp), %rax
cmpb $0x0, 0x84(%rax)
je 0x1e4fc
movl $0x7, -0xbc(%rbp)
movq -0x90(%rbp), %rdi
addq $0x4, %rdi
addq $0x3, %rdi
addq $0x1, %rdi
callq 0x177d0
movq %rax, -0xb8(%rbp)
cmpq $0x0, %rax
jne 0x1e3e1
movq -0x80(%rbp), %rax
movq (%rax), %rax
movq 0x50(%rax), %r8
movq -0x80(%rbp), %rax
movq (%rax), %rax
movq 0x40(%rax), %rdi
leaq 0x44cf2(%rip), %rax # 0x630a0
movq (%rax), %rdx
movl $0x7d8, %esi # imm = 0x7D8
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq *%r8
movq -0x80(%rbp), %rax
movb $0x2, 0x94(%rax)
movq -0x80(%rbp), %rax
movb $0x0, 0x80(%rax)
movl $0x1, -0x74(%rbp)
jmp 0x1e651
movq -0xb8(%rbp), %rdi
movl -0xbc(%rbp), %eax
addq %rax, %rdi
movq -0x88(%rbp), %rsi
movq -0x90(%rbp), %rdx
callq 0x174a0
movq -0x80(%rbp), %rdi
movq -0xb8(%rbp), %rsi
movl -0xbc(%rbp), %eax
addq %rax, %rsi
leaq -0x90(%rbp), %rdx
leaq -0xb0(%rbp), %rcx
callq 0x2fca0
cmpb $0x0, %al
je 0x1e43a
movq $0x0, -0xb0(%rbp)
jmp 0x1e43c
movq -0xb0(%rbp), %rax
movb %al, %cl
movq -0xb8(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0xb0(%rbp), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0xb8(%rbp), %rax
movb %cl, 0x5(%rax)
movq -0xb0(%rbp), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0xb8(%rbp), %rax
movb %cl, 0x6(%rax)
jmp 0x1e47f
movq -0x90(%rbp), %rax
movb %al, %cl
movq -0xb8(%rbp), %rax
movb %cl, (%rax)
movq -0x90(%rbp), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0xb8(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x90(%rbp), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0xb8(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x80(%rbp), %rcx
movl 0x64(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x64(%rcx)
movb %al, %cl
movq -0xb8(%rbp), %rax
movb %cl, 0x3(%rax)
movl -0xbc(%rbp), %eax
addq -0x90(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0xb8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
addq -0x90(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa0(%rbp), %rax
cmpq -0xa8(%rbp), %rax
je 0x1e614
movq -0x80(%rbp), %rax
movq (%rax), %rdi
movq -0xa0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movq -0xa0(%rbp), %rax
subq %rax, %rdx
callq 0x2e3f0
movq %rax, -0x98(%rbp)
cmpq $0x0, %rax
jg 0x1e5fa
callq 0x17050
movl (%rax), %eax
movl %eax, -0xc0(%rbp)
movq -0x80(%rbp), %rax
movb $0x2, 0x94(%rax)
movl -0xc0(%rbp), %edi
leaq -0x70(%rbp), %rsi
movl $0x64, %edx
callq 0x17290
movq -0x80(%rbp), %rax
movq (%rax), %rax
movq 0x50(%rax), %r10
movq -0x80(%rbp), %rax
movq (%rax), %rax
movq 0x40(%rax), %rdi
leaq 0x44aef(%rip), %rax # 0x630a0
movq (%rax), %rdx
leaq -0x70(%rbp), %r8
movl -0xc0(%rbp), %r9d
movl $0x1396, %esi # imm = 0x1396
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq *%r10
movq -0x80(%rbp), %rax
movb $0x0, 0x80(%rax)
movq -0x80(%rbp), %rax
cmpb $0x0, 0x84(%rax)
je 0x1e5f1
movq -0x88(%rbp), %rdi
callq 0x17710
movl $0x1, -0x74(%rbp)
jmp 0x1e651
movq -0x98(%rbp), %rax
addq -0xa0(%rbp), %rax
movq %rax, -0xa0(%rbp)
jmp 0x1e51f
movq -0x80(%rbp), %rax
cmpb $0x0, 0x84(%rax)
je 0x1e62d
movq -0x88(%rbp), %rdi
callq 0x17710
movq -0x80(%rbp), %rax
movb $0x0, 0x80(%rax)
movq -0xa0(%rbp), %rax
cmpq -0xa8(%rbp), %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %eax
movl %eax, -0xc4(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x1e67b
movl -0xc4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
callq 0x17690
| ma_net_real_write:
push rbp
mov rbp, rsp
sub rsp, 0D0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_80], rdi
mov [rbp+var_88], rsi
mov [rbp+var_90], rdx
mov rax, [rbp+var_80]
movzx eax, byte ptr [rax+94h]
cmp eax, 2
jnz short loc_1E346
mov [rbp+var_74], 0FFFFFFFFh
jmp loc_1E651
loc_1E346:
mov rax, [rbp+var_80]
mov byte ptr [rax+80h], 2
mov rax, [rbp+var_80]
cmp byte ptr [rax+84h], 0
jz loc_1E4FC
mov [rbp+var_BC], 7
mov rdi, [rbp+var_90]
add rdi, 4
add rdi, 3
add rdi, 1
call _malloc
mov [rbp+var_B8], rax
cmp rax, 0
jnz short loc_1E3E1
mov rax, [rbp+var_80]
mov rax, [rax]
mov r8, [rax+50h]
mov rax, [rbp+var_80]
mov rax, [rax]
mov rdi, [rax+40h]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov esi, 7D8h
xor eax, eax
mov ecx, eax
mov al, 0
call r8
mov rax, [rbp+var_80]
mov byte ptr [rax+94h], 2
mov rax, [rbp+var_80]
mov byte ptr [rax+80h], 0
mov [rbp+var_74], 1
jmp loc_1E651
loc_1E3E1:
mov rdi, [rbp+var_B8]
mov eax, [rbp+var_BC]
add rdi, rax
mov rsi, [rbp+var_88]
mov rdx, [rbp+var_90]
call _memcpy
mov rdi, [rbp+var_80]
mov rsi, [rbp+var_B8]
mov eax, [rbp+var_BC]
add rsi, rax
lea rdx, [rbp+var_90]
lea rcx, [rbp+var_B0]
call _mariadb_compress
cmp al, 0
jz short loc_1E43A
mov [rbp+var_B0], 0
loc_1E43A:
jmp short $+2
loc_1E43C:
mov rax, [rbp+var_B0]
mov cl, al
mov rax, [rbp+var_B8]
mov [rax+4], cl
mov rax, [rbp+var_B0]
shr rax, 8
mov cl, al
mov rax, [rbp+var_B8]
mov [rax+5], cl
mov rax, [rbp+var_B0]
shr rax, 10h
mov cl, al
mov rax, [rbp+var_B8]
mov [rax+6], cl
jmp short $+2
loc_1E47F:
mov rax, [rbp+var_90]
mov cl, al
mov rax, [rbp+var_B8]
mov [rax], cl
mov rax, [rbp+var_90]
shr rax, 8
mov cl, al
mov rax, [rbp+var_B8]
mov [rax+1], cl
mov rax, [rbp+var_90]
shr rax, 10h
mov cl, al
mov rax, [rbp+var_B8]
mov [rax+2], cl
mov rcx, [rbp+var_80]
mov eax, [rcx+64h]
mov edx, eax
add edx, 1
mov [rcx+64h], edx
mov cl, al
mov rax, [rbp+var_B8]
mov [rax+3], cl
mov eax, [rbp+var_BC]
add rax, [rbp+var_90]
mov [rbp+var_90], rax
mov rax, [rbp+var_B8]
mov [rbp+var_88], rax
loc_1E4FC:
mov rax, [rbp+var_88]
mov [rbp+var_A0], rax
mov rax, [rbp+var_A0]
add rax, [rbp+var_90]
mov [rbp+var_A8], rax
loc_1E51F:
mov rax, [rbp+var_A0]
cmp rax, [rbp+var_A8]
jz loc_1E614
mov rax, [rbp+var_80]
mov rdi, [rax]
mov rsi, [rbp+var_A0]
mov rdx, [rbp+var_A8]
mov rax, [rbp+var_A0]
sub rdx, rax
call ma_pvio_write
mov [rbp+var_98], rax
cmp rax, 0
jg loc_1E5FA
call ___errno_location
mov eax, [rax]
mov [rbp+var_C0], eax
mov rax, [rbp+var_80]
mov byte ptr [rax+94h], 2
mov edi, [rbp+var_C0]
lea rsi, [rbp+var_70]
mov edx, 64h ; 'd'
call ___xpg_strerror_r
mov rax, [rbp+var_80]
mov rax, [rax]
mov r10, [rax+50h]
mov rax, [rbp+var_80]
mov rax, [rax]
mov rdi, [rax+40h]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea r8, [rbp+var_70]
mov r9d, [rbp+var_C0]
mov esi, 1396h
xor eax, eax
mov ecx, eax
mov al, 0
call r10
mov rax, [rbp+var_80]
mov byte ptr [rax+80h], 0
mov rax, [rbp+var_80]
cmp byte ptr [rax+84h], 0
jz short loc_1E5F1
mov rdi, [rbp+var_88]
call _free
loc_1E5F1:
mov [rbp+var_74], 1
jmp short loc_1E651
loc_1E5FA:
mov rax, [rbp+var_98]
add rax, [rbp+var_A0]
mov [rbp+var_A0], rax
jmp loc_1E51F
loc_1E614:
mov rax, [rbp+var_80]
cmp byte ptr [rax+84h], 0
jz short loc_1E62D
mov rdi, [rbp+var_88]
call _free
loc_1E62D:
mov rax, [rbp+var_80]
mov byte ptr [rax+80h], 0
mov rax, [rbp+var_A0]
cmp rax, [rbp+var_A8]
setnz al
and al, 1
movzx eax, al
mov [rbp+var_74], eax
loc_1E651:
mov eax, [rbp+var_74]
mov [rbp+var_C4], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_1E67B
mov eax, [rbp+var_C4]
add rsp, 0D0h
pop rbp
retn
loc_1E67B:
call ___stack_chk_fail
| long long ma_net_real_write(_BYTE *a1, long long a2, long long a3)
{
int v3; // eax
long long v4; // rdi
unsigned int v6; // [rsp+10h] [rbp-C0h]
long long v7; // [rsp+18h] [rbp-B8h]
long long v8; // [rsp+20h] [rbp-B0h] BYREF
long long v9; // [rsp+28h] [rbp-A8h]
long long v10; // [rsp+30h] [rbp-A0h]
long long v11; // [rsp+38h] [rbp-98h]
long long v12; // [rsp+40h] [rbp-90h] BYREF
long long v13; // [rsp+48h] [rbp-88h]
_BYTE *v14; // [rsp+50h] [rbp-80h]
_BYTE v16[104]; // [rsp+60h] [rbp-70h] BYREF
unsigned long long v17; // [rsp+C8h] [rbp-8h]
v17 = __readfsqword(0x28u);
v14 = a1;
v13 = a2;
v12 = a3;
if ( a1[148] == 2 )
{
return (unsigned int)-1;
}
else
{
v14[128] = 2;
if ( v14[132] )
{
v7 = malloc(v12 + 8);
if ( !v7 )
{
(*(void ( **)(_QWORD, long long, char *, _QWORD))(*(_QWORD *)v14 + 80LL))(
*(_QWORD *)(*(_QWORD *)v14 + 64LL),
2008LL,
SQLSTATE_UNKNOWN,
0LL);
v14[148] = 2;
v14[128] = 0;
return 1;
}
memcpy(v7 + 7, v13, v12);
if ( (unsigned __int8)mariadb_compress(v14, v7 + 7, &v12, &v8) )
v8 = 0LL;
*(_WORD *)(v7 + 4) = v8;
*(_BYTE *)(v7 + 6) = BYTE2(v8);
*(_WORD *)v7 = v12;
*(_BYTE *)(v7 + 2) = BYTE2(v12);
v3 = *((_DWORD *)v14 + 25);
*((_DWORD *)v14 + 25) = v3 + 1;
*(_BYTE *)(v7 + 3) = v3;
v12 += 7LL;
v13 = v7;
}
v10 = v13;
v9 = v12 + v13;
while ( v10 != v9 )
{
v4 = *(_QWORD *)v14;
v11 = ma_pvio_write(*(_QWORD *)v14, v10, v9 - v10);
if ( v11 <= 0 )
{
v6 = *(_DWORD *)__errno_location(v4);
v14[148] = 2;
__xpg_strerror_r(v6, v16, 100LL);
(*(void ( **)(_QWORD, long long, char *, _QWORD, _BYTE *, _QWORD))(*(_QWORD *)v14 + 80LL))(
*(_QWORD *)(*(_QWORD *)v14 + 64LL),
5014LL,
SQLSTATE_UNKNOWN,
0LL,
v16,
v6);
v14[128] = 0;
if ( v14[132] )
free(v13);
return 1;
}
v10 += v11;
}
if ( v14[132] )
free(v13);
v14[128] = 0;
return v10 != v9;
}
}
| ma_net_real_write:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x80],RDI
MOV qword ptr [RBP + -0x88],RSI
MOV qword ptr [RBP + -0x90],RDX
MOV RAX,qword ptr [RBP + -0x80]
MOVZX EAX,byte ptr [RAX + 0x94]
CMP EAX,0x2
JNZ 0x0011e346
MOV dword ptr [RBP + -0x74],0xffffffff
JMP 0x0011e651
LAB_0011e346:
MOV RAX,qword ptr [RBP + -0x80]
MOV byte ptr [RAX + 0x80],0x2
MOV RAX,qword ptr [RBP + -0x80]
CMP byte ptr [RAX + 0x84],0x0
JZ 0x0011e4fc
MOV dword ptr [RBP + -0xbc],0x7
MOV RDI,qword ptr [RBP + -0x90]
ADD RDI,0x4
ADD RDI,0x3
ADD RDI,0x1
CALL 0x001177d0
MOV qword ptr [RBP + -0xb8],RAX
CMP RAX,0x0
JNZ 0x0011e3e1
MOV RAX,qword ptr [RBP + -0x80]
MOV RAX,qword ptr [RAX]
MOV R8,qword ptr [RAX + 0x50]
MOV RAX,qword ptr [RBP + -0x80]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + 0x40]
LEA RAX,[0x1630a0]
MOV RDX,qword ptr [RAX]
MOV ESI,0x7d8
XOR EAX,EAX
MOV ECX,EAX
MOV AL,0x0
CALL R8
MOV RAX,qword ptr [RBP + -0x80]
MOV byte ptr [RAX + 0x94],0x2
MOV RAX,qword ptr [RBP + -0x80]
MOV byte ptr [RAX + 0x80],0x0
MOV dword ptr [RBP + -0x74],0x1
JMP 0x0011e651
LAB_0011e3e1:
MOV RDI,qword ptr [RBP + -0xb8]
MOV EAX,dword ptr [RBP + -0xbc]
ADD RDI,RAX
MOV RSI,qword ptr [RBP + -0x88]
MOV RDX,qword ptr [RBP + -0x90]
CALL 0x001174a0
MOV RDI,qword ptr [RBP + -0x80]
MOV RSI,qword ptr [RBP + -0xb8]
MOV EAX,dword ptr [RBP + -0xbc]
ADD RSI,RAX
LEA RDX,[RBP + -0x90]
LEA RCX,[RBP + -0xb0]
CALL 0x0012fca0
CMP AL,0x0
JZ 0x0011e43a
MOV qword ptr [RBP + -0xb0],0x0
LAB_0011e43a:
JMP 0x0011e43c
LAB_0011e43c:
MOV RAX,qword ptr [RBP + -0xb0]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0xb8]
MOV byte ptr [RAX + 0x4],CL
MOV RAX,qword ptr [RBP + -0xb0]
SHR RAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0xb8]
MOV byte ptr [RAX + 0x5],CL
MOV RAX,qword ptr [RBP + -0xb0]
SHR RAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0xb8]
MOV byte ptr [RAX + 0x6],CL
JMP 0x0011e47f
LAB_0011e47f:
MOV RAX,qword ptr [RBP + -0x90]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0xb8]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x90]
SHR RAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0xb8]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x90]
SHR RAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0xb8]
MOV byte ptr [RAX + 0x2],CL
MOV RCX,qword ptr [RBP + -0x80]
MOV EAX,dword ptr [RCX + 0x64]
MOV EDX,EAX
ADD EDX,0x1
MOV dword ptr [RCX + 0x64],EDX
MOV CL,AL
MOV RAX,qword ptr [RBP + -0xb8]
MOV byte ptr [RAX + 0x3],CL
MOV EAX,dword ptr [RBP + -0xbc]
ADD RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RBP + -0x90],RAX
MOV RAX,qword ptr [RBP + -0xb8]
MOV qword ptr [RBP + -0x88],RAX
LAB_0011e4fc:
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RBP + -0xa0],RAX
MOV RAX,qword ptr [RBP + -0xa0]
ADD RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RBP + -0xa8],RAX
LAB_0011e51f:
MOV RAX,qword ptr [RBP + -0xa0]
CMP RAX,qword ptr [RBP + -0xa8]
JZ 0x0011e614
MOV RAX,qword ptr [RBP + -0x80]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0xa0]
MOV RDX,qword ptr [RBP + -0xa8]
MOV RAX,qword ptr [RBP + -0xa0]
SUB RDX,RAX
CALL 0x0012e3f0
MOV qword ptr [RBP + -0x98],RAX
CMP RAX,0x0
JG 0x0011e5fa
CALL 0x00117050
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0xc0],EAX
MOV RAX,qword ptr [RBP + -0x80]
MOV byte ptr [RAX + 0x94],0x2
MOV EDI,dword ptr [RBP + -0xc0]
LEA RSI,[RBP + -0x70]
MOV EDX,0x64
CALL 0x00117290
MOV RAX,qword ptr [RBP + -0x80]
MOV RAX,qword ptr [RAX]
MOV R10,qword ptr [RAX + 0x50]
MOV RAX,qword ptr [RBP + -0x80]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + 0x40]
LEA RAX,[0x1630a0]
MOV RDX,qword ptr [RAX]
LEA R8,[RBP + -0x70]
MOV R9D,dword ptr [RBP + -0xc0]
MOV ESI,0x1396
XOR EAX,EAX
MOV ECX,EAX
MOV AL,0x0
CALL R10
MOV RAX,qword ptr [RBP + -0x80]
MOV byte ptr [RAX + 0x80],0x0
MOV RAX,qword ptr [RBP + -0x80]
CMP byte ptr [RAX + 0x84],0x0
JZ 0x0011e5f1
MOV RDI,qword ptr [RBP + -0x88]
CALL 0x00117710
LAB_0011e5f1:
MOV dword ptr [RBP + -0x74],0x1
JMP 0x0011e651
LAB_0011e5fa:
MOV RAX,qword ptr [RBP + -0x98]
ADD RAX,qword ptr [RBP + -0xa0]
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x0011e51f
LAB_0011e614:
MOV RAX,qword ptr [RBP + -0x80]
CMP byte ptr [RAX + 0x84],0x0
JZ 0x0011e62d
MOV RDI,qword ptr [RBP + -0x88]
CALL 0x00117710
LAB_0011e62d:
MOV RAX,qword ptr [RBP + -0x80]
MOV byte ptr [RAX + 0x80],0x0
MOV RAX,qword ptr [RBP + -0xa0]
CMP RAX,qword ptr [RBP + -0xa8]
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RBP + -0x74],EAX
LAB_0011e651:
MOV EAX,dword ptr [RBP + -0x74]
MOV dword ptr [RBP + -0xc4],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0011e67b
MOV EAX,dword ptr [RBP + -0xc4]
ADD RSP,0xd0
POP RBP
RET
LAB_0011e67b:
CALL 0x00117690
|
uint ma_net_real_write(long *param_1,int1 *param_2,size_t param_3)
{
int iVar1;
char cVar2;
int1 *puVar3;
int *piVar4;
long in_FS_OFFSET;
int8 local_b8;
int1 *local_b0;
int1 *local_a8;
long local_a0;
size_t local_98;
int1 *local_90;
long *local_88;
uint local_7c;
int1 local_78 [104];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_98 = param_3;
local_90 = param_2;
local_88 = param_1;
if (*(char *)((long)param_1 + 0x94) == '\x02') {
local_7c = 0xffffffff;
}
else {
*(int1 *)(param_1 + 0x10) = 2;
if (*(char *)((long)param_1 + 0x84) != '\0') {
puVar3 = (int1 *)malloc(param_3 + 8);
if (puVar3 == (int1 *)0x0) {
(**(code **)(*local_88 + 0x50))(*(int8 *)(*local_88 + 0x40),0x7d8,SQLSTATE_UNKNOWN,0);
*(int1 *)((long)local_88 + 0x94) = 2;
*(int1 *)(local_88 + 0x10) = 0;
local_7c = 1;
goto LAB_0011e651;
}
memcpy(puVar3 + 7,local_90,local_98);
cVar2 = _mariadb_compress(local_88,puVar3 + 7,&local_98,&local_b8);
if (cVar2 != '\0') {
local_b8 = 0;
}
puVar3[4] = (char)local_b8;
puVar3[5] = (char)((ulong)local_b8 >> 8);
puVar3[6] = (char)((ulong)local_b8 >> 0x10);
*puVar3 = (char)local_98;
puVar3[1] = (char)(local_98 >> 8);
puVar3[2] = (char)(local_98 >> 0x10);
iVar1 = *(int *)((long)local_88 + 100);
*(int *)((long)local_88 + 100) = iVar1 + 1;
puVar3[3] = (char)iVar1;
local_98 = local_98 + 7;
local_90 = puVar3;
}
local_b0 = local_90 + local_98;
for (local_a8 = local_90; local_a8 != local_b0; local_a8 = local_a8 + local_a0) {
local_a0 = ma_pvio_write(*local_88,local_a8,(long)local_b0 - (long)local_a8);
if (local_a0 < 1) {
piVar4 = __errno_location();
iVar1 = *piVar4;
*(int1 *)((long)local_88 + 0x94) = 2;
__xpg_strerror_r(iVar1,local_78,100);
(**(code **)(*local_88 + 0x50))
(*(int8 *)(*local_88 + 0x40),0x1396,SQLSTATE_UNKNOWN,0,local_78,iVar1);
*(int1 *)(local_88 + 0x10) = 0;
if (*(char *)((long)local_88 + 0x84) != '\0') {
free(local_90);
}
local_7c = 1;
goto LAB_0011e651;
}
}
if (*(char *)((long)local_88 + 0x84) != '\0') {
free(local_90);
}
*(int1 *)(local_88 + 0x10) = 0;
local_7c = (uint)(local_a8 != local_b0);
}
LAB_0011e651:
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_7c;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
26,484 | my_vfprintf | eloqsql/strings/my_vsnprintf.c | int my_vfprintf(FILE *stream, const char* format, va_list args)
{
char cvtbuf[1024];
int alloc= 0;
char *p= cvtbuf;
size_t cur_len= sizeof(cvtbuf), actual;
int ret;
/*
We do not know how much buffer we need.
So start with a reasonably-sized stack-allocated buffer, and increase
it exponentially until it is big enough.
*/
for (;;)
{
size_t new_len;
actual= my_vsnprintf(p, cur_len, format, args);
if (actual < cur_len - 1)
break;
/*
Not enough space (or just enough with nothing to spare - but we cannot
distinguish this case from the return value). Allocate a bigger buffer
and try again.
*/
if (alloc)
my_free(p);
else
alloc= 1;
new_len= cur_len*2;
if (new_len < cur_len)
return 0; /* Overflow */
cur_len= new_len;
p= my_malloc(PSI_INSTRUMENT_ME, cur_len, MYF(MY_FAE));
if (!p)
return 0;
}
ret= (int) actual;
if (fputs(p, stream) < 0)
ret= -1;
if (alloc)
my_free(p);
return ret;
} | O0 | c | my_vfprintf:
pushq %rbp
movq %rsp, %rbp
subq $0x470, %rsp # imm = 0x470
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x420(%rbp)
movq %rsi, -0x428(%rbp)
movq %rdx, -0x430(%rbp)
movl $0x0, -0x434(%rbp)
leaq -0x410(%rbp), %rax
movq %rax, -0x440(%rbp)
movq $0x400, -0x448(%rbp) # imm = 0x400
movq -0x440(%rbp), %rdi
movq -0x448(%rbp), %rsi
movq -0x428(%rbp), %rdx
movq -0x430(%rbp), %rcx
callq 0x7cfa0
movq %rax, -0x450(%rbp)
movq -0x450(%rbp), %rax
movq -0x448(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x7d124
jmp 0x7d1b8
cmpl $0x0, -0x434(%rbp)
je 0x7d13b
movq -0x440(%rbp), %rdi
callq 0x2a830
jmp 0x7d145
movl $0x1, -0x434(%rbp)
movq -0x448(%rbp), %rax
shlq %rax
movq %rax, -0x460(%rbp)
movq -0x460(%rbp), %rax
cmpq -0x448(%rbp), %rax
jae 0x7d175
movl $0x0, -0x414(%rbp)
jmp 0x7d208
movq -0x460(%rbp), %rax
movq %rax, -0x448(%rbp)
movq -0x448(%rbp), %rsi
xorl %edi, %edi
movl $0x8, %edx
callq 0x2a4b0
movq %rax, -0x440(%rbp)
cmpq $0x0, -0x440(%rbp)
jne 0x7d1b3
movl $0x0, -0x414(%rbp)
jmp 0x7d208
jmp 0x7d0e0
movq -0x450(%rbp), %rax
movl %eax, -0x454(%rbp)
movq -0x440(%rbp), %rdi
movq -0x420(%rbp), %rsi
callq 0x24320
cmpl $0x0, %eax
jge 0x7d1e7
movl $0xffffffff, -0x454(%rbp) # imm = 0xFFFFFFFF
cmpl $0x0, -0x434(%rbp)
je 0x7d1fc
movq -0x440(%rbp), %rdi
callq 0x2a830
movl -0x454(%rbp), %eax
movl %eax, -0x414(%rbp)
movl -0x414(%rbp), %eax
movl %eax, -0x464(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x7d235
movl -0x464(%rbp), %eax
addq $0x470, %rsp # imm = 0x470
popq %rbp
retq
callq 0x24300
nopw (%rax,%rax)
| my_vfprintf:
push rbp
mov rbp, rsp
sub rsp, 470h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_420], rdi
mov [rbp+var_428], rsi
mov [rbp+var_430], rdx
mov [rbp+var_434], 0
lea rax, [rbp+var_410]
mov [rbp+var_440], rax
mov [rbp+var_448], 400h
loc_7D0E0:
mov rdi, [rbp+var_440]
mov rsi, [rbp+var_448]
mov rdx, [rbp+var_428]
mov rcx, [rbp+var_430]
call my_vsnprintf
mov [rbp+var_450], rax
mov rax, [rbp+var_450]
mov rcx, [rbp+var_448]
sub rcx, 1
cmp rax, rcx
jnb short loc_7D124
jmp loc_7D1B8
loc_7D124:
cmp [rbp+var_434], 0
jz short loc_7D13B
mov rdi, [rbp+var_440]
call my_free
jmp short loc_7D145
loc_7D13B:
mov [rbp+var_434], 1
loc_7D145:
mov rax, [rbp+var_448]
shl rax, 1
mov [rbp+var_460], rax
mov rax, [rbp+var_460]
cmp rax, [rbp+var_448]
jnb short loc_7D175
mov [rbp+var_414], 0
jmp loc_7D208
loc_7D175:
mov rax, [rbp+var_460]
mov [rbp+var_448], rax
mov rsi, [rbp+var_448]
xor edi, edi
mov edx, 8
call my_malloc
mov [rbp+var_440], rax
cmp [rbp+var_440], 0
jnz short loc_7D1B3
mov [rbp+var_414], 0
jmp short loc_7D208
loc_7D1B3:
jmp loc_7D0E0
loc_7D1B8:
mov rax, [rbp+var_450]
mov [rbp+var_454], eax
mov rdi, [rbp+var_440]
mov rsi, [rbp+var_420]
call _fputs
cmp eax, 0
jge short loc_7D1E7
mov [rbp+var_454], 0FFFFFFFFh
loc_7D1E7:
cmp [rbp+var_434], 0
jz short loc_7D1FC
mov rdi, [rbp+var_440]
call my_free
loc_7D1FC:
mov eax, [rbp+var_454]
mov [rbp+var_414], eax
loc_7D208:
mov eax, [rbp+var_414]
mov [rbp+var_464], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_7D235
mov eax, [rbp+var_464]
add rsp, 470h
pop rbp
retn
loc_7D235:
call ___stack_chk_fail
| long long my_vfprintf(long long a1, char *a2, int *a3)
{
unsigned long long v4; // [rsp+10h] [rbp-460h]
unsigned int v5; // [rsp+1Ch] [rbp-454h]
_BYTE *v6; // [rsp+20h] [rbp-450h]
unsigned long long i; // [rsp+28h] [rbp-448h]
char *v8; // [rsp+30h] [rbp-440h]
int v9; // [rsp+3Ch] [rbp-434h]
char v12; // [rsp+60h] [rbp-410h] BYREF
unsigned long long v13; // [rsp+468h] [rbp-8h]
v13 = __readfsqword(0x28u);
v9 = 0;
v8 = &v12;
for ( i = 1024LL; ; i *= 2LL )
{
v6 = my_vsnprintf(v8, i, a2, a3);
if ( (unsigned long long)v6 < i - 1 )
break;
if ( v9 )
my_free((long long)v8);
else
v9 = 1;
v4 = 2 * i;
if ( 2 * i < i )
return 0;
v8 = (char *)my_malloc(0, v4, 8);
if ( !v8 )
return 0;
}
v5 = (unsigned int)v6;
if ( (int)fputs(v8, a1) < 0 )
v5 = -1;
if ( v9 )
my_free((long long)v8);
return v5;
}
| my_vfprintf:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x470
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x420],RDI
MOV qword ptr [RBP + -0x428],RSI
MOV qword ptr [RBP + -0x430],RDX
MOV dword ptr [RBP + -0x434],0x0
LEA RAX,[RBP + -0x410]
MOV qword ptr [RBP + -0x440],RAX
MOV qword ptr [RBP + -0x448],0x400
LAB_0017d0e0:
MOV RDI,qword ptr [RBP + -0x440]
MOV RSI,qword ptr [RBP + -0x448]
MOV RDX,qword ptr [RBP + -0x428]
MOV RCX,qword ptr [RBP + -0x430]
CALL 0x0017cfa0
MOV qword ptr [RBP + -0x450],RAX
MOV RAX,qword ptr [RBP + -0x450]
MOV RCX,qword ptr [RBP + -0x448]
SUB RCX,0x1
CMP RAX,RCX
JNC 0x0017d124
JMP 0x0017d1b8
LAB_0017d124:
CMP dword ptr [RBP + -0x434],0x0
JZ 0x0017d13b
MOV RDI,qword ptr [RBP + -0x440]
CALL 0x0012a830
JMP 0x0017d145
LAB_0017d13b:
MOV dword ptr [RBP + -0x434],0x1
LAB_0017d145:
MOV RAX,qword ptr [RBP + -0x448]
SHL RAX,0x1
MOV qword ptr [RBP + -0x460],RAX
MOV RAX,qword ptr [RBP + -0x460]
CMP RAX,qword ptr [RBP + -0x448]
JNC 0x0017d175
MOV dword ptr [RBP + -0x414],0x0
JMP 0x0017d208
LAB_0017d175:
MOV RAX,qword ptr [RBP + -0x460]
MOV qword ptr [RBP + -0x448],RAX
MOV RSI,qword ptr [RBP + -0x448]
XOR EDI,EDI
MOV EDX,0x8
CALL 0x0012a4b0
MOV qword ptr [RBP + -0x440],RAX
CMP qword ptr [RBP + -0x440],0x0
JNZ 0x0017d1b3
MOV dword ptr [RBP + -0x414],0x0
JMP 0x0017d208
LAB_0017d1b3:
JMP 0x0017d0e0
LAB_0017d1b8:
MOV RAX,qword ptr [RBP + -0x450]
MOV dword ptr [RBP + -0x454],EAX
MOV RDI,qword ptr [RBP + -0x440]
MOV RSI,qword ptr [RBP + -0x420]
CALL 0x00124320
CMP EAX,0x0
JGE 0x0017d1e7
MOV dword ptr [RBP + -0x454],0xffffffff
LAB_0017d1e7:
CMP dword ptr [RBP + -0x434],0x0
JZ 0x0017d1fc
MOV RDI,qword ptr [RBP + -0x440]
CALL 0x0012a830
LAB_0017d1fc:
MOV EAX,dword ptr [RBP + -0x454]
MOV dword ptr [RBP + -0x414],EAX
LAB_0017d208:
MOV EAX,dword ptr [RBP + -0x414]
MOV dword ptr [RBP + -0x464],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0017d235
MOV EAX,dword ptr [RBP + -0x464]
ADD RSP,0x470
POP RBP
RET
LAB_0017d235:
CALL 0x00124300
|
int4 my_vfprintf(FILE *param_1,int8 param_2,int8 param_3)
{
bool bVar1;
int iVar2;
ulong uVar3;
long in_FS_OFFSET;
int4 local_45c;
ulong local_450;
char *local_448;
int4 local_41c;
char local_418 [1032];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
bVar1 = false;
local_448 = local_418;
local_450 = 0x400;
do {
uVar3 = my_vsnprintf(local_448,local_450,param_2,param_3);
if (uVar3 < local_450 - 1) {
local_45c = (int4)uVar3;
iVar2 = fputs(local_448,param_1);
if (iVar2 < 0) {
local_45c = 0xffffffff;
}
if (bVar1) {
my_free(local_448);
}
local_41c = local_45c;
goto LAB_0017d208;
}
if (bVar1) {
my_free(local_448);
}
else {
bVar1 = true;
}
uVar3 = local_450 << 1;
if (uVar3 < local_450) {
local_41c = 0;
goto LAB_0017d208;
}
local_448 = (char *)my_malloc(0,uVar3,8);
local_450 = uVar3;
} while (local_448 != (char *)0x0);
local_41c = 0;
LAB_0017d208:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_41c;
}
| |
26,485 | tailoring_append | eloqsql/strings/ctype.c | static int
tailoring_append(MY_XML_PARSER *st,
const char *fmt, size_t len, const char *attr)
{
struct my_cs_file_info *i= (struct my_cs_file_info *) st->user_data;
size_t newlen= i->tailoring_length + len + 64; /* 64 for format */
if (MY_XML_OK == my_charset_file_tailoring_realloc(i, newlen))
{
char *dst= i->tailoring + i->tailoring_length;
sprintf(dst, fmt, (int) len, attr);
i->tailoring_length+= strlen(dst);
return MY_XML_OK;
}
return MY_XML_ERROR;
} | O3 | c | tailoring_append:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r9
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x690(%rdi), %r13
leaq (%rdx,%r13), %rax
addq $0x40, %rax
cmpq %rax, 0x698(%rdi)
jbe 0xd1b4f
movq 0x688(%rbx), %rax
jmp 0xd1b93
movq %r9, %r14
addq %r15, %r13
movq 0x688(%rbx), %rdi
movq 0x7a8(%rbx), %rax
movq 0x90(%rax), %rax
addq $0x8040, %r13 # imm = 0x8040
movq %r13, 0x698(%rbx)
movq %r13, %rsi
callq *%rax
movq %rax, 0x688(%rbx)
testq %rax, %rax
je 0xd1bd6
movq 0x690(%rbx), %r13
movq %r14, %r9
addq %rax, %r13
xorl %r14d, %r14d
movq %r13, %rdi
movl $0x1, %esi
movq $-0x1, %rdx
movq %r12, %rcx
movl %r15d, %r8d
xorl %eax, %eax
callq 0x29970
movq %r13, %rdi
callq 0x29350
addq %rax, 0x690(%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %r14d
jmp 0xd1bc4
| tailoring_append:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r9, rcx
mov r15, rdx
mov r12, rsi
mov rbx, rdi
mov r13, [rdi+690h]
lea rax, [rdx+r13]
add rax, 40h ; '@'
cmp [rdi+698h], rax
jbe short loc_D1B4F
mov rax, [rbx+688h]
jmp short loc_D1B93
loc_D1B4F:
mov r14, r9
add r13, r15
mov rdi, [rbx+688h]
mov rax, [rbx+7A8h]
mov rax, [rax+90h]
add r13, 8040h
mov [rbx+698h], r13
mov rsi, r13
call rax
mov [rbx+688h], rax
test rax, rax
jz short loc_D1BD6
mov r13, [rbx+690h]
mov r9, r14
loc_D1B93:
add r13, rax
xor r14d, r14d
mov rdi, r13
mov esi, 1
mov rdx, 0FFFFFFFFFFFFFFFFh
mov rcx, r12
mov r8d, r15d
xor eax, eax
call ___sprintf_chk
mov rdi, r13
call _strlen
add [rbx+690h], rax
loc_D1BC4:
mov eax, r14d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_D1BD6:
mov r14d, 1
jmp short loc_D1BC4
| long long tailoring_append(_QWORD *a1, const char *a2, long long a3, long long a4)
{
long long v4; // rax
long long v5; // r9
unsigned int v6; // r15d
long long v8; // r13
long long v9; // rax
long long v11; // rdi
long long ( *v12)(long long, long long); // rax
long long v13; // r13
long long v14; // r13
unsigned int v15; // r14d
long long v17; // [rsp-8h] [rbp-30h]
v17 = v4;
v5 = a4;
v6 = a3;
v8 = a1[210];
if ( a1[211] <= (unsigned long long)(a3 + v8 + 64) )
{
v11 = a1[209];
v12 = *(long long ( **)(long long, long long))(a1[245] + 144LL);
v13 = a3 + v8 + 32832;
a1[211] = v13;
v9 = v12(v11, v13);
a1[209] = v9;
if ( !v9 )
return 1;
v8 = a1[210];
v5 = a4;
}
else
{
v9 = a1[209];
}
v14 = v9 + v8;
v15 = 0;
__sprintf_chk(v14, 1LL, -1LL, a2, v6, v5, v17);
a1[210] += strlen(v14);
return v15;
}
| tailoring_append:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R9,RCX
MOV R15,RDX
MOV R12,RSI
MOV RBX,RDI
MOV R13,qword ptr [RDI + 0x690]
LEA RAX,[RDX + R13*0x1]
ADD RAX,0x40
CMP qword ptr [RDI + 0x698],RAX
JBE 0x001d1b4f
MOV RAX,qword ptr [RBX + 0x688]
JMP 0x001d1b93
LAB_001d1b4f:
MOV R14,R9
ADD R13,R15
MOV RDI,qword ptr [RBX + 0x688]
MOV RAX,qword ptr [RBX + 0x7a8]
MOV RAX,qword ptr [RAX + 0x90]
ADD R13,0x8040
MOV qword ptr [RBX + 0x698],R13
MOV RSI,R13
CALL RAX
MOV qword ptr [RBX + 0x688],RAX
TEST RAX,RAX
JZ 0x001d1bd6
MOV R13,qword ptr [RBX + 0x690]
MOV R9,R14
LAB_001d1b93:
ADD R13,RAX
XOR R14D,R14D
MOV RDI,R13
MOV ESI,0x1
MOV RDX,-0x1
MOV RCX,R12
MOV R8D,R15D
XOR EAX,EAX
CALL 0x00129970
MOV RDI,R13
CALL 0x00129350
ADD qword ptr [RBX + 0x690],RAX
LAB_001d1bc4:
MOV EAX,R14D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001d1bd6:
MOV R14D,0x1
JMP 0x001d1bc4
|
int8 tailoring_append(long param_1,int8 param_2,ulong param_3,int8 param_4)
{
code *pcVar1;
long lVar2;
size_t sVar3;
long lVar4;
lVar4 = *(long *)(param_1 + 0x690);
if (param_3 + lVar4 + 0x40 < *(ulong *)(param_1 + 0x698)) {
lVar2 = *(long *)(param_1 + 0x688);
}
else {
pcVar1 = *(code **)(*(long *)(param_1 + 0x7a8) + 0x90);
lVar4 = lVar4 + param_3 + 0x8040;
*(long *)(param_1 + 0x698) = lVar4;
lVar2 = (*pcVar1)(*(int8 *)(param_1 + 0x688),lVar4);
*(long *)(param_1 + 0x688) = lVar2;
if (lVar2 == 0) {
return 1;
}
lVar4 = *(long *)(param_1 + 0x690);
}
__sprintf_chk((char *)(lVar4 + lVar2),1,0xffffffffffffffff,param_2,param_3 & 0xffffffff,param_4);
sVar3 = strlen((char *)(lVar4 + lVar2));
*(long *)(param_1 + 0x690) = *(long *)(param_1 + 0x690) + sVar3;
return 0;
}
| |
26,486 | flux::parser::Parser::namedType() | kvthweatt[P]FluxLang/src/parser/parser.cpp | std::unique_ptr<TypeExpr> Parser::namedType() {
auto name = consume(lexer::TokenType::IDENTIFIER, "Expected type name");
return std::make_unique<NamedTypeExpr>(
name.lexeme(),
makeRange(name)
);
} | O0 | cpp | flux::parser::Parser::namedType():
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0xf8(%rbp)
movq %rdi, %rax
movq %rax, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq 0xbb20(%rip), %rsi # 0x644d6
leaq -0x80(%rbp), %rdi
callq 0xd130
movq -0xe8(%rbp), %rsi
movq -0x80(%rbp), %rcx
movq -0x78(%rbp), %r8
leaq -0x70(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
movl $0x5, %edx
callq 0x43180
movq -0xe0(%rbp), %rdi
callq 0x2a860
movq %rdx, -0xd8(%rbp)
movq %rax, -0xd0(%rbp)
jmp 0x589ff
movq -0xe8(%rbp), %rsi
movq -0xd8(%rbp), %rax
movq -0xd0(%rbp), %rcx
movq %rcx, -0x98(%rbp)
movq %rax, -0x90(%rbp)
leaq -0xc8(%rbp), %rdi
leaq -0x70(%rbp), %rdx
callq 0x435d0
jmp 0x58a34
leaq -0x88(%rbp), %rdi
leaq -0x98(%rbp), %rsi
leaq -0xc8(%rbp), %rdx
callq 0x591b0
jmp 0x58a50
movq -0xf8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x229c0
leaq -0x88(%rbp), %rdi
callq 0x22a10
leaq -0x70(%rbp), %rdi
callq 0xa300
movq -0xf0(%rbp), %rax
addq $0x100, %rsp # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xa300
movq -0xa0(%rbp), %rdi
callq 0x75a0
nop
| _ZN4flux6parser6Parser9namedTypeEv:
push rbp
mov rbp, rsp
sub rsp, 100h
mov [rbp+var_F8], rdi
mov rax, rdi
mov [rbp+var_F0], rax
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov [rbp+var_E8], rax
lea rsi, aExpectedTypeNa; "Expected type name"
lea rdi, [rbp+var_80]
call _ZNSt17basic_string_viewIcSt11char_traitsIcEEC2EPKc; std::string_view::basic_string_view(char const*)
mov rsi, [rbp+var_E8]
mov rcx, [rbp+var_80]
mov r8, [rbp+var_78]
lea rdi, [rbp+var_70]
mov [rbp+var_E0], rdi
mov edx, 5
call _ZN4flux6parser6Parser7consumeENS_5lexer9TokenTypeESt17basic_string_viewIcSt11char_traitsIcEE; flux::parser::Parser::consume(flux::lexer::TokenType,std::string_view)
mov rdi, [rbp+var_E0]; this
call _ZNK4flux5lexer5Token6lexemeEv; flux::lexer::Token::lexeme(void)
mov [rbp+var_D8], rdx
mov [rbp+var_D0], rax
jmp short $+2
loc_589FF:
mov rsi, [rbp+var_E8]; flux::lexer::Token *
mov rax, [rbp+var_D8]
mov rcx, [rbp+var_D0]
mov [rbp+var_98], rcx
mov [rbp+var_90], rax
lea rdi, [rbp+var_C8]; this
lea rdx, [rbp+var_70]
call _ZNK4flux6parser6Parser9makeRangeERKNS_5lexer5TokenE; flux::parser::Parser::makeRange(flux::lexer::Token const&)
jmp short $+2
loc_58A34:
lea rdi, [rbp+var_88]
lea rsi, [rbp+var_98]
lea rdx, [rbp+var_C8]
call _ZSt11make_uniqueIN4flux6parser13NamedTypeExprEJSt17basic_string_viewIcSt11char_traitsIcEENS0_6common11SourceRangeEEENSt9_MakeUniqIT_E15__single_objectEDpOT0_; std::make_unique<flux::parser::NamedTypeExpr,std::string_view,flux::common::SourceRange>(std::string_view,flux::common::SourceRange &&)
jmp short $+2
loc_58A50:
mov rdi, [rbp+var_F8]
lea rsi, [rbp+var_88]
call _ZNSt10unique_ptrIN4flux6parser8TypeExprESt14default_deleteIS2_EEC2INS1_13NamedTypeExprES3_IS7_EvEEOS_IT_T0_E; std::unique_ptr<flux::parser::TypeExpr>::unique_ptr<flux::parser::NamedTypeExpr,std::default_delete<flux::parser::NamedTypeExpr>,void>(std::unique_ptr&&<flux::parser::NamedTypeExpr,std::default_delete<flux::parser::NamedTypeExpr>>)
lea rdi, [rbp+var_88]
call _ZNSt10unique_ptrIN4flux6parser13NamedTypeExprESt14default_deleteIS2_EED2Ev; std::unique_ptr<flux::parser::NamedTypeExpr>::~unique_ptr()
lea rdi, [rbp+var_70]; this
call _ZN4flux5lexer5TokenD2Ev; flux::lexer::Token::~Token()
mov rax, [rbp+var_F0]
add rsp, 100h
pop rbp
retn
mov rcx, rax
mov eax, edx
mov [rbp+var_A0], rcx
mov [rbp+var_A4], eax
lea rdi, [rbp+var_70]; this
call _ZN4flux5lexer5TokenD2Ev; flux::lexer::Token::~Token()
mov rdi, [rbp+var_A0]
call __Unwind_Resume
| flux::parser::Parser * flux::parser::Parser::namedType(
flux::parser::Parser *this,
const flux::lexer::Token *a2)
{
long long v2; // rdx
_BYTE v4[36]; // [rsp+38h] [rbp-C8h] BYREF
_QWORD v5[2]; // [rsp+68h] [rbp-98h] BYREF
_BYTE v6[8]; // [rsp+78h] [rbp-88h] BYREF
long long v7[2]; // [rsp+80h] [rbp-80h] BYREF
_BYTE v8[96]; // [rsp+90h] [rbp-70h] BYREF
const flux::lexer::Token *v9; // [rsp+F0h] [rbp-10h]
flux::parser::Parser *v10; // [rsp+F8h] [rbp-8h]
v10 = this;
v9 = a2;
std::string_view::basic_string_view(v7, (long long)"Expected type name");
flux::parser::Parser::consume((flux::parser::Parser *)v8, a2, 5, v7[0], v7[1]);
v5[0] = flux::lexer::Token::lexeme((flux::lexer::Token *)v8);
v5[1] = v2;
flux::parser::Parser::makeRange((flux::parser::Parser *)v4, a2, (flux::lexer::Token *)v8);
std::make_unique<flux::parser::NamedTypeExpr,std::string_view,flux::common::SourceRange>(v6, v5, v4);
std::unique_ptr<flux::parser::TypeExpr>::unique_ptr<flux::parser::NamedTypeExpr,std::default_delete<flux::parser::NamedTypeExpr>,void>(
(long long)this,
(long long)v6);
std::unique_ptr<flux::parser::NamedTypeExpr>::~unique_ptr((long long)v6);
flux::lexer::Token::~Token((flux::lexer::Token *)v8);
return this;
}
| namedType:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x100
MOV qword ptr [RBP + -0xf8],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0xf0],RAX
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0xe8],RAX
LEA RSI,[0x1644d6]
LEA RDI,[RBP + -0x80]
CALL 0x0010d130
MOV RSI,qword ptr [RBP + -0xe8]
MOV RCX,qword ptr [RBP + -0x80]
MOV R8,qword ptr [RBP + -0x78]
LEA RDI,[RBP + -0x70]
MOV qword ptr [RBP + -0xe0],RDI
MOV EDX,0x5
CALL 0x00143180
MOV RDI,qword ptr [RBP + -0xe0]
LAB_001589ea:
CALL 0x0012a860
MOV qword ptr [RBP + -0xd8],RDX
MOV qword ptr [RBP + -0xd0],RAX
JMP 0x001589ff
LAB_001589ff:
MOV RSI,qword ptr [RBP + -0xe8]
MOV RAX,qword ptr [RBP + -0xd8]
MOV RCX,qword ptr [RBP + -0xd0]
MOV qword ptr [RBP + -0x98],RCX
MOV qword ptr [RBP + -0x90],RAX
LEA RDI,[RBP + -0xc8]
LEA RDX,[RBP + -0x70]
CALL 0x001435d0
JMP 0x00158a34
LAB_00158a34:
LEA RDI,[RBP + -0x88]
LEA RSI,[RBP + -0x98]
LEA RDX,[RBP + -0xc8]
CALL 0x001591b0
LAB_00158a4e:
JMP 0x00158a50
LAB_00158a50:
MOV RDI,qword ptr [RBP + -0xf8]
LEA RSI,[RBP + -0x88]
CALL 0x001229c0
LEA RDI,[RBP + -0x88]
CALL 0x00122a10
LEA RDI,[RBP + -0x70]
CALL 0x0010a300
MOV RAX,qword ptr [RBP + -0xf0]
ADD RSP,0x100
POP RBP
RET
|
/* flux::parser::Parser::namedType() */
unique_ptr<flux::parser::TypeExpr,std::default_delete<flux::parser::TypeExpr>> *
flux::parser::Parser::namedType(void)
{
int8 in_RSI;
unique_ptr<flux::parser::TypeExpr,std::default_delete<flux::parser::TypeExpr>> *in_RDI;
Token local_d0 [48];
SourceRange local_a0 [16];
unique_ptr local_90 [8];
int8 local_88;
int8 local_80;
Token local_78 [112];
std::basic_string_view<char,std::char_traits<char>>::basic_string_view
((basic_string_view<char,std::char_traits<char>> *)&local_88,"Expected type name");
consume(local_78,in_RSI,5,local_88,local_80);
/* try { // try from 001589ea to 00158a4d has its CatchHandler @ 00158a88 */
local_a0 = (SourceRange [16])lexer::Token::lexeme(local_78);
makeRange(local_d0);
std::
make_unique<flux::parser::NamedTypeExpr,std::basic_string_view<char,std::char_traits<char>>,flux::common::SourceRange>
(local_90,local_a0);
std::unique_ptr<flux::parser::TypeExpr,std::default_delete<flux::parser::TypeExpr>>::
unique_ptr<flux::parser::NamedTypeExpr,std::default_delete<flux::parser::NamedTypeExpr>,void>
(in_RDI,local_90);
std::unique_ptr<flux::parser::NamedTypeExpr,std::default_delete<flux::parser::NamedTypeExpr>>::
~unique_ptr((unique_ptr<flux::parser::NamedTypeExpr,std::default_delete<flux::parser::NamedTypeExpr>>
*)local_90);
lexer::Token::~Token(local_78);
return in_RDI;
}
| |
26,487 | ma_state_info_read_dsk | eloqsql/storage/maria/ma_open.c | uint _ma_state_info_read_dsk(File file __attribute__((unused)),
MARIA_STATE_INFO *state __attribute__((unused)))
{
#ifdef MARIA_EXTERNAL_LOCKING
uchar buff[MARIA_STATE_INFO_SIZE + MARIA_STATE_EXTRA_SIZE];
/* trick to detect transactional tables */
DBUG_ASSERT(state->create_rename_lsn == LSN_IMPOSSIBLE);
if (!maria_single_user)
{
if (mysql_file_pread(file, buff, state->state_length, 0L, MYF(MY_NABP)))
return 1;
_ma_state_info_read(buff, state);
}
#endif
return 0;
} | O0 | c | ma_state_info_read_dsk:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
popq %rbp
retq
nop
| _ma_state_info_read_dsk:
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
xor eax, eax
pop rbp
retn
| long long ma_state_info_read_dsk()
{
return 0LL;
}
| _ma_state_info_read_dsk:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
XOR EAX,EAX
POP RBP
RET
|
int8 _ma_state_info_read_dsk(void)
{
return 0;
}
| |
26,488 | pfs_memory_free_v1 | eloqsql/storage/perfschema/pfs.cc | void pfs_memory_free_v1(PSI_memory_key key, size_t size, PSI_thread *owner)
{
PFS_memory_class *klass= find_memory_class(key);
if (klass == NULL)
return;
/*
Do not check klass->m_enabled.
Do not check flag_global_instrumentation.
If a memory alloc was instrumented,
the corresponding free must be instrumented.
*/
PFS_memory_stat *event_name_array;
PFS_memory_stat *stat;
uint index= klass->m_event_name_index;
PFS_memory_stat_delta delta_buffer;
PFS_memory_stat_delta *delta;
if (flag_thread_instrumentation && ! klass->is_global())
{
PFS_thread *pfs_thread= my_thread_get_THR_PFS();
if (likely(pfs_thread != NULL))
{
#ifdef PFS_PARANOID
PFS_thread *owner_thread= reinterpret_cast<PFS_thread*>(owner);
if (owner_thread != pfs_thread)
{
owner_thread= sanitize_thread(owner_thread);
if (owner_thread != NULL)
{
report_memory_accounting_error("pfs_memory_free_v1",
pfs_thread, size, klass, owner_thread);
}
}
#endif /* PFS_PARANOID */
/*
Do not check pfs_thread->m_enabled.
If a memory alloc was instrumented,
the corresponding free must be instrumented.
*/
/* Aggregate to MEMORY_SUMMARY_BY_THREAD_BY_EVENT_NAME */
event_name_array= pfs_thread->write_instr_class_memory_stats();
stat= & event_name_array[index];
delta= stat->count_free(size, &delta_buffer);
if (delta != NULL)
{
pfs_thread->carry_memory_stat_delta(delta, index);
}
return;
}
}
/* Aggregate to MEMORY_SUMMARY_GLOBAL_BY_EVENT_NAME */
event_name_array= global_instr_class_memory_array;
if (event_name_array)
{
stat= & event_name_array[index];
(void) stat->count_free(size, &delta_buffer);
}
return;
} | O3 | cpp | pfs_memory_free_v1:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
callq 0x3631b
testq %rax, %rax
je 0x3e776
movl 0x10(%rax), %ebx
leaq 0x3925b9(%rip), %rcx # 0x3d0c40
cmpb $0x1, (%rcx)
jne 0x3e76c
testb $0x1, 0x8(%rax)
jne 0x3e76c
movl 0x391bcc(%rip), %edi # 0x3d026c
callq 0x26540
testq %rax, %rax
je 0x3e76c
movq %rax, %r15
cmpb $0x0, 0x4(%rax)
jne 0x3e6c4
movq %r15, %rdi
callq 0x403ae
movb $0x1, 0x4(%r15)
movq 0x28(%r15), %rax
leaq (%rbx,%rbx,8), %rcx
leaq (%rax,%rcx,8), %rax
movb $0x1, (%rax)
incq 0x10(%rax)
movdqu 0x20(%rax), %xmm0
movq %r14, %xmm1
shufpd $0x2, 0x3c956(%rip), %xmm1 # xmm1 = xmm1[0],mem[1]
paddq %xmm0, %xmm1
movdqu %xmm1, 0x20(%rax)
addq %r14, 0x38(%rax)
movq 0x30(%rax), %rcx
testq %rcx, %rcx
je 0x3e720
movq 0x40(%rax), %rdx
subq %r14, %rdx
jae 0x3e75f
pxor %xmm0, %xmm0
movdqa %xmm0, -0x30(%rbp)
movdqa %xmm0, -0x40(%rbp)
decq %rcx
movq %rcx, 0x30(%rax)
jmp 0x3e736
pxor %xmm0, %xmm0
movdqa %xmm0, -0x40(%rbp)
movdqa %xmm0, -0x30(%rbp)
movq $0x1, -0x38(%rbp)
movq 0x40(%rax), %rdx
movq %rdx, %rcx
subq %r14, %rcx
jae 0x3e74b
subq %rdx, %r14
movq %r14, -0x28(%rbp)
xorl %ecx, %ecx
movq %rcx, 0x40(%rax)
leaq -0x40(%rbp), %rsi
movq %r15, %rdi
movl %ebx, %edx
callq 0x2f930
jmp 0x3e776
decq %rcx
movq %rcx, 0x30(%rax)
movq %rdx, 0x40(%rax)
jmp 0x3e776
movl %ebx, %edi
movq %r14, %rsi
callq 0x2ad71
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| pfs_memory_free_v1:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 28h
mov r14, rsi
call _Z17find_memory_classj; find_memory_class(uint)
test rax, rax
jz loc_3E776
mov ebx, [rax+10h]
lea rcx, flag_thread_instrumentation
cmp byte ptr [rcx], 1
jnz loc_3E76C
test byte ptr [rax+8], 1
jnz loc_3E76C
mov edi, cs:THR_PFS
call _pthread_getspecific
test rax, rax
jz loc_3E76C
mov r15, rax
cmp byte ptr [rax+4], 0
jnz short loc_3E6C4
mov rdi, r15; this
call _ZN20PFS_connection_slice19rebase_memory_statsEv; PFS_connection_slice::rebase_memory_stats(void)
mov byte ptr [r15+4], 1
loc_3E6C4:
mov rax, [r15+28h]
lea rcx, [rbx+rbx*8]
lea rax, [rax+rcx*8]
mov byte ptr [rax], 1
inc qword ptr [rax+10h]
movdqu xmm0, xmmword ptr [rax+20h]
movq xmm1, r14
shufpd xmm1, cs:xmmword_7B040, 2
paddq xmm1, xmm0
movdqu xmmword ptr [rax+20h], xmm1
add [rax+38h], r14
mov rcx, [rax+30h]
test rcx, rcx
jz short loc_3E720
mov rdx, [rax+40h]
sub rdx, r14
jnb short loc_3E75F
pxor xmm0, xmm0
movdqa [rbp+var_30], xmm0
movdqa [rbp+var_40], xmm0
dec rcx
mov [rax+30h], rcx
jmp short loc_3E736
loc_3E720:
pxor xmm0, xmm0
movdqa [rbp+var_40], xmm0
movdqa [rbp+var_30], xmm0
mov qword ptr [rbp+var_40+8], 1
loc_3E736:
mov rdx, [rax+40h]
mov rcx, rdx
sub rcx, r14
jnb short loc_3E74B
sub r14, rdx
mov qword ptr [rbp+var_30+8], r14
xor ecx, ecx
loc_3E74B:
mov [rax+40h], rcx
lea rsi, [rbp+var_40]
mov rdi, r15
mov edx, ebx
call _ZN10PFS_thread23carry_memory_stat_deltaEP21PFS_memory_stat_deltaj; PFS_thread::carry_memory_stat_delta(PFS_memory_stat_delta *,uint)
jmp short loc_3E776
loc_3E75F:
dec rcx
mov [rax+30h], rcx
mov [rax+40h], rdx
jmp short loc_3E776
loc_3E76C:
mov edi, ebx
mov rsi, r14
call pfs_memory_free_v1_cold_1
loc_3E776:
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
| __m128i * pfs_memory_free_v1(int a1, unsigned long long a2)
{
__m128i *result; // rax
long long v3; // rbx
PFS_connection_slice *v4; // rax
PFS_connection_slice *v5; // r15
long long v6; // rcx
unsigned long long v7; // rdx
bool v8; // cf
long long v9; // rdx
unsigned long long v10; // rcx
long long v11; // rcx
__int128 v12; // [rsp+0h] [rbp-40h] BYREF
__int128 v13; // [rsp+10h] [rbp-30h]
result = (__m128i *)find_memory_class(a1);
if ( result )
{
v3 = result[1].m128i_u32[0];
if ( flag_thread_instrumentation[0] == 1
&& (result->m128i_i8[8] & 1) == 0
&& (v4 = (PFS_connection_slice *)pthread_getspecific((unsigned int)THR_PFS)) != 0LL )
{
v5 = v4;
if ( !*((_BYTE *)v4 + 4) )
{
PFS_connection_slice::rebase_memory_stats(v4);
*((_BYTE *)v5 + 4) = 1;
}
result = (__m128i *)(*((_QWORD *)v5 + 5) + 72 * v3);
result->m128i_i8[0] = 1;
++result[1].m128i_i64[0];
result[2] = _mm_add_epi64(
(__m128i)_mm_shuffle_pd((__m128d)a2, (__m128d)xmmword_7B040, 2),
_mm_loadu_si128(result + 2));
result[3].m128i_i64[1] += a2;
v6 = result[3].m128i_i64[0];
if ( v6 )
{
v7 = result[4].m128i_u64[0];
v8 = v7 < a2;
v9 = v7 - a2;
if ( !v8 )
{
result[3].m128i_i64[0] = v6 - 1;
result[4].m128i_i64[0] = v9;
return result;
}
v13 = 0LL;
v12 = 0LL;
result[3].m128i_i64[0] = v6 - 1;
}
else
{
*(_QWORD *)&v12 = 0LL;
v13 = 0LL;
*((_QWORD *)&v12 + 1) = 1LL;
}
v10 = result[4].m128i_u64[0];
v8 = v10 < a2;
v11 = v10 - a2;
if ( v8 )
{
*((_QWORD *)&v13 + 1) = a2 - result[4].m128i_i64[0];
v11 = 0LL;
}
result[4].m128i_i64[0] = v11;
return (__m128i *)PFS_thread::carry_memory_stat_delta(v5, (unsigned long long *)&v12, v3);
}
else
{
return (__m128i *)pfs_memory_free_v1_cold_1(v3, a2);
}
}
return result;
}
| pfs_memory_free_v1:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV R14,RSI
CALL 0x0013631b
TEST RAX,RAX
JZ 0x0013e776
MOV EBX,dword ptr [RAX + 0x10]
LEA RCX,[0x4d0c40]
CMP byte ptr [RCX],0x1
JNZ 0x0013e76c
TEST byte ptr [RAX + 0x8],0x1
JNZ 0x0013e76c
MOV EDI,dword ptr [0x004d026c]
CALL 0x00126540
TEST RAX,RAX
JZ 0x0013e76c
MOV R15,RAX
CMP byte ptr [RAX + 0x4],0x0
JNZ 0x0013e6c4
MOV RDI,R15
CALL 0x001403ae
MOV byte ptr [R15 + 0x4],0x1
LAB_0013e6c4:
MOV RAX,qword ptr [R15 + 0x28]
LEA RCX,[RBX + RBX*0x8]
LEA RAX,[RAX + RCX*0x8]
MOV byte ptr [RAX],0x1
INC qword ptr [RAX + 0x10]
MOVDQU XMM0,xmmword ptr [RAX + 0x20]
MOVQ XMM1,R14
SHUFPD XMM1,xmmword ptr [0x0017b040],0x2
PADDQ XMM1,XMM0
MOVDQU xmmword ptr [RAX + 0x20],XMM1
ADD qword ptr [RAX + 0x38],R14
MOV RCX,qword ptr [RAX + 0x30]
TEST RCX,RCX
JZ 0x0013e720
MOV RDX,qword ptr [RAX + 0x40]
SUB RDX,R14
JNC 0x0013e75f
PXOR XMM0,XMM0
MOVDQA xmmword ptr [RBP + -0x30],XMM0
MOVDQA xmmword ptr [RBP + -0x40],XMM0
DEC RCX
MOV qword ptr [RAX + 0x30],RCX
JMP 0x0013e736
LAB_0013e720:
PXOR XMM0,XMM0
MOVDQA xmmword ptr [RBP + -0x40],XMM0
MOVDQA xmmword ptr [RBP + -0x30],XMM0
MOV qword ptr [RBP + -0x38],0x1
LAB_0013e736:
MOV RDX,qword ptr [RAX + 0x40]
MOV RCX,RDX
SUB RCX,R14
JNC 0x0013e74b
SUB R14,RDX
MOV qword ptr [RBP + -0x28],R14
XOR ECX,ECX
LAB_0013e74b:
MOV qword ptr [RAX + 0x40],RCX
LEA RSI,[RBP + -0x40]
MOV RDI,R15
MOV EDX,EBX
CALL 0x0012f930
JMP 0x0013e776
LAB_0013e75f:
DEC RCX
MOV qword ptr [RAX + 0x30],RCX
MOV qword ptr [RAX + 0x40],RDX
JMP 0x0013e776
LAB_0013e76c:
MOV EDI,EBX
MOV RSI,R14
CALL 0x0012ad71
LAB_0013e776:
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
RET
|
void pfs_memory_free_v1(uint param_1,ulong param_2)
{
int1 *puVar1;
uint uVar2;
ulong uVar3;
long lVar4;
PFS_connection_slice *this;
PFS_memory_stat_delta local_48 [16];
int1 local_38 [16];
lVar4 = find_memory_class(param_1);
if (lVar4 != 0) {
uVar2 = *(uint *)(lVar4 + 0x10);
if (((flag_thread_instrumentation == '\x01') && ((*(byte *)(lVar4 + 8) & 1) == 0)) &&
(this = (PFS_connection_slice *)pthread_getspecific(THR_PFS),
this != (PFS_connection_slice *)0x0)) {
if (this[4] == (PFS_connection_slice)0x0) {
PFS_connection_slice::rebase_memory_stats(this);
this[4] = (PFS_connection_slice)0x1;
}
puVar1 = (int1 *)(*(long *)(this + 0x28) + (ulong)uVar2 * 0x48);
*puVar1 = 1;
*(long *)(puVar1 + 0x10) = *(long *)(puVar1 + 0x10) + 1;
lVar4 = DAT_0017b048 + *(long *)(puVar1 + 0x28);
*(ulong *)(puVar1 + 0x20) = param_2 + *(long *)(puVar1 + 0x20);
*(long *)(puVar1 + 0x28) = lVar4;
*(ulong *)(puVar1 + 0x38) = *(long *)(puVar1 + 0x38) + param_2;
lVar4 = *(long *)(puVar1 + 0x30);
if (lVar4 == 0) {
local_48 = (PFS_memory_stat_delta [16])(ZEXT816(1) << 0x40);
}
else {
if (param_2 <= *(ulong *)(puVar1 + 0x40)) {
*(long *)(puVar1 + 0x30) = lVar4 + -1;
*(ulong *)(puVar1 + 0x40) = *(ulong *)(puVar1 + 0x40) - param_2;
return;
}
local_48[0] = (PFS_memory_stat_delta)0x0;
local_48[1] = (PFS_memory_stat_delta)0x0;
local_48[2] = (PFS_memory_stat_delta)0x0;
local_48[3] = (PFS_memory_stat_delta)0x0;
local_48[4] = (PFS_memory_stat_delta)0x0;
local_48[5] = (PFS_memory_stat_delta)0x0;
local_48[6] = (PFS_memory_stat_delta)0x0;
local_48[7] = (PFS_memory_stat_delta)0x0;
local_48[8] = (PFS_memory_stat_delta)0x0;
local_48[9] = (PFS_memory_stat_delta)0x0;
local_48[10] = (PFS_memory_stat_delta)0x0;
local_48[0xb] = (PFS_memory_stat_delta)0x0;
local_48[0xc] = (PFS_memory_stat_delta)0x0;
local_48[0xd] = (PFS_memory_stat_delta)0x0;
local_48[0xe] = (PFS_memory_stat_delta)0x0;
local_48[0xf] = (PFS_memory_stat_delta)0x0;
*(long *)(puVar1 + 0x30) = lVar4 + -1;
}
local_38 = (int1 [16])0x0;
uVar3 = *(ulong *)(puVar1 + 0x40);
lVar4 = uVar3 - param_2;
if (uVar3 < param_2) {
local_38._8_8_ = 0;
local_38._0_8_ = param_2 - uVar3;
local_38 = local_38 << 0x40;
lVar4 = 0;
}
*(long *)(puVar1 + 0x40) = lVar4;
PFS_thread::carry_memory_stat_delta((PFS_thread *)this,local_48,uVar2);
return;
}
pfs_memory_free_v1_cold_1((ulong)uVar2,param_2);
}
return;
}
| |
26,489 | bf_mul_2exp | bluesky950520[P]quickjs/libbf.c | int bf_mul_2exp(bf_t *r, slimb_t e, limb_t prec, bf_flags_t flags)
{
slimb_t e_max;
if (r->len == 0)
return 0;
e_max = ((limb_t)1 << BF_EXT_EXP_BITS_MAX) - 1;
e = bf_max(e, -e_max);
e = bf_min(e, e_max);
r->expn += e;
return __bf_round(r, prec, flags, r->len, 0);
} | O2 | c | bf_mul_2exp:
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x74bd1
movabsq $-0x3fffffffffffffff, %r8 # imm = 0xC000000000000001
cmpq %r8, %rsi
cmovgq %rsi, %r8
movabsq $0x3fffffffffffffff, %rsi # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rsi, %r8
cmovgeq %rsi, %r8
addq %r8, 0x10(%rdi)
movq %rdx, %rsi
movl %ecx, %edx
movq %rax, %rcx
xorl %r8d, %r8d
jmp 0x73360
xorl %eax, %eax
retq
| bf_mul_2exp:
mov rax, [rdi+18h]
test rax, rax
jz short loc_74BD1
mov r8, 0C000000000000001h
cmp rsi, r8
cmovg r8, rsi
mov rsi, 3FFFFFFFFFFFFFFFh
cmp r8, rsi
cmovge r8, rsi
add [rdi+10h], r8
mov rsi, rdx
mov edx, ecx
mov rcx, rax
xor r8d, r8d
jmp __bf_round
loc_74BD1:
xor eax, eax
retn
| long long bf_mul_2exp(long long a1, signed long long a2, long long a3, unsigned int a4)
{
unsigned long long v4; // rax
long long v5; // r8
v4 = *(_QWORD *)(a1 + 24);
if ( !v4 )
return 0LL;
v5 = 0xC000000000000001LL;
if ( a2 > (long long)0xC000000000000001LL )
v5 = a2;
if ( v5 >= 0x3FFFFFFFFFFFFFFFLL )
v5 = 0x3FFFFFFFFFFFFFFFLL;
*(_QWORD *)(a1 + 16) += v5;
return _bf_round(a1, a3, a4, v4, 0LL);
}
| bf_mul_2exp:
MOV RAX,qword ptr [RDI + 0x18]
TEST RAX,RAX
JZ 0x00174bd1
MOV R8,-0x3fffffffffffffff
CMP RSI,R8
CMOVG R8,RSI
MOV RSI,0x3fffffffffffffff
CMP R8,RSI
CMOVGE R8,RSI
ADD qword ptr [RDI + 0x10],R8
MOV RSI,RDX
MOV EDX,ECX
MOV RCX,RAX
XOR R8D,R8D
JMP 0x00173360
LAB_00174bd1:
XOR EAX,EAX
RET
|
int8 bf_mul_2exp(long param_1,long param_2,int8 param_3,int4 param_4)
{
int8 uVar1;
long lVar2;
if (*(long *)(param_1 + 0x18) != 0) {
lVar2 = -0x3fffffffffffffff;
if (-0x3fffffffffffffff < param_2) {
lVar2 = param_2;
}
if (0x3ffffffffffffffe < lVar2) {
lVar2 = 0x3fffffffffffffff;
}
*(long *)(param_1 + 0x10) = *(long *)(param_1 + 0x10) + lVar2;
uVar1 = __bf_round(param_1,param_3,param_4,*(long *)(param_1 + 0x18),0);
return uVar1;
}
return 0;
}
| |
26,490 | main | angrymouse[P]emittra/src/benchmark.cpp | int main() {
emittra::Emittra emitter(1024);
// Initialize the counters.
for (int i = 0; i < NUM_THREADS; i++) {
events_total_count[i] = 0;
}
std::thread emit_thread(emitter_thread, std::ref(emitter));
std::vector<std::thread> workers;
workers.reserve(NUM_THREADS);
for (int i = 0; i < NUM_THREADS; ++i) {
workers.emplace_back(worker, std::ref(emitter), i);
}
auto start = std::chrono::high_resolution_clock::now();
// Run benchmark for 10 seconds.
std::this_thread::sleep_for(std::chrono::seconds(10));
stop_processing.store(true, std::memory_order_relaxed);
emit_thread.join();
for (auto& t : workers) {
t.join();
}
auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
int total_processed = 0;
for (int i = 0; i < NUM_THREADS; i++) {
total_processed += events_total_count[i].load(std::memory_order_relaxed);
}
std::cout << "Time taken: " << duration.count() << " ms" << std::endl;
std::cout << "Total events processed: " << total_processed << std::endl;
std::cout << "Events per second: " << (total_processed * 1000.0 / duration.count()) << std::endl;
return 0;
} | O1 | cpp | main:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
leaq 0x40(%rsp), %rbx
movl $0x400, %esi # imm = 0x400
movq %rbx, %rdi
callq 0x4af4
xorl %eax, %eax
leaq 0xe6eb(%rip), %rbp # 0x12290
xorl %ecx, %ecx
xchgl %ecx, (%rax,%rbp)
addq $0x4, %rax
cmpq $0x40, %rax
jne 0x3ba5
leaq 0x10(%rsp), %rdx
movq %rbx, (%rdx)
leaq -0x517(%rip), %rsi # 0x36ac
leaq 0x8(%rsp), %rdi
callq 0x4054
xorpd %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movapd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x10, %esi
callq 0x40e6
leaq 0x4(%rsp), %r14
movl $0x0, (%r14)
leaq -0x33c(%rip), %r15 # 0x38c3
leaq 0x10(%rsp), %r12
leaq 0x30(%rsp), %r13
movq %rbx, 0x30(%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x4192
movl 0x4(%rsp), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x4(%rsp)
cmpl $0xf, %eax
jl 0x3c09
callq 0x3060
movq %rax, %rbx
leaq 0x30(%rsp), %r14
movq $0xa, (%r14)
movq $0x0, 0x8(%r14)
movq %r14, %rdi
movq %r14, %rsi
callq 0x30b0
cmpl $-0x1, %eax
jne 0x3c65
callq 0x3040
cmpl $0x4, (%rax)
je 0x3c4b
movb $0x1, 0xe615(%rip) # 0x12281
leaq 0x8(%rsp), %rdi
callq 0x3420
movq 0x10(%rsp), %r14
movq 0x18(%rsp), %r15
cmpq %r15, %r14
je 0x3c93
movq %r14, %rdi
callq 0x3420
addq $0x8, %r14
jmp 0x3c80
callq 0x3060
subq %rbx, %rax
xorl %ecx, %ecx
xorl %ebx, %ebx
movl (%rcx,%rbp), %edx
addl %edx, %ebx
addq $0x4, %rcx
cmpq $0x40, %rcx
jne 0x3c9f
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
imulq %rcx
movq %rdx, %r14
movq 0xe2fb(%rip), %rdi # 0x11fc0
leaq 0x8354(%rip), %rsi # 0xc020
movl $0xc, %edx
callq 0x32f0
movq %r14, %rax
shrq $0x3f, %rax
sarq $0x12, %r14
addq %rax, %r14
movq 0xe2d5(%rip), %rdi # 0x11fc0
movq %r14, %rsi
callq 0x3280
movq %rax, %r15
leaq 0x8330(%rip), %rsi # 0xc02d
movl $0x3, %edx
movq %rax, %rdi
callq 0x32f0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
movq 0xe288(%rip), %rdi # 0x11fc0
leaq 0x82f2(%rip), %rsi # 0xc031
movl $0x18, %edx
callq 0x32f0
movq 0xe270(%rip), %rdi # 0x11fc0
movl %ebx, %esi
callq 0x3440
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
movq 0xe238(%rip), %rdi # 0x11fc0
leaq 0x82bb(%rip), %rsi # 0xc04a
movl $0x13, %edx
callq 0x32f0
cvtsi2sd %ebx, %xmm0
mulsd 0x8263(%rip), %xmm0 # 0xc008
cvtsi2sd %r14, %xmm1
divsd %xmm1, %xmm0
movq 0xe20b(%rip), %rdi # 0x11fc0
callq 0x33d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
leaq 0x10(%rsp), %rdi
callq 0x41d4
cmpq $0x0, 0x8(%rsp)
jne 0x3e4a
leaq 0x78(%rsp), %rdi
callq 0x4288
xorl %eax, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3e23
jmp 0x3e23
movq %rax, %rbx
jmp 0x3e38
jmp 0x3e23
jmp 0x3e23
jmp 0x3e23
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x41d4
cmpq $0x0, 0x8(%rsp)
jne 0x3e4a
leaq 0x78(%rsp), %rdi
callq 0x4288
movq %rbx, %rdi
callq 0x3450
callq 0x30a0
nop
| main:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0B8h
lea rbx, [rsp+0E8h+var_A8]
mov esi, 400h; unsigned __int64
mov rdi, rbx; this
call _ZN7emittra7EmittraC2Em; emittra::Emittra::Emittra(ulong)
xor eax, eax
lea rbp, events_total_count
loc_3BA5:
xor ecx, ecx
xchg ecx, [rax+rbp]
add rax, 4
cmp rax, 40h ; '@'
jnz short loc_3BA5
lea rdx, [rsp+0E8h+var_D8]
mov [rdx], rbx
lea rsi, _Z14emitter_threadRN7emittra7EmittraE; emitter_thread(emittra::Emittra &)
lea rdi, [rsp+0E8h+var_E0]
call _ZNSt6threadC2IRFvRN7emittra7EmittraEEJSt17reference_wrapperIS2_EEvEEOT_DpOT0_; std::thread::thread<void (&)(emittra::Emittra &),std::reference_wrapper<emittra::Emittra>,void>(void (&)(emittra::Emittra &) &&,std::reference_wrapper<emittra::Emittra> &&)
xorpd xmm0, xmm0
lea rdi, [rsp+0E8h+var_D8]
movapd xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov esi, 10h
call _ZNSt6vectorISt6threadSaIS0_EE7reserveEm; std::vector<std::thread>::reserve(ulong)
lea r14, [rsp+0E8h+var_E4]
mov dword ptr [r14], 0
lea r15, _Z6workerRN7emittra7EmittraEi; worker(emittra::Emittra &,int)
lea r12, [rsp+0E8h+var_D8]
lea r13, [rsp+0E8h+var_B8]
loc_3C09:
mov [rsp+0E8h+var_B8], rbx
mov rdi, r12; this
mov rsi, r15
mov rdx, r13
mov rcx, r14
call _ZNSt6vectorISt6threadSaIS0_EE12emplace_backIJRFvRN7emittra7EmittraEiESt17reference_wrapperIS5_ERiEEERS0_DpOT_; std::vector<std::thread>::emplace_back<void (&)(emittra::Emittra &,int),std::reference_wrapper<emittra::Emittra>,int &>(void (&)(emittra::Emittra &,int),std::reference_wrapper<emittra::Emittra>,int &)
mov eax, [rsp+0E8h+var_E4]
lea ecx, [rax+1]
mov [rsp+0E8h+var_E4], ecx
cmp eax, 0Fh
jl short loc_3C09
call __ZNSt6chrono3_V212system_clock3nowEv; std::chrono::_V2::system_clock::now(void)
mov rbx, rax
lea r14, [rsp+0E8h+var_B8]
mov qword ptr [r14], 0Ah
mov qword ptr [r14+8], 0
loc_3C4B:
mov rdi, r14
mov rsi, r14
call _nanosleep
cmp eax, 0FFFFFFFFh
jnz short loc_3C65
call ___errno_location
cmp dword ptr [rax], 4
jz short loc_3C4B
loc_3C65:
mov cs:stop_processing, 1
lea rdi, [rsp+0E8h+var_E0]; this
call __ZNSt6thread4joinEv; std::thread::join(void)
mov r14, [rsp+0E8h+var_D8]
mov r15, [rsp+0E8h+var_D0]
loc_3C80:
cmp r14, r15
jz short loc_3C93
mov rdi, r14; this
call __ZNSt6thread4joinEv; std::thread::join(void)
add r14, 8
jmp short loc_3C80
loc_3C93:
call __ZNSt6chrono3_V212system_clock3nowEv; std::chrono::_V2::system_clock::now(void)
sub rax, rbx
xor ecx, ecx
xor ebx, ebx
loc_3C9F:
mov edx, [rcx+rbp]
add ebx, edx
add rcx, 4
cmp rcx, 40h ; '@'
jnz short loc_3C9F
mov rcx, 431BDE82D7B634DBh
imul rcx
mov r14, rdx
mov rdi, cs:_ZSt4cout_ptr
lea rsi, aTimeTaken; "Time taken: "
mov edx, 0Ch
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rax, r14
shr rax, 3Fh
sar r14, 12h
add r14, rax
mov rdi, cs:_ZSt4cout_ptr
mov rsi, r14
call __ZNSo9_M_insertIlEERSoT_; std::ostream::_M_insert<long>(long)
mov r15, rax
lea rsi, aMs; " ms"
mov edx, 3
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rax, [r15]
mov rdi, [rax-18h]
add rdi, r15
mov esi, 0Ah
call __ZNKSt9basic_iosIcSt11char_traitsIcEE5widenEc; std::ios::widen(char)
movsx esi, al; char
mov rdi, r15; this
call __ZNSo3putEc; std::ostream::put(char)
mov rdi, rax; this
call __ZNSo5flushEv; std::ostream::flush(void)
mov rdi, cs:_ZSt4cout_ptr
lea rsi, aTotalEventsPro; "Total events processed: "
mov edx, 18h
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, cs:_ZSt4cout_ptr
mov esi, ebx
call __ZNSolsEi; std::ostream::operator<<(int)
mov r15, rax
mov rax, [rax]
mov rdi, [rax-18h]
add rdi, r15
mov esi, 0Ah
call __ZNKSt9basic_iosIcSt11char_traitsIcEE5widenEc; std::ios::widen(char)
movsx esi, al; char
mov rdi, r15; this
call __ZNSo3putEc; std::ostream::put(char)
mov rdi, rax; this
call __ZNSo5flushEv; std::ostream::flush(void)
mov rdi, cs:_ZSt4cout_ptr
lea rsi, aEventsPerSecon; "Events per second: "
mov edx, 13h
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
cvtsi2sd xmm0, ebx
mulsd xmm0, cs:qword_C008
cvtsi2sd xmm1, r14
divsd xmm0, xmm1
mov rdi, cs:_ZSt4cout_ptr
call __ZNSo9_M_insertIdEERSoT_; std::ostream::_M_insert<double>(double)
mov rbx, rax
mov rax, [rax]
mov rdi, [rax-18h]
add rdi, rbx
mov esi, 0Ah
call __ZNKSt9basic_iosIcSt11char_traitsIcEE5widenEc; std::ios::widen(char)
movsx esi, al; char
mov rdi, rbx; this
call __ZNSo3putEc; std::ostream::put(char)
mov rdi, rax; this
call __ZNSo5flushEv; std::ostream::flush(void)
lea rdi, [rsp+0E8h+var_D8]
call _ZNSt6vectorISt6threadSaIS0_EED2Ev; std::vector<std::thread>::~vector()
cmp [rsp+0E8h+var_E0], 0
jnz short loc_3E4A
lea rdi, [rsp+0E8h+var_70]
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_St10shared_ptrIN7emittra7Emittra9EventDataEEESaISD_ENSt8__detail10_Select1stESt8equal_toIS5_ESt4hashIS5_ENSF_18_Mod_range_hashingENSF_20_Default_ranged_hashENSF_20_Prime_rehash_policyENSF_17_Hashtable_traitsILb1ELb0ELb1EEEED2Ev; std::_Hashtable<std::string,std::pair<std::string const,std::shared_ptr<emittra::Emittra::EventData>>,std::allocator<std::pair<std::string const,std::shared_ptr<emittra::Emittra::EventData>>>,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>>::~_Hashtable()
xor eax, eax
add rsp, 0B8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_3E23
jmp short loc_3E23
mov rbx, rax
jmp short loc_3E38
jmp short loc_3E23
jmp short loc_3E23
jmp short $+2
loc_3E23:
mov rbx, rax
lea rdi, [rsp+0E8h+var_D8]
call _ZNSt6vectorISt6threadSaIS0_EED2Ev; std::vector<std::thread>::~vector()
cmp [rsp+0E8h+var_E0], 0
jnz short loc_3E4A
loc_3E38:
lea rdi, [rsp+0E8h+var_70]
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_St10shared_ptrIN7emittra7Emittra9EventDataEEESaISD_ENSt8__detail10_Select1stESt8equal_toIS5_ESt4hashIS5_ENSF_18_Mod_range_hashingENSF_20_Default_ranged_hashENSF_20_Prime_rehash_policyENSF_17_Hashtable_traitsILb1ELb0ELb1EEEED2Ev; std::_Hashtable<std::string,std::pair<std::string const,std::shared_ptr<emittra::Emittra::EventData>>,std::allocator<std::pair<std::string const,std::shared_ptr<emittra::Emittra::EventData>>>,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>>::~_Hashtable()
mov rdi, rbx
call __Unwind_Resume
loc_3E4A:
call __ZSt9terminatev; std::terminate(void)
| int main(int argc, const char **argv, const char **envp)
{
int v3; // r8d
int v4; // r9d
long long i; // rax
__int32 v6; // ecx
int v7; // eax
long long v8; // rbx
std::chrono::_V2::system_clock *v9; // rdi
std::thread *v10; // r14
std::thread *v11; // r15
long long v12; // rax
long long v13; // rcx
int v14; // ebx
long long v15; // r14
long long v16; // r14
std::ostream *v17; // r15
char v18; // al
std::ostream *v19; // rax
std::ostream *v20; // r15
char v21; // al
std::ostream *v22; // rax
std::ostream *v23; // rbx
char v24; // al
std::ostream *v25; // rax
long long v27; // [rsp+0h] [rbp-E8h] BYREF
long long v28; // [rsp+8h] [rbp-E0h] BYREF
std::thread *v29[4]; // [rsp+10h] [rbp-D8h] BYREF
_QWORD v30[2]; // [rsp+30h] [rbp-B8h] BYREF
_BYTE v31[56]; // [rsp+40h] [rbp-A8h] BYREF
_BYTE v32[112]; // [rsp+78h] [rbp-70h] BYREF
emittra::Emittra::Emittra((emittra::Emittra *)v31, 0x400uLL);
for ( i = 0LL; i != 64; i += 4LL )
v6 = _InterlockedExchange((volatile __int32 *)((char *)&events_total_count + i), 0);
v29[0] = (std::thread *)v31;
std::thread::thread<void (&)(emittra::Emittra &),std::reference_wrapper<emittra::Emittra>,void>(
(unsigned int)&v28,
(unsigned int)emitter_thread,
(unsigned int)v29,
v6,
v3,
v4,
v27);
memset(v29, 0, 24);
std::vector<std::thread>::reserve(v29, 16LL);
HIDWORD(v27) = 0;
do
{
v30[0] = v31;
std::vector<std::thread>::emplace_back<void (&)(emittra::Emittra &,int),std::reference_wrapper<emittra::Emittra>,int &>(
v29,
worker,
v30,
(char *)&v27 + 4);
v7 = HIDWORD(v27)++;
}
while ( v7 < 15 );
v8 = std::chrono::_V2::system_clock::now((std::chrono::_V2::system_clock *)v29);
v30[0] = 10LL;
v30[1] = 0LL;
while ( (unsigned int)nanosleep(v30, v30) == -1 && *(_DWORD *)__errno_location() == 4 )
;
stop_processing = 1;
v9 = (std::chrono::_V2::system_clock *)&v28;
std::thread::join((std::thread *)&v28);
v10 = v29[0];
v11 = v29[1];
while ( v10 != v11 )
{
v9 = v10;
std::thread::join(v10);
v10 = (std::thread *)((char *)v10 + 8);
}
v12 = std::chrono::_V2::system_clock::now(v9) - v8;
v13 = 0LL;
v14 = 0;
do
{
v14 += *(_DWORD *)((char *)&events_total_count + v13);
v13 += 4LL;
}
while ( v13 != 64 );
v15 = (unsigned __int128)(0x431BDE82D7B634DBLL * (__int128)v12) >> 64;
std::__ostream_insert<char,std::char_traits<char>>(&std::cout, "Time taken: ", 12LL);
v16 = ((unsigned long long)v15 >> 63) + (v15 >> 18);
v17 = (std::ostream *)std::ostream::_M_insert<long>(&std::cout, v16);
std::__ostream_insert<char,std::char_traits<char>>(v17, " ms", 3LL);
v18 = std::ios::widen((char *)v17 + *(_QWORD *)(*(_QWORD *)v17 - 24LL), 10LL);
v19 = (std::ostream *)std::ostream::put(v17, v18);
std::ostream::flush(v19);
std::__ostream_insert<char,std::char_traits<char>>(&std::cout, "Total events processed: ", 24LL);
v20 = (std::ostream *)std::ostream::operator<<(&std::cout, (unsigned int)v14);
v21 = std::ios::widen((char *)v20 + *(_QWORD *)(*(_QWORD *)v20 - 24LL), 10LL);
v22 = (std::ostream *)std::ostream::put(v20, v21);
std::ostream::flush(v22);
std::__ostream_insert<char,std::char_traits<char>>(&std::cout, "Events per second: ", 19LL);
v23 = (std::ostream *)std::ostream::_M_insert<double>(&std::cout, (double)v14 * 1000.0 / (double)(int)v16);
v24 = std::ios::widen((char *)v23 + *(_QWORD *)(*(_QWORD *)v23 - 24LL), 10LL);
v25 = (std::ostream *)std::ostream::put(v23, v24);
std::ostream::flush(v25);
std::vector<std::thread>::~vector(v29);
if ( v28 )
std::terminate();
std::_Hashtable<std::string,std::pair<std::string const,std::shared_ptr<emittra::Emittra::EventData>>,std::allocator<std::pair<std::string const,std::shared_ptr<emittra::Emittra::EventData>>>,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>>::~_Hashtable(v32);
return 0;
}
| main:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xb8
LEA RBX,[RSP + 0x40]
MOV ESI,0x400
MOV RDI,RBX
CALL 0x00104af4
XOR EAX,EAX
LEA RBP,[0x112290]
LAB_00103ba5:
XOR ECX,ECX
XCHG dword ptr [RAX + RBP*0x1],ECX
ADD RAX,0x4
CMP RAX,0x40
JNZ 0x00103ba5
LEA RDX,[RSP + 0x10]
MOV qword ptr [RDX],RBX
LAB_00103bbc:
LEA RSI,[0x1036ac]
LEA RDI,[RSP + 0x8]
CALL 0x00104054
XORPD XMM0,XMM0
LEA RDI,[RSP + 0x10]
MOVAPD xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
LAB_00103be2:
MOV ESI,0x10
CALL 0x001040e6
LEA R14,[RSP + 0x4]
MOV dword ptr [R14],0x0
LEA R15,[0x1038c3]
LEA R12,[RSP + 0x10]
LEA R13,[RSP + 0x30]
LAB_00103c09:
MOV qword ptr [RSP + 0x30],RBX
LAB_00103c0e:
MOV RDI,R12
MOV RSI,R15
MOV RDX,R13
MOV RCX,R14
CALL 0x00104192
MOV EAX,dword ptr [RSP + 0x4]
LEA ECX,[RAX + 0x1]
MOV dword ptr [RSP + 0x4],ECX
CMP EAX,0xf
JL 0x00103c09
CALL 0x00103060
MOV RBX,RAX
LEA R14,[RSP + 0x30]
MOV qword ptr [R14],0xa
MOV qword ptr [R14 + 0x8],0x0
LAB_00103c4b:
MOV RDI,R14
MOV RSI,R14
CALL 0x001030b0
CMP EAX,-0x1
JNZ 0x00103c65
CALL 0x00103040
CMP dword ptr [RAX],0x4
JZ 0x00103c4b
LAB_00103c65:
MOV byte ptr [0x00112281],0x1
LAB_00103c6c:
LEA RDI,[RSP + 0x8]
CALL 0x00103420
MOV R14,qword ptr [RSP + 0x10]
MOV R15,qword ptr [RSP + 0x18]
LAB_00103c80:
CMP R14,R15
JZ 0x00103c93
LAB_00103c85:
MOV RDI,R14
CALL 0x00103420
ADD R14,0x8
JMP 0x00103c80
LAB_00103c93:
CALL 0x00103060
SUB RAX,RBX
XOR ECX,ECX
XOR EBX,EBX
LAB_00103c9f:
MOV EDX,dword ptr [RCX + RBP*0x1]
ADD EBX,EDX
ADD RCX,0x4
CMP RCX,0x40
JNZ 0x00103c9f
MOV RCX,0x431bde82d7b634db
IMUL RCX
MOV R14,RDX
LAB_00103cbe:
MOV RDI,qword ptr [0x00111fc0]
LEA RSI,[0x10c020]
MOV EDX,0xc
CALL 0x001032f0
MOV RAX,R14
SHR RAX,0x3f
SAR R14,0x12
ADD R14,RAX
MOV RDI,qword ptr [0x00111fc0]
MOV RSI,R14
CALL 0x00103280
MOV R15,RAX
LEA RSI,[0x10c02d]
MOV EDX,0x3
MOV RDI,RAX
CALL 0x001032f0
MOV RAX,qword ptr [R15]
MOV RDI,qword ptr [RAX + -0x18]
ADD RDI,R15
MOV ESI,0xa
CALL 0x00103290
MOVSX ESI,AL
MOV RDI,R15
CALL 0x00103030
MOV RDI,RAX
CALL 0x001031a0
MOV RDI,qword ptr [0x00111fc0]
LEA RSI,[0x10c031]
MOV EDX,0x18
CALL 0x001032f0
MOV RDI,qword ptr [0x00111fc0]
MOV ESI,EBX
CALL 0x00103440
MOV R15,RAX
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + -0x18]
ADD RDI,R15
MOV ESI,0xa
CALL 0x00103290
MOVSX ESI,AL
MOV RDI,R15
CALL 0x00103030
MOV RDI,RAX
CALL 0x001031a0
MOV RDI,qword ptr [0x00111fc0]
LEA RSI,[0x10c04a]
MOV EDX,0x13
CALL 0x001032f0
CVTSI2SD XMM0,EBX
MULSD XMM0,qword ptr [0x0010c008]
CVTSI2SD XMM1,R14
DIVSD XMM0,XMM1
MOV RDI,qword ptr [0x00111fc0]
CALL 0x001033d0
MOV RBX,RAX
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + -0x18]
ADD RDI,RBX
MOV ESI,0xa
CALL 0x00103290
MOVSX ESI,AL
MOV RDI,RBX
CALL 0x00103030
MOV RDI,RAX
CALL 0x001031a0
LAB_00103de4:
LEA RDI,[RSP + 0x10]
CALL 0x001041d4
CMP qword ptr [RSP + 0x8],0x0
JNZ 0x00103e4a
LEA RDI,[RSP + 0x78]
CALL 0x00104288
XOR EAX,EAX
ADD RSP,0xb8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00103e4a:
CALL 0x001030a0
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8 main(void)
{
bool bVar1;
int iVar2;
long lVar3;
int *piVar4;
long lVar5;
ostream *poVar6;
long *plVar7;
long lVar8;
Emittra *pEVar9;
int local_e4;
long local_e0;
Emittra *local_d8;
long lStack_d0;
int8 local_c8;
timespec local_b8;
Emittra local_a8 [56];
_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::shared_ptr<emittra::Emittra::EventData>>,std::allocator<std::pair<std::__cxx11::string_const,std::shared_ptr<emittra::Emittra::EventData>>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
local_70 [64];
emittra::Emittra::Emittra(local_a8,0x400);
lVar3 = 0;
do {
LOCK();
*(int4 *)((long)&events_total_count + lVar3) = 0;
UNLOCK();
lVar3 = lVar3 + 4;
} while (lVar3 != 0x40);
/* try { // try from 00103bbc to 00103bcc has its CatchHandler @ 00103e18 */
local_d8 = local_a8;
std::thread::thread<void(&)(emittra::Emittra&),std::reference_wrapper<emittra::Emittra>,void>
((thread *)&local_e0,emitter_thread,(reference_wrapper *)&local_d8);
local_d8 = (Emittra *)0x0;
lStack_d0 = 0;
local_c8 = 0;
/* try { // try from 00103be2 to 00103beb has its CatchHandler @ 00103e16 */
std::vector<std::thread,std::allocator<std::thread>>::reserve
((vector<std::thread,std::allocator<std::thread>> *)&local_d8,0x10);
local_e4 = 0;
do {
local_b8.tv_sec = (__time_t)local_a8;
/* try { // try from 00103c0e to 00103c1e has its CatchHandler @ 00103e23 */
std::vector<std::thread,std::allocator<std::thread>>::
emplace_back<void(&)(emittra::Emittra&,int),std::reference_wrapper<emittra::Emittra>,int&>
((vector<std::thread,std::allocator<std::thread>> *)&local_d8,worker,
(reference_wrapper *)&local_b8,&local_e4);
iVar2 = local_e4 + 1;
bVar1 = local_e4 < 0xf;
local_e4 = iVar2;
} while (bVar1);
lVar3 = std::chrono::_V2::system_clock::now();
local_b8.tv_sec = 10;
local_b8.tv_nsec = 0;
do {
/* try { // try from 00103c4b to 00103c55 has its CatchHandler @ 00103e1f */
iVar2 = nanosleep(&local_b8,&local_b8);
if (iVar2 != -1) break;
piVar4 = __errno_location();
} while (*piVar4 == 4);
stop_processing = 1;
/* try { // try from 00103c6c to 00103c75 has its CatchHandler @ 00103e14 */
std::thread::join();
lVar5 = lStack_d0;
for (pEVar9 = local_d8; pEVar9 != (Emittra *)lVar5; pEVar9 = (Emittra *)((long)pEVar9 + 8)) {
/* try { // try from 00103c85 to 00103c8c has its CatchHandler @ 00103e21 */
std::thread::join();
}
lVar5 = std::chrono::_V2::system_clock::now();
lVar8 = 0;
iVar2 = 0;
do {
iVar2 = iVar2 + *(int *)((long)&events_total_count + lVar8);
lVar8 = lVar8 + 4;
} while (lVar8 != 0x40);
/* try { // try from 00103cbe to 00103de3 has its CatchHandler @ 00103e1d */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cout_00111fc0,"Time taken: ",0xc);
poVar6 = std::ostream::_M_insert<long>((long)PTR_cout_00111fc0);
std::__ostream_insert<char,std::char_traits<char>>(poVar6," ms",3);
std::ios::widen((char)*(int8 *)(*(long *)poVar6 + -0x18) + (char)poVar6);
std::ostream::put((char)poVar6);
std::ostream::flush();
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cout_00111fc0,"Total events processed: ",0x18);
plVar7 = (long *)std::ostream::operator<<((ostream *)PTR_cout_00111fc0,iVar2);
std::ios::widen((char)*(int8 *)(*plVar7 + -0x18) + (char)plVar7);
std::ostream::put((char)plVar7);
std::ostream::flush();
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cout_00111fc0,"Events per second: ",0x13);
poVar6 = std::ostream::_M_insert<double>
(((double)iVar2 * _DAT_0010c008) / (double)((lVar5 - lVar3) / 1000000));
std::ios::widen((char)*(int8 *)(*(long *)poVar6 + -0x18) + (char)poVar6);
std::ostream::put((char)poVar6);
std::ostream::flush();
std::vector<std::thread,std::allocator<std::thread>>::~vector
((vector<std::thread,std::allocator<std::thread>> *)&local_d8);
if (local_e0 == 0) {
std::
_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::shared_ptr<emittra::Emittra::EventData>>,std::allocator<std::pair<std::__cxx11::string_const,std::shared_ptr<emittra::Emittra::EventData>>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
::~_Hashtable(local_70);
return 0;
}
/* WARNING: Subroutine does not return */
std::terminate();
}
| |
26,491 | main | angrymouse[P]emittra/src/benchmark.cpp | int main() {
emittra::Emittra emitter(1024);
// Initialize the counters.
for (int i = 0; i < NUM_THREADS; i++) {
events_total_count[i] = 0;
}
std::thread emit_thread(emitter_thread, std::ref(emitter));
std::vector<std::thread> workers;
workers.reserve(NUM_THREADS);
for (int i = 0; i < NUM_THREADS; ++i) {
workers.emplace_back(worker, std::ref(emitter), i);
}
auto start = std::chrono::high_resolution_clock::now();
// Run benchmark for 10 seconds.
std::this_thread::sleep_for(std::chrono::seconds(10));
stop_processing.store(true, std::memory_order_relaxed);
emit_thread.join();
for (auto& t : workers) {
t.join();
}
auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
int total_processed = 0;
for (int i = 0; i < NUM_THREADS; i++) {
total_processed += events_total_count[i].load(std::memory_order_relaxed);
}
std::cout << "Time taken: " << duration.count() << " ms" << std::endl;
std::cout << "Total events processed: " << total_processed << std::endl;
std::cout << "Events per second: " << (total_processed * 1000.0 / duration.count()) << std::endl;
return 0;
} | O2 | cpp | main:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
leaq 0x40(%rsp), %rbx
movl $0x400, %esi # imm = 0x400
movq %rbx, %rdi
callq 0x47f4
xorl %eax, %eax
leaq 0xfa3a(%rip), %rbp # 0x13280
cmpq $0x40, %rax
je 0x3857
xorl %ecx, %ecx
xchgl %ecx, (%rax,%rbp)
addq $0x4, %rax
jmp 0x3846
leaq 0x20(%rsp), %rdx
movq %rbx, (%rdx)
leaq -0x2ba(%rip), %rsi # 0x35ac
leaq 0x10(%rsp), %rdi
callq 0x3c6a
xorpd %xmm0, %xmm0
leaq 0x20(%rsp), %rdi
movapd %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
pushq $0x10
popq %rsi
callq 0x3ce4
xorl %eax, %eax
leaq -0x1c2(%rip), %r14 # 0x36d1
leaq 0x20(%rsp), %r15
leaq 0x18(%rsp), %r12
leaq 0xc(%rsp), %r13
movl %eax, 0xc(%rsp)
cmpl $0x10, %eax
jge 0x38c9
movq %rbx, 0x18(%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x3d76
movl 0xc(%rsp), %eax
incl %eax
jmp 0x38a2
callq 0x3050
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
movq $0xa, (%rdi)
callq 0x3dbe
movb $0x1, 0xf988(%rip) # 0x13271
leaq 0x10(%rsp), %rdi
callq 0x3410
movq 0x20(%rsp), %r14
movq 0x28(%rsp), %r15
cmpq %r15, %r14
je 0x3910
movq %r14, %rdi
callq 0x3410
addq $0x8, %r14
jmp 0x38fd
callq 0x3050
subq %rbx, %rax
xorl %ecx, %ecx
xorl %ebx, %ebx
cmpq $0x40, %rcx
je 0x392d
movl (%rcx,%rbp), %edx
addl %edx, %ebx
addq $0x4, %rcx
jmp 0x391c
movl $0xf4240, %ecx # imm = 0xF4240
cqto
idivq %rcx
movq %rax, %r14
movq 0xf67f(%rip), %rdi # 0x12fc0
leaq 0x76d8(%rip), %rsi # 0xb020
callq 0x3290
movq %rax, %rdi
movq %r14, %rsi
callq 0x3280
leaq 0x76ce(%rip), %rsi # 0xb02d
movq %rax, %rdi
callq 0x3290
movq %rax, %rdi
callq 0x3150
movq 0xf64a(%rip), %rdi # 0x12fc0
leaq 0x76b4(%rip), %rsi # 0xb031
callq 0x3290
movq %rax, %rdi
movl %ebx, %esi
callq 0x3430
movq %rax, %rdi
callq 0x3150
movq 0xf625(%rip), %rdi # 0x12fc0
leaq 0x76a8(%rip), %rsi # 0xb04a
callq 0x3290
cvtsi2sd %ebx, %xmm0
mulsd 0x7655(%rip), %xmm0 # 0xb008
cvtsi2sd %r14, %xmm1
divsd %xmm1, %xmm0
movq %rax, %rdi
callq 0x33c0
movq %rax, %rdi
callq 0x3150
leaq 0x20(%rsp), %rdi
callq 0x3df6
leaq 0x10(%rsp), %rdi
callq 0x3e18
leaq 0x78(%rsp), %rdi
callq 0x3eca
xorl %eax, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3a0d
jmp 0x3a0d
jmp 0x3a0d
movq %rax, %rbx
jmp 0x3a24
jmp 0x3a0d
jmp 0x3a0d
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3df6
leaq 0x10(%rsp), %rdi
callq 0x3e18
leaq 0x78(%rsp), %rdi
callq 0x3eca
movq %rbx, %rdi
callq 0x3440
| main:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0B8h
lea rbx, [rsp+0E8h+var_A8]
mov esi, 400h; unsigned __int64
mov rdi, rbx; this
call _ZN7emittra7EmittraC2Em; emittra::Emittra::Emittra(ulong)
xor eax, eax
lea rbp, events_total_count
loc_3846:
cmp rax, 40h ; '@'
jz short loc_3857
xor ecx, ecx
xchg ecx, [rax+rbp]
add rax, 4
jmp short loc_3846
loc_3857:
lea rdx, [rsp+0E8h+var_C8]
mov [rdx], rbx
lea rsi, _Z14emitter_threadRN7emittra7EmittraE; emitter_thread(emittra::Emittra &)
lea rdi, [rsp+0E8h+var_D8]
call _ZNSt6threadC2IRFvRN7emittra7EmittraEEJSt17reference_wrapperIS2_EEvEEOT_DpOT0_; std::thread::thread<void (&)(emittra::Emittra &),std::reference_wrapper<emittra::Emittra>,void>(void (&)(emittra::Emittra &) &&,std::reference_wrapper<emittra::Emittra> &&)
xorpd xmm0, xmm0
lea rdi, [rsp+0E8h+var_C8]; this
movapd xmmword ptr [rdi], xmm0
and qword ptr [rdi+10h], 0
push 10h
pop rsi
call _ZNSt6vectorISt6threadSaIS0_EE7reserveEm; std::vector<std::thread>::reserve(ulong)
xor eax, eax
lea r14, _Z6workerRN7emittra7EmittraEi; worker(emittra::Emittra &,int)
lea r15, [rsp+0E8h+var_C8]
lea r12, [rsp+0E8h+var_D0]
lea r13, [rsp+0E8h+var_DC]
loc_38A2:
mov [rsp+0E8h+var_DC], eax
cmp eax, 10h
jge short loc_38C9
mov [rsp+0E8h+var_D0], rbx
mov rdi, r15
mov rsi, r14
mov rdx, r12
mov rcx, r13
call _ZNSt6vectorISt6threadSaIS0_EE12emplace_backIJRFvRN7emittra7EmittraEiESt17reference_wrapperIS5_ERiEEERS0_DpOT_; std::vector<std::thread>::emplace_back<void (&)(emittra::Emittra &,int),std::reference_wrapper<emittra::Emittra>,int &>(void (&)(emittra::Emittra &,int),std::reference_wrapper<emittra::Emittra>,int &)
mov eax, [rsp+0E8h+var_DC]
inc eax
jmp short loc_38A2
loc_38C9:
call __ZNSt6chrono3_V212system_clock3nowEv; std::chrono::_V2::system_clock::now(void)
mov rbx, rax
lea rdi, [rsp+0E8h+var_D0]
mov qword ptr [rdi], 0Ah
call _ZNSt11this_thread9sleep_forIlSt5ratioILl1ELl1EEEEvRKNSt6chrono8durationIT_T0_EE; std::this_thread::sleep_for<long,std::ratio<1l,1l>>(std::chrono::duration<long,std::ratio<1l,1l>> const&)
mov cs:stop_processing, 1
lea rdi, [rsp+0E8h+var_D8]; this
call __ZNSt6thread4joinEv; std::thread::join(void)
mov r14, [rsp+0E8h+var_C8]
mov r15, [rsp+0E8h+var_C0]
loc_38FD:
cmp r14, r15
jz short loc_3910
mov rdi, r14; this
call __ZNSt6thread4joinEv; std::thread::join(void)
add r14, 8
jmp short loc_38FD
loc_3910:
call __ZNSt6chrono3_V212system_clock3nowEv; std::chrono::_V2::system_clock::now(void)
sub rax, rbx
xor ecx, ecx
xor ebx, ebx
loc_391C:
cmp rcx, 40h ; '@'
jz short loc_392D
mov edx, [rcx+rbp]
add ebx, edx
add rcx, 4
jmp short loc_391C
loc_392D:
mov ecx, 0F4240h
cqo
idiv rcx
mov r14, rax
mov rdi, cs:_ZSt4cout_ptr
lea rsi, aTimeTaken; "Time taken: "
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
mov rsi, r14
call __ZNSo9_M_insertIlEERSoT_; std::ostream::_M_insert<long>(long)
lea rsi, aMs; " ms"
mov rdi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
call __ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_; std::endl<char,std::char_traits<char>>(std::ostream &)
mov rdi, cs:_ZSt4cout_ptr
lea rsi, aTotalEventsPro; "Total events processed: "
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
mov esi, ebx
call __ZNSolsEi; std::ostream::operator<<(int)
mov rdi, rax
call __ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_; std::endl<char,std::char_traits<char>>(std::ostream &)
mov rdi, cs:_ZSt4cout_ptr
lea rsi, aEventsPerSecon; "Events per second: "
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
cvtsi2sd xmm0, ebx
mulsd xmm0, cs:qword_B008
cvtsi2sd xmm1, r14
divsd xmm0, xmm1
mov rdi, rax
call __ZNSo9_M_insertIdEERSoT_; std::ostream::_M_insert<double>(double)
mov rdi, rax
call __ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_; std::endl<char,std::char_traits<char>>(std::ostream &)
lea rdi, [rsp+0E8h+var_C8]
call _ZNSt6vectorISt6threadSaIS0_EED2Ev; std::vector<std::thread>::~vector()
lea rdi, [rsp+0E8h+var_D8]; this
call _ZNSt6threadD2Ev; std::thread::~thread()
lea rdi, [rsp+0E8h+var_70]
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_St10shared_ptrIN7emittra7Emittra9EventDataEEESaISD_ENSt8__detail10_Select1stESt8equal_toIS5_ESt4hashIS5_ENSF_18_Mod_range_hashingENSF_20_Default_ranged_hashENSF_20_Prime_rehash_policyENSF_17_Hashtable_traitsILb1ELb0ELb1EEEED2Ev; std::_Hashtable<std::string,std::pair<std::string const,std::shared_ptr<emittra::Emittra::EventData>>,std::allocator<std::pair<std::string const,std::shared_ptr<emittra::Emittra::EventData>>>,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>>::~_Hashtable()
xor eax, eax
add rsp, 0B8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_3A0D
jmp short loc_3A0D
jmp short loc_3A0D
mov rbx, rax
jmp short loc_3A24
jmp short loc_3A0D
jmp short $+2
loc_3A0D:
mov rbx, rax
lea rdi, [rsp+arg_18]
call _ZNSt6vectorISt6threadSaIS0_EED2Ev; std::vector<std::thread>::~vector()
lea rdi, [rsp+arg_8]; this
call _ZNSt6threadD2Ev; std::thread::~thread()
loc_3A24:
lea rdi, [rsp+arg_70]
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_St10shared_ptrIN7emittra7Emittra9EventDataEEESaISD_ENSt8__detail10_Select1stESt8equal_toIS5_ESt4hashIS5_ENSF_18_Mod_range_hashingENSF_20_Default_ranged_hashENSF_20_Prime_rehash_policyENSF_17_Hashtable_traitsILb1ELb0ELb1EEEED2Ev; std::_Hashtable<std::string,std::pair<std::string const,std::shared_ptr<emittra::Emittra::EventData>>,std::allocator<std::pair<std::string const,std::shared_ptr<emittra::Emittra::EventData>>>,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>>::~_Hashtable()
mov rdi, rbx
call __Unwind_Resume
| int main(int argc, const char **argv, const char **envp)
{
__int32 v3; // ecx
int v4; // r8d
int v5; // r9d
long long i; // rax
int j; // eax
long long v8; // rbx
std::chrono::_V2::system_clock *v9; // rdi
std::thread *v10; // r14
std::thread *v11; // r15
long long v12; // rax
long long v13; // rcx
int v14; // ebx
long long v15; // r14
long long v16; // rax
long long v17; // rax
long long v18; // rdx
long long v19; // rax
long long v20; // rdx
long long v21; // rax
long long v22; // rax
long long v23; // rdx
long long v24; // rax
long long v25; // rax
int v27; // [rsp+Ch] [rbp-DCh] BYREF
_BYTE v28[8]; // [rsp+10h] [rbp-D8h] BYREF
_BYTE *v29; // [rsp+18h] [rbp-D0h] BYREF
std::thread *v30[4]; // [rsp+20h] [rbp-C8h] BYREF
_BYTE v31[56]; // [rsp+40h] [rbp-A8h] BYREF
_BYTE v32[112]; // [rsp+78h] [rbp-70h] BYREF
emittra::Emittra::Emittra((emittra::Emittra *)v31, 0x400uLL);
for ( i = 0LL; i != 64; i += 4LL )
v3 = _InterlockedExchange((volatile __int32 *)((char *)&events_total_count + i), 0);
v30[0] = (std::thread *)v31;
std::thread::thread<void (&)(emittra::Emittra &),std::reference_wrapper<emittra::Emittra>,void>(
(unsigned int)v28,
(unsigned int)emitter_thread,
(unsigned int)v30,
v3,
v4,
v5);
memset(v30, 0, 24);
std::vector<std::thread>::reserve(v30, 16LL);
for ( j = 0; ; j = v27 + 1 )
{
v27 = j;
if ( j >= 16 )
break;
v29 = v31;
std::vector<std::thread>::emplace_back<void (&)(emittra::Emittra &,int),std::reference_wrapper<emittra::Emittra>,int &>(
v30,
worker,
&v29,
&v27);
}
v8 = std::chrono::_V2::system_clock::now((std::chrono::_V2::system_clock *)v30);
v29 = byte_9 + 1;
std::this_thread::sleep_for<long,std::ratio<1l,1l>>(&v29);
stop_processing = 1;
v9 = (std::chrono::_V2::system_clock *)v28;
std::thread::join((std::thread *)v28);
v10 = v30[0];
v11 = v30[1];
while ( v10 != v11 )
{
v9 = v10;
std::thread::join(v10);
v10 = (std::thread *)((char *)v10 + 8);
}
v12 = std::chrono::_V2::system_clock::now(v9) - v8;
v13 = 0LL;
v14 = 0;
while ( v13 != 64 )
{
v14 += *(_DWORD *)((char *)&events_total_count + v13);
v13 += 4LL;
}
v15 = v12 / 1000000;
v16 = std::operator<<<std::char_traits<char>>(&std::cout, "Time taken: ", v12 % 1000000);
v17 = std::ostream::_M_insert<long>(v16, v15);
v19 = std::operator<<<std::char_traits<char>>(v17, " ms", v18);
std::endl<char,std::char_traits<char>>(v19);
v21 = std::operator<<<std::char_traits<char>>(&std::cout, "Total events processed: ", v20);
v22 = std::ostream::operator<<(v21, (unsigned int)v14);
std::endl<char,std::char_traits<char>>(v22);
v24 = std::operator<<<std::char_traits<char>>(&std::cout, "Events per second: ", v23);
v25 = std::ostream::_M_insert<double>(v24, (double)v14 * 1000.0 / (double)(int)v15);
std::endl<char,std::char_traits<char>>(v25);
std::vector<std::thread>::~vector(v30);
std::thread::~thread((std::thread *)v28);
std::_Hashtable<std::string,std::pair<std::string const,std::shared_ptr<emittra::Emittra::EventData>>,std::allocator<std::pair<std::string const,std::shared_ptr<emittra::Emittra::EventData>>>,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>>::~_Hashtable(v32);
return 0;
}
| main:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xb8
LEA RBX,[RSP + 0x40]
MOV ESI,0x400
MOV RDI,RBX
CALL 0x001047f4
XOR EAX,EAX
LEA RBP,[0x113280]
LAB_00103846:
CMP RAX,0x40
JZ 0x00103857
XOR ECX,ECX
XCHG dword ptr [RAX + RBP*0x1],ECX
ADD RAX,0x4
JMP 0x00103846
LAB_00103857:
LEA RDX,[RSP + 0x20]
MOV qword ptr [RDX],RBX
LAB_0010385f:
LEA RSI,[0x1035ac]
LEA RDI,[RSP + 0x10]
CALL 0x00103c6a
XORPD XMM0,XMM0
LEA RDI,[RSP + 0x20]
MOVAPD xmmword ptr [RDI],XMM0
AND qword ptr [RDI + 0x10],0x0
LAB_00103882:
PUSH 0x10
POP RSI
CALL 0x00103ce4
XOR EAX,EAX
LEA R14,[0x1036d1]
LEA R15,[RSP + 0x20]
LEA R12,[RSP + 0x18]
LEA R13,[RSP + 0xc]
LAB_001038a2:
MOV dword ptr [RSP + 0xc],EAX
CMP EAX,0x10
JGE 0x001038c9
MOV qword ptr [RSP + 0x18],RBX
LAB_001038b0:
MOV RDI,R15
MOV RSI,R14
MOV RDX,R12
MOV RCX,R13
CALL 0x00103d76
MOV EAX,dword ptr [RSP + 0xc]
INC EAX
JMP 0x001038a2
LAB_001038c9:
CALL 0x00103050
MOV RBX,RAX
LEA RDI,[RSP + 0x18]
MOV qword ptr [RDI],0xa
LAB_001038dd:
CALL 0x00103dbe
MOV byte ptr [0x00113271],0x1
LAB_001038e9:
LEA RDI,[RSP + 0x10]
CALL 0x00103410
MOV R14,qword ptr [RSP + 0x20]
MOV R15,qword ptr [RSP + 0x28]
LAB_001038fd:
CMP R14,R15
JZ 0x00103910
LAB_00103902:
MOV RDI,R14
CALL 0x00103410
ADD R14,0x8
JMP 0x001038fd
LAB_00103910:
CALL 0x00103050
SUB RAX,RBX
XOR ECX,ECX
XOR EBX,EBX
LAB_0010391c:
CMP RCX,0x40
JZ 0x0010392d
MOV EDX,dword ptr [RCX + RBP*0x1]
ADD EBX,EDX
ADD RCX,0x4
JMP 0x0010391c
LAB_0010392d:
MOV ECX,0xf4240
CQO
IDIV RCX
MOV R14,RAX
LAB_0010393a:
MOV RDI,qword ptr [0x00112fc0]
LEA RSI,[0x10b020]
CALL 0x00103290
MOV RDI,RAX
MOV RSI,R14
CALL 0x00103280
LEA RSI,[0x10b02d]
MOV RDI,RAX
CALL 0x00103290
MOV RDI,RAX
CALL 0x00103150
MOV RDI,qword ptr [0x00112fc0]
LEA RSI,[0x10b031]
CALL 0x00103290
MOV RDI,RAX
MOV ESI,EBX
CALL 0x00103430
MOV RDI,RAX
CALL 0x00103150
MOV RDI,qword ptr [0x00112fc0]
LEA RSI,[0x10b04a]
CALL 0x00103290
CVTSI2SD XMM0,EBX
MULSD XMM0,qword ptr [0x0010b008]
CVTSI2SD XMM1,R14
DIVSD XMM0,XMM1
MOV RDI,RAX
CALL 0x001033c0
MOV RDI,RAX
CALL 0x00103150
LAB_001039cc:
LEA RDI,[RSP + 0x20]
CALL 0x00103df6
LEA RDI,[RSP + 0x10]
CALL 0x00103e18
LEA RDI,[RSP + 0x78]
CALL 0x00103eca
XOR EAX,EAX
ADD RSP,0xb8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8 main(void)
{
long lVar1;
long lVar2;
ostream *poVar3;
long lVar4;
int iVar5;
Emittra *pEVar6;
int local_dc;
thread local_d8 [8];
Emittra *local_d0;
Emittra *local_c8;
long lStack_c0;
int8 local_b8;
Emittra local_a8 [56];
_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::shared_ptr<emittra::Emittra::EventData>>,std::allocator<std::pair<std::__cxx11::string_const,std::shared_ptr<emittra::Emittra::EventData>>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
local_70 [64];
emittra::Emittra::Emittra(local_a8,0x400);
for (lVar1 = 0; lVar1 != 0x40; lVar1 = lVar1 + 4) {
LOCK();
*(int4 *)((long)&events_total_count + lVar1) = 0;
UNLOCK();
}
/* try { // try from 0010385f to 0010386f has its CatchHandler @ 00103a04 */
local_c8 = local_a8;
std::thread::thread<void(&)(emittra::Emittra&),std::reference_wrapper<emittra::Emittra>,void>
(local_d8,emitter_thread,(reference_wrapper *)&local_c8);
local_c8 = (Emittra *)0x0;
lStack_c0 = 0;
local_b8 = 0;
/* try { // try from 00103882 to 00103889 has its CatchHandler @ 00103a02 */
std::vector<std::thread,std::allocator<std::thread>>::reserve
((vector<std::thread,std::allocator<std::thread>> *)&local_c8,0x10);
for (local_dc = 0; local_dc < 0x10; local_dc = local_dc + 1) {
local_d0 = local_a8;
/* try { // try from 001038b0 to 001038c0 has its CatchHandler @ 00103a0d */
std::vector<std::thread,std::allocator<std::thread>>::
emplace_back<void(&)(emittra::Emittra&,int),std::reference_wrapper<emittra::Emittra>,int&>
((vector<std::thread,std::allocator<std::thread>> *)&local_c8,worker,
(reference_wrapper *)&local_d0,&local_dc);
}
lVar2 = std::chrono::_V2::system_clock::now();
local_d0 = (Emittra *)0xa;
/* try { // try from 001038dd to 001038e1 has its CatchHandler @ 00103a00 */
std::this_thread::sleep_for<long,std::ratio<1l,1l>>((duration *)&local_d0);
stop_processing = 1;
/* try { // try from 001038e9 to 001038f2 has its CatchHandler @ 001039fe */
std::thread::join();
lVar1 = lStack_c0;
for (pEVar6 = local_c8; pEVar6 != (Emittra *)lVar1; pEVar6 = (Emittra *)((long)pEVar6 + 8)) {
/* try { // try from 00103902 to 00103909 has its CatchHandler @ 00103a0b */
std::thread::join();
}
lVar1 = std::chrono::_V2::system_clock::now();
iVar5 = 0;
for (lVar4 = 0; lVar4 != 0x40; lVar4 = lVar4 + 4) {
iVar5 = iVar5 + *(int *)((long)&events_total_count + lVar4);
}
/* try { // try from 0010393a to 001039cb has its CatchHandler @ 00103a09 */
poVar3 = std::operator<<((ostream *)PTR_cout_00112fc0,"Time taken: ");
poVar3 = std::ostream::_M_insert<long>((long)poVar3);
poVar3 = std::operator<<(poVar3," ms");
std::endl<char,std::char_traits<char>>(poVar3);
poVar3 = std::operator<<((ostream *)PTR_cout_00112fc0,"Total events processed: ");
poVar3 = (ostream *)std::ostream::operator<<(poVar3,iVar5);
std::endl<char,std::char_traits<char>>(poVar3);
std::operator<<((ostream *)PTR_cout_00112fc0,"Events per second: ");
poVar3 = std::ostream::_M_insert<double>
(((double)iVar5 * _DAT_0010b008) / (double)((lVar1 - lVar2) / 1000000));
std::endl<char,std::char_traits<char>>(poVar3);
std::vector<std::thread,std::allocator<std::thread>>::~vector
((vector<std::thread,std::allocator<std::thread>> *)&local_c8);
std::thread::~thread(local_d8);
std::
_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::shared_ptr<emittra::Emittra::EventData>>,std::allocator<std::pair<std::__cxx11::string_const,std::shared_ptr<emittra::Emittra::EventData>>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
::~_Hashtable(local_70);
return 0;
}
| |
26,492 | main | angrymouse[P]emittra/src/benchmark.cpp | int main() {
emittra::Emittra emitter(1024);
// Initialize the counters.
for (int i = 0; i < NUM_THREADS; i++) {
events_total_count[i] = 0;
}
std::thread emit_thread(emitter_thread, std::ref(emitter));
std::vector<std::thread> workers;
workers.reserve(NUM_THREADS);
for (int i = 0; i < NUM_THREADS; ++i) {
workers.emplace_back(worker, std::ref(emitter), i);
}
auto start = std::chrono::high_resolution_clock::now();
// Run benchmark for 10 seconds.
std::this_thread::sleep_for(std::chrono::seconds(10));
stop_processing.store(true, std::memory_order_relaxed);
emit_thread.join();
for (auto& t : workers) {
t.join();
}
auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
int total_processed = 0;
for (int i = 0; i < NUM_THREADS; i++) {
total_processed += events_total_count[i].load(std::memory_order_relaxed);
}
std::cout << "Time taken: " << duration.count() << " ms" << std::endl;
std::cout << "Total events processed: " << total_processed << std::endl;
std::cout << "Events per second: " << (total_processed * 1000.0 / duration.count()) << std::endl;
return 0;
} | O3 | cpp | main:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
leaq 0x40(%rsp), %rbx
movl $0x400, %esi # imm = 0x400
movq %rbx, %rdi
callq 0x4acc
xorl %eax, %eax
leaq 0xe704(%rip), %rbp # 0x12290
xorl %ecx, %ecx
xchgl %ecx, (%rax,%rbp)
addq $0x4, %rax
cmpq $0x40, %rax
jne 0x3b8c
leaq 0x10(%rsp), %rdx
movq %rbx, (%rdx)
leaq -0x4fe(%rip), %rsi # 0x36ac
leaq 0x8(%rsp), %rdi
callq 0x4042
xorpd %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movapd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x10, %esi
callq 0x40c2
leaq 0x4(%rsp), %r14
movl $0x0, (%r14)
leaq -0x338(%rip), %r15 # 0x38ae
leaq 0x10(%rsp), %r12
leaq 0x30(%rsp), %r13
movq %rbx, 0x30(%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x416e
movl 0x4(%rsp), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x4(%rsp)
cmpl $0xf, %eax
jl 0x3bf0
callq 0x3060
movq %rax, %rbx
leaq 0x30(%rsp), %r14
movq $0xa, (%r14)
movq $0x0, 0x8(%r14)
movq %r14, %rdi
movq %r14, %rsi
callq 0x30b0
cmpl $-0x1, %eax
jne 0x3c4c
callq 0x3040
cmpl $0x4, (%rax)
je 0x3c32
movb $0x1, 0xe62e(%rip) # 0x12281
leaq 0x8(%rsp), %rdi
callq 0x3420
movq 0x10(%rsp), %r14
movq 0x18(%rsp), %r15
cmpq %r15, %r14
je 0x3c7a
movq %r14, %rdi
callq 0x3420
addq $0x8, %r14
jmp 0x3c67
callq 0x3060
subq %rbx, %rax
xorl %ecx, %ecx
xorl %ebx, %ebx
movl (%rcx,%rbp), %edx
addl %edx, %ebx
addq $0x4, %rcx
cmpq $0x40, %rcx
jne 0x3c86
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
imulq %rcx
movq %rdx, %r14
movq 0xe314(%rip), %rdi # 0x11fc0
leaq 0x836d(%rip), %rsi # 0xc020
movl $0xc, %edx
callq 0x32f0
movq %r14, %rax
shrq $0x3f, %rax
sarq $0x12, %r14
addq %rax, %r14
movq 0xe2ee(%rip), %rdi # 0x11fc0
movq %r14, %rsi
callq 0x3280
movq %rax, %r15
leaq 0x8349(%rip), %rsi # 0xc02d
movl $0x3, %edx
movq %rax, %rdi
callq 0x32f0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
movq 0xe2a1(%rip), %rdi # 0x11fc0
leaq 0x830b(%rip), %rsi # 0xc031
movl $0x18, %edx
callq 0x32f0
movq 0xe289(%rip), %rdi # 0x11fc0
movl %ebx, %esi
callq 0x3440
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
movq 0xe251(%rip), %rdi # 0x11fc0
leaq 0x82d4(%rip), %rsi # 0xc04a
movl $0x13, %edx
callq 0x32f0
cvtsi2sd %ebx, %xmm0
mulsd 0x827c(%rip), %xmm0 # 0xc008
cvtsi2sd %r14, %xmm1
divsd %xmm1, %xmm0
movq 0xe224(%rip), %rdi # 0x11fc0
callq 0x33d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
leaq 0x10(%rsp), %rdi
callq 0x41b6
cmpq $0x0, 0x8(%rsp)
jne 0x3e31
leaq 0x78(%rsp), %rdi
callq 0x426a
xorl %eax, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3e0a
jmp 0x3e0a
movq %rax, %rbx
jmp 0x3e1f
jmp 0x3e0a
jmp 0x3e0a
jmp 0x3e0a
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x41b6
cmpq $0x0, 0x8(%rsp)
jne 0x3e31
leaq 0x78(%rsp), %rdi
callq 0x426a
movq %rbx, %rdi
callq 0x3450
callq 0x30a0
| main:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0B8h
lea rbx, [rsp+0E8h+var_A8]
mov esi, 400h; unsigned __int64
mov rdi, rbx; this
call _ZN7emittra7EmittraC2Em; emittra::Emittra::Emittra(ulong)
xor eax, eax
lea rbp, events_total_count
loc_3B8C:
xor ecx, ecx
xchg ecx, [rax+rbp]
add rax, 4
cmp rax, 40h ; '@'
jnz short loc_3B8C
lea rdx, [rsp+0E8h+var_D8]
mov [rdx], rbx
lea rsi, _Z14emitter_threadRN7emittra7EmittraE; emitter_thread(emittra::Emittra &)
lea rdi, [rsp+0E8h+var_E0]
call _ZNSt6threadC2IRFvRN7emittra7EmittraEEJSt17reference_wrapperIS2_EEvEEOT_DpOT0_; std::thread::thread<void (&)(emittra::Emittra &),std::reference_wrapper<emittra::Emittra>,void>(void (&)(emittra::Emittra &) &&,std::reference_wrapper<emittra::Emittra> &&)
xorpd xmm0, xmm0
lea rdi, [rsp+0E8h+var_D8]
movapd xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov esi, 10h
call _ZNSt6vectorISt6threadSaIS0_EE7reserveEm; std::vector<std::thread>::reserve(ulong)
lea r14, [rsp+0E8h+var_E4]
mov dword ptr [r14], 0
lea r15, _Z6workerRN7emittra7EmittraEi; worker(emittra::Emittra &,int)
lea r12, [rsp+0E8h+var_D8]
lea r13, [rsp+0E8h+var_B8]
loc_3BF0:
mov [rsp+0E8h+var_B8], rbx
mov rdi, r12; this
mov rsi, r15
mov rdx, r13
mov rcx, r14
call _ZNSt6vectorISt6threadSaIS0_EE12emplace_backIJRFvRN7emittra7EmittraEiESt17reference_wrapperIS5_ERiEEERS0_DpOT_; std::vector<std::thread>::emplace_back<void (&)(emittra::Emittra &,int),std::reference_wrapper<emittra::Emittra>,int &>(void (&)(emittra::Emittra &,int),std::reference_wrapper<emittra::Emittra>,int &)
mov eax, [rsp+0E8h+var_E4]
lea ecx, [rax+1]
mov [rsp+0E8h+var_E4], ecx
cmp eax, 0Fh
jl short loc_3BF0
call __ZNSt6chrono3_V212system_clock3nowEv; std::chrono::_V2::system_clock::now(void)
mov rbx, rax
lea r14, [rsp+0E8h+var_B8]
mov qword ptr [r14], 0Ah
mov qword ptr [r14+8], 0
loc_3C32:
mov rdi, r14
mov rsi, r14
call _nanosleep
cmp eax, 0FFFFFFFFh
jnz short loc_3C4C
call ___errno_location
cmp dword ptr [rax], 4
jz short loc_3C32
loc_3C4C:
mov cs:stop_processing, 1
lea rdi, [rsp+0E8h+var_E0]; this
call __ZNSt6thread4joinEv; std::thread::join(void)
mov r14, [rsp+0E8h+var_D8]
mov r15, [rsp+0E8h+var_D0]
loc_3C67:
cmp r14, r15
jz short loc_3C7A
mov rdi, r14; this
call __ZNSt6thread4joinEv; std::thread::join(void)
add r14, 8
jmp short loc_3C67
loc_3C7A:
call __ZNSt6chrono3_V212system_clock3nowEv; std::chrono::_V2::system_clock::now(void)
sub rax, rbx
xor ecx, ecx
xor ebx, ebx
loc_3C86:
mov edx, [rcx+rbp]
add ebx, edx
add rcx, 4
cmp rcx, 40h ; '@'
jnz short loc_3C86
mov rcx, 431BDE82D7B634DBh
imul rcx
mov r14, rdx
mov rdi, cs:_ZSt4cout_ptr
lea rsi, aTimeTaken; "Time taken: "
mov edx, 0Ch
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rax, r14
shr rax, 3Fh
sar r14, 12h
add r14, rax
mov rdi, cs:_ZSt4cout_ptr
mov rsi, r14
call __ZNSo9_M_insertIlEERSoT_; std::ostream::_M_insert<long>(long)
mov r15, rax
lea rsi, aMs; " ms"
mov edx, 3
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rax, [r15]
mov rdi, [rax-18h]
add rdi, r15
mov esi, 0Ah
call __ZNKSt9basic_iosIcSt11char_traitsIcEE5widenEc; std::ios::widen(char)
movsx esi, al; char
mov rdi, r15; this
call __ZNSo3putEc; std::ostream::put(char)
mov rdi, rax; this
call __ZNSo5flushEv; std::ostream::flush(void)
mov rdi, cs:_ZSt4cout_ptr
lea rsi, aTotalEventsPro; "Total events processed: "
mov edx, 18h
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, cs:_ZSt4cout_ptr
mov esi, ebx
call __ZNSolsEi; std::ostream::operator<<(int)
mov r15, rax
mov rax, [rax]
mov rdi, [rax-18h]
add rdi, r15
mov esi, 0Ah
call __ZNKSt9basic_iosIcSt11char_traitsIcEE5widenEc; std::ios::widen(char)
movsx esi, al; char
mov rdi, r15; this
call __ZNSo3putEc; std::ostream::put(char)
mov rdi, rax; this
call __ZNSo5flushEv; std::ostream::flush(void)
mov rdi, cs:_ZSt4cout_ptr
lea rsi, aEventsPerSecon; "Events per second: "
mov edx, 13h
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
cvtsi2sd xmm0, ebx
mulsd xmm0, cs:qword_C008
cvtsi2sd xmm1, r14
divsd xmm0, xmm1
mov rdi, cs:_ZSt4cout_ptr
call __ZNSo9_M_insertIdEERSoT_; std::ostream::_M_insert<double>(double)
mov rbx, rax
mov rax, [rax]
mov rdi, [rax-18h]
add rdi, rbx
mov esi, 0Ah
call __ZNKSt9basic_iosIcSt11char_traitsIcEE5widenEc; std::ios::widen(char)
movsx esi, al; char
mov rdi, rbx; this
call __ZNSo3putEc; std::ostream::put(char)
mov rdi, rax; this
call __ZNSo5flushEv; std::ostream::flush(void)
lea rdi, [rsp+0E8h+var_D8]
call _ZNSt6vectorISt6threadSaIS0_EED2Ev; std::vector<std::thread>::~vector()
cmp [rsp+0E8h+var_E0], 0
jnz short loc_3E31
lea rdi, [rsp+0E8h+var_70]
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_St10shared_ptrIN7emittra7Emittra9EventDataEEESaISD_ENSt8__detail10_Select1stESt8equal_toIS5_ESt4hashIS5_ENSF_18_Mod_range_hashingENSF_20_Default_ranged_hashENSF_20_Prime_rehash_policyENSF_17_Hashtable_traitsILb1ELb0ELb1EEEED2Ev; std::_Hashtable<std::string,std::pair<std::string const,std::shared_ptr<emittra::Emittra::EventData>>,std::allocator<std::pair<std::string const,std::shared_ptr<emittra::Emittra::EventData>>>,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>>::~_Hashtable()
xor eax, eax
add rsp, 0B8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_3E0A
jmp short loc_3E0A
mov rbx, rax
jmp short loc_3E1F
jmp short loc_3E0A
jmp short loc_3E0A
jmp short $+2
loc_3E0A:
mov rbx, rax
lea rdi, [rsp+0E8h+var_D8]
call _ZNSt6vectorISt6threadSaIS0_EED2Ev; std::vector<std::thread>::~vector()
cmp [rsp+0E8h+var_E0], 0
jnz short loc_3E31
loc_3E1F:
lea rdi, [rsp+0E8h+var_70]
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_St10shared_ptrIN7emittra7Emittra9EventDataEEESaISD_ENSt8__detail10_Select1stESt8equal_toIS5_ESt4hashIS5_ENSF_18_Mod_range_hashingENSF_20_Default_ranged_hashENSF_20_Prime_rehash_policyENSF_17_Hashtable_traitsILb1ELb0ELb1EEEED2Ev; std::_Hashtable<std::string,std::pair<std::string const,std::shared_ptr<emittra::Emittra::EventData>>,std::allocator<std::pair<std::string const,std::shared_ptr<emittra::Emittra::EventData>>>,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>>::~_Hashtable()
mov rdi, rbx
call __Unwind_Resume
loc_3E31:
call __ZSt9terminatev; std::terminate(void)
| int main(int argc, const char **argv, const char **envp)
{
int v3; // r8d
int v4; // r9d
long long i; // rax
__int32 v6; // ecx
int v7; // eax
long long v8; // rbx
std::chrono::_V2::system_clock *v9; // rdi
std::thread *v10; // r14
std::thread *v11; // r15
long long v12; // rax
long long v13; // rcx
int v14; // ebx
long long v15; // r14
long long v16; // r14
std::ostream *v17; // r15
char v18; // al
std::ostream *v19; // rax
std::ostream *v20; // r15
char v21; // al
std::ostream *v22; // rax
std::ostream *v23; // rbx
char v24; // al
std::ostream *v25; // rax
long long v27; // [rsp+0h] [rbp-E8h] BYREF
long long v28; // [rsp+8h] [rbp-E0h] BYREF
std::thread *v29[4]; // [rsp+10h] [rbp-D8h] BYREF
_QWORD v30[2]; // [rsp+30h] [rbp-B8h] BYREF
_BYTE v31[56]; // [rsp+40h] [rbp-A8h] BYREF
_BYTE v32[112]; // [rsp+78h] [rbp-70h] BYREF
emittra::Emittra::Emittra((emittra::Emittra *)v31, 0x400uLL);
for ( i = 0LL; i != 64; i += 4LL )
v6 = _InterlockedExchange((volatile __int32 *)((char *)&events_total_count + i), 0);
v29[0] = (std::thread *)v31;
std::thread::thread<void (&)(emittra::Emittra &),std::reference_wrapper<emittra::Emittra>,void>(
(unsigned int)&v28,
(unsigned int)emitter_thread,
(unsigned int)v29,
v6,
v3,
v4,
v27);
memset(v29, 0, 24);
std::vector<std::thread>::reserve(v29, 16LL);
HIDWORD(v27) = 0;
do
{
v30[0] = v31;
std::vector<std::thread>::emplace_back<void (&)(emittra::Emittra &,int),std::reference_wrapper<emittra::Emittra>,int &>(
v29,
worker,
v30,
(char *)&v27 + 4);
v7 = HIDWORD(v27)++;
}
while ( v7 < 15 );
v8 = std::chrono::_V2::system_clock::now((std::chrono::_V2::system_clock *)v29);
v30[0] = 10LL;
v30[1] = 0LL;
while ( (unsigned int)nanosleep(v30, v30) == -1 && *(_DWORD *)__errno_location() == 4 )
;
stop_processing = 1;
v9 = (std::chrono::_V2::system_clock *)&v28;
std::thread::join((std::thread *)&v28);
v10 = v29[0];
v11 = v29[1];
while ( v10 != v11 )
{
v9 = v10;
std::thread::join(v10);
v10 = (std::thread *)((char *)v10 + 8);
}
v12 = std::chrono::_V2::system_clock::now(v9) - v8;
v13 = 0LL;
v14 = 0;
do
{
v14 += *(_DWORD *)((char *)&events_total_count + v13);
v13 += 4LL;
}
while ( v13 != 64 );
v15 = (unsigned __int128)(0x431BDE82D7B634DBLL * (__int128)v12) >> 64;
std::__ostream_insert<char,std::char_traits<char>>(&std::cout, "Time taken: ", 12LL);
v16 = ((unsigned long long)v15 >> 63) + (v15 >> 18);
v17 = (std::ostream *)std::ostream::_M_insert<long>(&std::cout, v16);
std::__ostream_insert<char,std::char_traits<char>>(v17, " ms", 3LL);
v18 = std::ios::widen((char *)v17 + *(_QWORD *)(*(_QWORD *)v17 - 24LL), 10LL);
v19 = (std::ostream *)std::ostream::put(v17, v18);
std::ostream::flush(v19);
std::__ostream_insert<char,std::char_traits<char>>(&std::cout, "Total events processed: ", 24LL);
v20 = (std::ostream *)std::ostream::operator<<(&std::cout, (unsigned int)v14);
v21 = std::ios::widen((char *)v20 + *(_QWORD *)(*(_QWORD *)v20 - 24LL), 10LL);
v22 = (std::ostream *)std::ostream::put(v20, v21);
std::ostream::flush(v22);
std::__ostream_insert<char,std::char_traits<char>>(&std::cout, "Events per second: ", 19LL);
v23 = (std::ostream *)std::ostream::_M_insert<double>(&std::cout, (double)v14 * 1000.0 / (double)(int)v16);
v24 = std::ios::widen((char *)v23 + *(_QWORD *)(*(_QWORD *)v23 - 24LL), 10LL);
v25 = (std::ostream *)std::ostream::put(v23, v24);
std::ostream::flush(v25);
std::vector<std::thread>::~vector(v29);
if ( v28 )
std::terminate();
std::_Hashtable<std::string,std::pair<std::string const,std::shared_ptr<emittra::Emittra::EventData>>,std::allocator<std::pair<std::string const,std::shared_ptr<emittra::Emittra::EventData>>>,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>>::~_Hashtable(v32);
return 0;
}
| main:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xb8
LEA RBX,[RSP + 0x40]
MOV ESI,0x400
MOV RDI,RBX
CALL 0x00104acc
XOR EAX,EAX
LEA RBP,[0x112290]
LAB_00103b8c:
XOR ECX,ECX
XCHG dword ptr [RAX + RBP*0x1],ECX
ADD RAX,0x4
CMP RAX,0x40
JNZ 0x00103b8c
LEA RDX,[RSP + 0x10]
MOV qword ptr [RDX],RBX
LAB_00103ba3:
LEA RSI,[0x1036ac]
LEA RDI,[RSP + 0x8]
CALL 0x00104042
XORPD XMM0,XMM0
LEA RDI,[RSP + 0x10]
MOVAPD xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
LAB_00103bc9:
MOV ESI,0x10
CALL 0x001040c2
LEA R14,[RSP + 0x4]
MOV dword ptr [R14],0x0
LEA R15,[0x1038ae]
LEA R12,[RSP + 0x10]
LEA R13,[RSP + 0x30]
LAB_00103bf0:
MOV qword ptr [RSP + 0x30],RBX
LAB_00103bf5:
MOV RDI,R12
MOV RSI,R15
MOV RDX,R13
MOV RCX,R14
CALL 0x0010416e
MOV EAX,dword ptr [RSP + 0x4]
LEA ECX,[RAX + 0x1]
MOV dword ptr [RSP + 0x4],ECX
CMP EAX,0xf
JL 0x00103bf0
CALL 0x00103060
MOV RBX,RAX
LEA R14,[RSP + 0x30]
MOV qword ptr [R14],0xa
MOV qword ptr [R14 + 0x8],0x0
LAB_00103c32:
MOV RDI,R14
MOV RSI,R14
CALL 0x001030b0
CMP EAX,-0x1
JNZ 0x00103c4c
CALL 0x00103040
CMP dword ptr [RAX],0x4
JZ 0x00103c32
LAB_00103c4c:
MOV byte ptr [0x00112281],0x1
LAB_00103c53:
LEA RDI,[RSP + 0x8]
CALL 0x00103420
MOV R14,qword ptr [RSP + 0x10]
MOV R15,qword ptr [RSP + 0x18]
LAB_00103c67:
CMP R14,R15
JZ 0x00103c7a
LAB_00103c6c:
MOV RDI,R14
CALL 0x00103420
ADD R14,0x8
JMP 0x00103c67
LAB_00103c7a:
CALL 0x00103060
SUB RAX,RBX
XOR ECX,ECX
XOR EBX,EBX
LAB_00103c86:
MOV EDX,dword ptr [RCX + RBP*0x1]
ADD EBX,EDX
ADD RCX,0x4
CMP RCX,0x40
JNZ 0x00103c86
MOV RCX,0x431bde82d7b634db
IMUL RCX
MOV R14,RDX
LAB_00103ca5:
MOV RDI,qword ptr [0x00111fc0]
LEA RSI,[0x10c020]
MOV EDX,0xc
CALL 0x001032f0
MOV RAX,R14
SHR RAX,0x3f
SAR R14,0x12
ADD R14,RAX
MOV RDI,qword ptr [0x00111fc0]
MOV RSI,R14
CALL 0x00103280
MOV R15,RAX
LEA RSI,[0x10c02d]
MOV EDX,0x3
MOV RDI,RAX
CALL 0x001032f0
MOV RAX,qword ptr [R15]
MOV RDI,qword ptr [RAX + -0x18]
ADD RDI,R15
MOV ESI,0xa
CALL 0x00103290
MOVSX ESI,AL
MOV RDI,R15
CALL 0x00103030
MOV RDI,RAX
CALL 0x001031a0
MOV RDI,qword ptr [0x00111fc0]
LEA RSI,[0x10c031]
MOV EDX,0x18
CALL 0x001032f0
MOV RDI,qword ptr [0x00111fc0]
MOV ESI,EBX
CALL 0x00103440
MOV R15,RAX
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + -0x18]
ADD RDI,R15
MOV ESI,0xa
CALL 0x00103290
MOVSX ESI,AL
MOV RDI,R15
CALL 0x00103030
MOV RDI,RAX
CALL 0x001031a0
MOV RDI,qword ptr [0x00111fc0]
LEA RSI,[0x10c04a]
MOV EDX,0x13
CALL 0x001032f0
CVTSI2SD XMM0,EBX
MULSD XMM0,qword ptr [0x0010c008]
CVTSI2SD XMM1,R14
DIVSD XMM0,XMM1
MOV RDI,qword ptr [0x00111fc0]
CALL 0x001033d0
MOV RBX,RAX
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + -0x18]
ADD RDI,RBX
MOV ESI,0xa
CALL 0x00103290
MOVSX ESI,AL
MOV RDI,RBX
CALL 0x00103030
MOV RDI,RAX
CALL 0x001031a0
LAB_00103dcb:
LEA RDI,[RSP + 0x10]
CALL 0x001041b6
CMP qword ptr [RSP + 0x8],0x0
JNZ 0x00103e31
LEA RDI,[RSP + 0x78]
CALL 0x0010426a
XOR EAX,EAX
ADD RSP,0xb8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00103e31:
CALL 0x001030a0
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8 main(void)
{
bool bVar1;
int iVar2;
long lVar3;
int *piVar4;
long lVar5;
ostream *poVar6;
long *plVar7;
long lVar8;
Emittra *pEVar9;
int local_e4;
long local_e0;
Emittra *local_d8;
long lStack_d0;
int8 local_c8;
timespec local_b8;
Emittra local_a8 [56];
_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::shared_ptr<emittra::Emittra::EventData>>,std::allocator<std::pair<std::__cxx11::string_const,std::shared_ptr<emittra::Emittra::EventData>>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
local_70 [64];
emittra::Emittra::Emittra(local_a8,0x400);
lVar3 = 0;
do {
LOCK();
*(int4 *)((long)&events_total_count + lVar3) = 0;
UNLOCK();
lVar3 = lVar3 + 4;
} while (lVar3 != 0x40);
/* try { // try from 00103ba3 to 00103bb3 has its CatchHandler @ 00103dff */
local_d8 = local_a8;
std::thread::thread<void(&)(emittra::Emittra&),std::reference_wrapper<emittra::Emittra>,void>
((thread *)&local_e0,emitter_thread,(reference_wrapper *)&local_d8);
local_d8 = (Emittra *)0x0;
lStack_d0 = 0;
local_c8 = 0;
/* try { // try from 00103bc9 to 00103bd2 has its CatchHandler @ 00103dfd */
std::vector<std::thread,std::allocator<std::thread>>::reserve
((vector<std::thread,std::allocator<std::thread>> *)&local_d8,0x10);
local_e4 = 0;
do {
local_b8.tv_sec = (__time_t)local_a8;
/* try { // try from 00103bf5 to 00103c05 has its CatchHandler @ 00103e0a */
std::vector<std::thread,std::allocator<std::thread>>::
emplace_back<void(&)(emittra::Emittra&,int),std::reference_wrapper<emittra::Emittra>,int&>
((vector<std::thread,std::allocator<std::thread>> *)&local_d8,worker,
(reference_wrapper *)&local_b8,&local_e4);
iVar2 = local_e4 + 1;
bVar1 = local_e4 < 0xf;
local_e4 = iVar2;
} while (bVar1);
lVar3 = std::chrono::_V2::system_clock::now();
local_b8.tv_sec = 10;
local_b8.tv_nsec = 0;
do {
/* try { // try from 00103c32 to 00103c3c has its CatchHandler @ 00103e06 */
iVar2 = nanosleep(&local_b8,&local_b8);
if (iVar2 != -1) break;
piVar4 = __errno_location();
} while (*piVar4 == 4);
stop_processing = 1;
/* try { // try from 00103c53 to 00103c5c has its CatchHandler @ 00103dfb */
std::thread::join();
lVar5 = lStack_d0;
for (pEVar9 = local_d8; pEVar9 != (Emittra *)lVar5; pEVar9 = (Emittra *)((long)pEVar9 + 8)) {
/* try { // try from 00103c6c to 00103c73 has its CatchHandler @ 00103e08 */
std::thread::join();
}
lVar5 = std::chrono::_V2::system_clock::now();
lVar8 = 0;
iVar2 = 0;
do {
iVar2 = iVar2 + *(int *)((long)&events_total_count + lVar8);
lVar8 = lVar8 + 4;
} while (lVar8 != 0x40);
/* try { // try from 00103ca5 to 00103dca has its CatchHandler @ 00103e04 */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cout_00111fc0,"Time taken: ",0xc);
poVar6 = std::ostream::_M_insert<long>((long)PTR_cout_00111fc0);
std::__ostream_insert<char,std::char_traits<char>>(poVar6," ms",3);
std::ios::widen((char)*(int8 *)(*(long *)poVar6 + -0x18) + (char)poVar6);
std::ostream::put((char)poVar6);
std::ostream::flush();
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cout_00111fc0,"Total events processed: ",0x18);
plVar7 = (long *)std::ostream::operator<<((ostream *)PTR_cout_00111fc0,iVar2);
std::ios::widen((char)*(int8 *)(*plVar7 + -0x18) + (char)plVar7);
std::ostream::put((char)plVar7);
std::ostream::flush();
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cout_00111fc0,"Events per second: ",0x13);
poVar6 = std::ostream::_M_insert<double>
(((double)iVar2 * _DAT_0010c008) / (double)((lVar5 - lVar3) / 1000000));
std::ios::widen((char)*(int8 *)(*(long *)poVar6 + -0x18) + (char)poVar6);
std::ostream::put((char)poVar6);
std::ostream::flush();
std::vector<std::thread,std::allocator<std::thread>>::~vector
((vector<std::thread,std::allocator<std::thread>> *)&local_d8);
if (local_e0 == 0) {
std::
_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::shared_ptr<emittra::Emittra::EventData>>,std::allocator<std::pair<std::__cxx11::string_const,std::shared_ptr<emittra::Emittra::EventData>>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
::~_Hashtable(local_70);
return 0;
}
/* WARNING: Subroutine does not return */
std::terminate();
}
| |
26,493 | translog_write_variable_record | eloqsql/storage/maria/ma_loghandler.c | static my_bool translog_write_variable_record(LSN *lsn,
enum translog_record_type type,
MARIA_HA *tbl_info,
SHORT_TRANSACTION_ID short_trid,
struct st_translog_parts *parts,
TRN *trn, void *hook_arg)
{
struct st_translog_buffer *buffer_to_flush= NULL;
uint header_length1= 1 + 2 + 2 +
translog_variable_record_length_bytes(parts->record_length);
ulong buffer_rest;
uint page_rest;
/* Max number of such LSNs per record is 2 */
uchar compressed_LSNs[MAX_NUMBER_OF_LSNS_PER_RECORD *
COMPRESSED_LSN_MAX_STORE_SIZE];
my_bool res;
DBUG_ENTER("translog_write_variable_record");
translog_lock();
DBUG_PRINT("info", ("horizon: " LSN_FMT,
LSN_IN_PARTS(log_descriptor.horizon)));
page_rest= TRANSLOG_PAGE_SIZE - log_descriptor.bc.current_page_fill;
DBUG_PRINT("info", ("header length: %u page_rest: %u",
header_length1, page_rest));
/*
header and part which we should read have to fit in one chunk
TODO: allow to divide readable header
*/
if (page_rest <
(header_length1 + log_record_type_descriptor[type].read_header_len))
{
DBUG_PRINT("info",
("Next page, size: %u header: %u + %u",
log_descriptor.bc.current_page_fill,
header_length1,
log_record_type_descriptor[type].read_header_len));
translog_page_next(&log_descriptor.horizon, &log_descriptor.bc,
&buffer_to_flush);
/* Chunk 2 header is 1 byte, so full page capacity will be one uchar more */
page_rest= log_descriptor.page_capacity_chunk_2 + 1;
DBUG_PRINT("info", ("page_rest: %u", page_rest));
}
/*
To minimize compressed size we will compress always relative to
very first chunk address (log_descriptor.horizon for now)
*/
if (log_record_type_descriptor[type].compressed_LSN > 0)
{
translog_relative_LSN_encode(parts, log_descriptor.horizon,
log_record_type_descriptor[type].
compressed_LSN, compressed_LSNs);
/* recalculate header length after compression */
header_length1= 1 + 2 + 2 +
translog_variable_record_length_bytes(parts->record_length);
DBUG_PRINT("info", ("after compressing LSN(s) header length: %u "
"record length: %lu",
header_length1, (ulong)parts->record_length));
}
/* TODO: check space on current page for header + few bytes */
if (page_rest >= parts->record_length + header_length1)
{
/* following function makes translog_unlock(); */
res= translog_write_variable_record_1chunk(lsn, type, tbl_info,
short_trid,
parts, buffer_to_flush,
header_length1, trn, hook_arg);
DBUG_RETURN(res);
}
buffer_rest= translog_get_current_group_size();
if (buffer_rest >= parts->record_length + header_length1 - page_rest)
{
/* following function makes translog_unlock(); */
res= translog_write_variable_record_1group(lsn, type, tbl_info,
short_trid,
parts, buffer_to_flush,
header_length1, trn, hook_arg);
DBUG_RETURN(res);
}
/* following function makes translog_unlock(); */
res= translog_write_variable_record_mgroup(lsn, type, tbl_info,
short_trid,
parts, buffer_to_flush,
header_length1,
buffer_rest, trn, hook_arg);
DBUG_RETURN(res);
} | O0 | c | translog_write_variable_record:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xa8, %rsp
movw %cx, %ax
movq 0x10(%rbp), %rcx
movq %fs:0x28, %rcx
movq %rcx, -0x10(%rbp)
movq %rdi, -0x40(%rbp)
movl %esi, -0x44(%rbp)
movq %rdx, -0x50(%rbp)
movw %ax, -0x52(%rbp)
movq %r8, -0x60(%rbp)
movq %r9, -0x68(%rbp)
movq $0x0, -0x70(%rbp)
movq -0x60(%rbp), %rax
movl (%rax), %edi
callq 0x35ce0
addl $0x5, %eax
movl %eax, -0x74(%rbp)
callq 0x2c3c0
jmp 0x309a7
movzwl 0xc50062(%rip), %ecx # 0xc80a10
movl $0x2000, %eax # imm = 0x2000
subl %ecx, %eax
movl %eax, -0x84(%rbp)
jmp 0x309bd
movl -0x84(%rbp), %eax
movl -0x74(%rbp), %ecx
movl -0x44(%rbp), %edx
movl %edx, %esi
leaq 0x44e1be(%rip), %rdx # 0x47eb90
imulq $0x48, %rsi, %rsi
addq %rsi, %rdx
movzwl 0x6(%rdx), %edx
addl %edx, %ecx
cmpl %ecx, %eax
jae 0x30a1c
jmp 0x309e5
jmp 0x309e7
leaq 0x44f3a2(%rip), %rsi # 0x47fd90
movq %rsi, %rdi
addq $0x800c48, %rdi # imm = 0x800C48
addq $0x800c50, %rsi # imm = 0x800C50
leaq -0x70(%rbp), %rdx
callq 0x35d30
movzwl 0x44f3a7(%rip), %eax # 0x47fdb6
addl $0x1, %eax
movl %eax, -0x84(%rbp)
jmp 0x30a1a
jmp 0x30a1c
movl -0x44(%rbp), %eax
movl %eax, %ecx
leaq 0x44e168(%rip), %rax # 0x47eb90
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movswl 0x20(%rax), %eax
cmpl $0x0, %eax
jle 0x30a78
movq -0x60(%rbp), %rdi
movq 0xc4ff95(%rip), %rsi # 0xc809d8
movl -0x44(%rbp), %eax
movl %eax, %ecx
leaq 0x44e141(%rip), %rax # 0x47eb90
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movswl 0x20(%rax), %edx
leaq -0x30(%rbp), %rcx
callq 0x35e30
movq -0x60(%rbp), %rax
movl (%rax), %edi
callq 0x35ce0
addl $0x5, %eax
movl %eax, -0x74(%rbp)
jmp 0x30a76
jmp 0x30a78
movl -0x84(%rbp), %eax
movq -0x60(%rbp), %rcx
movl (%rcx), %ecx
addl -0x74(%rbp), %ecx
cmpl %ecx, %eax
jb 0x30adf
movq -0x40(%rbp), %rdi
movl -0x44(%rbp), %esi
movq -0x50(%rbp), %rdx
movw -0x52(%rbp), %cx
movq -0x60(%rbp), %r8
movq -0x70(%rbp), %r9
movl -0x74(%rbp), %eax
movw %ax, %r11w
movq -0x68(%rbp), %r10
movq 0x10(%rbp), %rax
movzwl %cx, %ecx
movzwl %r11w, %r11d
movl %r11d, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x36150
movb %al, -0x85(%rbp)
movb -0x85(%rbp), %al
movb %al, -0x31(%rbp)
jmp 0x30bad
callq 0x37af0
movl %eax, %eax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq -0x60(%rbp), %rcx
movl (%rcx), %ecx
addl -0x74(%rbp), %ecx
subl -0x84(%rbp), %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jb 0x30b55
movq -0x40(%rbp), %rdi
movl -0x44(%rbp), %esi
movq -0x50(%rbp), %rdx
movw -0x52(%rbp), %cx
movq -0x60(%rbp), %r8
movq -0x70(%rbp), %r9
movl -0x74(%rbp), %eax
movw %ax, %r11w
movq -0x68(%rbp), %r10
movq 0x10(%rbp), %rax
movzwl %cx, %ecx
movzwl %r11w, %r11d
movl %r11d, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x362f0
movb %al, -0x85(%rbp)
movb -0x85(%rbp), %al
movb %al, -0x31(%rbp)
jmp 0x30bad
movq -0x40(%rbp), %rdi
movl -0x44(%rbp), %esi
movq -0x50(%rbp), %rdx
movw -0x52(%rbp), %cx
movq -0x60(%rbp), %r8
movq -0x70(%rbp), %r9
movl -0x74(%rbp), %eax
movw %ax, %bx
movq -0x80(%rbp), %rax
movl %eax, %r11d
movq -0x68(%rbp), %r10
movq 0x10(%rbp), %rax
movzwl %cx, %ecx
movzwl %bx, %ebx
movl %ebx, (%rsp)
movl %r11d, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x366d0
movb %al, -0x85(%rbp)
movb -0x85(%rbp), %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
movb %al, -0x86(%rbp)
movq %fs:0x28, %rax
movq -0x10(%rbp), %rcx
cmpq %rcx, %rax
jne 0x30bd8
movb -0x86(%rbp), %al
addq $0xa8, %rsp
popq %rbx
popq %rbp
retq
callq 0x2a250
nopl (%rax)
| translog_write_variable_record:
push rbp
mov rbp, rsp
push rbx
sub rsp, 0A8h
mov ax, cx
mov rcx, [rbp+arg_0]
mov rcx, fs:28h
mov [rbp+var_10], rcx
mov [rbp+var_40], rdi
mov [rbp+var_44], esi
mov [rbp+var_50], rdx
mov [rbp+var_52], ax
mov [rbp+var_60], r8
mov [rbp+var_68], r9
mov [rbp+var_70], 0
mov rax, [rbp+var_60]
mov edi, [rax]
call translog_variable_record_length_bytes
add eax, 5
mov [rbp+var_74], eax
call translog_lock
jmp short $+2
loc_309A7:
movzx ecx, cs:word_C80A10
mov eax, 2000h
sub eax, ecx
mov [rbp+var_84], eax
jmp short $+2
loc_309BD:
mov eax, [rbp+var_84]
mov ecx, [rbp+var_74]
mov edx, [rbp+var_44]
mov esi, edx
lea rdx, log_record_type_descriptor
imul rsi, 48h ; 'H'
add rdx, rsi
movzx edx, word ptr [rdx+6]
add ecx, edx
cmp eax, ecx
jnb short loc_30A1C
jmp short $+2
loc_309E5:
jmp short $+2
loc_309E7:
lea rsi, log_descriptor
mov rdi, rsi
add rdi, 800C48h
add rsi, 800C50h
lea rdx, [rbp+var_70]
call translog_page_next
movzx eax, cs:word_47FDB6
add eax, 1
mov [rbp+var_84], eax
jmp short $+2
loc_30A1A:
jmp short $+2
loc_30A1C:
mov eax, [rbp+var_44]
mov ecx, eax
lea rax, log_record_type_descriptor
imul rcx, 48h ; 'H'
add rax, rcx
movsx eax, word ptr [rax+20h]
cmp eax, 0
jle short loc_30A78
mov rdi, [rbp+var_60]
mov rsi, cs:qword_C809D8
mov eax, [rbp+var_44]
mov ecx, eax
lea rax, log_record_type_descriptor
imul rcx, 48h ; 'H'
add rax, rcx
movsx edx, word ptr [rax+20h]
lea rcx, [rbp+var_30]
call translog_relative_LSN_encode
mov rax, [rbp+var_60]
mov edi, [rax]
call translog_variable_record_length_bytes
add eax, 5
mov [rbp+var_74], eax
jmp short $+2
loc_30A76:
jmp short $+2
loc_30A78:
mov eax, [rbp+var_84]
mov rcx, [rbp+var_60]
mov ecx, [rcx]
add ecx, [rbp+var_74]
cmp eax, ecx
jb short loc_30ADF
mov rdi, [rbp+var_40]
mov esi, [rbp+var_44]
mov rdx, [rbp+var_50]
mov cx, [rbp+var_52]
mov r8, [rbp+var_60]
mov r9, [rbp+var_70]
mov eax, [rbp+var_74]
mov r11w, ax
mov r10, [rbp+var_68]
mov rax, [rbp+arg_0]
movzx ecx, cx
movzx r11d, r11w
mov [rsp+0B0h+var_B0], r11d
mov [rsp+0B0h+var_A8], r10
mov [rsp+0B0h+var_A0], rax
call translog_write_variable_record_1chunk
mov [rbp+var_85], al
mov al, [rbp+var_85]
mov [rbp+var_31], al
jmp loc_30BAD
loc_30ADF:
call translog_get_current_group_size
mov eax, eax
mov [rbp+var_80], rax
mov rax, [rbp+var_80]
mov rcx, [rbp+var_60]
mov ecx, [rcx]
add ecx, [rbp+var_74]
sub ecx, [rbp+var_84]
mov ecx, ecx
cmp rax, rcx
jb short loc_30B55
mov rdi, [rbp+var_40]
mov esi, [rbp+var_44]
mov rdx, [rbp+var_50]
mov cx, [rbp+var_52]
mov r8, [rbp+var_60]
mov r9, [rbp+var_70]
mov eax, [rbp+var_74]
mov r11w, ax
mov r10, [rbp+var_68]
mov rax, [rbp+arg_0]
movzx ecx, cx
movzx r11d, r11w
mov [rsp+0B0h+var_B0], r11d
mov [rsp+0B0h+var_A8], r10
mov [rsp+0B0h+var_A0], rax
call translog_write_variable_record_1group
mov [rbp+var_85], al
mov al, [rbp+var_85]
mov [rbp+var_31], al
jmp short loc_30BAD
loc_30B55:
mov rdi, [rbp+var_40]
mov esi, [rbp+var_44]
mov rdx, [rbp+var_50]
mov cx, [rbp+var_52]
mov r8, [rbp+var_60]
mov r9, [rbp+var_70]
mov eax, [rbp+var_74]
mov bx, ax
mov rax, [rbp+var_80]
mov r11d, eax
mov r10, [rbp+var_68]
mov rax, [rbp+arg_0]
movzx ecx, cx
movzx ebx, bx
mov [rsp+0B0h+var_B0], ebx
mov dword ptr [rsp+0B0h+var_A8], r11d
mov [rsp+0B0h+var_A0], r10
mov [rsp+0B0h+var_98], rax
call translog_write_variable_record_mgroup
mov [rbp+var_85], al
mov al, [rbp+var_85]
mov [rbp+var_31], al
loc_30BAD:
mov al, [rbp+var_31]
mov [rbp+var_86], al
mov rax, fs:28h
mov rcx, [rbp+var_10]
cmp rax, rcx
jnz short loc_30BD8
mov al, [rbp+var_86]
add rsp, 0A8h
pop rbx
pop rbp
retn
loc_30BD8:
call ___stack_chk_fail
| char translog_write_variable_record(
long long a1,
int a2,
long long a3,
unsigned __int16 a4,
unsigned int *a5,
long long a6,
long long a7)
{
unsigned int v8; // [rsp+2Ch] [rbp-84h]
unsigned long long current_group_size; // [rsp+30h] [rbp-80h]
_BYTE v10[12]; // [rsp+3Ch] [rbp-74h] BYREF
long long v11; // [rsp+48h] [rbp-68h]
_DWORD *v12; // [rsp+50h] [rbp-60h]
unsigned __int16 v13; // [rsp+5Eh] [rbp-52h]
long long v14; // [rsp+60h] [rbp-50h]
int v15; // [rsp+6Ch] [rbp-44h]
long long v16; // [rsp+70h] [rbp-40h]
_BYTE v18[32]; // [rsp+80h] [rbp-30h] BYREF
unsigned long long v19; // [rsp+A0h] [rbp-10h]
v19 = __readfsqword(0x28u);
v16 = a1;
v15 = a2;
v14 = a3;
v13 = a4;
v12 = a5;
v11 = a6;
*(_QWORD *)&v10[4] = 0LL;
*(_QWORD *)v10 = (unsigned int)translog_variable_record_length_bytes(*a5) + 5;
translog_lock();
v8 = 0x2000 - (unsigned __int16)word_C80A10;
if ( v8 < (unsigned int)HIWORD(log_record_type_descriptor[18 * a2 + 1]) + *(_DWORD *)v10 )
{
translog_page_next(&log_descriptor[1048969], &log_descriptor[1048970], &v10[4]);
v8 = (unsigned __int16)word_47FDB6 + 1;
}
if ( SLOWORD(log_record_type_descriptor[18 * v15 + 8]) > 0 )
{
translog_relative_LSN_encode(
v12,
qword_C809D8,
(unsigned int)SLOWORD(log_record_type_descriptor[18 * v15 + 8]),
v18);
*(_DWORD *)v10 = translog_variable_record_length_bytes((unsigned int)*v12) + 5;
}
if ( v8 >= *(_DWORD *)v10 + *v12 )
return translog_write_variable_record_1chunk(
v16,
v15,
v14,
v13,
(_DWORD)v12,
*(_DWORD *)&v10[4],
*(__int16 *)v10,
v11,
a7);
current_group_size = (unsigned int)translog_get_current_group_size();
if ( current_group_size < *(_DWORD *)v10 + *v12 - v8 )
return translog_write_variable_record_mgroup(
v16,
v15,
v14,
v13,
(_DWORD)v12,
*(_DWORD *)&v10[4],
*(__int16 *)v10,
current_group_size,
v11,
a7);
else
return translog_write_variable_record_1group(
v16,
v15,
v14,
v13,
(_DWORD)v12,
*(_DWORD *)&v10[4],
*(__int16 *)v10,
v11,
a7);
}
| translog_write_variable_record:
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xa8
MOV AX,CX
MOV RCX,qword ptr [RBP + 0x10]
MOV RCX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x10],RCX
MOV qword ptr [RBP + -0x40],RDI
MOV dword ptr [RBP + -0x44],ESI
MOV qword ptr [RBP + -0x50],RDX
MOV word ptr [RBP + -0x52],AX
MOV qword ptr [RBP + -0x60],R8
MOV qword ptr [RBP + -0x68],R9
MOV qword ptr [RBP + -0x70],0x0
MOV RAX,qword ptr [RBP + -0x60]
MOV EDI,dword ptr [RAX]
CALL 0x00135ce0
ADD EAX,0x5
MOV dword ptr [RBP + -0x74],EAX
CALL 0x0012c3c0
JMP 0x001309a7
LAB_001309a7:
MOVZX ECX,word ptr [0x00d80a10]
MOV EAX,0x2000
SUB EAX,ECX
MOV dword ptr [RBP + -0x84],EAX
JMP 0x001309bd
LAB_001309bd:
MOV EAX,dword ptr [RBP + -0x84]
MOV ECX,dword ptr [RBP + -0x74]
MOV EDX,dword ptr [RBP + -0x44]
MOV ESI,EDX
LEA RDX,[0x57eb90]
IMUL RSI,RSI,0x48
ADD RDX,RSI
MOVZX EDX,word ptr [RDX + 0x6]
ADD ECX,EDX
CMP EAX,ECX
JNC 0x00130a1c
JMP 0x001309e5
LAB_001309e5:
JMP 0x001309e7
LAB_001309e7:
LEA RSI,[0x57fd90]
MOV RDI,RSI
ADD RDI,0x800c48
ADD RSI,0x800c50
LEA RDX,[RBP + -0x70]
CALL 0x00135d30
MOVZX EAX,word ptr [0x0057fdb6]
ADD EAX,0x1
MOV dword ptr [RBP + -0x84],EAX
JMP 0x00130a1a
LAB_00130a1a:
JMP 0x00130a1c
LAB_00130a1c:
MOV EAX,dword ptr [RBP + -0x44]
MOV ECX,EAX
LEA RAX,[0x57eb90]
IMUL RCX,RCX,0x48
ADD RAX,RCX
MOVSX EAX,word ptr [RAX + 0x20]
CMP EAX,0x0
JLE 0x00130a78
MOV RDI,qword ptr [RBP + -0x60]
MOV RSI,qword ptr [0x00d809d8]
MOV EAX,dword ptr [RBP + -0x44]
MOV ECX,EAX
LEA RAX,[0x57eb90]
IMUL RCX,RCX,0x48
ADD RAX,RCX
MOVSX EDX,word ptr [RAX + 0x20]
LEA RCX,[RBP + -0x30]
CALL 0x00135e30
MOV RAX,qword ptr [RBP + -0x60]
MOV EDI,dword ptr [RAX]
CALL 0x00135ce0
ADD EAX,0x5
MOV dword ptr [RBP + -0x74],EAX
JMP 0x00130a76
LAB_00130a76:
JMP 0x00130a78
LAB_00130a78:
MOV EAX,dword ptr [RBP + -0x84]
MOV RCX,qword ptr [RBP + -0x60]
MOV ECX,dword ptr [RCX]
ADD ECX,dword ptr [RBP + -0x74]
CMP EAX,ECX
JC 0x00130adf
MOV RDI,qword ptr [RBP + -0x40]
MOV ESI,dword ptr [RBP + -0x44]
MOV RDX,qword ptr [RBP + -0x50]
MOV CX,word ptr [RBP + -0x52]
MOV R8,qword ptr [RBP + -0x60]
MOV R9,qword ptr [RBP + -0x70]
MOV EAX,dword ptr [RBP + -0x74]
MOV R11W,AX
MOV R10,qword ptr [RBP + -0x68]
MOV RAX,qword ptr [RBP + 0x10]
MOVZX ECX,CX
MOVZX R11D,R11W
MOV dword ptr [RSP],R11D
MOV qword ptr [RSP + 0x8],R10
MOV qword ptr [RSP + 0x10],RAX
CALL 0x00136150
MOV byte ptr [RBP + -0x85],AL
MOV AL,byte ptr [RBP + -0x85]
MOV byte ptr [RBP + -0x31],AL
JMP 0x00130bad
LAB_00130adf:
CALL 0x00137af0
MOV EAX,EAX
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x80]
MOV RCX,qword ptr [RBP + -0x60]
MOV ECX,dword ptr [RCX]
ADD ECX,dword ptr [RBP + -0x74]
SUB ECX,dword ptr [RBP + -0x84]
MOV ECX,ECX
CMP RAX,RCX
JC 0x00130b55
MOV RDI,qword ptr [RBP + -0x40]
MOV ESI,dword ptr [RBP + -0x44]
MOV RDX,qword ptr [RBP + -0x50]
MOV CX,word ptr [RBP + -0x52]
MOV R8,qword ptr [RBP + -0x60]
MOV R9,qword ptr [RBP + -0x70]
MOV EAX,dword ptr [RBP + -0x74]
MOV R11W,AX
MOV R10,qword ptr [RBP + -0x68]
MOV RAX,qword ptr [RBP + 0x10]
MOVZX ECX,CX
MOVZX R11D,R11W
MOV dword ptr [RSP],R11D
MOV qword ptr [RSP + 0x8],R10
MOV qword ptr [RSP + 0x10],RAX
CALL 0x001362f0
MOV byte ptr [RBP + -0x85],AL
MOV AL,byte ptr [RBP + -0x85]
MOV byte ptr [RBP + -0x31],AL
JMP 0x00130bad
LAB_00130b55:
MOV RDI,qword ptr [RBP + -0x40]
MOV ESI,dword ptr [RBP + -0x44]
MOV RDX,qword ptr [RBP + -0x50]
MOV CX,word ptr [RBP + -0x52]
MOV R8,qword ptr [RBP + -0x60]
MOV R9,qword ptr [RBP + -0x70]
MOV EAX,dword ptr [RBP + -0x74]
MOV BX,AX
MOV RAX,qword ptr [RBP + -0x80]
MOV R11D,EAX
MOV R10,qword ptr [RBP + -0x68]
MOV RAX,qword ptr [RBP + 0x10]
MOVZX ECX,CX
MOVZX EBX,BX
MOV dword ptr [RSP],EBX
MOV dword ptr [RSP + 0x8],R11D
MOV qword ptr [RSP + 0x10],R10
MOV qword ptr [RSP + 0x18],RAX
CALL 0x001366d0
MOV byte ptr [RBP + -0x85],AL
MOV AL,byte ptr [RBP + -0x85]
MOV byte ptr [RBP + -0x31],AL
LAB_00130bad:
MOV AL,byte ptr [RBP + -0x31]
MOV byte ptr [RBP + -0x86],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,RCX
JNZ 0x00130bd8
MOV AL,byte ptr [RBP + -0x86]
ADD RSP,0xa8
POP RBX
POP RBP
RET
LAB_00130bd8:
CALL 0x0012a250
|
int8
translog_write_variable_record
(int8 param_1,uint param_2,int8 param_3,int2 param_4,int *param_5,
int8 param_6,int8 param_7)
{
int iVar1;
uint uVar2;
long in_FS_OFFSET;
int8 in_stack_ffffffffffffff50;
int4 uVar3;
uint local_8c;
uint local_7c;
int8 local_78;
int8 local_70;
int *local_68;
int2 local_5a;
int8 local_58;
uint local_4c;
int8 local_48;
int1 local_39;
int1 local_38 [32];
long local_18;
uVar3 = (int4)((ulong)in_stack_ffffffffffffff50 >> 0x20);
local_18 = *(long *)(in_FS_OFFSET + 0x28);
local_78 = 0;
local_70 = param_6;
local_68 = param_5;
local_5a = param_4;
local_58 = param_3;
local_4c = param_2;
local_48 = param_1;
iVar1 = translog_variable_record_length_bytes(*param_5);
local_7c = iVar1 + 5;
translog_lock();
local_8c = 0x2000 - DAT_00d80a10;
if (local_8c < local_7c + *(ushort *)(log_record_type_descriptor + (ulong)local_4c * 0x48 + 6)) {
translog_page_next(&DAT_00d809d8,&DAT_00d809e0,&local_78);
local_8c = DAT_0057fdb6 + 1;
}
if (0 < *(short *)(log_record_type_descriptor + (ulong)local_4c * 0x48 + 0x20)) {
translog_relative_LSN_encode
(local_68,DAT_00d809d8,
(int)*(short *)(log_record_type_descriptor + (ulong)local_4c * 0x48 + 0x20),local_38)
;
iVar1 = translog_variable_record_length_bytes(*local_68);
local_7c = iVar1 + 5;
}
if (local_8c < *local_68 + local_7c) {
uVar2 = translog_get_current_group_size();
if (uVar2 < (*local_68 + local_7c) - local_8c) {
local_39 = translog_write_variable_record_mgroup
(local_48,local_4c,local_58,local_5a,local_68,local_78,local_7c & 0xffff,
CONCAT44(uVar3,uVar2),local_70,param_7);
}
else {
local_39 = translog_write_variable_record_1group
(local_48,local_4c,local_58,local_5a,local_68,local_78,local_7c & 0xffff,
local_70,param_7);
}
}
else {
local_39 = translog_write_variable_record_1chunk
(local_48,local_4c,local_58,local_5a,local_68,local_78,local_7c & 0xffff,
local_70,param_7);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_18) {
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),local_39);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
26,494 | JS_GetUint8Array | bluesky950520[P]quickjs/quickjs.c | uint8_t *JS_GetUint8Array(JSContext *ctx, size_t *psize, JSValue obj)
{
JSObject *p;
JSTypedArray *ta;
JSArrayBuffer *abuf;
p = get_typed_array(ctx, obj);
if (!p)
goto fail;
if (typed_array_is_oob(p)) {
JS_ThrowTypeErrorArrayBufferOOB(ctx);
goto fail;
}
if (p->class_id != JS_CLASS_UINT8_ARRAY && p->class_id != JS_CLASS_UINT8C_ARRAY) {
JS_ThrowTypeError(ctx, "not a Uint8Array");
goto fail;
}
ta = p->u.typed_array;
abuf = ta->buffer->u.array_buffer;
*psize = ta->length;
return abuf->data + ta->offset;
fail:
*psize = 0;
return NULL;
} | O1 | c | JS_GetUint8Array:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, 0x8(%rsp)
cmpl $-0x1, %ecx
jne 0x39756
movq 0x8(%rsp), %r15
movzwl 0x6(%r15), %eax
addl $-0x15, %eax
cmpw $0xc, %ax
jb 0x3976a
leaq 0x68cb4(%rip), %rsi # 0xa2411
xorl %r15d, %r15d
movq %r14, %rdi
xorl %eax, %eax
callq 0x22567
testq %r15, %r15
je 0x3978c
movq %r15, %rdi
callq 0x396c4
testl %eax, %eax
je 0x3979f
leaq 0x68ca0(%rip), %rsi # 0xa2422
movq %r14, %rdi
xorl %eax, %eax
callq 0x22567
movq $0x0, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movzwl 0x6(%r15), %eax
orl $0x2, %eax
cmpl $0x17, %eax
jne 0x397c7
movq 0x30(%r15), %rax
movq 0x18(%rax), %rcx
movq 0x30(%rcx), %rcx
movl 0x24(%rax), %edx
movq %rdx, (%rbx)
movl 0x20(%rax), %eax
addq 0x10(%rcx), %rax
jmp 0x39795
leaq 0x6568c(%rip), %rsi # 0x9ee5a
jmp 0x39782
| JS_GetUint8Array:
push r15
push r14
push rbx
sub rsp, 10h
mov rbx, rsi
mov r14, rdi
mov [rsp+28h+var_20], rdx
cmp ecx, 0FFFFFFFFh
jnz short loc_39756
mov r15, [rsp+28h+var_20]
movzx eax, word ptr [r15+6]
add eax, 0FFFFFFEBh
cmp ax, 0Ch
jb short loc_3976A
loc_39756:
lea rsi, aNotATypedarray; "not a TypedArray"
xor r15d, r15d
mov rdi, r14
xor eax, eax
call JS_ThrowTypeError
loc_3976A:
test r15, r15
jz short loc_3978C
mov rdi, r15
call typed_array_is_oob
test eax, eax
jz short loc_3979F
lea rsi, aArraybufferIsD_0; "ArrayBuffer is detached or resized"
loc_39782:
mov rdi, r14
xor eax, eax
call JS_ThrowTypeError
loc_3978C:
mov qword ptr [rbx], 0
xor eax, eax
loc_39795:
add rsp, 10h
pop rbx
pop r14
pop r15
retn
loc_3979F:
movzx eax, word ptr [r15+6]
or eax, 2
cmp eax, 17h
jnz short loc_397C7
mov rax, [r15+30h]
mov rcx, [rax+18h]
mov rcx, [rcx+30h]
mov edx, [rax+24h]
mov [rbx], rdx
mov eax, [rax+20h]
add rax, [rcx+10h]
jmp short loc_39795
loc_397C7:
lea rsi, aNotAUint8array; "not a Uint8Array"
jmp short loc_39782
| long long JS_GetUint8Array(
long long a1,
_QWORD *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 v15; // r15
long long v16; // rdx
long long v17; // rcx
long long v18; // r8
long long v19; // r9
__m128 v20; // xmm4
__m128 v21; // xmm5
const char *v22; // rsi
long long v24; // rax
long long v25; // rcx
char v26; // [rsp+0h] [rbp-28h]
if ( (_DWORD)a4 != -1 || (v15 = a3, (unsigned __int16)(*(_WORD *)(a3 + 6) - 21) >= 0xCu) )
{
v15 = 0LL;
JS_ThrowTypeError(a1, (long long)"not a TypedArray", a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v26);
}
if ( !v15 )
goto LABEL_8;
if ( typed_array_is_oob(v15) )
{
v22 = "ArrayBuffer is detached or resized";
LABEL_7:
JS_ThrowTypeError(a1, (long long)v22, v16, v17, v18, v19, a7, a8, a9, a10, v20, v21, a13, a14, v26);
LABEL_8:
*a2 = 0LL;
return 0LL;
}
if ( (*(unsigned __int16 *)(v15 + 6) | 2) != 0x17 )
{
v22 = "not a Uint8Array";
goto LABEL_7;
}
v24 = *(_QWORD *)(v15 + 48);
v25 = *(_QWORD *)(*(_QWORD *)(v24 + 24) + 48LL);
*a2 = *(unsigned int *)(v24 + 36);
return *(_QWORD *)(v25 + 16) + *(unsigned int *)(v24 + 32);
}
| |||
26,495 | JS_GetUint8Array | bluesky950520[P]quickjs/quickjs.c | uint8_t *JS_GetUint8Array(JSContext *ctx, size_t *psize, JSValue obj)
{
JSObject *p;
JSTypedArray *ta;
JSArrayBuffer *abuf;
p = get_typed_array(ctx, obj);
if (!p)
goto fail;
if (typed_array_is_oob(p)) {
JS_ThrowTypeErrorArrayBufferOOB(ctx);
goto fail;
}
if (p->class_id != JS_CLASS_UINT8_ARRAY && p->class_id != JS_CLASS_UINT8C_ARRAY) {
JS_ThrowTypeError(ctx, "not a Uint8Array");
goto fail;
}
ta = p->u.typed_array;
abuf = ta->buffer->u.array_buffer;
*psize = ta->length;
return abuf->data + ta->offset;
fail:
*psize = 0;
return NULL;
} | O2 | c | JS_GetUint8Array:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x3280b
testq %rax, %rax
je 0x328db
movq %rax, %r15
movq %rax, %rdi
callq 0x32836
testl %eax, %eax
je 0x328e7
movq %r14, %rdi
callq 0x3289b
andq $0x0, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movzwl 0x6(%r15), %eax
orl $0x2, %eax
cmpl $0x17, %eax
jne 0x3290f
movq 0x30(%r15), %rax
movq 0x18(%rax), %rcx
movq 0x30(%rcx), %rcx
movl 0x24(%rax), %edx
movq %rdx, (%rbx)
movl 0x20(%rax), %eax
addq 0x10(%rcx), %rax
jmp 0x328e1
leaq 0x53494(%rip), %rsi # 0x85daa
movq %r14, %rdi
xorl %eax, %eax
callq 0x1c64d
jmp 0x328db
| JS_GetUint8Array:
push r15
push r14
push rbx
mov rbx, rsi
mov r14, rdi
mov rsi, rdx
mov rdx, rcx
call get_typed_array
test rax, rax
jz short loc_328DB
mov r15, rax
mov rdi, rax
call typed_array_is_oob
test eax, eax
jz short loc_328E7
mov rdi, r14
call JS_ThrowTypeErrorArrayBufferOOB
loc_328DB:
and qword ptr [rbx], 0
xor eax, eax
loc_328E1:
pop rbx
pop r14
pop r15
retn
loc_328E7:
movzx eax, word ptr [r15+6]
or eax, 2
cmp eax, 17h
jnz short loc_3290F
mov rax, [r15+30h]
mov rcx, [rax+18h]
mov rcx, [rcx+30h]
mov edx, [rax+24h]
mov [rbx], rdx
mov eax, [rax+20h]
add rax, [rcx+10h]
jmp short loc_328E1
loc_3290F:
lea rsi, aNotAUint8array; "not a Uint8Array"
mov rdi, r14
xor eax, eax
call JS_ThrowTypeError
jmp short loc_328DB
| long long JS_GetUint8Array(
long long a1,
_QWORD *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 typed_array; // rax
long long v17; // r15
long long v18; // rdx
long long v19; // rcx
long long v20; // r8
long long v21; // r9
__m128 v22; // xmm4
__m128 v23; // xmm5
long long v25; // rax
long long v26; // rcx
char v27; // [rsp+0h] [rbp-18h]
typed_array = get_typed_array(a1, a3, a4, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
if ( !typed_array )
goto LABEL_4;
v17 = typed_array;
if ( typed_array_is_oob(typed_array) )
{
JS_ThrowTypeErrorArrayBufferOOB(a1, a7, a8, a9, a10, v22, v23, a13, a14, a3, v18, v19, v20, v21, v27);
LABEL_4:
*a2 = 0LL;
return 0LL;
}
if ( (*(unsigned __int16 *)(v17 + 6) | 2) != 0x17 )
{
JS_ThrowTypeError(a1, (long long)"not a Uint8Array", v18, v19, v20, v21, a7, a8, a9, a10, v22, v23, a13, a14, v27);
goto LABEL_4;
}
v25 = *(_QWORD *)(v17 + 48);
v26 = *(_QWORD *)(*(_QWORD *)(v25 + 24) + 48LL);
*a2 = *(unsigned int *)(v25 + 36);
return *(_QWORD *)(v26 + 16) + *(unsigned int *)(v25 + 32);
}
| JS_GetUint8Array:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
MOV RSI,RDX
MOV RDX,RCX
CALL 0x0013280b
TEST RAX,RAX
JZ 0x001328db
MOV R15,RAX
MOV RDI,RAX
CALL 0x00132836
TEST EAX,EAX
JZ 0x001328e7
MOV RDI,R14
CALL 0x0013289b
LAB_001328db:
AND qword ptr [RBX],0x0
XOR EAX,EAX
LAB_001328e1:
POP RBX
POP R14
POP R15
RET
LAB_001328e7:
MOVZX EAX,word ptr [R15 + 0x6]
OR EAX,0x2
CMP EAX,0x17
JNZ 0x0013290f
MOV RAX,qword ptr [R15 + 0x30]
MOV RCX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RCX + 0x30]
MOV EDX,dword ptr [RAX + 0x24]
MOV qword ptr [RBX],RDX
MOV EAX,dword ptr [RAX + 0x20]
ADD RAX,qword ptr [RCX + 0x10]
JMP 0x001328e1
LAB_0013290f:
LEA RSI,[0x185daa]
MOV RDI,R14
XOR EAX,EAX
CALL 0x0011c64d
JMP 0x001328db
|
long JS_GetUint8Array(int8 param_1,ulong *param_2,int8 param_3,int8 param_4)
{
long lVar1;
int iVar2;
long lVar3;
lVar3 = get_typed_array(param_1,param_3,param_4);
if (lVar3 != 0) {
iVar2 = typed_array_is_oob(lVar3);
if (iVar2 == 0) {
if ((*(ushort *)(lVar3 + 6) | 2) == 0x17) {
lVar3 = *(long *)(lVar3 + 0x30);
lVar1 = *(long *)(*(long *)(lVar3 + 0x18) + 0x30);
*param_2 = (ulong)*(uint *)(lVar3 + 0x24);
return (ulong)*(uint *)(lVar3 + 0x20) + *(long *)(lVar1 + 0x10);
}
JS_ThrowTypeError(param_1,"not a Uint8Array");
}
else {
JS_ThrowTypeErrorArrayBufferOOB(param_1);
}
}
*param_2 = 0;
return 0;
}
| |
26,496 | JS_GetUint8Array | bluesky950520[P]quickjs/quickjs.c | uint8_t *JS_GetUint8Array(JSContext *ctx, size_t *psize, JSValue obj)
{
JSObject *p;
JSTypedArray *ta;
JSArrayBuffer *abuf;
p = get_typed_array(ctx, obj);
if (!p)
goto fail;
if (typed_array_is_oob(p)) {
JS_ThrowTypeErrorArrayBufferOOB(ctx);
goto fail;
}
if (p->class_id != JS_CLASS_UINT8_ARRAY && p->class_id != JS_CLASS_UINT8C_ARRAY) {
JS_ThrowTypeError(ctx, "not a Uint8Array");
goto fail;
}
ta = p->u.typed_array;
abuf = ta->buffer->u.array_buffer;
*psize = ta->length;
return abuf->data + ta->offset;
fail:
*psize = 0;
return NULL;
} | O3 | c | JS_GetUint8Array:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x6a927(%rip), %rsi # 0xa53bb
cmpl $-0x1, %ecx
jne 0x3aabf
movq %rdx, %r15
movzwl 0x6(%rdx), %r12d
leal -0x15(%r12), %eax
cmpw $0xb, %ax
ja 0x3aabf
movq %r15, %rdi
callq 0x3aa19
testl %eax, %eax
je 0x3aae2
leaq 0x6a90d(%rip), %rsi # 0xa53cc
xorl %r15d, %r15d
movq %r14, %rdi
xorl %eax, %eax
callq 0x22d8b
movq $0x0, (%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
orl $0x2, %r12d
cmpl $0x17, %r12d
jne 0x3ab08
movq 0x30(%r15), %rax
movq 0x18(%rax), %rcx
movq 0x30(%rcx), %rcx
movl 0x24(%rax), %edx
movq %rdx, (%rbx)
movl 0x20(%rax), %r15d
addq 0x10(%rcx), %r15
jmp 0x3aad3
leaq 0x6730b(%rip), %rsi # 0xa1e1a
jmp 0x3aabf
| JS_GetUint8Array:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rsi
mov r14, rdi
lea rsi, aNotATypedarray; "not a TypedArray"
cmp ecx, 0FFFFFFFFh
jnz short loc_3AABF
mov r15, rdx
movzx r12d, word ptr [rdx+6]
lea eax, [r12-15h]
cmp ax, 0Bh
ja short loc_3AABF
mov rdi, r15
call typed_array_is_oob
test eax, eax
jz short loc_3AAE2
lea rsi, aArraybufferIsD_0; "ArrayBuffer is detached or resized"
loc_3AABF:
xor r15d, r15d
mov rdi, r14
xor eax, eax
call JS_ThrowTypeError
mov qword ptr [rbx], 0
loc_3AAD3:
mov rax, r15
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
loc_3AAE2:
or r12d, 2
cmp r12d, 17h
jnz short loc_3AB08
mov rax, [r15+30h]
mov rcx, [rax+18h]
mov rcx, [rcx+30h]
mov edx, [rax+24h]
mov [rbx], rdx
mov r15d, [rax+20h]
add r15, [rcx+10h]
jmp short loc_3AAD3
loc_3AB08:
lea rsi, aNotAUint8array; "not a Uint8Array"
jmp short loc_3AABF
| long long JS_GetUint8Array(
long long a1,
_QWORD *a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
char v14; // al
const char *v16; // rsi
int v18; // r12d
long long v19; // r15
long long v21; // rax
long long v22; // rcx
char v23; // [rsp-8h] [rbp-28h]
v23 = v14;
v16 = "not a TypedArray";
if ( (_DWORD)a4 == -1 )
{
v18 = *(unsigned __int16 *)(a3 + 6);
if ( (unsigned __int16)(v18 - 21) <= 0xBu )
{
if ( typed_array_is_oob(a3) )
{
v16 = "ArrayBuffer is detached or resized";
}
else
{
if ( (v18 | 2) == 0x17 )
{
v21 = *(_QWORD *)(a3 + 48);
v22 = *(_QWORD *)(*(_QWORD *)(v21 + 24) + 48LL);
*a2 = *(unsigned int *)(v21 + 36);
return *(_QWORD *)(v22 + 16) + *(unsigned int *)(v21 + 32);
}
v16 = "not a Uint8Array";
}
}
}
v19 = 0LL;
JS_ThrowTypeError(a1, (long long)v16, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v23);
*a2 = 0LL;
return v19;
}
| JS_GetUint8Array:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
LEA RSI,[0x1a53bb]
CMP ECX,-0x1
JNZ 0x0013aabf
MOV R15,RDX
MOVZX R12D,word ptr [RDX + 0x6]
LEA EAX,[R12 + -0x15]
CMP AX,0xb
JA 0x0013aabf
MOV RDI,R15
CALL 0x0013aa19
TEST EAX,EAX
JZ 0x0013aae2
LEA RSI,[0x1a53cc]
LAB_0013aabf:
XOR R15D,R15D
MOV RDI,R14
XOR EAX,EAX
CALL 0x00122d8b
MOV qword ptr [RBX],0x0
LAB_0013aad3:
MOV RAX,R15
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
LAB_0013aae2:
OR R12D,0x2
CMP R12D,0x17
JNZ 0x0013ab08
MOV RAX,qword ptr [R15 + 0x30]
MOV RCX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RCX + 0x30]
MOV EDX,dword ptr [RAX + 0x24]
MOV qword ptr [RBX],RDX
MOV R15D,dword ptr [RAX + 0x20]
ADD R15,qword ptr [RCX + 0x10]
JMP 0x0013aad3
LAB_0013ab08:
LEA RSI,[0x1a1e1a]
JMP 0x0013aabf
|
long JS_GetUint8Array(int8 param_1,ulong *param_2,long param_3,int param_4)
{
ushort uVar1;
long lVar2;
long lVar3;
int iVar4;
char *pcVar5;
pcVar5 = "not a TypedArray";
if ((param_4 == -1) && (uVar1 = *(ushort *)(param_3 + 6), (ushort)(uVar1 - 0x15) < 0xc)) {
iVar4 = typed_array_is_oob(param_3,"not a TypedArray");
if (iVar4 == 0) {
if ((uVar1 | 2) == 0x17) {
lVar2 = *(long *)(param_3 + 0x30);
lVar3 = *(long *)(*(long *)(lVar2 + 0x18) + 0x30);
*param_2 = (ulong)*(uint *)(lVar2 + 0x24);
return (ulong)*(uint *)(lVar2 + 0x20) + *(long *)(lVar3 + 0x10);
}
pcVar5 = "not a Uint8Array";
}
else {
pcVar5 = "ArrayBuffer is detached or resized";
}
}
JS_ThrowTypeError(param_1,pcVar5);
*param_2 = 0;
return 0;
}
| |
26,497 | create_cond(PFS_cond_class*, void const*) | eloqsql/storage/perfschema/pfs_instr.cc | PFS_cond* create_cond(PFS_cond_class *klass, const void *identity)
{
PFS_cond *pfs;
pfs_dirty_state dirty_state;
pfs= global_cond_container.allocate(& dirty_state);
if (pfs != NULL)
{
pfs->m_identity= identity;
pfs->m_class= klass;
pfs->m_enabled= klass->m_enabled && flag_global_instrumentation;
pfs->m_timed= klass->m_timed;
pfs->m_cond_stat.reset();
pfs->m_lock.dirty_to_allocated(& dirty_state);
if (klass->is_singleton())
klass->m_singleton= pfs;
}
return pfs;
} | O0 | cpp | create_cond(PFS_cond_class*, void const*):
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x396fe1(%rip), %rdi # 0x3d0f58
leaq -0x1c(%rbp), %rsi
callq 0x3ebc0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3a01a
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
testb $0x1, 0x4(%rcx)
movb %al, -0x1d(%rbp)
je 0x39fc2
leaq 0x3d6fc3(%rip), %rax # 0x410f80
movb (%rax), %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x4(%rax)
movq -0x8(%rbp), %rax
movb 0x5(%rax), %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x5(%rax)
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x3ef70
movq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x30e60
movq -0x8(%rbp), %rdi
callq 0x3e720
testb $0x1, %al
jne 0x3a009
jmp 0x3a018
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xc0(%rax)
jmp 0x3a01a
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _Z11create_condP14PFS_cond_classPKv:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
lea rdi, global_cond_container
lea rsi, [rbp+var_1C]
call _ZN29PFS_buffer_scalable_containerI8PFS_condLi256ELi256E24PFS_buffer_default_arrayIS0_E28PFS_buffer_default_allocatorIS0_EE8allocateEP15pfs_dirty_state; PFS_buffer_scalable_container<PFS_cond,256,256,PFS_buffer_default_array<PFS_cond>,PFS_buffer_default_allocator<PFS_cond>>::allocate(pfs_dirty_state *)
mov [rbp+var_18], rax
cmp [rbp+var_18], 0
jz loc_3A01A
mov rcx, [rbp+var_10]
mov rax, [rbp+var_18]
mov [rax+10h], rcx
mov rcx, [rbp+var_8]
mov rax, [rbp+var_18]
mov [rax+18h], rcx
mov rcx, [rbp+var_8]
xor eax, eax
test byte ptr [rcx+4], 1
mov [rbp+var_1D], al
jz short loc_39FC2
lea rax, flag_global_instrumentation
mov al, [rax]
mov [rbp+var_1D], al
loc_39FC2:
mov cl, [rbp+var_1D]
mov rax, [rbp+var_18]
and cl, 1
mov [rax+4], cl
mov rax, [rbp+var_8]
mov cl, [rax+5]
mov rax, [rbp+var_18]
and cl, 1
mov [rax+5], cl
mov rdi, [rbp+var_18]
add rdi, 20h ; ' '; this
call _ZN13PFS_cond_stat5resetEv; PFS_cond_stat::reset(void)
mov rdi, [rbp+var_18]
lea rsi, [rbp+var_1C]
call _ZN8pfs_lock18dirty_to_allocatedEPK15pfs_dirty_state; pfs_lock::dirty_to_allocated(pfs_dirty_state const*)
mov rdi, [rbp+var_8]; this
call _ZNK15PFS_instr_class12is_singletonEv; PFS_instr_class::is_singleton(void)
test al, 1
jnz short loc_3A009
jmp short loc_3A018
loc_3A009:
mov rcx, [rbp+var_18]
mov rax, [rbp+var_8]
mov [rax+0C0h], rcx
loc_3A018:
jmp short $+2
loc_3A01A:
mov rax, [rbp+var_18]
add rsp, 20h
pop rbp
retn
| PFS_atomic * create_cond(PFS_instr_class *a1, long long a2)
{
unsigned int v2; // edx
char v4; // [rsp+3h] [rbp-1Dh]
int v5; // [rsp+4h] [rbp-1Ch] BYREF
PFS_atomic *v6; // [rsp+8h] [rbp-18h]
long long v7; // [rsp+10h] [rbp-10h]
PFS_instr_class *v8; // [rsp+18h] [rbp-8h]
v8 = a1;
v7 = a2;
v6 = (PFS_atomic *)PFS_buffer_scalable_container<PFS_cond,256,256,PFS_buffer_default_array<PFS_cond>,PFS_buffer_default_allocator<PFS_cond>>::allocate(
&global_cond_container,
&v5);
if ( v6 )
{
*((_QWORD *)v6 + 2) = v7;
*((_QWORD *)v6 + 3) = v8;
v4 = 0;
if ( (*((_BYTE *)v8 + 4) & 1) != 0 )
v4 = flag_global_instrumentation;
*((_BYTE *)v6 + 4) = v4 & 1;
*((_BYTE *)v6 + 5) = *((_BYTE *)v8 + 5) & 1;
PFS_cond_stat::reset((PFS_atomic *)((char *)v6 + 32));
pfs_lock::dirty_to_allocated(v6, &v5, v2);
if ( (PFS_instr_class::is_singleton(v8) & 1) != 0 )
*((_QWORD *)v8 + 24) = v6;
}
return v6;
}
| create_cond:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
LEA RDI,[0x4d0f58]
LEA RSI,[RBP + -0x1c]
CALL 0x0013ebc0
MOV qword ptr [RBP + -0x18],RAX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x0013a01a
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x18],RCX
MOV RCX,qword ptr [RBP + -0x8]
XOR EAX,EAX
TEST byte ptr [RCX + 0x4],0x1
MOV byte ptr [RBP + -0x1d],AL
JZ 0x00139fc2
LEA RAX,[0x510f80]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x1d],AL
LAB_00139fc2:
MOV CL,byte ptr [RBP + -0x1d]
MOV RAX,qword ptr [RBP + -0x18]
AND CL,0x1
MOV byte ptr [RAX + 0x4],CL
MOV RAX,qword ptr [RBP + -0x8]
MOV CL,byte ptr [RAX + 0x5]
MOV RAX,qword ptr [RBP + -0x18]
AND CL,0x1
MOV byte ptr [RAX + 0x5],CL
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x20
CALL 0x0013ef70
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[RBP + -0x1c]
CALL 0x00130e60
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0013e720
TEST AL,0x1
JNZ 0x0013a009
JMP 0x0013a018
LAB_0013a009:
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xc0],RCX
LAB_0013a018:
JMP 0x0013a01a
LAB_0013a01a:
MOV RAX,qword ptr [RBP + -0x18]
ADD RSP,0x20
POP RBP
RET
|
/* create_cond(PFS_cond_class*, void const*) */
pfs_lock * create_cond(PFS_cond_class *param_1,void *param_2)
{
ulong uVar1;
byte local_25;
pfs_dirty_state local_24 [4];
pfs_lock *local_20;
void *local_18;
PFS_cond_class *local_10;
local_18 = param_2;
local_10 = param_1;
local_20 = (pfs_lock *)
PFS_buffer_scalable_container<PFS_cond,256,256,PFS_buffer_default_array<PFS_cond>,PFS_buffer_default_allocator<PFS_cond>>
::allocate((PFS_buffer_scalable_container<PFS_cond,256,256,PFS_buffer_default_array<PFS_cond>,PFS_buffer_default_allocator<PFS_cond>>
*)global_cond_container,local_24);
if (local_20 != (pfs_lock *)0x0) {
*(void **)(local_20 + 0x10) = local_18;
*(PFS_cond_class **)(local_20 + 0x18) = local_10;
local_25 = 0;
if (((byte)local_10[4] & 1) != 0) {
local_25 = flag_global_instrumentation;
}
local_20[4] = (pfs_lock)(local_25 & 1);
local_20[5] = (pfs_lock)((byte)local_10[5] & 1);
PFS_cond_stat::reset((PFS_cond_stat *)(local_20 + 0x20));
pfs_lock::dirty_to_allocated(local_20,local_24);
uVar1 = PFS_instr_class::is_singleton((PFS_instr_class *)local_10);
if ((uVar1 & 1) != 0) {
*(pfs_lock **)(local_10 + 0xc0) = local_20;
}
}
return local_20;
}
| |
26,498 | JS_ThrowTypeError | bluesky950520[P]quickjs/quickjs.c | JSValue __attribute__((format(printf, 2, 3))) JS_ThrowTypeError(JSContext *ctx, const char *fmt, ...)
{
JSValue val;
va_list ap;
va_start(ap, fmt);
val = JS_ThrowError(ctx, JS_TYPE_ERROR, fmt, ap);
va_end(ap);
return val;
} | O1 | c | JS_ThrowTypeError:
subq $0xd8, %rsp
movq %rsi, %r10
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x225c1
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rcx
movq %rsi, 0x10(%rcx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax # imm = 0x3000000010
movq %rax, (%rcx)
movl $0x4, %esi
movq %r10, %rdx
callq 0x22450
movl $0x6, %edx
xorl %eax, %eax
addq $0xd8, %rsp
retq
| JS_ThrowTypeError:
sub rsp, 0D8h
mov r10, rsi
lea rsi, [rsp+0D8h+var_B8]
mov [rsi+10h], rdx
mov [rsi+18h], rcx
mov [rsi+20h], r8
mov [rsi+28h], r9
test al, al
jz short loc_225C1
movaps [rsp+0D8h+var_88], xmm0
movaps [rsp+0D8h+var_78], xmm1
movaps [rsp+0D8h+var_68], xmm2
movaps [rsp+0D8h+var_58], xmm3
movaps [rsp+0D8h+var_48], xmm4
movaps [rsp+0D8h+var_38], xmm5
movaps [rsp+0D8h+var_28], xmm6
movaps [rsp+0D8h+var_18], xmm7
loc_225C1:
mov rcx, rsp
mov [rcx+10h], rsi
lea rax, [rsp+0D8h+arg_0]
mov [rcx+8], rax
mov rax, 3000000010h
mov [rcx], rax
mov esi, 4
mov rdx, r10
call JS_ThrowError
mov edx, 6
xor eax, eax
add rsp, 0D8h
retn
| long long JS_ThrowTypeError(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
_QWORD v16[4]; // [rsp+0h] [rbp-D8h] BYREF
char v17; // [rsp+20h] [rbp-B8h] BYREF
long long v18; // [rsp+30h] [rbp-A8h]
long long v19; // [rsp+38h] [rbp-A0h]
long long v20; // [rsp+40h] [rbp-98h]
long long v21; // [rsp+48h] [rbp-90h]
__m128 v22; // [rsp+50h] [rbp-88h]
__m128 v23; // [rsp+60h] [rbp-78h]
__m128 v24; // [rsp+70h] [rbp-68h]
__m128 v25; // [rsp+80h] [rbp-58h]
__m128 v26; // [rsp+90h] [rbp-48h]
__m128 v27; // [rsp+A0h] [rbp-38h]
__m128 v28; // [rsp+B0h] [rbp-28h]
__m128 v29; // [rsp+C0h] [rbp-18h]
v22 = a7;
v23 = a8;
v24 = a9;
v25 = a10;
v26 = a11;
v27 = a12;
v28 = a13;
v29 = a14;
v18 = a3;
v19 = a4;
v20 = a5;
v21 = a6;
v16[2] = &v17;
v16[1] = &a15;
v16[0] = 0x3000000010LL;
JS_ThrowError(a1, 4LL, a2, (long long)v16);
return 0LL;
}
| JS_ThrowTypeError:
SUB RSP,0xd8
MOV R10,RSI
LEA RSI,[RSP + 0x20]
MOV qword ptr [RSI + 0x10],RDX
MOV qword ptr [RSI + 0x18],RCX
MOV qword ptr [RSI + 0x20],R8
MOV qword ptr [RSI + 0x28],R9
TEST AL,AL
JZ 0x001225c1
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM1
MOVAPS xmmword ptr [RSP + 0x70],XMM2
MOVAPS xmmword ptr [RSP + 0x80],XMM3
MOVAPS xmmword ptr [RSP + 0x90],XMM4
MOVAPS xmmword ptr [RSP + 0xa0],XMM5
MOVAPS xmmword ptr [RSP + 0xb0],XMM6
MOVAPS xmmword ptr [RSP + 0xc0],XMM7
LAB_001225c1:
MOV RCX,RSP
MOV qword ptr [RCX + 0x10],RSI
LEA RAX,[RSP + 0xe0]
MOV qword ptr [RCX + 0x8],RAX
MOV RAX,0x3000000010
MOV qword ptr [RCX],RAX
MOV ESI,0x4
MOV RDX,R10
CALL 0x00122450
MOV EDX,0x6
XOR EAX,EAX
ADD RSP,0xd8
RET
|
int1 [16] JS_ThrowTypeError(int8 param_1,int8 param_2)
{
JS_ThrowError(param_1,4,param_2);
return ZEXT816(6) << 0x40;
}
| |
26,499 | JS_ThrowTypeError | bluesky950520[P]quickjs/quickjs.c | JSValue __attribute__((format(printf, 2, 3))) JS_ThrowTypeError(JSContext *ctx, const char *fmt, ...)
{
JSValue val;
va_list ap;
va_start(ap, fmt);
val = JS_ThrowError(ctx, JS_TYPE_ERROR, fmt, ap);
va_end(ap);
return val;
} | O2 | c | JS_ThrowTypeError:
subq $0xd8, %rsp
movq %rsi, %r10
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x1c6a7
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rcx
movq %rsi, 0x10(%rcx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax # imm = 0x3000000010
movq %rax, (%rcx)
pushq $0x4
popq %rsi
movq %r10, %rdx
callq 0x1c551
pushq $0x6
popq %rdx
xorl %eax, %eax
addq $0xd8, %rsp
retq
| JS_ThrowTypeError:
sub rsp, 0D8h
mov r10, rsi
lea rsi, [rsp+0D8h+var_B8]
mov [rsi+10h], rdx
mov [rsi+18h], rcx
mov [rsi+20h], r8
mov [rsi+28h], r9
test al, al
jz short loc_1C6A7
movaps [rsp+0D8h+var_88], xmm0
movaps [rsp+0D8h+var_78], xmm1
movaps [rsp+0D8h+var_68], xmm2
movaps [rsp+0D8h+var_58], xmm3
movaps [rsp+0D8h+var_48], xmm4
movaps [rsp+0D8h+var_38], xmm5
movaps [rsp+0D8h+var_28], xmm6
movaps [rsp+0D8h+var_18], xmm7
loc_1C6A7:
mov rcx, rsp
mov [rcx+10h], rsi
lea rax, [rsp+0D8h+arg_0]
mov [rcx+8], rax
mov rax, 3000000010h
mov [rcx], rax
push 4
pop rsi
mov rdx, r10
call JS_ThrowError
push 6
pop rdx
xor eax, eax
add rsp, 0D8h
retn
| long long JS_ThrowTypeError(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
_QWORD v16[4]; // [rsp+0h] [rbp-D8h] BYREF
char v17; // [rsp+20h] [rbp-B8h] BYREF
long long v18; // [rsp+30h] [rbp-A8h]
long long v19; // [rsp+38h] [rbp-A0h]
long long v20; // [rsp+40h] [rbp-98h]
long long v21; // [rsp+48h] [rbp-90h]
__m128 v22; // [rsp+50h] [rbp-88h]
__m128 v23; // [rsp+60h] [rbp-78h]
__m128 v24; // [rsp+70h] [rbp-68h]
__m128 v25; // [rsp+80h] [rbp-58h]
__m128 v26; // [rsp+90h] [rbp-48h]
__m128 v27; // [rsp+A0h] [rbp-38h]
__m128 v28; // [rsp+B0h] [rbp-28h]
__m128 v29; // [rsp+C0h] [rbp-18h]
v22 = a7;
v23 = a8;
v24 = a9;
v25 = a10;
v26 = a11;
v27 = a12;
v28 = a13;
v29 = a14;
v18 = a3;
v19 = a4;
v20 = a5;
v21 = a6;
v16[2] = &v17;
v16[1] = &a15;
v16[0] = 0x3000000010LL;
JS_ThrowError(a1, 4LL, a2, (long long)v16);
return 0LL;
}
| JS_ThrowTypeError:
SUB RSP,0xd8
MOV R10,RSI
LEA RSI,[RSP + 0x20]
MOV qword ptr [RSI + 0x10],RDX
MOV qword ptr [RSI + 0x18],RCX
MOV qword ptr [RSI + 0x20],R8
MOV qword ptr [RSI + 0x28],R9
TEST AL,AL
JZ 0x0011c6a7
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM1
MOVAPS xmmword ptr [RSP + 0x70],XMM2
MOVAPS xmmword ptr [RSP + 0x80],XMM3
MOVAPS xmmword ptr [RSP + 0x90],XMM4
MOVAPS xmmword ptr [RSP + 0xa0],XMM5
MOVAPS xmmword ptr [RSP + 0xb0],XMM6
MOVAPS xmmword ptr [RSP + 0xc0],XMM7
LAB_0011c6a7:
MOV RCX,RSP
MOV qword ptr [RCX + 0x10],RSI
LEA RAX,[RSP + 0xe0]
MOV qword ptr [RCX + 0x8],RAX
MOV RAX,0x3000000010
MOV qword ptr [RCX],RAX
PUSH 0x4
POP RSI
MOV RDX,R10
CALL 0x0011c551
PUSH 0x6
POP RDX
XOR EAX,EAX
ADD RSP,0xd8
RET
|
int1 [16] JS_ThrowTypeError(int8 param_1,int8 param_2)
{
JS_ThrowError(param_1,4,param_2);
return ZEXT816(6) << 0x40;
}
|
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.