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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
8,100 |
nlohmann::json_abi_v3_11_3::detail::invalid_iterator nlohmann::json_abi_v3_11_3::detail::invalid_iterator::create<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const*, 0>(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const*)
|
monkey531[P]llama/common/json.hpp
|
static invalid_iterator create(int id_, const std::string& what_arg, BasicJsonContext context)
{
const std::string w = concat(exception::name("invalid_iterator", id_), exception::diagnostics(context), what_arg);
return {id_, w.c_str()};
}
|
O1
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::invalid_iterator nlohmann::json_abi_v3_11_3::detail::invalid_iterator::create<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const*, 0>(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x60e58(%rip), %rsi # 0xedf29
leaq 0x60e61(%rip), %rdx # 0xedf39
leaq 0x28(%rsp), %rdi
callq 0x21c52
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movl %ebp, %edx
callq 0x57ada
leaq 0x78(%rsp), %r14
movq %r14, -0x10(%r14)
xorl %eax, %eax
movq %rax, -0x8(%r14)
movb %al, (%r14)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb %al, (%r12)
movq 0x8(%r15), %rsi
addq 0x50(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x1ad50
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0x1a250
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0x1a250
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq 0x8(%rsp), %rdi
callq 0x1a250
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0x8d17b
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x1a8b0
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8d196
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x1a8b0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x8d1ad
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1a8b0
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x57d48
leaq 0x9dd2d(%rip), %rax # 0x12aef0
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x8d1e1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a8b0
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x8d26f
movq 0x18(%rsp), %rsi
jmp 0x8d267
movq %rax, %rbx
jmp 0x8d258
movq %rax, %rbx
jmp 0x8d26f
movq %rdx, %rbx
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x8d231
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a8b0
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rdx
leaq 0x88(%rsp), %r12
movq %r14, %rsi
movq %r15, %rcx
movl %ebx, %r8d
movq %r12, %r9
callq 0x1bd5b
movq (%r12), %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x8d26f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1a8b0
movq %rbx, %rdi
callq 0x1af70
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 98h
mov r15, rdx
mov ebp, esi
mov rbx, rdi
lea r13, [rsp+0C8h+var_90]
mov [r13-10h], r13
lea rsi, aInvalidIterato; "invalid_iterator"
lea rdx, aInvalidIterato+10h; ""
lea rdi, [rsp+0C8h+var_A0]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rdi, [rsp+0C8h+var_80]; int
lea rsi, [rsp+0C8h+var_A0]; int
mov edx, ebp; int
call _ZN8nlohmann16json_abi_v3_11_36detail9exception4nameERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi; nlohmann::json_abi_v3_11_3::detail::exception::name(std::string const&,int)
lea r14, [rsp+0C8h+var_50]
mov [r14-10h], r14
xor eax, eax
mov [r14-8], rax
mov [r14], al
lea r12, [rsp+0C8h+var_B0]
mov [r12-10h], r12
mov [r12-8], rax
mov [r12], al
mov rsi, [r15+8]
add rsi, [rsp+0C8h+var_78]
lea rdi, [rsp+0C8h+var_C0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
mov rsi, qword ptr [rsp+0C8h+var_80]
mov rdx, [rsp+0C8h+var_78]
lea rdi, [rsp+0C8h+var_C0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rsi, [rsp+0C8h+var_60]
mov rdx, [rsp+0C8h+var_58]
lea rdi, [rsp+0C8h+var_C0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rsi, [r15]
mov rdx, [r15+8]
lea rdi, [rsp+0C8h+var_C0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rdi, [rsp+0C8h+var_60]; void *
cmp rdi, r14
jz short loc_8D17B
mov rsi, [rsp+0C8h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_8D17B:
lea rax, [rsp+0C8h+var_70]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_8D196
mov rsi, [rsp+0C8h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_8D196:
mov rdi, [rsp+0C8h+var_A0]; void *
cmp rdi, r13
jz short loc_8D1AD
mov rsi, [rsp+0C8h+var_90]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_8D1AD:
mov rdx, [rsp+0C8h+var_C0]; char *
mov rdi, rbx; this
mov esi, ebp; int
call _ZN8nlohmann16json_abi_v3_11_36detail9exceptionC2EiPKc; nlohmann::json_abi_v3_11_3::detail::exception::exception(int,char const*)
lea rax, _ZTVN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorE; `vtable for'nlohmann::json_abi_v3_11_3::detail::invalid_iterator
add rax, 10h
mov [rbx], rax
mov rdi, [rsp+0C8h+var_C0]; void *
cmp rdi, r12
jz short loc_8D1E1
mov rsi, [rsp+0C8h+var_B0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_8D1E1:
mov rax, rbx
add rsp, 98h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rsp+arg_0]
cmp rdi, r12
jz short loc_8D26F
mov rsi, [rsp+arg_10]
jmp short loc_8D267
mov rbx, rax
jmp short loc_8D258
mov rbx, rax
jmp short loc_8D26F
mov rbx, rdx
mov r15, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, r12
jz short loc_8D231
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_8D231:
lea rdi, [rsp+arg_60]
lea rdx, [rsp+arg_40]
lea r12, [rsp+arg_80]
mov rsi, r14
mov rcx, r15
mov r8d, ebx
mov r9, r12
call _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK__cold_1
mov rbx, [r12]
loc_8D258:
mov rdi, [rsp+arg_20]; void *
cmp rdi, r13
jz short loc_8D26F
mov rsi, [rsp+arg_30]
loc_8D267:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_8D26F:
mov rdi, rbx
call __Unwind_Resume
|
nlohmann::json_abi_v3_11_3::detail::exception * ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
nlohmann::json_abi_v3_11_3::detail::exception *this,
int a2,
_QWORD *a3)
{
char *v5[2]; // [rsp+8h] [rbp-C0h] BYREF
_QWORD v6[2]; // [rsp+18h] [rbp-B0h] BYREF
void *v7[2]; // [rsp+28h] [rbp-A0h] BYREF
_QWORD v8[2]; // [rsp+38h] [rbp-90h] BYREF
int v9[2]; // [rsp+48h] [rbp-80h] BYREF
long long v10; // [rsp+50h] [rbp-78h]
long long v11; // [rsp+58h] [rbp-70h] BYREF
void *v12; // [rsp+68h] [rbp-60h]
long long v13; // [rsp+70h] [rbp-58h]
_QWORD v14[10]; // [rsp+78h] [rbp-50h] BYREF
v7[0] = v8;
std::string::_M_construct<char const*>(v7, "invalid_iterator", (long long)"");
nlohmann::json_abi_v3_11_3::detail::exception::name((long long)v9, (long long)v7, a2);
v12 = v14;
v13 = 0LL;
LOBYTE(v14[0]) = 0;
v5[0] = (char *)v6;
v5[1] = 0LL;
LOBYTE(v6[0]) = 0;
std::string::reserve(v5, v10 + a3[1]);
std::string::_M_append(v5, *(_QWORD *)v9, v10);
std::string::_M_append(v5, v12, v13);
std::string::_M_append(v5, *a3, a3[1]);
if ( v12 != v14 )
operator delete(v12, v14[0] + 1LL);
if ( *(long long **)v9 != &v11 )
operator delete(*(void **)v9, v11 + 1);
if ( v7[0] != v8 )
operator delete(v7[0], v8[0] + 1LL);
nlohmann::json_abi_v3_11_3::detail::exception::exception(this, a2, v5[0]);
*(_QWORD *)this = &`vtable for'nlohmann::json_abi_v3_11_3::detail::invalid_iterator + 2;
if ( (_QWORD *)v5[0] != v6 )
operator delete(v5[0], v6[0] + 1LL);
return this;
}
|
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x98
MOV R15,RDX
MOV EBP,ESI
MOV RBX,RDI
LEA R13,[RSP + 0x38]
MOV qword ptr [R13 + -0x10],R13
LAB_0018d0ca:
LEA RSI,[0x1edf29]
LEA RDX,[0x1edf39]
LEA RDI,[RSP + 0x28]
CALL 0x00121c52
LAB_0018d0e2:
LEA RDI,[RSP + 0x48]
LEA RSI,[RSP + 0x28]
MOV EDX,EBP
CALL 0x00157ada
LEA R14,[RSP + 0x78]
MOV qword ptr [R14 + -0x10],R14
XOR EAX,EAX
MOV qword ptr [R14 + -0x8],RAX
MOV byte ptr [R14],AL
LEA R12,[RSP + 0x18]
MOV qword ptr [R12 + -0x10],R12
MOV qword ptr [R12 + -0x8],RAX
MOV byte ptr [R12],AL
MOV RSI,qword ptr [R15 + 0x8]
ADD RSI,qword ptr [RSP + 0x50]
LAB_0018d121:
LEA RDI,[RSP + 0x8]
CALL 0x0011ad50
MOV RSI,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RSP + 0x50]
LEA RDI,[RSP + 0x8]
CALL 0x0011a250
MOV RSI,qword ptr [RSP + 0x68]
MOV RDX,qword ptr [RSP + 0x70]
LEA RDI,[RSP + 0x8]
CALL 0x0011a250
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
LEA RDI,[RSP + 0x8]
CALL 0x0011a250
MOV RDI,qword ptr [RSP + 0x68]
CMP RDI,R14
JZ 0x0018d17b
MOV RSI,qword ptr [RSP + 0x78]
INC RSI
CALL 0x0011a8b0
LAB_0018d17b:
LEA RAX,[RSP + 0x58]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0018d196
MOV RSI,qword ptr [RSP + 0x58]
INC RSI
CALL 0x0011a8b0
LAB_0018d196:
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,R13
JZ 0x0018d1ad
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x0011a8b0
LAB_0018d1ad:
MOV RDX,qword ptr [RSP + 0x8]
LAB_0018d1b2:
MOV RDI,RBX
MOV ESI,EBP
CALL 0x00157d48
LAB_0018d1bc:
LEA RAX,[0x22aef0]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R12
JZ 0x0018d1e1
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011a8b0
LAB_0018d1e1:
MOV RAX,RBX
ADD RSP,0x98
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
exception *
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(exception *param_1,int param_2,ulong *param_3)
{
char *local_c0;
int8 local_b8;
char local_b0;
int7 uStack_af;
long *local_a0 [2];
long local_90 [2];
long *local_80 [2];
long local_70 [2];
int1 *local_60;
int8 local_58;
int1 local_50;
int7 uStack_4f;
/* try { // try from 0018d0ca to 0018d0e1 has its CatchHandler @ 0018d20f */
local_a0[0] = local_90;
std::__cxx11::string::_M_construct<char_const*>(local_a0,"invalid_iterator","");
/* try { // try from 0018d0e2 to 0018d0f2 has its CatchHandler @ 0018d20a */
nlohmann::json_abi_v3_11_3::detail::exception::name
((exception *)local_80,(string *)local_a0,param_2);
local_58 = 0;
local_50 = 0;
local_b8 = 0;
local_b0 = '\0';
/* try { // try from 0018d121 to 0018d163 has its CatchHandler @ 0018d214 */
local_c0 = &local_b0;
local_60 = &local_50;
std::__cxx11::string::reserve((ulong)&local_c0);
std::__cxx11::string::_M_append((char *)&local_c0,(ulong)local_80[0]);
std::__cxx11::string::_M_append((char *)&local_c0,(ulong)local_60);
std::__cxx11::string::_M_append((char *)&local_c0,*param_3);
if (local_60 != &local_50) {
operator_delete(local_60,CONCAT71(uStack_4f,local_50) + 1);
}
if (local_80[0] != local_70) {
operator_delete(local_80[0],local_70[0] + 1);
}
if (local_a0[0] != local_90) {
operator_delete(local_a0[0],local_90[0] + 1);
}
/* try { // try from 0018d1b2 to 0018d1bb has its CatchHandler @ 0018d1f6 */
nlohmann::json_abi_v3_11_3::detail::exception::exception(param_1,param_2,local_c0);
*(int ***)param_1 = &PTR__exception_0022af00;
if (local_c0 != &local_b0) {
operator_delete(local_c0,CONCAT71(uStack_af,local_b0) + 1);
}
return param_1;
}
|
|
8,101 |
wake_up_waiters
|
eloqsql/mysys/thr_lock.c
|
static void wake_up_waiters(THR_LOCK *lock)
{
THR_LOCK_DATA *data;
enum thr_lock_type lock_type;
DBUG_ENTER("wake_up_waiters");
check_locks(lock, "before waking up waiters", TL_UNLOCK, 1);
if (!lock->write.data) /* If no active write locks */
{
data=lock->write_wait.data;
if (!lock->read.data) /* If no more locks in use */
{
/* Release write-locks with TL_WRITE or TL_WRITE_ONLY priority first */
if (data &&
(data->type != TL_WRITE_LOW_PRIORITY || !lock->read_wait.data ||
lock->read_wait.data->type < TL_READ_HIGH_PRIORITY))
{
if (lock->write_lock_count++ > max_write_lock_count)
{
/* Too many write locks in a row; Release all waiting read locks */
lock->write_lock_count=0;
if (lock->read_wait.data)
{
DBUG_PRINT("info",("Freeing all read_locks because of max_write_lock_count"));
free_all_read_locks(lock,0);
goto end;
}
}
for (;;)
{
if (((*data->prev)=data->next)) /* remove from wait-list */
data->next->prev= data->prev;
else
lock->write_wait.last=data->prev;
(*lock->write.last)=data; /* Put in execute list */
data->prev=lock->write.last;
data->next=0;
lock->write.last= &data->next;
if (data->type == TL_WRITE_CONCURRENT_INSERT &&
(*lock->check_status)(data->status_param))
data->type=TL_WRITE; /* Upgrade lock */
/* purecov: begin inspected */
DBUG_PRINT("lock",("giving write lock of type %d to thread: %lu",
data->type, (ulong) data->owner->thread_id));
/* purecov: end */
{
mysql_cond_t *cond= data->cond;
data->cond=0; /* Mark thread free */
mysql_cond_signal(cond); /* Start waiting thread */
}
if (data->type != TL_WRITE_ALLOW_WRITE ||
!lock->write_wait.data ||
lock->write_wait.data->type != TL_WRITE_ALLOW_WRITE)
break;
data=lock->write_wait.data; /* Free this too */
}
if (data->type >= TL_WRITE_LOW_PRIORITY)
goto end;
/* Release possible read locks together with the write lock */
}
if (lock->read_wait.data)
free_all_read_locks(lock,
data &&
(data->type == TL_WRITE_CONCURRENT_INSERT ||
data->type == TL_WRITE_ALLOW_WRITE));
else
{
DBUG_PRINT("lock",("No waiting read locks to free"));
}
}
else if (data &&
(lock_type=data->type) <= TL_WRITE_DELAYED &&
((lock_type != TL_WRITE_CONCURRENT_INSERT &&
lock_type != TL_WRITE_ALLOW_WRITE) ||
!lock->read_no_write_count))
{
/*
For DELAYED, ALLOW_READ, WRITE_ALLOW_WRITE or CONCURRENT_INSERT locks
start WRITE locks together with the READ locks
*/
if (lock_type == TL_WRITE_CONCURRENT_INSERT &&
(*lock->check_status)(data->status_param))
{
data->type=TL_WRITE; /* Upgrade lock */
if (lock->read_wait.data)
free_all_read_locks(lock,0);
goto end;
}
do {
mysql_cond_t *cond= data->cond;
if (((*data->prev)=data->next)) /* remove from wait-list */
data->next->prev= data->prev;
else
lock->write_wait.last=data->prev;
(*lock->write.last)=data; /* Put in execute list */
data->prev=lock->write.last;
lock->write.last= &data->next;
data->next=0; /* Only one write lock */
data->cond=0; /* Mark thread free */
mysql_cond_signal(cond); /* Start waiting thread */
} while (lock_type == TL_WRITE_ALLOW_WRITE &&
(data=lock->write_wait.data) &&
data->type == TL_WRITE_ALLOW_WRITE);
if (lock->read_wait.data)
free_all_read_locks(lock,
(lock_type == TL_WRITE_CONCURRENT_INSERT ||
lock_type == TL_WRITE_ALLOW_WRITE));
}
else if (!data && lock->read_wait.data)
free_all_read_locks(lock,0);
}
end:
check_locks(lock, "after waking up waiters", TL_UNLOCK, 0);
DBUG_VOID_RETURN;
}
|
O0
|
c
|
wake_up_waiters:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x90(%rax)
jne 0xf7a91
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x70(%rax)
jne 0xf78c5
cmpq $0x0, -0x10(%rbp)
je 0xf7862
movq -0x10(%rbp), %rax
cmpl $0xb, 0x40(%rax)
jne 0xf76de
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0xf76de
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
cmpl $0x4, 0x40(%rax)
jge 0xf7862
movq -0x8(%rbp), %rcx
movq 0xa0(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0xa0(%rcx)
leaq 0x1c755a(%rip), %rcx # 0x2bec58
cmpq (%rcx), %rax
jbe 0xf7733
movq -0x8(%rbp), %rax
movq $0x0, 0xa0(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0xf7731
jmp 0xf771f
jmp 0xf7721
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0xf9100
jmp 0xf7a93
jmp 0xf7733
jmp 0xf7735
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0xf7764
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0xf7777
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
addq $0x8, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
cmpl $0x8, 0x40(%rax)
jne 0xf77ed
movq -0x8(%rbp), %rax
movq 0xd8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rdi
callq *%rax
movsbl %al, %eax
cmpl $0x0, %eax
je 0xf77ed
movq -0x10(%rbp), %rax
movl $0xd, 0x40(%rax)
jmp 0xf77ef
jmp 0xf77f1
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x20(%rbp), %rdi
callq 0xf8780
movq -0x10(%rbp), %rax
cmpl $0x7, 0x40(%rax)
jne 0xf783b
movq -0x8(%rbp), %rax
cmpq $0x0, 0x80(%rax)
je 0xf783b
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
cmpl $0x7, 0x40(%rax)
je 0xf783d
jmp 0xf7851
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xf7735
movq -0x10(%rbp), %rax
cmpl $0xb, 0x40(%rax)
jl 0xf7860
jmp 0xf7a93
jmp 0xf7862
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0xf78ba
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x29(%rbp)
je 0xf78a4
movq -0x10(%rbp), %rcx
movb $0x1, %al
cmpl $0x8, 0x40(%rcx)
movb %al, -0x39(%rbp)
je 0xf789e
movq -0x10(%rbp), %rax
cmpl $0x7, 0x40(%rax)
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
movb %al, -0x29(%rbp)
movq -0x38(%rbp), %rdi
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movsbl %al, %esi
callq 0xf9100
jmp 0xf78c0
jmp 0xf78bc
jmp 0xf78be
jmp 0xf78c0
jmp 0xf7a8f
cmpq $0x0, -0x10(%rbp)
je 0xf7a6e
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x9, %eax
jg 0xf7a6e
cmpl $0x8, -0x14(%rbp)
je 0xf78ef
cmpl $0x7, -0x14(%rbp)
jne 0xf7900
movq -0x8(%rbp), %rax
cmpl $0x0, 0xa8(%rax)
jne 0xf7a6e
cmpl $0x8, -0x14(%rbp)
jne 0xf7949
movq -0x8(%rbp), %rax
movq 0xd8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rdi
callq *%rax
movsbl %al, %eax
cmpl $0x0, %eax
je 0xf7949
movq -0x10(%rbp), %rax
movl $0xd, 0x40(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0xf7944
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0xf9100
jmp 0xf7a93
jmp 0xf794b
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0xf7986
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0xf7999
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
addq $0x8, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x28(%rbp), %rdi
callq 0xf8780
xorl %eax, %eax
cmpl $0x7, -0x14(%rbp)
movb %al, -0x3a(%rbp)
jne 0xf7a25
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rcx
movq %rcx, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x3a(%rbp)
je 0xf7a25
movq -0x10(%rbp), %rax
cmpl $0x7, 0x40(%rax)
sete %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
testb $0x1, %al
jne 0xf794b
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0xf7a6c
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movb $0x1, %al
cmpl $0x8, -0x14(%rbp)
movb %al, -0x3b(%rbp)
je 0xf7a58
cmpl $0x7, -0x14(%rbp)
sete %al
movb %al, -0x3b(%rbp)
movq -0x48(%rbp), %rdi
movb -0x3b(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movsbl %al, %esi
callq 0xf9100
jmp 0xf7a8d
cmpq $0x0, -0x10(%rbp)
jne 0xf7a8b
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0xf7a8b
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0xf9100
jmp 0xf7a8d
jmp 0xf7a8f
jmp 0xf7a91
jmp 0xf7a93
jmp 0xf7a95
jmp 0xf7a97
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
|
wake_up_waiters:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
cmp qword ptr [rax+90h], 0
jnz loc_F7A91
mov rax, [rbp+var_8]
mov rax, [rax+80h]
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
cmp qword ptr [rax+70h], 0
jnz loc_F78C5
cmp [rbp+var_10], 0
jz loc_F7862
mov rax, [rbp+var_10]
cmp dword ptr [rax+40h], 0Bh
jnz short loc_F76DE
mov rax, [rbp+var_8]
cmp qword ptr [rax+60h], 0
jz short loc_F76DE
mov rax, [rbp+var_8]
mov rax, [rax+60h]
cmp dword ptr [rax+40h], 4
jge loc_F7862
loc_F76DE:
mov rcx, [rbp+var_8]
mov rax, [rcx+0A0h]
mov rdx, rax
add rdx, 1
mov [rcx+0A0h], rdx
lea rcx, max_write_lock_count
cmp rax, [rcx]
jbe short loc_F7733
mov rax, [rbp+var_8]
mov qword ptr [rax+0A0h], 0
mov rax, [rbp+var_8]
cmp qword ptr [rax+60h], 0
jz short loc_F7731
jmp short $+2
loc_F771F:
jmp short $+2
loc_F7721:
mov rdi, [rbp+var_8]
xor esi, esi
call free_all_read_locks
jmp loc_F7A93
loc_F7731:
jmp short $+2
loc_F7733:
jmp short $+2
loc_F7735:
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov rcx, [rbp+var_10]
mov rcx, [rcx+10h]
mov [rcx], rax
cmp rax, 0
jz short loc_F7764
mov rax, [rbp+var_10]
mov rcx, [rax+10h]
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rax+10h], rcx
jmp short loc_F7777
loc_F7764:
mov rax, [rbp+var_10]
mov rcx, [rax+10h]
mov rax, [rbp+var_8]
mov [rax+88h], rcx
loc_F7777:
mov rcx, [rbp+var_10]
mov rax, [rbp+var_8]
mov rax, [rax+98h]
mov [rax], rcx
mov rax, [rbp+var_8]
mov rcx, [rax+98h]
mov rax, [rbp+var_10]
mov [rax+10h], rcx
mov rax, [rbp+var_10]
mov qword ptr [rax+8], 0
mov rcx, [rbp+var_10]
add rcx, 8
mov rax, [rbp+var_8]
mov [rax+98h], rcx
mov rax, [rbp+var_10]
cmp dword ptr [rax+40h], 8
jnz short loc_F77ED
mov rax, [rbp+var_8]
mov rax, [rax+0D8h]
mov rcx, [rbp+var_10]
mov rdi, [rcx+28h]
call rax
movsx eax, al
cmp eax, 0
jz short loc_F77ED
mov rax, [rbp+var_10]
mov dword ptr [rax+40h], 0Dh
loc_F77ED:
jmp short $+2
loc_F77EF:
jmp short $+2
loc_F77F1:
mov rax, [rbp+var_10]
mov rax, [rax+20h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov qword ptr [rax+20h], 0
mov rdi, [rbp+var_20]
call inline_mysql_cond_signal_4
mov rax, [rbp+var_10]
cmp dword ptr [rax+40h], 7
jnz short loc_F783B
mov rax, [rbp+var_8]
cmp qword ptr [rax+80h], 0
jz short loc_F783B
mov rax, [rbp+var_8]
mov rax, [rax+80h]
cmp dword ptr [rax+40h], 7
jz short loc_F783D
loc_F783B:
jmp short loc_F7851
loc_F783D:
mov rax, [rbp+var_8]
mov rax, [rax+80h]
mov [rbp+var_10], rax
jmp loc_F7735
loc_F7851:
mov rax, [rbp+var_10]
cmp dword ptr [rax+40h], 0Bh
jl short loc_F7860
jmp loc_F7A93
loc_F7860:
jmp short $+2
loc_F7862:
mov rax, [rbp+var_8]
cmp qword ptr [rax+60h], 0
jz short loc_F78BA
mov rax, [rbp+var_8]
mov [rbp+var_38], rax
xor eax, eax
cmp [rbp+var_10], 0
mov [rbp+var_29], al
jz short loc_F78A4
mov rcx, [rbp+var_10]
mov al, 1
cmp dword ptr [rcx+40h], 8
mov [rbp+var_39], al
jz short loc_F789E
mov rax, [rbp+var_10]
cmp dword ptr [rax+40h], 7
setz al
mov [rbp+var_39], al
loc_F789E:
mov al, [rbp+var_39]
mov [rbp+var_29], al
loc_F78A4:
mov rdi, [rbp+var_38]
mov al, [rbp+var_29]
and al, 1
movzx eax, al
movsx esi, al
call free_all_read_locks
jmp short loc_F78C0
loc_F78BA:
jmp short $+2
loc_F78BC:
jmp short $+2
loc_F78BE:
jmp short $+2
loc_F78C0:
jmp loc_F7A8F
loc_F78C5:
cmp [rbp+var_10], 0
jz loc_F7A6E
mov rax, [rbp+var_10]
mov eax, [rax+40h]
mov [rbp+var_14], eax
cmp eax, 9
jg loc_F7A6E
cmp [rbp+var_14], 8
jz short loc_F78EF
cmp [rbp+var_14], 7
jnz short loc_F7900
loc_F78EF:
mov rax, [rbp+var_8]
cmp dword ptr [rax+0A8h], 0
jnz loc_F7A6E
loc_F7900:
cmp [rbp+var_14], 8
jnz short loc_F7949
mov rax, [rbp+var_8]
mov rax, [rax+0D8h]
mov rcx, [rbp+var_10]
mov rdi, [rcx+28h]
call rax
movsx eax, al
cmp eax, 0
jz short loc_F7949
mov rax, [rbp+var_10]
mov dword ptr [rax+40h], 0Dh
mov rax, [rbp+var_8]
cmp qword ptr [rax+60h], 0
jz short loc_F7944
mov rdi, [rbp+var_8]
xor esi, esi
call free_all_read_locks
loc_F7944:
jmp loc_F7A93
loc_F7949:
jmp short $+2
loc_F794B:
mov rax, [rbp+var_10]
mov rax, [rax+20h]
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov rcx, [rbp+var_10]
mov rcx, [rcx+10h]
mov [rcx], rax
cmp rax, 0
jz short loc_F7986
mov rax, [rbp+var_10]
mov rcx, [rax+10h]
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rax+10h], rcx
jmp short loc_F7999
loc_F7986:
mov rax, [rbp+var_10]
mov rcx, [rax+10h]
mov rax, [rbp+var_8]
mov [rax+88h], rcx
loc_F7999:
mov rcx, [rbp+var_10]
mov rax, [rbp+var_8]
mov rax, [rax+98h]
mov [rax], rcx
mov rax, [rbp+var_8]
mov rcx, [rax+98h]
mov rax, [rbp+var_10]
mov [rax+10h], rcx
mov rcx, [rbp+var_10]
add rcx, 8
mov rax, [rbp+var_8]
mov [rax+98h], rcx
mov rax, [rbp+var_10]
mov qword ptr [rax+8], 0
mov rax, [rbp+var_10]
mov qword ptr [rax+20h], 0
mov rdi, [rbp+var_28]
call inline_mysql_cond_signal_4
xor eax, eax
cmp [rbp+var_14], 7
mov [rbp+var_3A], al
jnz short loc_F7A25
mov rax, [rbp+var_8]
mov rcx, [rax+80h]
mov [rbp+var_10], rcx
xor eax, eax
cmp rcx, 0
mov [rbp+var_3A], al
jz short loc_F7A25
mov rax, [rbp+var_10]
cmp dword ptr [rax+40h], 7
setz al
mov [rbp+var_3A], al
loc_F7A25:
mov al, [rbp+var_3A]
test al, 1
jnz loc_F794B
mov rax, [rbp+var_8]
cmp qword ptr [rax+60h], 0
jz short loc_F7A6C
mov rax, [rbp+var_8]
mov [rbp+var_48], rax
mov al, 1
cmp [rbp+var_14], 8
mov [rbp+var_3B], al
jz short loc_F7A58
cmp [rbp+var_14], 7
setz al
mov [rbp+var_3B], al
loc_F7A58:
mov rdi, [rbp+var_48]
mov al, [rbp+var_3B]
and al, 1
movzx eax, al
movsx esi, al
call free_all_read_locks
loc_F7A6C:
jmp short loc_F7A8D
loc_F7A6E:
cmp [rbp+var_10], 0
jnz short loc_F7A8B
mov rax, [rbp+var_8]
cmp qword ptr [rax+60h], 0
jz short loc_F7A8B
mov rdi, [rbp+var_8]
xor esi, esi
call free_all_read_locks
loc_F7A8B:
jmp short $+2
loc_F7A8D:
jmp short $+2
loc_F7A8F:
jmp short $+2
loc_F7A91:
jmp short $+2
loc_F7A93:
jmp short $+2
loc_F7A95:
jmp short $+2
loc_F7A97:
add rsp, 50h
pop rbp
retn
|
long long wake_up_waiters(long long a1)
{
long long result; // rax
unsigned long long v2; // rax
long long v3; // rax
long long v4; // rax
bool v5; // [rsp+15h] [rbp-3Bh]
bool v6; // [rsp+16h] [rbp-3Ah]
bool v7; // [rsp+17h] [rbp-39h]
bool v8; // [rsp+27h] [rbp-29h]
long long v9; // [rsp+28h] [rbp-28h]
long long v10; // [rsp+30h] [rbp-20h]
int v11; // [rsp+3Ch] [rbp-14h]
long long v12; // [rsp+40h] [rbp-10h]
result = a1;
if ( *(_QWORD *)(a1 + 144) )
return result;
v12 = *(_QWORD *)(a1 + 128);
result = a1;
if ( *(_QWORD *)(a1 + 112) )
{
if ( v12 )
{
result = *(unsigned int *)(v12 + 64);
v11 = result;
if ( (int)result <= 9 )
{
if ( (_DWORD)result != 8 && (_DWORD)result != 7 || (result = a1, !*(_DWORD *)(a1 + 168)) )
{
if ( v11 == 8 && (*(unsigned __int8 ( **)(_QWORD))(a1 + 216))(*(_QWORD *)(v12 + 40)) )
{
*(_DWORD *)(v12 + 64) = 13;
result = a1;
if ( *(_QWORD *)(a1 + 96) )
return free_all_read_locks(a1, 0LL);
}
else
{
do
{
v9 = *(_QWORD *)(v12 + 32);
v4 = *(_QWORD *)(v12 + 8);
**(_QWORD **)(v12 + 16) = v4;
if ( v4 )
*(_QWORD *)(*(_QWORD *)(v12 + 8) + 16LL) = *(_QWORD *)(v12 + 16);
else
*(_QWORD *)(a1 + 136) = *(_QWORD *)(v12 + 16);
**(_QWORD **)(a1 + 152) = v12;
*(_QWORD *)(v12 + 16) = *(_QWORD *)(a1 + 152);
*(_QWORD *)(a1 + 152) = v12 + 8;
*(_QWORD *)(v12 + 8) = 0LL;
*(_QWORD *)(v12 + 32) = 0LL;
inline_mysql_cond_signal_4(v9);
v6 = 0;
if ( v11 == 7 )
{
v12 = *(_QWORD *)(a1 + 128);
v6 = 0;
if ( v12 )
v6 = *(_DWORD *)(v12 + 64) == 7;
}
}
while ( v6 );
result = a1;
if ( *(_QWORD *)(a1 + 96) )
{
v5 = 1;
if ( v11 != 8 )
v5 = v11 == 7;
return free_all_read_locks(a1, v5);
}
}
return result;
}
}
}
if ( v12 )
return result;
result = a1;
if ( !*(_QWORD *)(a1 + 96) )
return result;
return free_all_read_locks(a1, 0LL);
}
if ( !v12 || *(_DWORD *)(v12 + 64) == 11 && *(_QWORD *)(a1 + 96) && *(int *)(*(_QWORD *)(a1 + 96) + 64LL) >= 4 )
{
LABEL_21:
result = a1;
if ( *(_QWORD *)(a1 + 96) )
{
v8 = 0;
if ( v12 )
{
v7 = 1;
if ( *(_DWORD *)(v12 + 64) != 8 )
v7 = *(_DWORD *)(v12 + 64) == 7;
v8 = v7;
}
return free_all_read_locks(a1, v8);
}
return result;
}
v2 = *(_QWORD *)(a1 + 160);
*(_QWORD *)(a1 + 160) = v2 + 1;
if ( v2 > max_write_lock_count )
{
*(_QWORD *)(a1 + 160) = 0LL;
if ( *(_QWORD *)(a1 + 96) )
return free_all_read_locks(a1, 0LL);
}
while ( 1 )
{
v3 = *(_QWORD *)(v12 + 8);
**(_QWORD **)(v12 + 16) = v3;
if ( v3 )
*(_QWORD *)(*(_QWORD *)(v12 + 8) + 16LL) = *(_QWORD *)(v12 + 16);
else
*(_QWORD *)(a1 + 136) = *(_QWORD *)(v12 + 16);
**(_QWORD **)(a1 + 152) = v12;
*(_QWORD *)(v12 + 16) = *(_QWORD *)(a1 + 152);
*(_QWORD *)(v12 + 8) = 0LL;
*(_QWORD *)(a1 + 152) = v12 + 8;
if ( *(_DWORD *)(v12 + 64) == 8 && (*(unsigned __int8 ( **)(_QWORD))(a1 + 216))(*(_QWORD *)(v12 + 40)) )
*(_DWORD *)(v12 + 64) = 13;
v10 = *(_QWORD *)(v12 + 32);
*(_QWORD *)(v12 + 32) = 0LL;
inline_mysql_cond_signal_4(v10);
if ( *(_DWORD *)(v12 + 64) != 7 || !*(_QWORD *)(a1 + 128) || *(_DWORD *)(*(_QWORD *)(a1 + 128) + 64LL) != 7 )
break;
v12 = *(_QWORD *)(a1 + 128);
}
result = v12;
if ( *(int *)(v12 + 64) < 11 )
goto LABEL_21;
return result;
}
|
wake_up_waiters:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x90],0x0
JNZ 0x001f7a91
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x80]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x70],0x0
JNZ 0x001f78c5
CMP qword ptr [RBP + -0x10],0x0
JZ 0x001f7862
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x40],0xb
JNZ 0x001f76de
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x60],0x0
JZ 0x001f76de
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x60]
CMP dword ptr [RAX + 0x40],0x4
JGE 0x001f7862
LAB_001f76de:
MOV RCX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RCX + 0xa0]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RCX + 0xa0],RDX
LEA RCX,[0x3bec58]
CMP RAX,qword ptr [RCX]
JBE 0x001f7733
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xa0],0x0
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x60],0x0
JZ 0x001f7731
JMP 0x001f771f
LAB_001f771f:
JMP 0x001f7721
LAB_001f7721:
MOV RDI,qword ptr [RBP + -0x8]
XOR ESI,ESI
CALL 0x001f9100
JMP 0x001f7a93
LAB_001f7731:
JMP 0x001f7733
LAB_001f7733:
JMP 0x001f7735
LAB_001f7735:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x10]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JZ 0x001f7764
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX + 0x10],RCX
JMP 0x001f7777
LAB_001f7764:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x88],RCX
LAB_001f7777:
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x98]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x98]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],0x0
MOV RCX,qword ptr [RBP + -0x10]
ADD RCX,0x8
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x98],RCX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x40],0x8
JNZ 0x001f77ed
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xd8]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RCX + 0x28]
CALL RAX
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x001f77ed
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x40],0xd
LAB_001f77ed:
JMP 0x001f77ef
LAB_001f77ef:
JMP 0x001f77f1
LAB_001f77f1:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x20],0x0
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001f8780
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x40],0x7
JNZ 0x001f783b
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x80],0x0
JZ 0x001f783b
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x80]
CMP dword ptr [RAX + 0x40],0x7
JZ 0x001f783d
LAB_001f783b:
JMP 0x001f7851
LAB_001f783d:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x80]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001f7735
LAB_001f7851:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x40],0xb
JL 0x001f7860
JMP 0x001f7a93
LAB_001f7860:
JMP 0x001f7862
LAB_001f7862:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x60],0x0
JZ 0x001f78ba
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
CMP qword ptr [RBP + -0x10],0x0
MOV byte ptr [RBP + -0x29],AL
JZ 0x001f78a4
MOV RCX,qword ptr [RBP + -0x10]
MOV AL,0x1
CMP dword ptr [RCX + 0x40],0x8
MOV byte ptr [RBP + -0x39],AL
JZ 0x001f789e
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x40],0x7
SETZ AL
MOV byte ptr [RBP + -0x39],AL
LAB_001f789e:
MOV AL,byte ptr [RBP + -0x39]
MOV byte ptr [RBP + -0x29],AL
LAB_001f78a4:
MOV RDI,qword ptr [RBP + -0x38]
MOV AL,byte ptr [RBP + -0x29]
AND AL,0x1
MOVZX EAX,AL
MOVSX ESI,AL
CALL 0x001f9100
JMP 0x001f78c0
LAB_001f78ba:
JMP 0x001f78bc
LAB_001f78bc:
JMP 0x001f78be
LAB_001f78be:
JMP 0x001f78c0
LAB_001f78c0:
JMP 0x001f7a8f
LAB_001f78c5:
CMP qword ptr [RBP + -0x10],0x0
JZ 0x001f7a6e
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x40]
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x9
JG 0x001f7a6e
CMP dword ptr [RBP + -0x14],0x8
JZ 0x001f78ef
CMP dword ptr [RBP + -0x14],0x7
JNZ 0x001f7900
LAB_001f78ef:
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0xa8],0x0
JNZ 0x001f7a6e
LAB_001f7900:
CMP dword ptr [RBP + -0x14],0x8
JNZ 0x001f7949
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xd8]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RCX + 0x28]
CALL RAX
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x001f7949
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x40],0xd
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x60],0x0
JZ 0x001f7944
MOV RDI,qword ptr [RBP + -0x8]
XOR ESI,ESI
CALL 0x001f9100
LAB_001f7944:
JMP 0x001f7a93
LAB_001f7949:
JMP 0x001f794b
LAB_001f794b:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x10]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JZ 0x001f7986
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX + 0x10],RCX
JMP 0x001f7999
LAB_001f7986:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x88],RCX
LAB_001f7999:
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x98]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x98]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RBP + -0x10]
ADD RCX,0x8
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x98],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x20],0x0
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x001f8780
XOR EAX,EAX
CMP dword ptr [RBP + -0x14],0x7
MOV byte ptr [RBP + -0x3a],AL
JNZ 0x001f7a25
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x80]
MOV qword ptr [RBP + -0x10],RCX
XOR EAX,EAX
CMP RCX,0x0
MOV byte ptr [RBP + -0x3a],AL
JZ 0x001f7a25
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x40],0x7
SETZ AL
MOV byte ptr [RBP + -0x3a],AL
LAB_001f7a25:
MOV AL,byte ptr [RBP + -0x3a]
TEST AL,0x1
JNZ 0x001f794b
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x60],0x0
JZ 0x001f7a6c
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x48],RAX
MOV AL,0x1
CMP dword ptr [RBP + -0x14],0x8
MOV byte ptr [RBP + -0x3b],AL
JZ 0x001f7a58
CMP dword ptr [RBP + -0x14],0x7
SETZ AL
MOV byte ptr [RBP + -0x3b],AL
LAB_001f7a58:
MOV RDI,qword ptr [RBP + -0x48]
MOV AL,byte ptr [RBP + -0x3b]
AND AL,0x1
MOVZX EAX,AL
MOVSX ESI,AL
CALL 0x001f9100
LAB_001f7a6c:
JMP 0x001f7a8d
LAB_001f7a6e:
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x001f7a8b
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x60],0x0
JZ 0x001f7a8b
MOV RDI,qword ptr [RBP + -0x8]
XOR ESI,ESI
CALL 0x001f9100
LAB_001f7a8b:
JMP 0x001f7a8d
LAB_001f7a8d:
JMP 0x001f7a8f
LAB_001f7a8f:
JMP 0x001f7a91
LAB_001f7a91:
JMP 0x001f7a93
LAB_001f7a93:
JMP 0x001f7a95
LAB_001f7a95:
JMP 0x001f7a97
LAB_001f7a97:
ADD RSP,0x50
POP RBP
RET
|
void wake_up_waiters(long param_1)
{
int iVar1;
ulong uVar2;
long lVar3;
int8 uVar4;
char cVar5;
bool bVar6;
bool local_43;
bool local_41;
bool local_31;
long local_18;
if (*(long *)(param_1 + 0x90) == 0) {
local_18 = *(long *)(param_1 + 0x80);
if (*(long *)(param_1 + 0x70) == 0) {
if ((local_18 != 0) &&
(((*(int *)(local_18 + 0x40) != 0xb || (*(long *)(param_1 + 0x60) == 0)) ||
(*(int *)(*(long *)(param_1 + 0x60) + 0x40) < 4)))) {
uVar2 = *(ulong *)(param_1 + 0xa0);
*(ulong *)(param_1 + 0xa0) = uVar2 + 1;
if ((max_write_lock_count < uVar2) &&
(*(int8 *)(param_1 + 0xa0) = 0, *(long *)(param_1 + 0x60) != 0)) {
free_all_read_locks(param_1,0);
return;
}
while( true ) {
lVar3 = *(long *)(local_18 + 8);
**(long **)(local_18 + 0x10) = lVar3;
if (lVar3 == 0) {
*(int8 *)(param_1 + 0x88) = *(int8 *)(local_18 + 0x10);
}
else {
*(int8 *)(*(long *)(local_18 + 8) + 0x10) = *(int8 *)(local_18 + 0x10);
}
**(long **)(param_1 + 0x98) = local_18;
*(int8 *)(local_18 + 0x10) = *(int8 *)(param_1 + 0x98);
*(int8 *)(local_18 + 8) = 0;
*(long *)(param_1 + 0x98) = local_18 + 8;
if ((*(int *)(local_18 + 0x40) == 8) &&
(cVar5 = (**(code **)(param_1 + 0xd8))(*(int8 *)(local_18 + 0x28)), cVar5 != '\0'
)) {
*(int4 *)(local_18 + 0x40) = 0xd;
}
uVar4 = *(int8 *)(local_18 + 0x20);
*(int8 *)(local_18 + 0x20) = 0;
inline_mysql_cond_signal(uVar4);
if (((*(int *)(local_18 + 0x40) != 7) || (*(long *)(param_1 + 0x80) == 0)) ||
(*(int *)(*(long *)(param_1 + 0x80) + 0x40) != 7)) break;
local_18 = *(long *)(param_1 + 0x80);
}
if (10 < *(int *)(local_18 + 0x40)) {
return;
}
}
if (*(long *)(param_1 + 0x60) != 0) {
local_31 = false;
if (local_18 != 0) {
local_41 = true;
if (*(int *)(local_18 + 0x40) != 8) {
local_41 = *(int *)(local_18 + 0x40) == 7;
}
local_31 = local_41;
}
free_all_read_locks(param_1,local_31);
}
}
else if (((local_18 == 0) || (iVar1 = *(int *)(local_18 + 0x40), 9 < iVar1)) ||
(((iVar1 == 8 || (iVar1 == 7)) && (*(int *)(param_1 + 0xa8) != 0)))) {
if ((local_18 == 0) && (*(long *)(param_1 + 0x60) != 0)) {
free_all_read_locks(param_1,0);
}
}
else if ((iVar1 == 8) &&
(cVar5 = (**(code **)(param_1 + 0xd8))(*(int8 *)(local_18 + 0x28)), cVar5 != '\0')
) {
*(int4 *)(local_18 + 0x40) = 0xd;
if (*(long *)(param_1 + 0x60) != 0) {
free_all_read_locks(param_1,0);
}
}
else {
do {
uVar4 = *(int8 *)(local_18 + 0x20);
lVar3 = *(long *)(local_18 + 8);
**(long **)(local_18 + 0x10) = lVar3;
if (lVar3 == 0) {
*(int8 *)(param_1 + 0x88) = *(int8 *)(local_18 + 0x10);
}
else {
*(int8 *)(*(long *)(local_18 + 8) + 0x10) = *(int8 *)(local_18 + 0x10);
}
**(long **)(param_1 + 0x98) = local_18;
*(int8 *)(local_18 + 0x10) = *(int8 *)(param_1 + 0x98);
*(long *)(param_1 + 0x98) = local_18 + 8;
*(int8 *)(local_18 + 8) = 0;
*(int8 *)(local_18 + 0x20) = 0;
inline_mysql_cond_signal(uVar4);
bVar6 = false;
if (iVar1 == 7) {
local_18 = *(long *)(param_1 + 0x80);
bVar6 = false;
if (local_18 != 0) {
bVar6 = *(int *)(local_18 + 0x40) == 7;
}
}
} while (bVar6);
if (*(long *)(param_1 + 0x60) != 0) {
local_43 = iVar1 == 8 || iVar1 == 7;
free_all_read_locks(param_1,local_43);
}
}
}
return;
}
|
|
8,102 |
stbi__resample_row_hv_2_simd(unsigned char*, unsigned char*, unsigned char*, int, int)
|
monkey531[P]llama/examples/llava/../../common/stb_image.h
|
static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
{
// need to generate 2x2 samples for every one in input
int i=0,t0,t1;
if (w == 1) {
out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
return out;
}
t1 = 3*in_near[0] + in_far[0];
// process groups of 8 pixels for as long as we can.
// note we can't handle the last pixel in a row in this loop
// because we need to handle the filter boundary conditions.
for (; i < ((w-1) & ~7); i += 8) {
#if defined(STBI_SSE2)
// load and perform the vertical filtering pass
// this uses 3*x + y = 4*x + (y - x)
__m128i zero = _mm_setzero_si128();
__m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i));
__m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i));
__m128i farw = _mm_unpacklo_epi8(farb, zero);
__m128i nearw = _mm_unpacklo_epi8(nearb, zero);
__m128i diff = _mm_sub_epi16(farw, nearw);
__m128i nears = _mm_slli_epi16(nearw, 2);
__m128i curr = _mm_add_epi16(nears, diff); // current row
// horizontal filter works the same based on shifted vers of current
// row. "prev" is current row shifted right by 1 pixel; we need to
// insert the previous pixel value (from t1).
// "next" is current row shifted left by 1 pixel, with first pixel
// of next block of 8 pixels added in.
__m128i prv0 = _mm_slli_si128(curr, 2);
__m128i nxt0 = _mm_srli_si128(curr, 2);
__m128i prev = _mm_insert_epi16(prv0, t1, 0);
__m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7);
// horizontal filter, polyphase implementation since it's convenient:
// even pixels = 3*cur + prev = cur*4 + (prev - cur)
// odd pixels = 3*cur + next = cur*4 + (next - cur)
// note the shared term.
__m128i bias = _mm_set1_epi16(8);
__m128i curs = _mm_slli_epi16(curr, 2);
__m128i prvd = _mm_sub_epi16(prev, curr);
__m128i nxtd = _mm_sub_epi16(next, curr);
__m128i curb = _mm_add_epi16(curs, bias);
__m128i even = _mm_add_epi16(prvd, curb);
__m128i odd = _mm_add_epi16(nxtd, curb);
// interleave even and odd pixels, then undo scaling.
__m128i int0 = _mm_unpacklo_epi16(even, odd);
__m128i int1 = _mm_unpackhi_epi16(even, odd);
__m128i de0 = _mm_srli_epi16(int0, 4);
__m128i de1 = _mm_srli_epi16(int1, 4);
// pack and write output
__m128i outv = _mm_packus_epi16(de0, de1);
_mm_storeu_si128((__m128i *) (out + i*2), outv);
#elif defined(STBI_NEON)
// load and perform the vertical filtering pass
// this uses 3*x + y = 4*x + (y - x)
uint8x8_t farb = vld1_u8(in_far + i);
uint8x8_t nearb = vld1_u8(in_near + i);
int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb));
int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2));
int16x8_t curr = vaddq_s16(nears, diff); // current row
// horizontal filter works the same based on shifted vers of current
// row. "prev" is current row shifted right by 1 pixel; we need to
// insert the previous pixel value (from t1).
// "next" is current row shifted left by 1 pixel, with first pixel
// of next block of 8 pixels added in.
int16x8_t prv0 = vextq_s16(curr, curr, 7);
int16x8_t nxt0 = vextq_s16(curr, curr, 1);
int16x8_t prev = vsetq_lane_s16(t1, prv0, 0);
int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7);
// horizontal filter, polyphase implementation since it's convenient:
// even pixels = 3*cur + prev = cur*4 + (prev - cur)
// odd pixels = 3*cur + next = cur*4 + (next - cur)
// note the shared term.
int16x8_t curs = vshlq_n_s16(curr, 2);
int16x8_t prvd = vsubq_s16(prev, curr);
int16x8_t nxtd = vsubq_s16(next, curr);
int16x8_t even = vaddq_s16(curs, prvd);
int16x8_t odd = vaddq_s16(curs, nxtd);
// undo scaling and round, then store with even/odd phases interleaved
uint8x8x2_t o;
o.val[0] = vqrshrun_n_s16(even, 4);
o.val[1] = vqrshrun_n_s16(odd, 4);
vst2_u8(out + i*2, o);
#endif
// "previous" value for next iter
t1 = 3*in_near[i+7] + in_far[i+7];
}
t0 = t1;
t1 = 3*in_near[i] + in_far[i];
out[i*2] = stbi__div16(3*t1 + t0 + 8);
for (++i; i < w; ++i) {
t0 = t1;
t1 = 3*in_near[i]+in_far[i];
out[i*2-1] = stbi__div16(3*t0 + t1 + 8);
out[i*2 ] = stbi__div16(3*t1 + t0 + 8);
}
out[w*2-1] = stbi__div4(t1+2);
STBI_NOTUSED(hs);
return out;
}
|
O2
|
c
|
stbi__resample_row_hv_2_simd(unsigned char*, unsigned char*, unsigned char*, int, int):
movq %rdi, %rax
movzbl (%rsi), %r8d
movzbl (%rdx), %edi
cmpl $0x1, %ecx
jne 0x402fd
movzwl %r8w, %ecx
leal (%rcx,%rcx,2), %ecx
movzwl %di, %edx
addl %edx, %ecx
addl $0x2, %ecx
shrl $0x2, %ecx
movb %cl, 0x1(%rax)
movb %cl, (%rax)
retq
movzwl %r8w, %r8d
leal (%r8,%r8,2), %r8d
movzwl %di, %r9d
addl %r8d, %r9d
leal -0x1(%rcx), %edi
andl $-0x8, %edi
movslq %edi, %r8
xorl %edi, %edi
pxor %xmm0, %xmm0
movdqa 0x8591d(%rip), %xmm1 # 0xc5c40
cmpq %r8, %rdi
jge 0x403d0
movq (%rdx,%rdi), %xmm2
movq (%rsi,%rdi), %xmm3
punpcklbw %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1],xmm2[2],xmm0[2],xmm2[3],xmm0[3],xmm2[4],xmm0[4],xmm2[5],xmm0[5],xmm2[6],xmm0[6],xmm2[7],xmm0[7]
punpcklbw %xmm0, %xmm3 # xmm3 = xmm3[0],xmm0[0],xmm3[1],xmm0[1],xmm3[2],xmm0[2],xmm3[3],xmm0[3],xmm3[4],xmm0[4],xmm3[5],xmm0[5],xmm3[6],xmm0[6],xmm3[7],xmm0[7]
psubw %xmm3, %xmm2
psllw $0x2, %xmm3
paddw %xmm2, %xmm3
movdqa %xmm3, %xmm2
pslldq $0x2, %xmm2 # xmm2 = zero,zero,xmm2[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
pinsrw $0x0, %r9d, %xmm2
movdqa %xmm3, %xmm4
psrldq $0x2, %xmm4 # xmm4 = xmm4[2,3,4,5,6,7,8,9,10,11,12,13,14,15],zero,zero
movzbl 0x8(%rsi,%rdi), %r9d
leal (%r9,%r9,2), %r9d
movzbl 0x8(%rdx,%rdi), %r10d
addl %r9d, %r10d
pinsrw $0x7, %r10d, %xmm4
psubw %xmm3, %xmm2
psubw %xmm3, %xmm4
psllw $0x2, %xmm3
paddw %xmm1, %xmm3
paddw %xmm3, %xmm2
paddw %xmm3, %xmm4
movdqa %xmm2, %xmm3
punpcklwd %xmm4, %xmm3 # xmm3 = xmm3[0],xmm4[0],xmm3[1],xmm4[1],xmm3[2],xmm4[2],xmm3[3],xmm4[3]
punpckhwd %xmm4, %xmm2 # xmm2 = xmm2[4],xmm4[4],xmm2[5],xmm4[5],xmm2[6],xmm4[6],xmm2[7],xmm4[7]
psrlw $0x4, %xmm3
psrlw $0x4, %xmm2
packuswb %xmm2, %xmm3
movdqu %xmm3, (%rax,%rdi,2)
movzbl 0x7(%rsi,%rdi), %r10d
movzbl 0x7(%rdx,%rdi), %r9d
addq $0x8, %rdi
leal (%r10,%r10,2), %r10d
addl %r10d, %r9d
jmp 0x40323
movzbl (%rsi,%rdi), %r8d
leal (%r8,%r8,2), %r10d
movzbl (%rdx,%rdi), %r8d
addl %r10d, %r8d
leal (%r8,%r8,2), %r10d
addl %r10d, %r9d
addl $0x8, %r9d
shrl $0x4, %r9d
movb %r9b, (%rax,%rdi,2)
movslq %ecx, %rcx
incq %rdi
cmpq %rcx, %rdi
jge 0x4043f
movzbl (%rsi,%rdi), %r9d
leal (%r9,%r9,2), %r9d
movzbl (%rdx,%rdi), %r10d
addl %r9d, %r10d
leal (%r8,%r8,2), %r9d
addl %r10d, %r9d
addl $0x8, %r9d
shrl $0x4, %r9d
movb %r9b, -0x1(%rax,%rdi,2)
leal (%r10,%r10,2), %r9d
addl %r9d, %r8d
addl $0x8, %r8d
shrl $0x4, %r8d
movb %r8b, (%rax,%rdi,2)
incq %rdi
movl %r10d, %r8d
jmp 0x403fa
addl $0x2, %r8d
shrl $0x2, %r8d
movb %r8b, -0x1(%rax,%rcx,2)
retq
|
_ZL28stbi__resample_row_hv_2_simdPhS_S_ii:
mov rax, rdi
movzx r8d, byte ptr [rsi]
movzx edi, byte ptr [rdx]
cmp ecx, 1
jnz short loc_402FD
movzx ecx, r8w
lea ecx, [rcx+rcx*2]
movzx edx, di
add ecx, edx
add ecx, 2
shr ecx, 2
mov [rax+1], cl
mov [rax], cl
retn
loc_402FD:
movzx r8d, r8w
lea r8d, [r8+r8*2]
movzx r9d, di
add r9d, r8d
lea edi, [rcx-1]
and edi, 0FFFFFFF8h
movsxd r8, edi
xor edi, edi
pxor xmm0, xmm0
movdqa xmm1, cs:xmmword_C5C40
loc_40323:
cmp rdi, r8
jge loc_403D0
movq xmm2, qword ptr [rdx+rdi]
movq xmm3, qword ptr [rsi+rdi]
punpcklbw xmm2, xmm0
punpcklbw xmm3, xmm0
psubw xmm2, xmm3
psllw xmm3, 2
paddw xmm3, xmm2
movdqa xmm2, xmm3
pslldq xmm2, 2
pinsrw xmm2, r9d, 0
movdqa xmm4, xmm3
psrldq xmm4, 2
movzx r9d, byte ptr [rsi+rdi+8]
lea r9d, [r9+r9*2]
movzx r10d, byte ptr [rdx+rdi+8]
add r10d, r9d
pinsrw xmm4, r10d, 7
psubw xmm2, xmm3
psubw xmm4, xmm3
psllw xmm3, 2
paddw xmm3, xmm1
paddw xmm2, xmm3
paddw xmm4, xmm3
movdqa xmm3, xmm2
punpcklwd xmm3, xmm4
punpckhwd xmm2, xmm4
psrlw xmm3, 4
psrlw xmm2, 4
packuswb xmm3, xmm2
movdqu xmmword ptr [rax+rdi*2], xmm3
movzx r10d, byte ptr [rsi+rdi+7]
movzx r9d, byte ptr [rdx+rdi+7]
add rdi, 8
lea r10d, [r10+r10*2]
add r9d, r10d
jmp loc_40323
loc_403D0:
movzx r8d, byte ptr [rsi+rdi]
lea r10d, [r8+r8*2]
movzx r8d, byte ptr [rdx+rdi]
add r8d, r10d
lea r10d, [r8+r8*2]
add r9d, r10d
add r9d, 8
shr r9d, 4
mov [rax+rdi*2], r9b
movsxd rcx, ecx
inc rdi
loc_403FA:
cmp rdi, rcx
jge short loc_4043F
movzx r9d, byte ptr [rsi+rdi]
lea r9d, [r9+r9*2]
movzx r10d, byte ptr [rdx+rdi]
add r10d, r9d
lea r9d, [r8+r8*2]
add r9d, r10d
add r9d, 8
shr r9d, 4
mov [rax+rdi*2-1], r9b
lea r9d, [r10+r10*2]
add r8d, r9d
add r8d, 8
shr r8d, 4
mov [rax+rdi*2], r8b
inc rdi
mov r8d, r10d
jmp short loc_403FA
loc_4043F:
add r8d, 2
shr r8d, 2
mov [rax+rcx*2-1], r8b
retn
|
unsigned __int8 * stbi__resample_row_hv_2_simd(
unsigned __int8 *a1,
unsigned __int8 *a2,
unsigned __int8 *a3,
int a4)
{
unsigned __int8 *result; // rax
unsigned int v5; // ecx
unsigned int v6; // r9d
long long v7; // rdi
__m128i si128; // xmm1
__m128i v9; // xmm3
__m128i v10; // xmm3
__m128i v11; // xmm2
__m128i v12; // xmm4
__m128i v13; // xmm3
__m128i v14; // xmm2
__m128i v15; // xmm4
int v16; // r10d
int v17; // r9d
int v18; // r8d
long long i; // rdi
int v20; // r10d
result = a1;
if ( a4 == 1 )
{
v5 = (*a3 + 3 * (unsigned int)*a2 + 2) >> 2;
a1[1] = v5;
*a1 = v5;
}
else
{
v6 = 3 * *a2 + *a3;
v7 = 0LL;
si128 = _mm_load_si128((const __m128i *)&xmmword_C5C40);
while ( v7 < (int)((a4 - 1) & 0xFFFFFFF8) )
{
v9 = _mm_unpacklo_epi8(_mm_loadl_epi64((const __m128i *)&a2[v7]), (__m128i)0LL);
v10 = _mm_add_epi16(
_mm_slli_epi16(v9, 2u),
_mm_sub_epi16(_mm_unpacklo_epi8(_mm_loadl_epi64((const __m128i *)&a3[v7]), (__m128i)0LL), v9));
v11 = _mm_sub_epi16(_mm_insert_epi16(_mm_slli_si128(v10, 2), v6, 0), v10);
v12 = _mm_sub_epi16(_mm_insert_epi16(_mm_srli_si128(v10, 2), 3 * a2[v7 + 8] + (unsigned int)a3[v7 + 8], 7), v10);
v13 = _mm_add_epi16(_mm_slli_epi16(v10, 2u), si128);
v14 = _mm_add_epi16(v11, v13);
v15 = _mm_add_epi16(v12, v13);
*(__m128i *)&result[2 * v7] = _mm_packus_epi16(
_mm_srli_epi16(_mm_unpacklo_epi16(v14, v15), 4u),
_mm_srli_epi16(_mm_unpackhi_epi16(v14, v15), 4u));
v16 = a2[v7 + 7];
v17 = a3[v7 + 7];
v7 += 8LL;
v6 = 3 * v16 + v17;
}
v18 = 3 * a2[v7] + a3[v7];
result[2 * v7] = (3 * v18 + v6 + 8) >> 4;
for ( i = v7 + 1; i < a4; ++i )
{
v20 = 3 * a2[i] + a3[i];
result[2 * i - 1] = (unsigned int)(v20 + 3 * v18 + 8) >> 4;
result[2 * i] = (unsigned int)(3 * v20 + v18 + 8) >> 4;
v18 = v20;
}
result[2 * a4 - 1] = (unsigned int)(v18 + 2) >> 2;
}
return result;
}
|
stbi__resample_row_hv_2_simd:
MOV RAX,RDI
MOVZX R8D,byte ptr [RSI]
MOVZX EDI,byte ptr [RDX]
CMP ECX,0x1
JNZ 0x001402fd
MOVZX ECX,R8W
LEA ECX,[RCX + RCX*0x2]
MOVZX EDX,DI
ADD ECX,EDX
ADD ECX,0x2
SHR ECX,0x2
MOV byte ptr [RAX + 0x1],CL
MOV byte ptr [RAX],CL
RET
LAB_001402fd:
MOVZX R8D,R8W
LEA R8D,[R8 + R8*0x2]
MOVZX R9D,DI
ADD R9D,R8D
LEA EDI,[RCX + -0x1]
AND EDI,0xfffffff8
MOVSXD R8,EDI
XOR EDI,EDI
PXOR XMM0,XMM0
MOVDQA XMM1,xmmword ptr [0x001c5c40]
LAB_00140323:
CMP RDI,R8
JGE 0x001403d0
MOVQ XMM2,qword ptr [RDX + RDI*0x1]
MOVQ XMM3,qword ptr [RSI + RDI*0x1]
PUNPCKLBW XMM2,XMM0
PUNPCKLBW XMM3,XMM0
PSUBW XMM2,XMM3
PSLLW XMM3,0x2
PADDW XMM3,XMM2
MOVDQA XMM2,XMM3
PSLLDQ XMM2,0x2
PINSRW XMM2,R9D,0x0
MOVDQA XMM4,XMM3
PSRLDQ XMM4,0x2
MOVZX R9D,byte ptr [RSI + RDI*0x1 + 0x8]
LEA R9D,[R9 + R9*0x2]
MOVZX R10D,byte ptr [RDX + RDI*0x1 + 0x8]
ADD R10D,R9D
PINSRW XMM4,R10D,0x7
PSUBW XMM2,XMM3
PSUBW XMM4,XMM3
PSLLW XMM3,0x2
PADDW XMM3,XMM1
PADDW XMM2,XMM3
PADDW XMM4,XMM3
MOVDQA XMM3,XMM2
PUNPCKLWD XMM3,XMM4
PUNPCKHWD XMM2,XMM4
PSRLW XMM3,0x4
PSRLW XMM2,0x4
PACKUSWB XMM3,XMM2
MOVDQU xmmword ptr [RAX + RDI*0x2],XMM3
MOVZX R10D,byte ptr [RSI + RDI*0x1 + 0x7]
MOVZX R9D,byte ptr [RDX + RDI*0x1 + 0x7]
ADD RDI,0x8
LEA R10D,[R10 + R10*0x2]
ADD R9D,R10D
JMP 0x00140323
LAB_001403d0:
MOVZX R8D,byte ptr [RSI + RDI*0x1]
LEA R10D,[R8 + R8*0x2]
MOVZX R8D,byte ptr [RDX + RDI*0x1]
ADD R8D,R10D
LEA R10D,[R8 + R8*0x2]
ADD R9D,R10D
ADD R9D,0x8
SHR R9D,0x4
MOV byte ptr [RAX + RDI*0x2],R9B
MOVSXD RCX,ECX
INC RDI
LAB_001403fa:
CMP RDI,RCX
JGE 0x0014043f
MOVZX R9D,byte ptr [RSI + RDI*0x1]
LEA R9D,[R9 + R9*0x2]
MOVZX R10D,byte ptr [RDX + RDI*0x1]
ADD R10D,R9D
LEA R9D,[R8 + R8*0x2]
ADD R9D,R10D
ADD R9D,0x8
SHR R9D,0x4
MOV byte ptr [RAX + RDI*0x2 + -0x1],R9B
LEA R9D,[R10 + R10*0x2]
ADD R8D,R9D
ADD R8D,0x8
SHR R8D,0x4
MOV byte ptr [RAX + RDI*0x2],R8B
INC RDI
MOV R8D,R10D
JMP 0x001403fa
LAB_0014043f:
ADD R8D,0x2
SHR R8D,0x2
MOV byte ptr [RAX + RCX*0x2 + -0x1],R8B
RET
|
/* WARNING: Removing unreachable block (ram,0x0014034f) */
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* stbi__resample_row_hv_2_simd(unsigned char*, unsigned char*, unsigned char*, int, int) */
void stbi__resample_row_hv_2_simd
(uchar *param_1,uchar *param_2,uchar *param_3,int param_4,int param_5)
{
uchar *puVar1;
ulong uVar2;
ulong uVar3;
byte bVar4;
int1 auVar5 [15];
int1 auVar6 [15];
int1 auVar7 [15];
int1 auVar8 [15];
int1 auVar9 [15];
int1 auVar10 [15];
int1 auVar11 [15];
int1 auVar12 [15];
int1 auVar13 [15];
int1 auVar14 [15];
int1 auVar15 [15];
int1 auVar16 [15];
int1 auVar17 [15];
int1 auVar18 [15];
int1 auVar19 [15];
unkuint9 Var20;
int1 auVar21 [11];
int1 auVar22 [15];
unkuint9 Var23;
int1 auVar24 [11];
int1 auVar25 [15];
int1 auVar26 [15];
int1 auVar27 [15];
int1 auVar28 [15];
short sVar29;
short sVar30;
short sVar31;
short sVar32;
short sVar33;
short sVar34;
short sVar35;
short sVar36;
uchar uVar37;
long lVar38;
int iVar39;
int iVar40;
ushort uVar41;
ushort uVar42;
ushort uVar43;
ushort uVar44;
ushort uVar45;
ushort uVar46;
ushort uVar47;
ushort uVar48;
short sVar49;
ushort uVar50;
short sVar54;
ushort uVar55;
short sVar56;
ushort uVar57;
short sVar58;
ushort uVar59;
short sVar60;
ushort uVar61;
short sVar62;
ushort uVar63;
short sVar64;
ushort uVar65;
int1 auVar51 [16];
int1 auVar52 [16];
int1 auVar53 [16];
short sVar66;
ushort uVar67;
sVar36 = _UNK_001c5c4e;
sVar35 = _UNK_001c5c4c;
sVar34 = _UNK_001c5c4a;
sVar33 = _UNK_001c5c48;
sVar32 = _UNK_001c5c46;
sVar31 = _UNK_001c5c44;
sVar30 = _UNK_001c5c42;
sVar29 = _DAT_001c5c40;
bVar4 = *param_2;
if (param_4 == 1) {
uVar37 = (uchar)((uint)bVar4 + (uint)bVar4 * 2 + (uint)*param_3 + 2 >> 2);
param_1[1] = uVar37;
*param_1 = uVar37;
return;
}
iVar40 = (uint)*param_3 + (uint)bVar4 + (uint)bVar4 * 2;
for (lVar38 = 0; lVar38 < (int)(param_4 - 1U & 0xfffffff8); lVar38 = lVar38 + 8) {
uVar2 = *(ulong *)(param_3 + lVar38);
uVar3 = *(ulong *)(param_2 + lVar38);
auVar5._8_6_ = 0;
auVar5._0_8_ = uVar2;
auVar5[0xe] = (char)(uVar2 >> 0x38);
auVar7._8_4_ = 0;
auVar7._0_8_ = uVar2;
auVar7[0xc] = (char)(uVar2 >> 0x30);
auVar7._13_2_ = auVar5._13_2_;
auVar9._8_4_ = 0;
auVar9._0_8_ = uVar2;
auVar9._12_3_ = auVar7._12_3_;
auVar11._8_2_ = 0;
auVar11._0_8_ = uVar2;
auVar11[10] = (char)(uVar2 >> 0x28);
auVar11._11_4_ = auVar9._11_4_;
auVar13._8_2_ = 0;
auVar13._0_8_ = uVar2;
auVar13._10_5_ = auVar11._10_5_;
auVar15[8] = (char)(uVar2 >> 0x20);
auVar15._0_8_ = uVar2;
auVar15._9_6_ = auVar13._9_6_;
auVar19._7_8_ = 0;
auVar19._0_7_ = auVar15._8_7_;
Var20 = CONCAT81(SUB158(auVar19 << 0x40,7),(char)(uVar2 >> 0x18));
auVar25._9_6_ = 0;
auVar25._0_9_ = Var20;
auVar21._1_10_ = SUB1510(auVar25 << 0x30,5);
auVar21[0] = (char)(uVar2 >> 0x10);
auVar26._11_4_ = 0;
auVar26._0_11_ = auVar21;
auVar17[2] = (char)(uVar2 >> 8);
auVar17._0_2_ = (ushort)uVar2;
auVar17._3_12_ = SUB1512(auVar26 << 0x20,3);
auVar6._8_6_ = 0;
auVar6._0_8_ = uVar3;
auVar6[0xe] = (char)(uVar3 >> 0x38);
auVar8._8_4_ = 0;
auVar8._0_8_ = uVar3;
auVar8[0xc] = (char)(uVar3 >> 0x30);
auVar8._13_2_ = auVar6._13_2_;
auVar10._8_4_ = 0;
auVar10._0_8_ = uVar3;
auVar10._12_3_ = auVar8._12_3_;
auVar12._8_2_ = 0;
auVar12._0_8_ = uVar3;
auVar12[10] = (char)(uVar3 >> 0x28);
auVar12._11_4_ = auVar10._11_4_;
auVar14._8_2_ = 0;
auVar14._0_8_ = uVar3;
auVar14._10_5_ = auVar12._10_5_;
auVar16[8] = (char)(uVar3 >> 0x20);
auVar16._0_8_ = uVar3;
auVar16._9_6_ = auVar14._9_6_;
auVar22._7_8_ = 0;
auVar22._0_7_ = auVar16._8_7_;
Var23 = CONCAT81(SUB158(auVar22 << 0x40,7),(char)(uVar3 >> 0x18));
auVar27._9_6_ = 0;
auVar27._0_9_ = Var23;
auVar24._1_10_ = SUB1510(auVar27 << 0x30,5);
auVar24[0] = (char)(uVar3 >> 0x10);
auVar28._11_4_ = 0;
auVar28._0_11_ = auVar24;
auVar18[2] = (char)(uVar3 >> 8);
auVar18._0_2_ = (ushort)uVar3;
auVar18._3_12_ = SUB1512(auVar28 << 0x20,3);
auVar53._0_2_ = (ushort)uVar3 & 0xff;
auVar53._2_13_ = auVar18._2_13_;
auVar53[0xf] = 0;
auVar51 = psllw(auVar53,2);
auVar52._0_2_ = auVar51._0_2_ + (((ushort)uVar2 & 0xff) - auVar53._0_2_);
auVar52._2_2_ = auVar51._2_2_ + (auVar17._2_2_ - auVar18._2_2_);
auVar52._4_2_ = auVar51._4_2_ + (auVar21._0_2_ - auVar24._0_2_);
auVar52._6_2_ = auVar51._6_2_ + ((short)Var20 - (short)Var23);
auVar52._8_2_ = auVar51._8_2_ + (auVar15._8_2_ - auVar16._8_2_);
auVar52._10_2_ = auVar51._10_2_ + (auVar11._10_2_ - auVar12._10_2_);
auVar52._12_2_ = auVar51._12_2_ + (auVar7._12_2_ - auVar8._12_2_);
auVar52._14_2_ = auVar51._14_2_ + ((auVar5._13_2_ >> 8) - (auVar6._13_2_ >> 8));
auVar53 = psllw(auVar52,2);
sVar49 = auVar53._0_2_ + sVar29;
sVar54 = auVar53._2_2_ + sVar30;
sVar56 = auVar53._4_2_ + sVar31;
sVar58 = auVar53._6_2_ + sVar32;
sVar60 = auVar53._8_2_ + sVar33;
sVar62 = auVar53._10_2_ + sVar34;
sVar64 = auVar53._12_2_ + sVar35;
sVar66 = auVar53._14_2_ + sVar36;
uVar50 = (ushort)(((short)iVar40 - auVar52._0_2_) + sVar49) >> 4;
uVar55 = (ushort)((auVar52._2_2_ - auVar52._0_2_) + sVar49) >> 4;
uVar57 = (ushort)((auVar52._0_2_ - auVar52._2_2_) + sVar54) >> 4;
uVar59 = (ushort)((auVar52._4_2_ - auVar52._2_2_) + sVar54) >> 4;
uVar61 = (ushort)((auVar52._2_2_ - auVar52._4_2_) + sVar56) >> 4;
uVar63 = (ushort)((auVar52._6_2_ - auVar52._4_2_) + sVar56) >> 4;
uVar65 = (ushort)((auVar52._4_2_ - auVar52._6_2_) + sVar58) >> 4;
uVar67 = (ushort)((auVar52._8_2_ - auVar52._6_2_) + sVar58) >> 4;
uVar41 = (ushort)((auVar52._6_2_ - auVar52._8_2_) + sVar60) >> 4;
uVar42 = (ushort)((auVar52._10_2_ - auVar52._8_2_) + sVar60) >> 4;
uVar43 = (ushort)((auVar52._8_2_ - auVar52._10_2_) + sVar62) >> 4;
uVar44 = (ushort)((auVar52._12_2_ - auVar52._10_2_) + sVar62) >> 4;
uVar45 = (ushort)((auVar52._10_2_ - auVar52._12_2_) + sVar64) >> 4;
uVar46 = (ushort)((auVar52._14_2_ - auVar52._12_2_) + sVar64) >> 4;
uVar47 = (ushort)((auVar52._12_2_ - auVar52._14_2_) + sVar66) >> 4;
uVar48 = (ushort)((((ushort)param_3[lVar38 + 8] +
(ushort)param_2[lVar38 + 8] + (ushort)param_2[lVar38 + 8] * 2) -
auVar52._14_2_) + sVar66) >> 4;
puVar1 = param_1 + lVar38 * 2;
*puVar1 = (uVar50 != 0) * (uVar50 < 0x100) * (char)uVar50 - (0xff < uVar50);
puVar1[1] = (uVar55 != 0) * (uVar55 < 0x100) * (char)uVar55 - (0xff < uVar55);
puVar1[2] = (uVar57 != 0) * (uVar57 < 0x100) * (char)uVar57 - (0xff < uVar57);
puVar1[3] = (uVar59 != 0) * (uVar59 < 0x100) * (char)uVar59 - (0xff < uVar59);
puVar1[4] = (uVar61 != 0) * (uVar61 < 0x100) * (char)uVar61 - (0xff < uVar61);
puVar1[5] = (uVar63 != 0) * (uVar63 < 0x100) * (char)uVar63 - (0xff < uVar63);
puVar1[6] = (uVar65 != 0) * (uVar65 < 0x100) * (char)uVar65 - (0xff < uVar65);
puVar1[7] = (uVar67 != 0) * (uVar67 < 0x100) * (char)uVar67 - (0xff < uVar67);
puVar1[8] = (uVar41 != 0) * (uVar41 < 0x100) * (char)uVar41 - (0xff < uVar41);
puVar1[9] = (uVar42 != 0) * (uVar42 < 0x100) * (char)uVar42 - (0xff < uVar42);
puVar1[10] = (uVar43 != 0) * (uVar43 < 0x100) * (char)uVar43 - (0xff < uVar43);
puVar1[0xb] = (uVar44 != 0) * (uVar44 < 0x100) * (char)uVar44 - (0xff < uVar44);
puVar1[0xc] = (uVar45 != 0) * (uVar45 < 0x100) * (char)uVar45 - (0xff < uVar45);
puVar1[0xd] = (uVar46 != 0) * (uVar46 < 0x100) * (char)uVar46 - (0xff < uVar46);
puVar1[0xe] = (uVar47 != 0) * (uVar47 < 0x100) * (char)uVar47 - (0xff < uVar47);
puVar1[0xf] = (uVar48 != 0) * (uVar48 < 0x100) * (char)uVar48 - (0xff < uVar48);
iVar40 = (uint)param_3[lVar38 + 7] + (uint)param_2[lVar38 + 7] + (uint)param_2[lVar38 + 7] * 2;
}
iVar39 = (uint)param_3[lVar38] + (uint)param_2[lVar38] + (uint)param_2[lVar38] * 2;
param_1[lVar38 * 2] = (uchar)(iVar40 + iVar39 * 3 + 8U >> 4);
while (lVar38 = lVar38 + 1, lVar38 < param_4) {
iVar40 = (uint)param_3[lVar38] + (uint)param_2[lVar38] + (uint)param_2[lVar38] * 2;
param_1[lVar38 * 2 + -1] = (uchar)(iVar39 * 3 + iVar40 + 8U >> 4);
param_1[lVar38 * 2] = (uchar)(iVar39 + iVar40 * 3 + 8U >> 4);
iVar39 = iVar40;
}
param_1[(long)param_4 * 2 + -1] = (uchar)(iVar39 + 2U >> 2);
return;
}
|
|
8,103 |
JS_ToLengthFree
|
bluesky950520[P]quickjs/quickjs.c
|
static __exception int JS_ToLengthFree(JSContext *ctx, int64_t *plen,
JSValue val)
{
int res = JS_ToInt64Clamp(ctx, plen, val, 0, MAX_SAFE_INTEGER, 0);
JS_FreeValue(ctx, val);
return res;
}
|
O3
|
c
|
JS_ToLengthFree:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq $0x0, (%rsp)
movabsq $0x1fffffffffffff, %r9 # imm = 0x1FFFFFFFFFFFFF
xorl %r8d, %r8d
callq 0x272da
movl %eax, %ebp
cmpl $-0x9, %ebx
jb 0x4869c
movq 0x18(%r15), %rdi
movl (%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r14)
cmpl $0x1, %eax
jg 0x4869c
movq %r14, %rsi
movq %rbx, %rdx
callq 0x20d90
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
JS_ToLengthFree:
push rbp
push r15
push r14
push rbx
push rax
mov rbx, rcx
mov r14, rdx
mov r15, rdi
mov [rsp+28h+var_28], 0
mov r9, 1FFFFFFFFFFFFFh
xor r8d, r8d
call JS_ToInt64Clamp
mov ebp, eax
cmp ebx, 0FFFFFFF7h
jb short loc_4869C
mov rdi, [r15+18h]
mov eax, [r14]
lea ecx, [rax-1]
mov [r14], ecx
cmp eax, 1
jg short loc_4869C
mov rsi, r14
mov rdx, rbx
call js_free_value_rt
loc_4869C:
mov eax, ebp
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long JS_ToLengthFree(long long a1, unsigned long long *a2, int *a3, long long a4)
{
unsigned int v6; // ebp
long long v7; // r8
long long v8; // r9
long long v9; // rdi
int v10; // eax
long long v11; // rcx
v6 = JS_ToInt64Clamp(a1, a2, a3, a4, 0LL, 0x1FFFFFFFFFFFFFLL, 0LL);
if ( (unsigned int)a4 >= 0xFFFFFFF7 )
{
v9 = *(_QWORD *)(a1 + 24);
v10 = *a3;
v11 = (unsigned int)(*a3 - 1);
*a3 = v11;
if ( v10 <= 1 )
js_free_value_rt(v9, a3, a4, v11, v7, v8);
}
return v6;
}
|
JS_ToLengthFree:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R14,RDX
MOV R15,RDI
MOV qword ptr [RSP],0x0
MOV R9,0x1fffffffffffff
XOR R8D,R8D
CALL 0x001272da
MOV EBP,EAX
CMP EBX,-0x9
JC 0x0014869c
MOV RDI,qword ptr [R15 + 0x18]
MOV EAX,dword ptr [R14]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R14],ECX
CMP EAX,0x1
JG 0x0014869c
MOV RSI,R14
MOV RDX,RBX
CALL 0x00120d90
LAB_0014869c:
MOV EAX,EBP
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4 JS_ToLengthFree(long param_1,int8 param_2,int *param_3,int8 param_4)
{
int iVar1;
int8 uVar2;
int4 uVar3;
uVar3 = JS_ToInt64Clamp();
if (0xfffffff6 < (uint)param_4) {
uVar2 = *(int8 *)(param_1 + 0x18);
iVar1 = *param_3;
*param_3 = iVar1 + -1;
if (iVar1 < 2) {
js_free_value_rt(uVar2,param_3,param_4);
}
}
return uVar3;
}
|
|
8,104 |
my_fopen
|
eloqsql/mysys/my_fopen.c
|
FILE *my_fopen(const char *filename, int flags, myf MyFlags)
{
FILE *fd;
char type[10];
DBUG_ENTER("my_fopen");
DBUG_PRINT("my",("Name: '%s' flags: %d MyFlags: %lu",
filename, flags, MyFlags));
make_ftype(type,flags);
#ifdef _WIN32
fd= my_win_fopen(filename, type);
#else
fd= fopen(filename, type);
#endif
if (fd != 0)
{
/*
The test works if MY_NFILE < 128. The problem is that fileno() is char
on some OS (SUNOS). Actually the filename save isn't that important
so we can ignore if this doesn't work.
*/
int filedesc= my_fileno(fd);
if ((uint)filedesc >= my_file_limit)
{
statistic_increment(my_stream_opened,&THR_LOCK_open);
DBUG_RETURN(fd); /* safeguard */
}
my_file_info[filedesc].name= my_strdup(key_memory_my_file_info, filename, MyFlags);
statistic_increment(my_stream_opened, &THR_LOCK_open);
statistic_increment(my_file_total_opened, &THR_LOCK_open);
my_file_info[filedesc].type= STREAM_BY_FOPEN;
DBUG_PRINT("exit",("stream: %p", fd));
DBUG_RETURN(fd);
}
else
my_errno=errno;
DBUG_PRINT("error",("Got error %d on open",my_errno));
if (MyFlags & (MY_FFNF | MY_FAE | MY_WME))
my_error((flags & O_RDONLY) ? EE_FILENOTFOUND : EE_CANTCREATEFILE,
MYF(ME_BELL), filename, my_errno);
DBUG_RETURN((FILE*) 0);
}
|
O3
|
c
|
my_fopen:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
testb $0x1, %sil
jne 0x31d3c
testb $0x2, %sil
jne 0x31d56
leaq -0x31(%rbp), %rax
movb $0x72, -0x1(%rax)
jmp 0x31d80
btl $0xa, %esi
movl $0x77, %eax
movl $0x61, %ecx
cmovael %eax, %ecx
leaq -0x31(%rbp), %rax
movb %cl, -0x1(%rax)
jmp 0x31d80
btl $0xa, %esi
movl $0x72, %eax
movl $0x61, %ecx
cmovael %eax, %ecx
testl $0x240, %esi # imm = 0x240
movl $0x77, %edx
cmovel %ecx, %edx
leaq -0x30(%rbp), %rax
movb %dl, -0x2(%rax)
movb $0x2b, -0x1(%rax)
movw $0x65, (%rax)
leaq -0x32(%rbp), %rsi
movq %rbx, %rdi
callq 0x24410
movq %rax, %r15
testq %rax, %rax
je 0x31dfa
movq %r15, %rdi
callq 0x3215a
movl %eax, %r12d
leaq 0x2c4ba5(%rip), %rax # 0x2f6950
cmpl (%rax), %r12d
jae 0x31e2d
leaq 0x33c13d(%rip), %rax # 0x36def4
movl (%rax), %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2b068
leaq 0x2c4b8d(%rip), %rcx # 0x2f6958
movq (%rcx), %rdx
movslq %r12d, %rsi
shlq $0x4, %rsi
movq %rax, (%rdx,%rsi)
leaq 0x33bbc0(%rip), %rax # 0x36d9a0
incq (%rax)
leaq 0x33bbc6(%rip), %rax # 0x36d9b0
incq (%rax)
movq (%rcx), %rax
movl $0x3, 0x8(%rax,%rsi)
jmp 0x31e37
callq 0x24050
movl (%rax), %r12d
callq 0x2bff6
movl %r12d, (%rax)
testb $0x19, %r14b
je 0x31e37
callq 0x2bff6
movl (%rax), %ecx
movl $0x4, %esi
movl $0x1, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x27c17
jmp 0x31e37
leaq 0x33bb6c(%rip), %rax # 0x36d9a0
incq (%rax)
movq %fs:0x28, %rax
cmpq -0x28(%rbp), %rax
jne 0x31e56
movq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x24400
|
my_fopen:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 20h
mov r14, rdx
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_28], rax
test sil, 1
jnz short loc_31D3C
test sil, 2
jnz short loc_31D56
lea rax, [rbp+var_31]
mov byte ptr [rax-1], 72h ; 'r'
jmp short loc_31D80
loc_31D3C:
bt esi, 0Ah
mov eax, 77h ; 'w'
mov ecx, 61h ; 'a'
cmovnb ecx, eax
lea rax, [rbp+var_31]
mov [rax-1], cl
jmp short loc_31D80
loc_31D56:
bt esi, 0Ah
mov eax, 72h ; 'r'
mov ecx, 61h ; 'a'
cmovnb ecx, eax
test esi, 240h
mov edx, 77h ; 'w'
cmovz edx, ecx
lea rax, [rbp+var_30]
mov [rax-2], dl
mov byte ptr [rax-1], 2Bh ; '+'
loc_31D80:
mov word ptr [rax], 65h ; 'e'
lea rsi, [rbp+var_32]
mov rdi, rbx
call _fopen64
mov r15, rax
test rax, rax
jz short loc_31DFA
mov rdi, r15
call my_fileno
mov r12d, eax
lea rax, my_file_limit
cmp r12d, [rax]
jnb short loc_31E2D
lea rax, key_memory_my_file_info
mov edi, [rax]
mov rsi, rbx
mov rdx, r14
call my_strdup
lea rcx, my_file_info
mov rdx, [rcx]
movsxd rsi, r12d
shl rsi, 4
mov [rdx+rsi], rax
lea rax, my_stream_opened
inc qword ptr [rax]
lea rax, my_file_total_opened
inc qword ptr [rax]
mov rax, [rcx]
mov dword ptr [rax+rsi+8], 3
jmp short loc_31E37
loc_31DFA:
call ___errno_location
mov r12d, [rax]
call _my_thread_var
mov [rax], r12d
test r14b, 19h
jz short loc_31E37
call _my_thread_var
mov ecx, [rax]
mov esi, 4
mov edi, 1
mov rdx, rbx
xor eax, eax
call my_error
jmp short loc_31E37
loc_31E2D:
lea rax, my_stream_opened
inc qword ptr [rax]
loc_31E37:
mov rax, fs:28h
cmp rax, [rbp+var_28]
jnz short loc_31E56
mov rax, r15
add rsp, 20h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_31E56:
call ___stack_chk_fail
|
long long my_fopen(long long a1, __int16 a2, int a3)
{
char *v4; // rax
char v5; // cl
char v6; // cl
char v7; // dl
long long v8; // rax
long long v9; // r15
unsigned int v10; // r12d
long long v11; // rsi
int v12; // r12d
unsigned int *v13; // rax
char v15; // [rsp+Eh] [rbp-32h] BYREF
char v16; // [rsp+Fh] [rbp-31h] BYREF
char v17; // [rsp+10h] [rbp-30h] BYREF
unsigned long long v18; // [rsp+18h] [rbp-28h]
v18 = __readfsqword(0x28u);
if ( (a2 & 1) != 0 )
{
v5 = 97;
if ( (a2 & 0x400) == 0 )
v5 = 119;
v4 = &v16;
v15 = v5;
}
else if ( (a2 & 2) != 0 )
{
v6 = 97;
if ( (a2 & 0x400) == 0 )
v6 = 114;
v7 = 119;
if ( (a2 & 0x240) == 0 )
v7 = v6;
v4 = &v17;
v15 = v7;
v16 = 43;
}
else
{
v4 = &v16;
v15 = 114;
}
*(_WORD *)v4 = 101;
v8 = fopen64(a1, &v15);
v9 = v8;
if ( v8 )
{
v10 = my_fileno(v8);
if ( v10 >= my_file_limit )
{
++my_stream_opened;
}
else
{
v11 = 16LL * (int)v10;
*(_QWORD *)((char *)my_file_info + v11) = my_strdup(key_memory_my_file_info, a1, a3);
++my_stream_opened;
++my_file_total_opened;
*(_DWORD *)((char *)my_file_info + v11 + 8) = 3;
}
}
else
{
v12 = *(_DWORD *)__errno_location(a1);
*(_DWORD *)my_thread_var() = v12;
if ( (a3 & 0x19) != 0 )
{
v13 = (unsigned int *)my_thread_var();
my_error(1u, 4LL, a1, *v13);
}
}
return v9;
}
|
my_fopen:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV R14,RDX
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
TEST SIL,0x1
JNZ 0x00131d3c
TEST SIL,0x2
JNZ 0x00131d56
LEA RAX,[RBP + -0x31]
MOV byte ptr [RAX + -0x1],0x72
JMP 0x00131d80
LAB_00131d3c:
BT ESI,0xa
MOV EAX,0x77
MOV ECX,0x61
CMOVNC ECX,EAX
LEA RAX,[RBP + -0x31]
MOV byte ptr [RAX + -0x1],CL
JMP 0x00131d80
LAB_00131d56:
BT ESI,0xa
MOV EAX,0x72
MOV ECX,0x61
CMOVNC ECX,EAX
TEST ESI,0x240
MOV EDX,0x77
CMOVZ EDX,ECX
LEA RAX,[RBP + -0x30]
MOV byte ptr [RAX + -0x2],DL
MOV byte ptr [RAX + -0x1],0x2b
LAB_00131d80:
MOV word ptr [RAX],0x65
LEA RSI,[RBP + -0x32]
MOV RDI,RBX
CALL 0x00124410
MOV R15,RAX
TEST RAX,RAX
JZ 0x00131dfa
MOV RDI,R15
CALL 0x0013215a
MOV R12D,EAX
LEA RAX,[0x3f6950]
CMP R12D,dword ptr [RAX]
JNC 0x00131e2d
LEA RAX,[0x46def4]
MOV EDI,dword ptr [RAX]
MOV RSI,RBX
MOV RDX,R14
CALL 0x0012b068
LEA RCX,[0x3f6958]
MOV RDX,qword ptr [RCX]
MOVSXD RSI,R12D
SHL RSI,0x4
MOV qword ptr [RDX + RSI*0x1],RAX
LEA RAX,[0x46d9a0]
INC qword ptr [RAX]
LEA RAX,[0x46d9b0]
INC qword ptr [RAX]
MOV RAX,qword ptr [RCX]
MOV dword ptr [RAX + RSI*0x1 + 0x8],0x3
JMP 0x00131e37
LAB_00131dfa:
CALL 0x00124050
MOV R12D,dword ptr [RAX]
CALL 0x0012bff6
MOV dword ptr [RAX],R12D
TEST R14B,0x19
JZ 0x00131e37
CALL 0x0012bff6
MOV ECX,dword ptr [RAX]
MOV ESI,0x4
MOV EDI,0x1
MOV RDX,RBX
XOR EAX,EAX
CALL 0x00127c17
JMP 0x00131e37
LAB_00131e2d:
LEA RAX,[0x46d9a0]
INC qword ptr [RAX]
LAB_00131e37:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x28]
JNZ 0x00131e56
MOV RAX,R15
ADD RSP,0x20
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00131e56:
CALL 0x00124400
|
FILE * my_fopen(char *param_1,uint param_2,ulong param_3)
{
int iVar1;
uint uVar2;
int2 *puVar3;
FILE *pFVar4;
int8 uVar5;
int *piVar6;
int4 *puVar7;
char cVar8;
long in_FS_OFFSET;
char local_3a;
int1 local_39 [9];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
if ((param_2 & 1) == 0) {
if ((param_2 & 2) == 0) {
puVar3 = (int2 *)local_39;
local_3a = 'r';
}
else {
cVar8 = 'a';
if ((param_2 >> 10 & 1) == 0) {
cVar8 = 'r';
}
local_3a = 'w';
if ((param_2 & 0x240) == 0) {
local_3a = cVar8;
}
puVar3 = (int2 *)(local_39 + 1);
local_39[0] = 0x2b;
}
}
else {
local_3a = 'a';
if ((param_2 >> 10 & 1) == 0) {
local_3a = 'w';
}
puVar3 = (int2 *)local_39;
}
*puVar3 = 0x65;
pFVar4 = fopen64(param_1,&local_3a);
if (pFVar4 == (FILE *)0x0) {
piVar6 = __errno_location();
iVar1 = *piVar6;
piVar6 = (int *)_my_thread_var();
*piVar6 = iVar1;
if ((param_3 & 0x19) != 0) {
puVar7 = (int4 *)_my_thread_var();
my_error(1,4,param_1,*puVar7);
}
}
else {
uVar2 = my_fileno(pFVar4);
if (uVar2 < my_file_limit) {
uVar5 = my_strdup(key_memory_my_file_info,param_1,param_3);
*(int8 *)(my_file_info + (long)(int)uVar2 * 0x10) = uVar5;
my_stream_opened = my_stream_opened + 1;
my_file_total_opened = my_file_total_opened + 1;
*(int4 *)(my_file_info + (long)(int)uVar2 * 0x10 + 8) = 3;
}
else {
my_stream_opened = my_stream_opened + 1;
}
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_30) {
return pFVar4;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
8,105 |
minja::Parser::consumeToken(std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char>> const&, minja::SpaceHandling)
|
monkey531[P]llama/common/minja.hpp
|
std::string consumeToken(const std::regex & regex, SpaceHandling space_handling = SpaceHandling::Strip) {
auto start = it;
consumeSpaces(space_handling);
std::smatch match;
if (std::regex_search(it, end, match, regex) && match.position() == 0) {
it += match[0].length();
return match[0].str();
}
it = start;
return "";
}
|
O3
|
cpp
|
minja::Parser::consumeToken(std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char>> const&, minja::SpaceHandling):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rsi), %r12
movq %rsi, %rdi
movl %ecx, %esi
callq 0x63e14
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq 0x18(%r14), %rsi
movq 0x20(%r14), %rdi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x235db
testb %al, %al
je 0x63089
movq 0x18(%rsp), %rsi
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, %rdx
subq %rax, %rdx
je 0x63070
movq (%rax), %r8
cmpq $0x48, %rdx
jne 0x63081
cmpq %rsi, %r8
jne 0x63089
jmp 0x63077
cmpq %rsi, -0x48(%rax,%rdx)
jne 0x63089
leaq (%rax,%rdx), %rdi
addq $-0x48, %rdi
jmp 0x630cb
movq %rax, %rdi
cmpq %rsi, %r8
je 0x630cb
movq %r12, 0x20(%r14)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x517a2(%rip), %rdx # 0xb483d
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x22878
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x630bc
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x196d0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%rdi), %r8
subq %rsi, %r8
xorl %esi, %esi
cmpb $0x0, 0x10(%rdi)
cmovneq %r8, %rsi
addq %rsi, 0x20(%r14)
cmpq $0x48, %rdx
leaq -0x48(%rax,%rdx), %rsi
movq %rax, %rdx
cmoveq %rsi, %rdx
cmpq %rcx, %rax
cmoveq %rsi, %rdx
cmpb $0x1, 0x10(%rdx)
jne 0x63115
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x47a9a
jmp 0x630a6
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
jmp 0x630a6
jmp 0x6312f
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x63148
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x196d0
movq %rbx, %rdi
callq 0x19c00
|
_ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE:
push r15
push r14
push r12
push rbx
sub rsp, 28h
mov r15, rdx
mov r14, rsi
mov rbx, rdi
mov r12, [rsi+20h]
mov rdi, rsi
mov esi, ecx
call _ZN5minja6Parser13consumeSpacesENS_13SpaceHandlingE; minja::Parser::consumeSpaces(minja::SpaceHandling)
xorps xmm0, xmm0
mov rdx, rsp
movaps xmmword ptr [rdx+10h], xmm0
movaps xmmword ptr [rdx], xmm0
mov rsi, [r14+18h]
mov rdi, [r14+20h]
mov rcx, r15
xor r8d, r8d
call _ZNSt8__detail17__regex_algo_implIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEEcNS5_12regex_traitsIcEELNS_20_RegexExecutorPolicyE0ELb0EEEbT_SI_RNS5_13match_resultsISI_T0_EERKNS5_11basic_regexIT1_T2_EENSt15regex_constants15match_flag_typeE; std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>,(std::__detail::_RegexExecutorPolicy)0,false>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> &,std::basic_regex<char,std::regex_traits<char>> const&,std::regex_constants::match_flag_type)
test al, al
jz short loc_63089
mov rsi, [rsp+48h+var_30]
mov rax, [rsp+48h+var_48]
mov rcx, [rsp+48h+var_40]
mov rdx, rcx
sub rdx, rax
jz short loc_63070
mov r8, [rax]
cmp rdx, 48h ; 'H'
jnz short loc_63081
cmp r8, rsi
jnz short loc_63089
jmp short loc_63077
loc_63070:
cmp [rax+rdx-48h], rsi
jnz short loc_63089
loc_63077:
lea rdi, [rax+rdx]
add rdi, 0FFFFFFFFFFFFFFB8h
jmp short loc_630CB
loc_63081:
mov rdi, rax
cmp r8, rsi
jz short loc_630CB
loc_63089:
mov [r14+20h], r12
lea rax, [rbx+10h]
mov [rbx], rax
lea rdx, asc_B4839+4; ""
mov rdi, rbx
mov rsi, rdx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
loc_630A6:
mov rdi, [rsp+48h+var_48]; void *
test rdi, rdi
jz short loc_630BC
mov rsi, [rsp+48h+var_38]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_630BC:
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r14
pop r15
retn
loc_630CB:
mov r8, [rdi+8]
sub r8, rsi
xor esi, esi
cmp byte ptr [rdi+10h], 0
cmovnz rsi, r8
add [r14+20h], rsi
cmp rdx, 48h ; 'H'
lea rsi, [rax+rdx-48h]
mov rdx, rax
cmovz rdx, rsi
cmp rax, rcx
cmovz rdx, rsi
cmp byte ptr [rdx+10h], 1
jnz short loc_63115
mov rsi, [rdx]
mov rdx, [rdx+8]
lea rax, [rbx+10h]
mov [rbx], rax
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIN9__gnu_cxx17__normal_iteratorIPKcS4_EEEEvT_SB_St20forward_iterator_tag; std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::forward_iterator_tag)
jmp short loc_630A6
loc_63115:
lea rax, [rbx+10h]
mov [rbx], rax
mov qword ptr [rbx+8], 0
mov byte ptr [rbx+10h], 0
jmp loc_630A6
jmp short $+2
loc_6312F:
mov rbx, rax
mov rdi, [rsp+0]; void *
test rdi, rdi
jz short loc_63148
mov rsi, [rsp+arg_8]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_63148:
mov rdi, rbx
call __Unwind_Resume
|
long long minja::Parser::consumeToken(long long a1, long long a2, long long a3, unsigned int a4)
{
long long v7; // r12
__int128 v8; // kr00_16
long long v9; // rdx
long long v10; // r8
long long v11; // rdi
long long v13; // rsi
bool v14; // zf
long long v15; // rsi
long long v16; // rdx
_BYTE *v17; // rsi
long long v18; // rdx
__int128 v19; // [rsp+0h] [rbp-48h] BYREF
__int128 v20; // [rsp+10h] [rbp-38h]
v7 = *(_QWORD *)(a2 + 32);
minja::Parser::consumeSpaces(a2, a4);
v20 = 0LL;
v19 = 0LL;
if ( !std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>,(std::__detail::_RegexExecutorPolicy)0,false>(
*(long long **)(a2 + 32),
*(_QWORD *)(a2 + 24),
(long long **)&v19,
a3,
0) )
goto LABEL_9;
v8 = v19;
v9 = *((_QWORD *)&v19 + 1) - v19;
if ( *((_QWORD *)&v19 + 1) != (_QWORD)v19 )
{
v10 = *(_QWORD *)v19;
if ( v9 == 72 )
{
if ( v10 == *((_QWORD *)&v20 + 1) )
goto LABEL_7;
}
else
{
v11 = v19;
if ( v10 == *((_QWORD *)&v20 + 1) )
goto LABEL_13;
}
LABEL_9:
*(_QWORD *)(a2 + 32) = v7;
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<char const*>(a1, "", (long long)"");
goto LABEL_10;
}
if ( *(_QWORD *)(*((_QWORD *)&v19 + 1) - 72LL) != *((_QWORD *)&v20 + 1) )
goto LABEL_9;
LABEL_7:
v11 = *((_QWORD *)&v19 + 1) - 72LL;
LABEL_13:
v13 = 0LL;
if ( *(_BYTE *)(v11 + 16) )
v13 = *(_QWORD *)(v11 + 8) - *((_QWORD *)&v20 + 1);
*(_QWORD *)(a2 + 32) += v13;
v14 = v9 == 72;
v15 = v8 + v9 - 72;
v16 = v8;
if ( v14 )
v16 = v15;
if ( (_QWORD)v8 == *((_QWORD *)&v8 + 1) )
v16 = v15;
if ( *(_BYTE *)(v16 + 16) == 1 )
{
v17 = *(_BYTE **)v16;
v18 = *(_QWORD *)(v16 + 8);
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(a1, v17, v18);
}
else
{
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
}
LABEL_10:
if ( (_QWORD)v19 )
operator delete((void *)v19, v20 - v19);
return a1;
}
|
consumeToken:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
MOV R12,qword ptr [RSI + 0x20]
MOV RDI,RSI
MOV ESI,ECX
CALL 0x00163e14
XORPS XMM0,XMM0
MOV RDX,RSP
MOVAPS xmmword ptr [RDX + 0x10],XMM0
MOVAPS xmmword ptr [RDX],XMM0
MOV RSI,qword ptr [R14 + 0x18]
MOV RDI,qword ptr [R14 + 0x20]
LAB_0016303b:
MOV RCX,R15
XOR R8D,R8D
CALL 0x001235db
TEST AL,AL
JZ 0x00163089
MOV RSI,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [RSP + 0x8]
MOV RDX,RCX
SUB RDX,RAX
JZ 0x00163070
MOV R8,qword ptr [RAX]
CMP RDX,0x48
JNZ 0x00163081
CMP R8,RSI
JNZ 0x00163089
JMP 0x00163077
LAB_00163070:
CMP qword ptr [RAX + RDX*0x1 + -0x48],RSI
JNZ 0x00163089
LAB_00163077:
LEA RDI,[RAX + RDX*0x1]
ADD RDI,-0x48
JMP 0x001630cb
LAB_00163081:
MOV RDI,RAX
CMP R8,RSI
JZ 0x001630cb
LAB_00163089:
MOV qword ptr [R14 + 0x20],R12
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LAB_00163094:
LEA RDX,[0x1b483d]
MOV RDI,RBX
MOV RSI,RDX
CALL 0x00122878
LAB_001630a6:
MOV RDI,qword ptr [RSP]
TEST RDI,RDI
JZ 0x001630bc
MOV RSI,qword ptr [RSP + 0x10]
SUB RSI,RDI
CALL 0x001196d0
LAB_001630bc:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R14
POP R15
RET
LAB_001630cb:
MOV R8,qword ptr [RDI + 0x8]
SUB R8,RSI
XOR ESI,ESI
CMP byte ptr [RDI + 0x10],0x0
CMOVNZ RSI,R8
ADD qword ptr [R14 + 0x20],RSI
CMP RDX,0x48
LEA RSI,[RAX + RDX*0x1 + -0x48]
MOV RDX,RAX
CMOVZ RDX,RSI
CMP RAX,RCX
CMOVZ RDX,RSI
CMP byte ptr [RDX + 0x10],0x1
JNZ 0x00163115
MOV RSI,qword ptr [RDX]
MOV RDX,qword ptr [RDX + 0x8]
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LAB_0016310b:
MOV RDI,RBX
CALL 0x00147a9a
LAB_00163113:
JMP 0x001630a6
LAB_00163115:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
MOV qword ptr [RBX + 0x8],0x0
MOV byte ptr [RBX + 0x10],0x0
JMP 0x001630a6
|
/* minja::Parser::consumeToken(std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char> >
const&, minja::SpaceHandling) */
long * minja::Parser::consumeToken
(long *param_1,Parser *param_2,int8 param_3,int4 param_4)
{
int8 uVar1;
bool bVar2;
long lVar3;
long *plVar4;
long lVar5;
long *plVar6;
long *local_48;
long *plStack_40;
long local_38;
long lStack_30;
uVar1 = *(int8 *)(param_2 + 0x20);
consumeSpaces(param_2,param_4);
local_38 = 0;
lStack_30 = 0;
local_48 = (long *)0x0;
plStack_40 = (long *)0x0;
/* try { // try from 0016303b to 00163045 has its CatchHandler @ 0016312f */
bVar2 = std::__detail::
__regex_algo_impl<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>,char,std::__cxx11::regex_traits<char>,(std::__detail::_RegexExecutorPolicy)0,false>
(*(int8 *)(param_2 + 0x20),*(int8 *)(param_2 + 0x18),&local_48,
param_3,0);
if (bVar2) {
lVar3 = (long)plStack_40 - (long)local_48;
if (lVar3 == 0) {
lVar5 = local_48[-9];
joined_r0x00163075:
if (lVar5 != lStack_30) goto LAB_00163089;
plVar6 = (long *)((long)local_48 + lVar3 + -0x48);
}
else {
lVar5 = *local_48;
if (lVar3 == 0x48) goto joined_r0x00163075;
plVar6 = local_48;
if (lVar5 != lStack_30) goto LAB_00163089;
}
lVar5 = 0;
if ((char)plVar6[2] != '\0') {
lVar5 = plVar6[1] - lStack_30;
}
*(long *)(param_2 + 0x20) = *(long *)(param_2 + 0x20) + lVar5;
plVar6 = (long *)((long)local_48 + lVar3 + -0x48);
plVar4 = local_48;
if (lVar3 == 0x48) {
plVar4 = plVar6;
}
if (local_48 == plStack_40) {
plVar4 = plVar6;
}
if ((char)plVar4[2] == '\x01') {
lVar3 = *plVar4;
lVar5 = plVar4[1];
*param_1 = (long)(param_1 + 2);
/* try { // try from 0016310b to 00163112 has its CatchHandler @ 0016312f */
std::__cxx11::string::
_M_construct<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>
(param_1,lVar3,lVar5);
}
else {
*param_1 = (long)(param_1 + 2);
param_1[1] = 0;
*(int1 *)(param_1 + 2) = 0;
}
}
else {
LAB_00163089:
*(int8 *)(param_2 + 0x20) = uVar1;
*param_1 = (long)(param_1 + 2);
/* try { // try from 00163094 to 001630a5 has its CatchHandler @ 0016312d */
std::__cxx11::string::_M_construct<char_const*>(param_1,&DAT_001b483d);
}
if (local_48 != (long *)0x0) {
operator_delete(local_48,local_38 - (long)local_48);
}
return param_1;
}
|
|
8,106 |
ggml_custom_4d
|
ngxson[P]ggml-easy/ggml/src/ggml.c
|
struct ggml_tensor * ggml_custom_4d(
struct ggml_context * ctx,
enum ggml_type type,
int64_t ne0,
int64_t ne1,
int64_t ne2,
int64_t ne3,
struct ggml_tensor ** args,
int n_args,
ggml_custom_op_t fun,
int n_tasks,
void * userdata) {
GGML_ASSERT(n_args < GGML_MAX_SRC);
struct ggml_tensor * result = ggml_new_tensor_4d(ctx, type, ne0, ne1, ne2, ne3);
struct ggml_custom_op_params params = {
/*.fun =*/ fun,
/*.n_tasks =*/ n_tasks,
/*.userdata =*/ userdata
};
ggml_set_op_params(result, ¶ms, sizeof(params));
result->op = GGML_OP_CUSTOM;
for (int i = 0; i < n_args; i++) {
result->src[i] = args[i];
}
return result;
}
|
O1
|
c
|
ggml_custom_4d:
pushq %rbx
subq $0x20, %rsp
movl 0x38(%rsp), %ebx
cmpl $0xa, %ebx
jge 0x1fb36
movq %rsp, %rax
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
movq %r8, 0x10(%rax)
movq %r9, 0x18(%rax)
movl $0x4, %edx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x19cd9
testq %rax, %rax
je 0x1fb52
movq 0x50(%rsp), %rcx
movl 0x48(%rsp), %edx
movq 0x40(%rsp), %rsi
movq %rsi, 0x54(%rax)
movl %edx, 0x5c(%rax)
movq %rcx, 0x64(%rax)
movl $0x4e, 0x50(%rax)
testl %ebx, %ebx
jle 0x1fb30
movq 0x30(%rsp), %rcx
movl %ebx, %edx
xorl %esi, %esi
movq (%rcx,%rsi,8), %rdi
movq %rdi, 0x98(%rax,%rsi,8)
incq %rsi
cmpq %rsi, %rdx
jne 0x1fb1c
addq $0x20, %rsp
popq %rbx
retq
leaq 0x2aad2(%rip), %rdi # 0x4a60f
leaq 0x2ab16(%rip), %rdx # 0x4a65a
leaq 0x2b87f(%rip), %rcx # 0x4b3ca
movl $0x13b6, %esi # imm = 0x13B6
jmp 0x1fb6c
leaq 0x2cc7f(%rip), %rdi # 0x4c7d8
leaq 0x2aafa(%rip), %rdx # 0x4a65a
leaq 0x2ccc1(%rip), %rcx # 0x4c828
movl $0x70, %esi
xorl %eax, %eax
callq 0x17c70
|
ggml_custom_4d:
push rbx
sub rsp, 20h
mov ebx, [rsp+28h+arg_8]
cmp ebx, 0Ah
jge short loc_1FB36
mov rax, rsp
mov [rax], rdx
mov [rax+8], rcx
mov [rax+10h], r8
mov [rax+18h], r9
mov edx, 4
mov rcx, rax
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
test rax, rax
jz short loc_1FB52
mov rcx, [rsp+28h+arg_20]
mov edx, [rsp+28h+arg_18]
mov rsi, [rsp+28h+arg_10]
mov [rax+54h], rsi
mov [rax+5Ch], edx
mov [rax+64h], rcx
mov dword ptr [rax+50h], 4Eh ; 'N'
test ebx, ebx
jle short loc_1FB30
mov rcx, [rsp+28h+arg_0]
mov edx, ebx
xor esi, esi
loc_1FB1C:
mov rdi, [rcx+rsi*8]
mov [rax+rsi*8+98h], rdi
inc rsi
cmp rdx, rsi
jnz short loc_1FB1C
loc_1FB30:
add rsp, 20h
pop rbx
retn
loc_1FB36:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aNArgsGgmlMaxSr; "n_args < GGML_MAX_SRC"
mov esi, 13B6h
jmp short loc_1FB6C
loc_1FB52:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aTensorNull; "tensor != NULL"
mov esi, 70h ; 'p'
loc_1FB6C:
xor eax, eax
call _ggml_abort
|
long long ggml_custom_4d(
long long a1,
unsigned int a2,
long long a3,
long long a4,
long long a5,
long long a6,
long long a7,
int a8,
long long a9,
int a10,
long long a11)
{
long long result; // rax
long long i; // rsi
const char *v13; // rdi
const char *v14; // rcx
int v15; // esi
_QWORD v16[5]; // [rsp+0h] [rbp-28h] BYREF
if ( a8 >= 10 )
{
v13 = "/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c";
v14 = "n_args < GGML_MAX_SRC";
v15 = 5046;
goto LABEL_9;
}
v16[0] = a3;
v16[1] = a4;
v16[2] = a5;
v16[3] = a6;
result = ggml_new_tensor_impl(a1, a2, 4, v16, 0LL, 0LL);
if ( !result )
{
v13 = "/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml-impl.h";
v14 = "tensor != NULL";
v15 = 112;
LABEL_9:
ggml_abort((_DWORD)v13, v15, (unsigned int)"GGML_ASSERT(%s) failed", (_DWORD)v14, a5, a6);
}
*(_QWORD *)(result + 84) = a9;
*(_DWORD *)(result + 92) = a10;
*(_QWORD *)(result + 100) = a11;
*(_DWORD *)(result + 80) = 78;
if ( a8 > 0 )
{
for ( i = 0LL; i != a8; ++i )
*(_QWORD *)(result + 8 * i + 152) = *(_QWORD *)(a7 + 8 * i);
}
return result;
}
|
ggml_custom_4d:
PUSH RBX
SUB RSP,0x20
MOV EBX,dword ptr [RSP + 0x38]
CMP EBX,0xa
JGE 0x0011fb36
MOV RAX,RSP
MOV qword ptr [RAX],RDX
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [RAX + 0x10],R8
MOV qword ptr [RAX + 0x18],R9
MOV EDX,0x4
MOV RCX,RAX
XOR R8D,R8D
XOR R9D,R9D
CALL 0x00119cd9
TEST RAX,RAX
JZ 0x0011fb52
MOV RCX,qword ptr [RSP + 0x50]
MOV EDX,dword ptr [RSP + 0x48]
MOV RSI,qword ptr [RSP + 0x40]
MOV qword ptr [RAX + 0x54],RSI
MOV dword ptr [RAX + 0x5c],EDX
MOV qword ptr [RAX + 0x64],RCX
MOV dword ptr [RAX + 0x50],0x4e
TEST EBX,EBX
JLE 0x0011fb30
MOV RCX,qword ptr [RSP + 0x30]
MOV EDX,EBX
XOR ESI,ESI
LAB_0011fb1c:
MOV RDI,qword ptr [RCX + RSI*0x8]
MOV qword ptr [RAX + RSI*0x8 + 0x98],RDI
INC RSI
CMP RDX,RSI
JNZ 0x0011fb1c
LAB_0011fb30:
ADD RSP,0x20
POP RBX
RET
LAB_0011fb36:
LEA RDI,[0x14a60f]
LEA RDX,[0x14a65a]
LEA RCX,[0x14b3ca]
MOV ESI,0x13b6
JMP 0x0011fb6c
LAB_0011fb52:
LEA RDI,[0x14c7d8]
LEA RDX,[0x14a65a]
LEA RCX,[0x14c828]
MOV ESI,0x70
LAB_0011fb6c:
XOR EAX,EAX
CALL 0x00117c70
|
void ggml_custom_4d(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,long param_7,uint param_8,
int8 param_9,int4 param_10,int8 param_11)
{
long lVar1;
char *pcVar2;
ulong uVar3;
int8 uVar4;
char *pcVar5;
int8 local_28;
int8 local_20;
int8 local_18;
int8 local_10;
if ((int)param_8 < 10) {
local_28 = param_3;
local_20 = param_4;
local_18 = param_5;
local_10 = param_6;
lVar1 = ggml_new_tensor_impl(param_1,param_2,4,&local_28,0,0);
if (lVar1 != 0) {
*(int8 *)(lVar1 + 0x54) = param_9;
*(int4 *)(lVar1 + 0x5c) = param_10;
*(int8 *)(lVar1 + 100) = param_11;
*(int4 *)(lVar1 + 0x50) = 0x4e;
if (0 < (int)param_8) {
uVar3 = 0;
do {
*(int8 *)(lVar1 + 0x98 + uVar3 * 8) = *(int8 *)(param_7 + uVar3 * 8);
uVar3 = uVar3 + 1;
} while (param_8 != uVar3);
}
return;
}
pcVar5 = "/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml-impl.h";
pcVar2 = "tensor != NULL";
uVar4 = 0x70;
}
else {
pcVar5 = "/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c";
pcVar2 = "n_args < GGML_MAX_SRC";
uVar4 = 0x13b6;
}
/* WARNING: Subroutine does not return */
ggml_abort(pcVar5,uVar4,"GGML_ASSERT(%s) failed",pcVar2);
}
|
|
8,107 |
ggml_custom_4d
|
ngxson[P]ggml-easy/ggml/src/ggml.c
|
struct ggml_tensor * ggml_custom_4d(
struct ggml_context * ctx,
enum ggml_type type,
int64_t ne0,
int64_t ne1,
int64_t ne2,
int64_t ne3,
struct ggml_tensor ** args,
int n_args,
ggml_custom_op_t fun,
int n_tasks,
void * userdata) {
GGML_ASSERT(n_args < GGML_MAX_SRC);
struct ggml_tensor * result = ggml_new_tensor_4d(ctx, type, ne0, ne1, ne2, ne3);
struct ggml_custom_op_params params = {
/*.fun =*/ fun,
/*.n_tasks =*/ n_tasks,
/*.userdata =*/ userdata
};
ggml_set_op_params(result, ¶ms, sizeof(params));
result->op = GGML_OP_CUSTOM;
for (int i = 0; i < n_args; i++) {
result->src[i] = args[i];
}
return result;
}
|
O2
|
c
|
ggml_custom_4d:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl 0x58(%rsp), %r14d
cmpl $0xa, %r14d
jge 0x254de
movq 0x70(%rsp), %r12
movl 0x68(%rsp), %ebp
movq 0x60(%rsp), %r13
movq 0x50(%rsp), %r15
callq 0x1edb0
movq %rax, %rbx
movq %rsp, %rsi
movq %r13, (%rsi)
movl %ebp, 0x8(%rsi)
movq %r12, 0x10(%rsi)
pushq $0x18
popq %rdx
movq %rax, %rdi
callq 0x20fbc
movl $0x4e, 0x50(%rbx)
xorl %eax, %eax
testl %r14d, %r14d
cmovlel %eax, %r14d
cmpq %rax, %r14
je 0x254cc
movq (%r15,%rax,8), %rcx
movq %rcx, 0x98(%rbx,%rax,8)
incq %rax
jmp 0x254b6
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2609e(%rip), %rdi # 0x4b583
leaq 0x260e2(%rip), %rdx # 0x4b5ce
leaq 0x26e4b(%rip), %rcx # 0x4c33e
movl $0x13b6, %esi # imm = 0x13B6
xorl %eax, %eax
callq 0x1e770
|
ggml_custom_4d:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r14d, [rsp+48h+arg_8]
cmp r14d, 0Ah
jge short loc_254DE
mov r12, [rsp+48h+arg_20]
mov ebp, [rsp+48h+arg_18]
mov r13, [rsp+48h+arg_10]
mov r15, [rsp+48h+arg_0]
call _ggml_new_tensor_4d
mov rbx, rax
mov rsi, rsp
mov [rsi], r13
mov [rsi+8], ebp
mov [rsi+10h], r12
push 18h
pop rdx
mov rdi, rax
call ggml_set_op_params
mov dword ptr [rbx+50h], 4Eh ; 'N'
xor eax, eax
test r14d, r14d
cmovle r14d, eax
loc_254B6:
cmp r14, rax
jz short loc_254CC
mov rcx, [r15+rax*8]
mov [rbx+rax*8+98h], rcx
inc rax
jmp short loc_254B6
loc_254CC:
mov rax, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_254DE:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aNArgsGgmlMaxSr; "n_args < GGML_MAX_SRC"
mov esi, 13B6h
xor eax, eax
call _ggml_abort
|
long long ggml_custom_4d(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
long long a15,
int a16,
long long a17,
int a18,
long long a19)
{
long long v19; // r14
long long v20; // rbx
long long v21; // rcx
long long v22; // r8
long long v23; // r9
__m128 v24; // xmm4
__m128 v25; // xmm5
long long v26; // rax
long long v28; // [rsp+0h] [rbp-48h] BYREF
int v29; // [rsp+8h] [rbp-40h]
long long v30; // [rsp+10h] [rbp-38h]
v19 = (unsigned int)a16;
if ( a16 >= 10 )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c",
5046,
(long long)"GGML_ASSERT(%s) failed",
(long long)"n_args < GGML_MAX_SRC",
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v28);
v20 = ggml_new_tensor_4d(a1, a2, a3, a4, a5, a6);
v28 = a17;
v29 = a18;
v30 = a19;
ggml_set_op_params(v20, (long long)&v28, 24LL, a7, a8, a9, a10, v24, v25, a13, a14, v21, v22, v23);
*(_DWORD *)(v20 + 80) = 78;
v26 = 0LL;
if ( a16 <= 0 )
v19 = 0LL;
while ( v19 != v26 )
{
*(_QWORD *)(v20 + 8 * v26 + 152) = *(_QWORD *)(a15 + 8 * v26);
++v26;
}
return v20;
}
|
ggml_custom_4d:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R14D,dword ptr [RSP + 0x58]
CMP R14D,0xa
JGE 0x001254de
MOV R12,qword ptr [RSP + 0x70]
MOV EBP,dword ptr [RSP + 0x68]
MOV R13,qword ptr [RSP + 0x60]
MOV R15,qword ptr [RSP + 0x50]
CALL 0x0011edb0
MOV RBX,RAX
MOV RSI,RSP
MOV qword ptr [RSI],R13
MOV dword ptr [RSI + 0x8],EBP
MOV qword ptr [RSI + 0x10],R12
PUSH 0x18
POP RDX
MOV RDI,RAX
CALL 0x00120fbc
MOV dword ptr [RBX + 0x50],0x4e
XOR EAX,EAX
TEST R14D,R14D
CMOVLE R14D,EAX
LAB_001254b6:
CMP R14,RAX
JZ 0x001254cc
MOV RCX,qword ptr [R15 + RAX*0x8]
MOV qword ptr [RBX + RAX*0x8 + 0x98],RCX
INC RAX
JMP 0x001254b6
LAB_001254cc:
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001254de:
LEA RDI,[0x14b583]
LEA RDX,[0x14b5ce]
LEA RCX,[0x14c33e]
MOV ESI,0x13b6
XOR EAX,EAX
CALL 0x0011e770
|
long ggml_custom_4d(void)
{
long lVar1;
ulong uVar2;
ulong uVar3;
long in_stack_00000008;
uint in_stack_00000010;
int8 in_stack_00000018;
int4 in_stack_00000020;
int8 in_stack_00000028;
int8 local_48;
int4 local_40;
int8 local_38;
if ((int)in_stack_00000010 < 10) {
lVar1 = ggml_new_tensor_4d();
local_48 = in_stack_00000018;
local_40 = in_stack_00000020;
local_38 = in_stack_00000028;
ggml_set_op_params(lVar1,&local_48,0x18);
*(int4 *)(lVar1 + 0x50) = 0x4e;
uVar2 = 0;
uVar3 = (ulong)in_stack_00000010;
if ((int)in_stack_00000010 < 1) {
uVar3 = uVar2;
}
for (; uVar3 != uVar2; uVar2 = uVar2 + 1) {
*(int8 *)(lVar1 + 0x98 + uVar2 * 8) = *(int8 *)(in_stack_00000008 + uVar2 * 8);
}
return lVar1;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c",0x13b6,
"GGML_ASSERT(%s) failed","n_args < GGML_MAX_SRC");
}
|
|
8,108 |
js_bound_function_mark
|
bluesky950520[P]quickjs/quickjs.c
|
static void js_bound_function_mark(JSRuntime *rt, JSValue val,
JS_MarkFunc *mark_func)
{
JSObject *p = JS_VALUE_GET_OBJ(val);
JSBoundFunction *bf = p->u.bound_function;
int i;
JS_MarkValue(rt, bf->func_obj, mark_func);
JS_MarkValue(rt, bf->this_val, mark_func);
for(i = 0; i < bf->argc; i++)
JS_MarkValue(rt, bf->argv[i], mark_func);
}
|
O1
|
c
|
js_bound_function_mark:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movl $0xfffffffe, %r15d # imm = 0xFFFFFFFE
movq 0x30(%rsi), %r12
movsd (%r12), %xmm0
movl 0x8(%r12), %eax
movsd %xmm0, (%rsp)
andl $-0x2, %eax
cmpl %r15d, %eax
jne 0x3aa56
movq (%rsp), %rsi
movq %r14, %rdi
callq *%rbx
movsd 0x10(%r12), %xmm0
movl 0x18(%r12), %eax
movsd %xmm0, (%rsp)
andl $-0x2, %eax
cmpl %r15d, %eax
jne 0x3aa78
movq (%rsp), %rsi
movq %r14, %rdi
callq *%rbx
cmpl $0x0, 0x20(%r12)
jle 0x3aab8
leaq 0x30(%r12), %r13
xorl %ebp, %ebp
movsd -0x8(%r13), %xmm0
movl (%r13), %eax
movsd %xmm0, (%rsp)
andl $-0x2, %eax
cmpl %r15d, %eax
jne 0x3aaa7
movq (%rsp), %rsi
movq %r14, %rdi
callq *%rbx
incq %rbp
movslq 0x20(%r12), %rax
addq $0x10, %r13
cmpq %rax, %rbp
jl 0x3aa87
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
js_bound_function_mark:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rcx
mov r14, rdi
mov r15d, 0FFFFFFFEh
mov r12, [rsi+30h]
movsd xmm0, qword ptr [r12]
mov eax, [r12+8]
movsd [rsp+38h+var_38], xmm0
and eax, 0FFFFFFFEh
cmp eax, r15d
jnz short loc_3AA56
mov rsi, [rsp+38h+var_38]
mov rdi, r14
call rbx
loc_3AA56:
movsd xmm0, qword ptr [r12+10h]
mov eax, [r12+18h]
movsd [rsp+38h+var_38], xmm0
and eax, 0FFFFFFFEh
cmp eax, r15d
jnz short loc_3AA78
mov rsi, [rsp+38h+var_38]
mov rdi, r14
call rbx
loc_3AA78:
cmp dword ptr [r12+20h], 0
jle short loc_3AAB8
lea r13, [r12+30h]
xor ebp, ebp
loc_3AA87:
movsd xmm0, qword ptr [r13-8]
mov eax, [r13+0]
movsd [rsp+38h+var_38], xmm0
and eax, 0FFFFFFFEh
cmp eax, r15d
jnz short loc_3AAA7
mov rsi, [rsp+38h+var_38]
mov rdi, r14
call rbx
loc_3AAA7:
inc rbp
movsxd rax, dword ptr [r12+20h]
add r13, 10h
cmp rbp, rax
jl short loc_3AA87
loc_3AAB8:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long js_bound_function_mark(long long a1, long long a2, long long a3, void ( *a4)(long long, _QWORD))
{
long long v5; // r12
long long result; // rax
_DWORD *v7; // r13
long long v8; // rbp
v5 = *(_QWORD *)(a2 + 48);
if ( (*(_DWORD *)(v5 + 8) & 0xFFFFFFFE) == 0xFFFFFFFE )
a4(a1, *(_QWORD *)v5);
result = *(_DWORD *)(v5 + 24) & 0xFFFFFFFE;
if ( (_DWORD)result == -2 )
result = ((long long ( *)(long long, _QWORD))a4)(a1, *(_QWORD *)(v5 + 16));
if ( *(int *)(v5 + 32) > 0 )
{
v7 = (_DWORD *)(v5 + 48);
v8 = 0LL;
do
{
if ( (*v7 & 0xFFFFFFFE) == 0xFFFFFFFE )
a4(a1, *((_QWORD *)v7 - 1));
++v8;
result = *(int *)(v5 + 32);
v7 += 4;
}
while ( v8 < result );
}
return result;
}
|
js_bound_function_mark:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R14,RDI
MOV R15D,0xfffffffe
MOV R12,qword ptr [RSI + 0x30]
MOVSD XMM0,qword ptr [R12]
MOV EAX,dword ptr [R12 + 0x8]
MOVSD qword ptr [RSP],XMM0
AND EAX,0xfffffffe
CMP EAX,R15D
JNZ 0x0013aa56
MOV RSI,qword ptr [RSP]
MOV RDI,R14
CALL RBX
LAB_0013aa56:
MOVSD XMM0,qword ptr [R12 + 0x10]
MOV EAX,dword ptr [R12 + 0x18]
MOVSD qword ptr [RSP],XMM0
AND EAX,0xfffffffe
CMP EAX,R15D
JNZ 0x0013aa78
MOV RSI,qword ptr [RSP]
MOV RDI,R14
CALL RBX
LAB_0013aa78:
CMP dword ptr [R12 + 0x20],0x0
JLE 0x0013aab8
LEA R13,[R12 + 0x30]
XOR EBP,EBP
LAB_0013aa87:
MOVSD XMM0,qword ptr [R13 + -0x8]
MOV EAX,dword ptr [R13]
MOVSD qword ptr [RSP],XMM0
AND EAX,0xfffffffe
CMP EAX,R15D
JNZ 0x0013aaa7
MOV RSI,qword ptr [RSP]
MOV RDI,R14
CALL RBX
LAB_0013aaa7:
INC RBP
MOVSXD RAX,dword ptr [R12 + 0x20]
ADD R13,0x10
CMP RBP,RAX
JL 0x0013aa87
LAB_0013aab8:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void js_bound_function_mark(int8 param_1,long param_2,int8 param_3,code *param_4)
{
int8 *puVar1;
long lVar2;
uint *puVar3;
puVar1 = *(int8 **)(param_2 + 0x30);
if ((*(uint *)(puVar1 + 1) & 0xfffffffe) == 0xfffffffe) {
(*param_4)(param_1,*puVar1);
}
if ((*(uint *)(puVar1 + 3) & 0xfffffffe) == 0xfffffffe) {
(*param_4)(param_1,puVar1[2]);
}
if (0 < *(int *)(puVar1 + 4)) {
puVar3 = (uint *)(puVar1 + 6);
lVar2 = 0;
do {
if ((*puVar3 & 0xfffffffe) == 0xfffffffe) {
(*param_4)(param_1,*(int8 *)(puVar3 + -2));
}
lVar2 = lVar2 + 1;
puVar3 = puVar3 + 4;
} while (lVar2 < *(int *)(puVar1 + 4));
}
return;
}
|
|
8,109 |
js_bound_function_mark
|
bluesky950520[P]quickjs/quickjs.c
|
static void js_bound_function_mark(JSRuntime *rt, JSValue val,
JS_MarkFunc *mark_func)
{
JSObject *p = JS_VALUE_GET_OBJ(val);
JSBoundFunction *bf = p->u.bound_function;
int i;
JS_MarkValue(rt, bf->func_obj, mark_func);
JS_MarkValue(rt, bf->this_val, mark_func);
for(i = 0; i < bf->argc; i++)
JS_MarkValue(rt, bf->argv[i], mark_func);
}
|
O2
|
c
|
js_bound_function_mark:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movl $0xfffffffe, %r15d # imm = 0xFFFFFFFE
movq 0x30(%rsi), %r12
movl 0x8(%r12), %eax
andl $-0x2, %eax
cmpl %r15d, %eax
jne 0x33ac6
movq (%r12), %rsi
movq %r14, %rdi
callq *%rbx
movl 0x18(%r12), %eax
andl $-0x2, %eax
cmpl %r15d, %eax
jne 0x33add
movq 0x10(%r12), %rsi
movq %r14, %rdi
callq *%rbx
leaq 0x30(%r12), %r13
xorl %ebp, %ebp
movslq 0x20(%r12), %rax
cmpq %rax, %rbp
jge 0x33b0c
movl (%r13), %eax
andl $-0x2, %eax
cmpl %r15d, %eax
jne 0x33b03
movq -0x8(%r13), %rsi
movq %r14, %rdi
callq *%rbx
incq %rbp
addq $0x10, %r13
jmp 0x33ae4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
js_bound_function_mark:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rcx
mov r14, rdi
mov r15d, 0FFFFFFFEh
mov r12, [rsi+30h]
mov eax, [r12+8]
and eax, 0FFFFFFFEh
cmp eax, r15d
jnz short loc_33AC6
mov rsi, [r12]
mov rdi, r14
call rbx
loc_33AC6:
mov eax, [r12+18h]
and eax, 0FFFFFFFEh
cmp eax, r15d
jnz short loc_33ADD
mov rsi, [r12+10h]
mov rdi, r14
call rbx
loc_33ADD:
lea r13, [r12+30h]
xor ebp, ebp
loc_33AE4:
movsxd rax, dword ptr [r12+20h]
cmp rbp, rax
jge short loc_33B0C
mov eax, [r13+0]
and eax, 0FFFFFFFEh
cmp eax, r15d
jnz short loc_33B03
mov rsi, [r13-8]
mov rdi, r14
call rbx
loc_33B03:
inc rbp
add r13, 10h
jmp short loc_33AE4
loc_33B0C:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long js_bound_function_mark(long long a1, long long a2, long long a3, void ( *a4)(long long, _QWORD))
{
long long v5; // r12
_DWORD *v6; // r13
long long i; // rbp
long long result; // rax
v5 = *(_QWORD *)(a2 + 48);
if ( (*(_DWORD *)(v5 + 8) & 0xFFFFFFFE) == 0xFFFFFFFE )
a4(a1, *(_QWORD *)v5);
if ( (*(_DWORD *)(v5 + 24) & 0xFFFFFFFE) == 0xFFFFFFFE )
a4(a1, *(_QWORD *)(v5 + 16));
v6 = (_DWORD *)(v5 + 48);
for ( i = 0LL; ; ++i )
{
result = *(int *)(v5 + 32);
if ( i >= result )
break;
if ( (*v6 & 0xFFFFFFFE) == 0xFFFFFFFE )
a4(a1, *((_QWORD *)v6 - 1));
v6 += 4;
}
return result;
}
|
js_bound_function_mark:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R14,RDI
MOV R15D,0xfffffffe
MOV R12,qword ptr [RSI + 0x30]
MOV EAX,dword ptr [R12 + 0x8]
AND EAX,0xfffffffe
CMP EAX,R15D
JNZ 0x00133ac6
MOV RSI,qword ptr [R12]
MOV RDI,R14
CALL RBX
LAB_00133ac6:
MOV EAX,dword ptr [R12 + 0x18]
AND EAX,0xfffffffe
CMP EAX,R15D
JNZ 0x00133add
MOV RSI,qword ptr [R12 + 0x10]
MOV RDI,R14
CALL RBX
LAB_00133add:
LEA R13,[R12 + 0x30]
XOR EBP,EBP
LAB_00133ae4:
MOVSXD RAX,dword ptr [R12 + 0x20]
CMP RBP,RAX
JGE 0x00133b0c
MOV EAX,dword ptr [R13]
AND EAX,0xfffffffe
CMP EAX,R15D
JNZ 0x00133b03
MOV RSI,qword ptr [R13 + -0x8]
MOV RDI,R14
CALL RBX
LAB_00133b03:
INC RBP
ADD R13,0x10
JMP 0x00133ae4
LAB_00133b0c:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void js_bound_function_mark(int8 param_1,long param_2,int8 param_3,code *param_4)
{
int8 *puVar1;
long lVar2;
uint *puVar3;
puVar1 = *(int8 **)(param_2 + 0x30);
if ((*(uint *)(puVar1 + 1) & 0xfffffffe) == 0xfffffffe) {
(*param_4)(param_1,*puVar1);
}
if ((*(uint *)(puVar1 + 3) & 0xfffffffe) == 0xfffffffe) {
(*param_4)(param_1,puVar1[2]);
}
puVar3 = (uint *)(puVar1 + 6);
for (lVar2 = 0; lVar2 < *(int *)(puVar1 + 4); lVar2 = lVar2 + 1) {
if ((*puVar3 & 0xfffffffe) == 0xfffffffe) {
(*param_4)(param_1,*(int8 *)(puVar3 + -2));
}
puVar3 = puVar3 + 4;
}
return;
}
|
|
8,110 |
js_std_file_close
|
bluesky950520[P]quickjs/quickjs-libc.c
|
static JSValue js_std_file_close(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSRuntime *rt = JS_GetRuntime(ctx);
JSThreadState *ts = js_get_thread_state(rt);
JSSTDFile *s = JS_GetOpaque2(ctx, this_val, ts->std_file_class_id);
int err;
if (!s)
return JS_EXCEPTION;
if (!s->f)
return JS_ThrowTypeError(ctx, "invalid file handle");
if (is_stdio(s->f))
return JS_ThrowTypeError(ctx, "cannot close stdio");
#if !defined(__wasi__)
if (s->is_popen)
err = js_get_errno(pclose(s->f));
else
#endif
err = js_get_errno(fclose(s->f));
s->f = NULL;
return JS_NewInt32(ctx, err);
}
|
O0
|
c
|
js_std_file_close:
subq $0x78, %rsp
movq %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq %rdi, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movq %r8, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x27f00
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x115d0
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0x78(%rax), %ecx
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x383b0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x12959
movl $0x0, 0x48(%rsp)
movq $0x6, 0x50(%rsp)
jmp 0x12a3c
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x12986
movq 0x30(%rsp), %rdi
leaq 0xf72b0(%rip), %rsi # 0x109c20
movb $0x0, %al
callq 0x2d300
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
jmp 0x12a3c
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x12880
cmpl $0x0, %eax
je 0x129ba
movq 0x30(%rsp), %rdi
leaq 0xf7290(%rip), %rsi # 0x109c34
movb $0x0, %al
callq 0x2d300
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
jmp 0x12a3c
movq 0x8(%rsp), %rax
cmpl $0x0, 0x8(%rax)
je 0x129e0
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xe2c0
movslq %eax, %rdi
callq 0x13a50
movl %eax, 0x4(%rsp)
jmp 0x129f9
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xe220
movslq %eax, %rdi
callq 0x13a50
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq 0x30(%rsp), %rcx
movl 0x4(%rsp), %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
movl 0x5c(%rsp), %eax
movl %eax, 0x68(%rsp)
movq $0x0, 0x70(%rsp)
movq 0x68(%rsp), %rcx
movq 0x70(%rsp), %rax
movq %rcx, 0x48(%rsp)
movq %rax, 0x50(%rsp)
movq 0x48(%rsp), %rax
movq 0x50(%rsp), %rdx
addq $0x78, %rsp
retq
nopl (%rax,%rax)
|
js_std_file_close:
sub rsp, 78h
mov [rsp+78h+var_40], rsi
mov [rsp+78h+var_38], rdx
mov [rsp+78h+var_48], rdi
mov [rsp+78h+var_4C], ecx
mov [rsp+78h+var_58], r8
mov rdi, [rsp+78h+var_48]
call JS_GetRuntime
mov [rsp+78h+var_60], rax
mov rdi, [rsp+78h+var_60]
call js_get_thread_state
mov [rsp+78h+var_68], rax
mov rdi, [rsp+78h+var_48]
mov rax, [rsp+78h+var_68]
mov ecx, [rax+78h]
mov rsi, [rsp+78h+var_40]
mov rdx, [rsp+78h+var_38]
call JS_GetOpaque2
mov [rsp+78h+var_70], rax
cmp [rsp+78h+var_70], 0
jnz short loc_12959
mov dword ptr [rsp+78h+var_30], 0
mov [rsp+78h+var_28], 6
jmp loc_12A3C
loc_12959:
mov rax, [rsp+78h+var_70]
cmp qword ptr [rax], 0
jnz short loc_12986
mov rdi, [rsp+78h+var_48]
lea rsi, aInvalidFileHan; "invalid file handle"
mov al, 0
call JS_ThrowTypeError
mov [rsp+78h+var_30], rax
mov [rsp+78h+var_28], rdx
jmp loc_12A3C
loc_12986:
mov rax, [rsp+78h+var_70]
mov rdi, [rax]
call is_stdio
cmp eax, 0
jz short loc_129BA
mov rdi, [rsp+78h+var_48]
lea rsi, aCannotCloseStd; "cannot close stdio"
mov al, 0
call JS_ThrowTypeError
mov [rsp+78h+var_30], rax
mov [rsp+78h+var_28], rdx
jmp loc_12A3C
loc_129BA:
mov rax, [rsp+78h+var_70]
cmp dword ptr [rax+8], 0
jz short loc_129E0
mov rax, [rsp+78h+var_70]
mov rdi, [rax]
call _pclose
movsxd rdi, eax
call js_get_errno
mov [rsp+78h+var_74], eax
jmp short loc_129F9
loc_129E0:
mov rax, [rsp+78h+var_70]
mov rdi, [rax]
call _fclose
movsxd rdi, eax
call js_get_errno
mov [rsp+78h+var_74], eax
loc_129F9:
mov rax, [rsp+78h+var_70]
mov qword ptr [rax], 0
mov rcx, [rsp+78h+var_48]
mov eax, [rsp+78h+var_74]
mov [rsp+78h+var_18], rcx
mov [rsp+78h+var_1C], eax
mov eax, [rsp+78h+var_1C]
mov dword ptr [rsp+78h+var_10], eax
mov [rsp+78h+var_8], 0
mov rcx, [rsp+78h+var_10]
mov rax, [rsp+78h+var_8]
mov [rsp+78h+var_30], rcx
mov [rsp+78h+var_28], rax
loc_12A3C:
mov rax, [rsp+78h+var_30]
mov rdx, [rsp+78h+var_28]
add rsp, 78h
retn
|
long long js_std_file_close(long long a1, long long a2, long long a3)
{
int v3; // edx
int v4; // ecx
int v5; // r8d
int v6; // r9d
int v7; // edx
int v8; // ecx
int v9; // r8d
int v10; // r9d
int v11; // edx
int v12; // ecx
int v13; // r8d
int v14; // r9d
int v15; // eax
int errno; // [rsp+4h] [rbp-74h]
long long *Opaque2; // [rsp+8h] [rbp-70h]
long long thread_state; // [rsp+10h] [rbp-68h]
int Runtime; // [rsp+18h] [rbp-60h]
long long v22; // [rsp+48h] [rbp-30h]
long long v23; // [rsp+68h] [rbp-10h]
Runtime = JS_GetRuntime(a1);
thread_state = js_get_thread_state(Runtime, a2, v3, v4, v5, v6);
Opaque2 = (long long *)JS_GetOpaque2(a1, a2, a3, *(unsigned int *)(thread_state + 120));
if ( Opaque2 )
{
if ( *Opaque2 )
{
if ( is_stdio(*Opaque2) )
{
return JS_ThrowTypeError(a1, (unsigned int)"cannot close stdio", v11, v12, v13, v14);
}
else
{
if ( *((_DWORD *)Opaque2 + 2) )
v15 = pclose(*Opaque2);
else
v15 = fclose(*Opaque2);
errno = js_get_errno(v15);
*Opaque2 = 0LL;
LODWORD(v23) = errno;
return v23;
}
}
else
{
return JS_ThrowTypeError(a1, (unsigned int)"invalid file handle", v7, v8, v9, v10);
}
}
else
{
LODWORD(v22) = 0;
}
return v22;
}
|
js_std_file_close:
SUB RSP,0x78
MOV qword ptr [RSP + 0x38],RSI
MOV qword ptr [RSP + 0x40],RDX
MOV qword ptr [RSP + 0x30],RDI
MOV dword ptr [RSP + 0x2c],ECX
MOV qword ptr [RSP + 0x20],R8
MOV RDI,qword ptr [RSP + 0x30]
CALL 0x00127f00
MOV qword ptr [RSP + 0x18],RAX
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001115d0
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x10]
MOV ECX,dword ptr [RAX + 0x78]
MOV RSI,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x40]
CALL 0x001383b0
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
JNZ 0x00112959
MOV dword ptr [RSP + 0x48],0x0
MOV qword ptr [RSP + 0x50],0x6
JMP 0x00112a3c
LAB_00112959:
MOV RAX,qword ptr [RSP + 0x8]
CMP qword ptr [RAX],0x0
JNZ 0x00112986
MOV RDI,qword ptr [RSP + 0x30]
LEA RSI,[0x209c20]
MOV AL,0x0
CALL 0x0012d300
MOV qword ptr [RSP + 0x48],RAX
MOV qword ptr [RSP + 0x50],RDX
JMP 0x00112a3c
LAB_00112986:
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX]
CALL 0x00112880
CMP EAX,0x0
JZ 0x001129ba
MOV RDI,qword ptr [RSP + 0x30]
LEA RSI,[0x209c34]
MOV AL,0x0
CALL 0x0012d300
MOV qword ptr [RSP + 0x48],RAX
MOV qword ptr [RSP + 0x50],RDX
JMP 0x00112a3c
LAB_001129ba:
MOV RAX,qword ptr [RSP + 0x8]
CMP dword ptr [RAX + 0x8],0x0
JZ 0x001129e0
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX]
CALL 0x0010e2c0
MOVSXD RDI,EAX
CALL 0x00113a50
MOV dword ptr [RSP + 0x4],EAX
JMP 0x001129f9
LAB_001129e0:
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX]
CALL 0x0010e220
MOVSXD RDI,EAX
CALL 0x00113a50
MOV dword ptr [RSP + 0x4],EAX
LAB_001129f9:
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX],0x0
MOV RCX,qword ptr [RSP + 0x30]
MOV EAX,dword ptr [RSP + 0x4]
MOV qword ptr [RSP + 0x60],RCX
MOV dword ptr [RSP + 0x5c],EAX
MOV EAX,dword ptr [RSP + 0x5c]
MOV dword ptr [RSP + 0x68],EAX
MOV qword ptr [RSP + 0x70],0x0
MOV RCX,qword ptr [RSP + 0x68]
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0x48],RCX
MOV qword ptr [RSP + 0x50],RAX
LAB_00112a3c:
MOV RAX,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RSP + 0x50]
ADD RSP,0x78
RET
|
int1 [16] js_std_file_close(int8 param_1,int8 param_2,int8 param_3)
{
int iVar1;
int8 uVar2;
long lVar3;
long *plVar4;
int1 auVar5 [16];
int4 local_74;
int4 local_30;
int4 uStack_2c;
int8 local_28;
int4 uStack_c;
uVar2 = JS_GetRuntime(param_1);
lVar3 = js_get_thread_state(uVar2);
plVar4 = (long *)JS_GetOpaque2(param_1,param_2,param_3,*(int4 *)(lVar3 + 0x78));
if (plVar4 == (long *)0x0) {
local_30 = 0;
local_28 = 6;
}
else if (*plVar4 == 0) {
auVar5 = JS_ThrowTypeError(param_1,"invalid file handle");
local_28 = auVar5._8_8_;
local_30 = auVar5._0_4_;
uStack_2c = auVar5._4_4_;
}
else {
iVar1 = is_stdio(*plVar4);
if (iVar1 == 0) {
if ((int)plVar4[1] == 0) {
iVar1 = fclose((FILE *)*plVar4);
local_74 = js_get_errno((long)iVar1);
}
else {
iVar1 = pclose((FILE *)*plVar4);
local_74 = js_get_errno((long)iVar1);
}
*plVar4 = 0;
local_30 = local_74;
uStack_2c = uStack_c;
local_28 = 0;
}
else {
auVar5 = JS_ThrowTypeError(param_1,"cannot close stdio");
local_28 = auVar5._8_8_;
local_30 = auVar5._0_4_;
uStack_2c = auVar5._4_4_;
}
}
auVar5._4_4_ = uStack_2c;
auVar5._0_4_ = local_30;
auVar5._8_8_ = local_28;
return auVar5;
}
|
|
8,111 |
js_std_file_close
|
bluesky950520[P]quickjs/quickjs-libc.c
|
static JSValue js_std_file_close(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSRuntime *rt = JS_GetRuntime(ctx);
JSThreadState *ts = js_get_thread_state(rt);
JSSTDFile *s = JS_GetOpaque2(ctx, this_val, ts->std_file_class_id);
int err;
if (!s)
return JS_EXCEPTION;
if (!s->f)
return JS_ThrowTypeError(ctx, "invalid file handle");
if (is_stdio(s->f))
return JS_ThrowTypeError(ctx, "cannot close stdio");
#if !defined(__wasi__)
if (s->is_popen)
err = js_get_errno(pclose(s->f));
else
#endif
err = js_get_errno(fclose(s->f));
s->f = NULL;
return JS_NewInt32(ctx, err);
}
|
O1
|
c
|
js_std_file_close:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
callq 0x1fd7e
xorl %r14d, %r14d
xorl %edi, %edi
movq %rax, %rsi
xorl %eax, %eax
callq 0x3a5f3
movl 0x78(%rax), %ecx
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x275b5
testq %rax, %rax
je 0x15f0c
movq %rax, %rbx
movq (%rax), %rdi
testq %rdi, %rdi
je 0x15f15
movq 0xb70d6(%rip), %rax # 0xccfb8
cmpq %rdi, (%rax)
je 0x15f1e
movq 0xb70c2(%rip), %rax # 0xccfb0
cmpq %rdi, (%rax)
je 0x15f1e
movq 0xb70f6(%rip), %rax # 0xccff0
cmpq %rdi, (%rax)
je 0x15f1e
cmpl $0x0, 0x8(%rbx)
je 0x15f41
callq 0xe2c0
jmp 0x15f46
movl $0x6, %edx
xorl %ecx, %ecx
jmp 0x15f65
leaq 0x85bec(%rip), %rsi # 0x9bb08
jmp 0x15f25
leaq 0x85bf7(%rip), %rsi # 0x9bb1c
movq %r15, %rdi
xorl %eax, %eax
callq 0x22567
movq %rax, %r14
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
jmp 0x15f65
callq 0xe220
cmpl $-0x1, %eax
jne 0x15f57
callq 0xe0b0
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movq $0x0, (%rbx)
movl %eax, %r14d
xorl %ecx, %ecx
xorl %edx, %edx
movl %r14d, %eax
orq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
js_std_file_close:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rdx
mov r12, rsi
mov r15, rdi
call JS_GetRuntime
xor r14d, r14d
xor edi, edi
mov rsi, rax
xor eax, eax
call js_std_cmd
mov ecx, [rax+78h]
mov rdi, r15
mov rsi, r12
mov rdx, rbx
call JS_GetOpaque2
test rax, rax
jz short loc_15F0C
mov rbx, rax
mov rdi, [rax]
test rdi, rdi
jz short loc_15F15
mov rax, cs:stdin_ptr
cmp [rax], rdi
jz short loc_15F1E
mov rax, cs:stdout_ptr
cmp [rax], rdi
jz short loc_15F1E
mov rax, cs:stderr_ptr
cmp [rax], rdi
jz short loc_15F1E
cmp dword ptr [rbx+8], 0
jz short loc_15F41
call _pclose
jmp short loc_15F46
loc_15F0C:
mov edx, 6
xor ecx, ecx
jmp short loc_15F65
loc_15F15:
lea rsi, aInvalidFileHan; "invalid file handle"
jmp short loc_15F25
loc_15F1E:
lea rsi, aCannotCloseStd; "cannot close stdio"
loc_15F25:
mov rdi, r15
xor eax, eax
call JS_ThrowTypeError
mov r14, rax
mov rcx, 0FFFFFFFF00000000h
and rcx, rax
jmp short loc_15F65
loc_15F41:
call _fclose
loc_15F46:
cmp eax, 0FFFFFFFFh
jnz short loc_15F57
call ___errno_location
mov rcx, rax
xor eax, eax
sub eax, [rcx]
loc_15F57:
mov qword ptr [rbx], 0
mov r14d, eax
xor ecx, ecx
xor edx, edx
loc_15F65:
mov eax, r14d
or rax, rcx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
unsigned long long js_std_file_close(long long a1, long long a2, long long a3)
{
int v4; // r15d
int Runtime; // eax
unsigned int v6; // r14d
int v7; // edx
int v8; // ecx
int v9; // r8d
int v10; // r9d
long long v11; // rax
long long Opaque2; // rax
int v13; // edx
int v14; // ecx
int v15; // r8d
int v16; // r9d
_QWORD *v17; // rbx
long long v18; // rdi
int v19; // eax
unsigned long long v20; // rcx
const char *v21; // rsi
long long v22; // rax
v4 = a1;
Runtime = JS_GetRuntime(a1);
v6 = 0;
v11 = js_std_cmd(0, Runtime, v7, v8, v9, v10);
Opaque2 = JS_GetOpaque2(a1, a2, a3, *(unsigned int *)(v11 + 120));
if ( !Opaque2 )
{
v20 = 0LL;
return v20 | v6;
}
v17 = (_QWORD *)Opaque2;
v18 = *(_QWORD *)Opaque2;
if ( !*(_QWORD *)Opaque2 )
{
v21 = "invalid file handle";
LABEL_11:
v22 = JS_ThrowTypeError(v4, (_DWORD)v21, v13, v14, v15, v16);
v6 = v22;
v20 = v22 & 0xFFFFFFFF00000000LL;
return v20 | v6;
}
if ( stdin == v18 || stdout == v18 || stderr == v18 )
{
v21 = "cannot close stdio";
goto LABEL_11;
}
if ( *(_DWORD *)(Opaque2 + 8) )
v19 = pclose(v18);
else
v19 = fclose(v18);
if ( v19 == -1 )
v19 = -*(_DWORD *)__errno_location(v18);
*v17 = 0LL;
v6 = v19;
v20 = 0LL;
return v20 | v6;
}
|
js_std_file_close:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R12,RSI
MOV R15,RDI
CALL 0x0011fd7e
XOR R14D,R14D
XOR EDI,EDI
MOV RSI,RAX
XOR EAX,EAX
CALL 0x0013a5f3
MOV ECX,dword ptr [RAX + 0x78]
MOV RDI,R15
MOV RSI,R12
MOV RDX,RBX
CALL 0x001275b5
TEST RAX,RAX
JZ 0x00115f0c
MOV RBX,RAX
MOV RDI,qword ptr [RAX]
TEST RDI,RDI
JZ 0x00115f15
MOV RAX,qword ptr [0x001ccfb8]
CMP qword ptr [RAX],RDI
JZ 0x00115f1e
MOV RAX,qword ptr [0x001ccfb0]
CMP qword ptr [RAX],RDI
JZ 0x00115f1e
MOV RAX,qword ptr [0x001ccff0]
CMP qword ptr [RAX],RDI
JZ 0x00115f1e
CMP dword ptr [RBX + 0x8],0x0
JZ 0x00115f41
CALL 0x0010e2c0
JMP 0x00115f46
LAB_00115f0c:
MOV EDX,0x6
XOR ECX,ECX
JMP 0x00115f65
LAB_00115f15:
LEA RSI,[0x19bb08]
JMP 0x00115f25
LAB_00115f1e:
LEA RSI,[0x19bb1c]
LAB_00115f25:
MOV RDI,R15
XOR EAX,EAX
CALL 0x00122567
MOV R14,RAX
MOV RCX,-0x100000000
AND RCX,RAX
JMP 0x00115f65
LAB_00115f41:
CALL 0x0010e220
LAB_00115f46:
CMP EAX,-0x1
JNZ 0x00115f57
CALL 0x0010e0b0
MOV RCX,RAX
XOR EAX,EAX
SUB EAX,dword ptr [RCX]
LAB_00115f57:
MOV qword ptr [RBX],0x0
MOV R14D,EAX
XOR ECX,ECX
XOR EDX,EDX
LAB_00115f65:
MOV EAX,R14D
OR RAX,RCX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
ulong js_std_file_close(int8 param_1,int8 param_2,int8 param_3)
{
FILE *__stream;
uint uVar1;
int8 uVar2;
long lVar3;
int8 *puVar4;
ulong uVar5;
int *piVar6;
ulong uVar7;
char *pcVar8;
uVar2 = JS_GetRuntime();
uVar5 = 0;
lVar3 = js_std_cmd(0,uVar2);
puVar4 = (int8 *)JS_GetOpaque2(param_1,param_2,param_3,*(int4 *)(lVar3 + 0x78));
if (puVar4 == (int8 *)0x0) {
uVar7 = 0;
}
else {
__stream = (FILE *)*puVar4;
if (__stream == (FILE *)0x0) {
pcVar8 = "invalid file handle";
}
else {
if (((*(FILE **)PTR_stdin_001ccfb8 != __stream) && (*(FILE **)PTR_stdout_001ccfb0 != __stream)
) && (*(FILE **)PTR_stderr_001ccff0 != __stream)) {
if (*(int *)(puVar4 + 1) == 0) {
uVar1 = fclose(__stream);
}
else {
uVar1 = pclose(__stream);
}
if (uVar1 == 0xffffffff) {
piVar6 = __errno_location();
uVar1 = -*piVar6;
}
*puVar4 = 0;
uVar5 = (ulong)uVar1;
uVar7 = 0;
goto LAB_00115f65;
}
pcVar8 = "cannot close stdio";
}
uVar5 = JS_ThrowTypeError(param_1,pcVar8);
uVar7 = uVar5 & 0xffffffff00000000;
}
LAB_00115f65:
return uVar5 & 0xffffffff | uVar7;
}
|
|
8,112 |
js_std_file_close
|
bluesky950520[P]quickjs/quickjs-libc.c
|
static JSValue js_std_file_close(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSRuntime *rt = JS_GetRuntime(ctx);
JSThreadState *ts = js_get_thread_state(rt);
JSSTDFile *s = JS_GetOpaque2(ctx, this_val, ts->std_file_class_id);
int err;
if (!s)
return JS_EXCEPTION;
if (!s->f)
return JS_ThrowTypeError(ctx, "invalid file handle");
if (is_stdio(s->f))
return JS_ThrowTypeError(ctx, "cannot close stdio");
#if !defined(__wasi__)
if (s->is_popen)
err = js_get_errno(pclose(s->f));
else
#endif
err = js_get_errno(fclose(s->f));
s->f = NULL;
return JS_NewInt32(ctx, err);
}
|
O2
|
c
|
js_std_file_close:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x1a185
movq %rax, %rdi
callq 0x1028a
movl 0x78(%rax), %ecx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x21207
testq %rax, %rax
je 0x10da7
movq %rax, %rbx
movq (%rax), %r15
testq %r15, %r15
je 0x10db0
movq %r15, %rdi
callq 0x10d27
testl %eax, %eax
je 0x10dd0
leaq 0x71d23(%rip), %rsi # 0x82ac8
jmp 0x10db7
pushq $0x6
popq %rdx
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x10df8
leaq 0x71cfd(%rip), %rsi # 0x82ab4
movq %r14, %rdi
xorl %eax, %eax
callq 0x1c64d
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
jmp 0x10df8
cmpl $0x0, 0x8(%rbx)
je 0x10de0
movq %r15, %rdi
callq 0xe2d0
jmp 0x10de8
movq %r15, %rdi
callq 0xe230
movslq %eax, %rdi
callq 0x113ab
andq $0x0, (%rbx)
xorl %ecx, %ecx
xorl %edx, %edx
movl %eax, %eax
orq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
|
js_std_file_close:
push r15
push r14
push rbx
mov rbx, rdx
mov r15, rsi
mov r14, rdi
call JS_GetRuntime
mov rdi, rax
call js_get_thread_state
mov ecx, [rax+78h]
mov rdi, r14
mov rsi, r15
mov rdx, rbx
call JS_GetOpaque2
test rax, rax
jz short loc_10DA7
mov rbx, rax
mov r15, [rax]
test r15, r15
jz short loc_10DB0
mov rdi, r15
call is_stdio
test eax, eax
jz short loc_10DD0
lea rsi, aCannotCloseStd; "cannot close stdio"
jmp short loc_10DB7
loc_10DA7:
push 6
pop rdx
xor eax, eax
xor ecx, ecx
jmp short loc_10DF8
loc_10DB0:
lea rsi, aInvalidFileHan; "invalid file handle"
loc_10DB7:
mov rdi, r14
xor eax, eax
call JS_ThrowTypeError
mov rcx, 0FFFFFFFF00000000h
and rcx, rax
jmp short loc_10DF8
loc_10DD0:
cmp dword ptr [rbx+8], 0
jz short loc_10DE0
mov rdi, r15
call _pclose
jmp short loc_10DE8
loc_10DE0:
mov rdi, r15
call _fclose
loc_10DE8:
movsxd rdi, eax
call js_get_errno
and qword ptr [rbx], 0
xor ecx, ecx
xor edx, edx
loc_10DF8:
mov eax, eax
or rax, rcx
pop rbx
pop r14
pop r15
retn
|
unsigned long long js_std_file_close(long long a1, long long a2, long long a3)
{
int Runtime; // eax
int v5; // edx
int v6; // ecx
int v7; // r8d
int v8; // r9d
long long thread_state; // rax
long long *Opaque2; // rax
int v11; // edx
int v12; // ecx
int v13; // r8d
int v14; // r9d
long long *v15; // rbx
long long v16; // r15
const char *v17; // rsi
long long v18; // rax
unsigned long long v19; // rcx
int v20; // eax
char v22; // [rsp+0h] [rbp-18h]
Runtime = JS_GetRuntime(a1);
thread_state = js_get_thread_state(Runtime, a2, v5, v6, v7, v8, v22);
Opaque2 = (long long *)JS_GetOpaque2(a1, a2, a3, *(unsigned int *)(thread_state + 120));
if ( Opaque2 )
{
v15 = Opaque2;
v16 = *Opaque2;
if ( !*Opaque2 )
{
v17 = "invalid file handle";
goto LABEL_7;
}
if ( (unsigned int)is_stdio(*Opaque2) )
{
v17 = "cannot close stdio";
LABEL_7:
v18 = JS_ThrowTypeError(a1, (_DWORD)v17, v11, v12, v13, v14);
v19 = v18 & 0xFFFFFFFF00000000LL;
return v19 | (unsigned int)v18;
}
if ( *((_DWORD *)v15 + 2) )
v20 = pclose(v16);
else
v20 = fclose(v16);
LODWORD(v18) = js_get_errno(v20);
*v15 = 0LL;
v19 = 0LL;
}
else
{
LODWORD(v18) = 0;
v19 = 0LL;
}
return v19 | (unsigned int)v18;
}
|
js_std_file_close:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDX
MOV R15,RSI
MOV R14,RDI
CALL 0x0011a185
MOV RDI,RAX
CALL 0x0011028a
MOV ECX,dword ptr [RAX + 0x78]
MOV RDI,R14
MOV RSI,R15
MOV RDX,RBX
CALL 0x00121207
TEST RAX,RAX
JZ 0x00110da7
MOV RBX,RAX
MOV R15,qword ptr [RAX]
TEST R15,R15
JZ 0x00110db0
MOV RDI,R15
CALL 0x00110d27
TEST EAX,EAX
JZ 0x00110dd0
LEA RSI,[0x182ac8]
JMP 0x00110db7
LAB_00110da7:
PUSH 0x6
POP RDX
XOR EAX,EAX
XOR ECX,ECX
JMP 0x00110df8
LAB_00110db0:
LEA RSI,[0x182ab4]
LAB_00110db7:
MOV RDI,R14
XOR EAX,EAX
CALL 0x0011c64d
MOV RCX,-0x100000000
AND RCX,RAX
JMP 0x00110df8
LAB_00110dd0:
CMP dword ptr [RBX + 0x8],0x0
JZ 0x00110de0
MOV RDI,R15
CALL 0x0010e2d0
JMP 0x00110de8
LAB_00110de0:
MOV RDI,R15
CALL 0x0010e230
LAB_00110de8:
MOVSXD RDI,EAX
CALL 0x001113ab
AND qword ptr [RBX],0x0
XOR ECX,ECX
XOR EDX,EDX
LAB_00110df8:
MOV EAX,EAX
OR RAX,RCX
POP RBX
POP R14
POP R15
RET
|
ulong js_std_file_close(int8 param_1,int8 param_2,int8 param_3)
{
FILE *__stream;
int iVar1;
int8 uVar2;
long lVar3;
int8 *puVar4;
ulong uVar5;
ulong uVar6;
char *pcVar7;
uVar2 = JS_GetRuntime();
lVar3 = js_get_thread_state(uVar2);
puVar4 = (int8 *)JS_GetOpaque2(param_1,param_2,param_3,*(int4 *)(lVar3 + 0x78));
if (puVar4 == (int8 *)0x0) {
uVar5 = 0;
uVar6 = 0;
}
else {
__stream = (FILE *)*puVar4;
if (__stream == (FILE *)0x0) {
pcVar7 = "invalid file handle";
}
else {
iVar1 = is_stdio(__stream);
if (iVar1 == 0) {
if (*(int *)(puVar4 + 1) == 0) {
iVar1 = fclose(__stream);
}
else {
iVar1 = pclose(__stream);
}
uVar5 = js_get_errno((long)iVar1);
*puVar4 = 0;
uVar6 = 0;
goto LAB_00110df8;
}
pcVar7 = "cannot close stdio";
}
uVar5 = JS_ThrowTypeError(param_1,pcVar7);
uVar6 = uVar5 & 0xffffffff00000000;
}
LAB_00110df8:
return uVar5 & 0xffffffff | uVar6;
}
|
|
8,113 |
my_like_range_simple
|
eloqsql/strings/ctype-simple.c
|
my_bool my_like_range_simple(CHARSET_INFO *cs,
const char *ptr, size_t ptr_length,
pbool escape, pbool w_one, pbool w_many,
size_t res_length,
char *min_str,char *max_str,
size_t *min_length, size_t *max_length)
{
const char *end= ptr + ptr_length;
char *min_org=min_str;
char *min_end=min_str+res_length;
size_t charlen= res_length / cs->mbmaxlen;
for (; ptr != end && min_str != min_end && charlen > 0 ; ptr++, charlen--)
{
if (*ptr == escape && ptr+1 != end)
{
ptr++; /* Skip escape */
*min_str++= *max_str++ = *ptr;
continue;
}
if (*ptr == w_one) /* '_' in SQL */
{
*min_str++='\0'; /* This should be min char */
*max_str++= (char) cs->max_sort_char;
continue;
}
if (*ptr == w_many) /* '%' in SQL */
{
/* Calculate length of keys */
*min_length= (cs->state & (MY_CS_BINSORT | MY_CS_NOPAD)) ?
(size_t) (min_str - min_org) :
res_length;
*max_length= res_length;
do
{
*min_str++= 0;
*max_str++= (char) cs->max_sort_char;
} while (min_str != min_end);
return 0;
}
*min_str++= *max_str++ = *ptr;
}
*min_length= *max_length = (size_t) (min_str - min_org);
while (min_str != min_end)
*min_str++= *max_str++ = ' '; /* Because if key compression */
return 0;
}
|
O3
|
c
|
my_like_range_simple:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r10
movq 0x30(%rbp), %rdx
movq 0x28(%rbp), %r12
movq 0x20(%rbp), %rbx
movq 0x18(%rbp), %r14
movq 0x10(%rbp), %r11
testq %r10, %r10
je 0x6f395
addq %rsi, %r10
movl 0x9c(%rdi), %r15d
xorl %r13d, %r13d
movq %r11, %rax
xorl %edx, %edx
divq %r15
addq $-0x1, %rax
setb %dl
cmpq %r13, %r11
je 0x6f388
testb %dl, %dl
je 0x6f388
movb (%rsi), %r15b
cmpb %cl, %r15b
jne 0x6f354
leaq 0x1(%rsi), %rdx
cmpq %r10, %rdx
je 0x6f354
movb (%rdx), %sil
movb %sil, (%rbx,%r13)
movb %sil, (%r14,%r13)
jmp 0x6f37a
cmpb %r8b, %r15b
jne 0x6f36a
movb $0x0, (%r14,%r13)
movb 0xa8(%rdi), %dl
movb %dl, (%rbx,%r13)
jmp 0x6f377
cmpb %r9b, %r15b
je 0x6f3cb
movb %r15b, (%rbx,%r13)
movb %r15b, (%r14,%r13)
movq %rsi, %rdx
incq %rdx
incq %r13
movq %rdx, %rsi
cmpq %r10, %rdx
jne 0x6f326
leaq (%r14,%r13), %rax
addq %r13, %rbx
movq 0x30(%rbp), %rdx
jmp 0x6f398
movq %r14, %rax
addq %r14, %r11
movq %rax, %rcx
subq %r14, %rcx
movq %rcx, (%rdx)
movq %rcx, (%r12)
cmpq %r11, %rax
je 0x6f3be
movb $0x20, %cl
movb %cl, (%rbx)
incq %rbx
movb %cl, (%rax)
incq %rax
cmpq %r11, %rax
jne 0x6f3af
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl $0x20010, 0xc(%rdi) # imm = 0x20010
movq %r13, %rax
cmoveq %r11, %rax
movq %rax, (%r12)
movq 0x30(%rbp), %rax
movq %r11, (%rax)
movb $0x0, (%r14,%r13)
movb 0xa8(%rdi), %al
movb %al, (%rbx,%r13)
incq %r13
cmpq %r13, %r11
jne 0x6f3e4
jmp 0x6f3be
|
my_like_range_simple:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
mov r10, rdx
mov rdx, [rbp+arg_20]
mov r12, [rbp+arg_18]
mov rbx, [rbp+arg_10]
mov r14, [rbp+arg_8]
mov r11, [rbp+arg_0]
test r10, r10
jz loc_6F395
add r10, rsi
mov r15d, [rdi+9Ch]
xor r13d, r13d
mov rax, r11
xor edx, edx
div r15
loc_6F326:
add rax, 0FFFFFFFFFFFFFFFFh
setb dl
cmp r11, r13
jz short loc_6F388
test dl, dl
jz short loc_6F388
mov r15b, [rsi]
cmp r15b, cl
jnz short loc_6F354
lea rdx, [rsi+1]
cmp rdx, r10
jz short loc_6F354
mov sil, [rdx]
mov [rbx+r13], sil
mov [r14+r13], sil
jmp short loc_6F37A
loc_6F354:
cmp r15b, r8b
jnz short loc_6F36A
mov byte ptr [r14+r13], 0
mov dl, [rdi+0A8h]
mov [rbx+r13], dl
jmp short loc_6F377
loc_6F36A:
cmp r15b, r9b
jz short loc_6F3CB
mov [rbx+r13], r15b
mov [r14+r13], r15b
loc_6F377:
mov rdx, rsi
loc_6F37A:
inc rdx
inc r13
mov rsi, rdx
cmp rdx, r10
jnz short loc_6F326
loc_6F388:
lea rax, [r14+r13]
add rbx, r13
mov rdx, [rbp+arg_20]
jmp short loc_6F398
loc_6F395:
mov rax, r14
loc_6F398:
add r11, r14
mov rcx, rax
sub rcx, r14
mov [rdx], rcx
mov [r12], rcx
cmp rax, r11
jz short loc_6F3BE
mov cl, 20h ; ' '
loc_6F3AF:
mov [rbx], cl
inc rbx
mov [rax], cl
inc rax
cmp rax, r11
jnz short loc_6F3AF
loc_6F3BE:
xor eax, eax
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_6F3CB:
test dword ptr [rdi+0Ch], 20010h
mov rax, r13
cmovz rax, r11
mov [r12], rax
mov rax, [rbp+arg_20]
mov [rax], r11
loc_6F3E4:
mov byte ptr [r14+r13], 0
mov al, [rdi+0A8h]
mov [rbx+r13], al
inc r13
cmp r11, r13
jnz short loc_6F3E4
jmp short loc_6F3BE
|
long long my_like_range_simple(
long long a1,
char *a2,
long long a3,
char a4,
char a5,
char a6,
unsigned long long a7,
long long a8,
_BYTE *a9,
unsigned long long *a10,
_QWORD *a11)
{
_QWORD *v12; // rdx
_BYTE *v13; // rbx
char *v14; // r10
unsigned long long v15; // r13
unsigned long long v16; // rax
bool v17; // cf
char v18; // r15
char *v19; // rdx
char v20; // si
_BYTE *v21; // rax
unsigned long long v23; // rax
v12 = a11;
v13 = a9;
if ( a3 )
{
v14 = &a2[a3];
v15 = 0LL;
v16 = a7 / *(unsigned int *)(a1 + 156);
while ( 1 )
{
v17 = v16-- != 0;
if ( a7 == v15 || !v17 )
{
LABEL_14:
v21 = (_BYTE *)(a8 + v15);
v13 = &a9[v15];
v12 = a11;
goto LABEL_16;
}
v18 = *a2;
if ( *a2 != a4 || (v19 = a2 + 1, a2 + 1 == v14) )
{
if ( v18 == a5 )
{
*(_BYTE *)(a8 + v15) = 0;
a9[v15] = *(_BYTE *)(a1 + 168);
}
else
{
if ( v18 == a6 )
{
v23 = v15;
if ( (*(_DWORD *)(a1 + 12) & 0x20010) == 0 )
v23 = a7;
*a10 = v23;
*a11 = a7;
do
{
*(_BYTE *)(a8 + v15) = 0;
a9[v15++] = *(_BYTE *)(a1 + 168);
}
while ( a7 != v15 );
return 0LL;
}
a9[v15] = v18;
*(_BYTE *)(a8 + v15) = v18;
}
v19 = a2;
}
else
{
v20 = *v19;
a9[v15] = *v19;
*(_BYTE *)(a8 + v15) = v20;
}
++v15;
a2 = v19 + 1;
if ( v19 + 1 == v14 )
goto LABEL_14;
}
}
v21 = (_BYTE *)a8;
LABEL_16:
*v12 = &v21[-a8];
for ( *a10 = (unsigned long long)&v21[-a8]; v21 != (_BYTE *)(a8 + a7); ++v21 )
{
*v13++ = 32;
*v21 = 32;
}
return 0LL;
}
|
my_like_range_simple:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R10,RDX
MOV RDX,qword ptr [RBP + 0x30]
MOV R12,qword ptr [RBP + 0x28]
MOV RBX,qword ptr [RBP + 0x20]
MOV R14,qword ptr [RBP + 0x18]
MOV R11,qword ptr [RBP + 0x10]
TEST R10,R10
JZ 0x0016f395
ADD R10,RSI
MOV R15D,dword ptr [RDI + 0x9c]
XOR R13D,R13D
MOV RAX,R11
XOR EDX,EDX
DIV R15
LAB_0016f326:
ADD RAX,-0x1
SETC DL
CMP R11,R13
JZ 0x0016f388
TEST DL,DL
JZ 0x0016f388
MOV R15B,byte ptr [RSI]
CMP R15B,CL
JNZ 0x0016f354
LEA RDX,[RSI + 0x1]
CMP RDX,R10
JZ 0x0016f354
MOV SIL,byte ptr [RDX]
MOV byte ptr [RBX + R13*0x1],SIL
MOV byte ptr [R14 + R13*0x1],SIL
JMP 0x0016f37a
LAB_0016f354:
CMP R15B,R8B
JNZ 0x0016f36a
MOV byte ptr [R14 + R13*0x1],0x0
MOV DL,byte ptr [RDI + 0xa8]
MOV byte ptr [RBX + R13*0x1],DL
JMP 0x0016f377
LAB_0016f36a:
CMP R15B,R9B
JZ 0x0016f3cb
MOV byte ptr [RBX + R13*0x1],R15B
MOV byte ptr [R14 + R13*0x1],R15B
LAB_0016f377:
MOV RDX,RSI
LAB_0016f37a:
INC RDX
INC R13
MOV RSI,RDX
CMP RDX,R10
JNZ 0x0016f326
LAB_0016f388:
LEA RAX,[R14 + R13*0x1]
ADD RBX,R13
MOV RDX,qword ptr [RBP + 0x30]
JMP 0x0016f398
LAB_0016f395:
MOV RAX,R14
LAB_0016f398:
ADD R11,R14
MOV RCX,RAX
SUB RCX,R14
MOV qword ptr [RDX],RCX
MOV qword ptr [R12],RCX
CMP RAX,R11
JZ 0x0016f3be
MOV CL,0x20
LAB_0016f3af:
MOV byte ptr [RBX],CL
INC RBX
MOV byte ptr [RAX],CL
INC RAX
CMP RAX,R11
JNZ 0x0016f3af
LAB_0016f3be:
XOR EAX,EAX
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0016f3cb:
TEST dword ptr [RDI + 0xc],0x20010
MOV RAX,R13
CMOVZ RAX,R11
MOV qword ptr [R12],RAX
MOV RAX,qword ptr [RBP + 0x30]
MOV qword ptr [RAX],R11
LAB_0016f3e4:
MOV byte ptr [R14 + R13*0x1],0x0
MOV AL,byte ptr [RDI + 0xa8]
MOV byte ptr [RBX + R13*0x1],AL
INC R13
CMP R11,R13
JNZ 0x0016f3e4
JMP 0x0016f3be
|
int8
my_like_range_simple
(long param_1,char *param_2,long param_3,char param_4,char param_5,char param_6,
ulong param_7,int1 *param_8,int1 *param_9,ulong *param_10,ulong *param_11)
{
char *pcVar1;
char cVar2;
ulong uVar3;
int1 *puVar4;
char *pcVar5;
ulong uVar6;
bool bVar7;
puVar4 = param_8;
if (param_3 != 0) {
pcVar5 = param_2 + param_3;
uVar6 = 0;
uVar3 = param_7 / *(uint *)(param_1 + 0x9c);
do {
bVar7 = uVar3 == 0;
uVar3 = uVar3 - 1;
if ((param_7 == uVar6) || (bVar7)) break;
cVar2 = *param_2;
if ((cVar2 == param_4) && (pcVar1 = param_2 + 1, pcVar1 != pcVar5)) {
cVar2 = *pcVar1;
param_9[uVar6] = cVar2;
param_8[uVar6] = cVar2;
param_2 = pcVar1;
}
else if (cVar2 == param_5) {
param_8[uVar6] = 0;
param_9[uVar6] = *(int1 *)(param_1 + 0xa8);
}
else {
if (cVar2 == param_6) {
uVar3 = uVar6;
if ((*(uint *)(param_1 + 0xc) & 0x20010) == 0) {
uVar3 = param_7;
}
*param_10 = uVar3;
*param_11 = param_7;
do {
param_8[uVar6] = 0;
param_9[uVar6] = *(int1 *)(param_1 + 0xa8);
uVar6 = uVar6 + 1;
} while (param_7 != uVar6);
return 0;
}
param_9[uVar6] = cVar2;
param_8[uVar6] = cVar2;
}
param_2 = param_2 + 1;
uVar6 = uVar6 + 1;
} while (param_2 != pcVar5);
param_9 = param_9 + uVar6;
puVar4 = param_8 + uVar6;
}
*param_11 = (long)puVar4 - (long)param_8;
*param_10 = (long)puVar4 - (long)param_8;
for (; puVar4 != param_8 + param_7; puVar4 = puVar4 + 1) {
*param_9 = 0x20;
param_9 = param_9 + 1;
*puVar4 = 0x20;
}
return 0;
}
|
|
8,114 |
my_default_csname
|
eloqsql/mysys/charset.c
|
const char* my_default_csname()
{
const char* csname = NULL;
#ifdef _WIN32
char cpbuf[64];
int cp = GetConsoleCP();
if (cp == 0)
cp = GetACP();
snprintf(cpbuf, sizeof(cpbuf), "cp%d", (int)cp);
csname = my_os_charset_to_mysql_charset(cpbuf);
#elif defined(HAVE_SETLOCALE) && defined(HAVE_NL_LANGINFO)
if (setlocale(LC_CTYPE, "") && (csname = nl_langinfo(CODESET)))
csname = my_os_charset_to_mysql_charset(csname);
#endif
return csname ? csname : MYSQL_DEFAULT_CHARSET_NAME;
}
|
O3
|
c
|
my_default_csname:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x35926(%rip), %rsi # 0x5ea60
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x24230
testq %rax, %rax
je 0x29196
movl $0xe, %edi
callq 0x24270
testq %rax, %rax
je 0x29193
movq %rax, %rbx
leaq 0x32414(%rip), %rdi # 0x5b576
leaq 0x2bc73f(%rip), %r15 # 0x2e58a8
xorl %r14d, %r14d
movq %rbx, %rsi
callq 0x242c0
testl %eax, %eax
je 0x29186
movq (%r15), %rdi
addq $0x18, %r15
testq %rdi, %rdi
jne 0x2916c
jmp 0x29196
cmpl $0x2, -0x8(%r15)
jae 0x29193
movq -0x10(%r15), %r14
jmp 0x29196
xorl %r14d, %r14d
testq %r14, %r14
leaq 0x3234c(%rip), %rax # 0x5b4ec
cmovneq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
my_default_csname:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
lea rsi, asc_5EA5C+4; ""
xor r14d, r14d
xor edi, edi
call _setlocale
test rax, rax
jz short loc_29196
mov edi, 0Eh
call _nl_langinfo
test rax, rax
jz short loc_29193
mov rbx, rax
lea rdi, a646; "646"
lea r15, off_2E58A8; "ANSI_X3.4-1968"
xor r14d, r14d
loc_2916C:
mov rsi, rbx
call _strcasecmp
test eax, eax
jz short loc_29186
mov rdi, [r15]
add r15, 18h
test rdi, rdi
jnz short loc_2916C
jmp short loc_29196
loc_29186:
cmp dword ptr [r15-8], 2
jnb short loc_29193
mov r14, [r15-10h]
jmp short loc_29196
loc_29193:
xor r14d, r14d
loc_29196:
test r14, r14
lea rax, aLatin1; "latin1"
cmovnz rax, r14
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
const char *my_default_csname()
{
long long v0; // r14
long long v1; // rax
long long v2; // rbx
const char *v3; // rdi
const char **v4; // r15
const char *result; // rax
v0 = 0LL;
if ( setlocale(0LL, "") )
{
v1 = nl_langinfo(14LL);
if ( !v1 )
goto LABEL_9;
v2 = v1;
v3 = "646";
v4 = (const char **)off_2E58A8;
v0 = 0LL;
while ( (unsigned int)strcasecmp(v3, v2) )
{
v3 = *v4;
v4 += 3;
if ( !v3 )
goto LABEL_10;
}
if ( *((_DWORD *)v4 - 2) < 2u )
v0 = (long long)*(v4 - 2);
else
LABEL_9:
v0 = 0LL;
}
LABEL_10:
result = "latin1";
if ( v0 )
return (const char *)v0;
return result;
}
|
my_default_csname:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
LEA RSI,[0x15ea60]
XOR R14D,R14D
XOR EDI,EDI
CALL 0x00124230
TEST RAX,RAX
JZ 0x00129196
MOV EDI,0xe
CALL 0x00124270
TEST RAX,RAX
JZ 0x00129193
MOV RBX,RAX
LEA RDI,[0x15b576]
LEA R15,[0x3e58a8]
XOR R14D,R14D
LAB_0012916c:
MOV RSI,RBX
CALL 0x001242c0
TEST EAX,EAX
JZ 0x00129186
MOV RDI,qword ptr [R15]
ADD R15,0x18
TEST RDI,RDI
JNZ 0x0012916c
JMP 0x00129196
LAB_00129186:
CMP dword ptr [R15 + -0x8],0x2
JNC 0x00129193
MOV R14,qword ptr [R15 + -0x10]
JMP 0x00129196
LAB_00129193:
XOR R14D,R14D
LAB_00129196:
TEST R14,R14
LEA RAX,[0x15b4ec]
CMOVNZ RAX,R14
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
char * my_default_csname(void)
{
int iVar1;
char *pcVar2;
char *__s1;
char *pcVar3;
long *plVar4;
pcVar3 = (char *)0x0;
pcVar2 = setlocale(0,"");
if (pcVar2 != (char *)0x0) {
pcVar2 = nl_langinfo(0xe);
if (pcVar2 == (char *)0x0) {
LAB_00129193:
pcVar3 = (char *)0x0;
}
else {
__s1 = "646";
plVar4 = (long *)(charsets + 0x18);
pcVar3 = (char *)0x0;
do {
iVar1 = strcasecmp(__s1,pcVar2);
if (iVar1 == 0) {
if (1 < *(uint *)(plVar4 + -1)) goto LAB_00129193;
pcVar3 = (char *)plVar4[-2];
break;
}
__s1 = (char *)*plVar4;
plVar4 = plVar4 + 3;
} while (__s1 != (char *)0x0);
}
}
pcVar2 = "latin1";
if (pcVar3 != (char *)0x0) {
pcVar2 = pcVar3;
}
return pcVar2;
}
|
|
8,115 |
ma_scramble_41
|
eloqsql/libmariadb/libmariadb/ma_password.c
|
void ma_scramble_41(const unsigned char *buffer, const char *scramble, const char *password)
{
_MA_SHA1_CTX context;
unsigned char sha1[SHA1_MAX_LENGTH];
unsigned char sha2[SHA1_MAX_LENGTH];
/* Phase 1: hash password */
ma_SHA1Init(&context);
ma_SHA1Update(&context, (unsigned char *)password, strlen((char *)password));
ma_SHA1Final(sha1, &context);
/* Phase 2: hash sha1 */
ma_SHA1Init(&context);
ma_SHA1Update(&context, (unsigned char*)sha1, SHA1_MAX_LENGTH);
ma_SHA1Final(sha2, &context);
/* Phase 3: hash scramble + sha2 */
ma_SHA1Init(&context);
ma_SHA1Update(&context, (unsigned char *)scramble, SCRAMBLE_LENGTH);
ma_SHA1Update(&context, (unsigned char*)sha2, SHA1_MAX_LENGTH);
ma_SHA1Final((unsigned char *)buffer, &context);
/* let's crypt buffer now */
my_crypt((uchar *)buffer, (const unsigned char *)buffer, (const unsigned char *)sha1, SHA1_MAX_LENGTH);
}
|
O3
|
c
|
ma_scramble_41:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
leaq -0x84(%rbp), %r14
movq %r14, %rdi
callq 0x32868
movq %r12, %rdi
callq 0x131c0
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x32888
leaq -0xa0(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x33a10
movq %r14, %rdi
callq 0x32868
movl $0x14, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x32888
leaq -0xc0(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x33a10
movq %r14, %rdi
callq 0x32868
movl $0x14, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x32888
movl $0x14, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x32888
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33a10
xorl %eax, %eax
movb -0xa0(%rbp,%rax), %cl
xorb %cl, (%rbx,%rax)
leaq 0x1(%rax), %rcx
movq %rcx, %rax
cmpq $0x14, %rcx
jne 0x32538
movq %fs:0x28, %rax
cmpq -0x28(%rbp), %rax
jne 0x3256e
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x13500
|
ma_scramble_41:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 0A0h
mov r12, rdx
mov r15, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_28], rax
lea r14, [rbp+var_84]
mov rdi, r14
call ma_SHA1Init
mov rdi, r12
call _strlen
mov rdi, r14
mov rsi, r12
mov rdx, rax
call ma_SHA1Update
lea r12, [rbp+var_A0]
mov rdi, r12
mov rsi, r14
call ma_SHA1Final
mov rdi, r14
call ma_SHA1Init
mov edx, 14h
mov rdi, r14
mov rsi, r12
call ma_SHA1Update
lea r12, [rbp+var_C0]
mov rdi, r12
mov rsi, r14
call ma_SHA1Final
mov rdi, r14
call ma_SHA1Init
mov edx, 14h
mov rdi, r14
mov rsi, r15
call ma_SHA1Update
mov edx, 14h
mov rdi, r14
mov rsi, r12
call ma_SHA1Update
mov rdi, rbx
mov rsi, r14
call ma_SHA1Final
xor eax, eax
loc_32538:
mov cl, [rbp+rax+var_A0]
xor [rbx+rax], cl
lea rcx, [rax+1]
mov rax, rcx
cmp rcx, 14h
jnz short loc_32538
mov rax, fs:28h
cmp rax, [rbp+var_28]
jnz short loc_3256E
add rsp, 0A0h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_3256E:
call ___stack_chk_fail
|
unsigned long long ma_scramble_41(long long a1, long long a2, long long a3)
{
long long v4; // rax
long long i; // rax
_BYTE v7[32]; // [rsp+0h] [rbp-C0h] BYREF
_BYTE v8[28]; // [rsp+20h] [rbp-A0h] BYREF
_BYTE v9[92]; // [rsp+3Ch] [rbp-84h] BYREF
unsigned long long v10; // [rsp+98h] [rbp-28h]
v10 = __readfsqword(0x28u);
ma_SHA1Init(v9);
v4 = strlen(a3);
ma_SHA1Update(v9, a3, v4);
ma_SHA1Final(v8, v9);
ma_SHA1Init(v9);
ma_SHA1Update(v9, v8, 20LL);
ma_SHA1Final(v7, v9);
ma_SHA1Init(v9);
ma_SHA1Update(v9, a2, 20LL);
ma_SHA1Update(v9, v7, 20LL);
ma_SHA1Final(a1, v9);
for ( i = 0LL; i != 20; ++i )
*(_BYTE *)(a1 + i) ^= v8[i];
return __readfsqword(0x28u);
}
|
ma_scramble_41:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0xa0
MOV R12,RDX
MOV R15,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
LEA R14,[RBP + -0x84]
MOV RDI,R14
CALL 0x00132868
MOV RDI,R12
CALL 0x001131c0
MOV RDI,R14
MOV RSI,R12
MOV RDX,RAX
CALL 0x00132888
LEA R12,[RBP + -0xa0]
MOV RDI,R12
MOV RSI,R14
CALL 0x00133a10
MOV RDI,R14
CALL 0x00132868
MOV EDX,0x14
MOV RDI,R14
MOV RSI,R12
CALL 0x00132888
LEA R12,[RBP + -0xc0]
MOV RDI,R12
MOV RSI,R14
CALL 0x00133a10
MOV RDI,R14
CALL 0x00132868
MOV EDX,0x14
MOV RDI,R14
MOV RSI,R15
CALL 0x00132888
MOV EDX,0x14
MOV RDI,R14
MOV RSI,R12
CALL 0x00132888
MOV RDI,RBX
MOV RSI,R14
CALL 0x00133a10
XOR EAX,EAX
LAB_00132538:
MOV CL,byte ptr [RBP + RAX*0x1 + -0xa0]
XOR byte ptr [RBX + RAX*0x1],CL
LEA RCX,[RAX + 0x1]
MOV RAX,RCX
CMP RCX,0x14
JNZ 0x00132538
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x28]
JNZ 0x0013256e
ADD RSP,0xa0
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0013256e:
CALL 0x00113500
|
void ma_scramble_41(long param_1,int8 param_2,char *param_3)
{
size_t sVar1;
long lVar2;
long in_FS_OFFSET;
int1 local_c8 [32];
byte local_a8 [28];
int1 local_8c [92];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
ma_SHA1Init(local_8c);
sVar1 = strlen(param_3);
ma_SHA1Update(local_8c,param_3,sVar1);
ma_SHA1Final(local_a8,local_8c);
ma_SHA1Init(local_8c);
ma_SHA1Update(local_8c,local_a8,0x14);
ma_SHA1Final(local_c8,local_8c);
ma_SHA1Init(local_8c);
ma_SHA1Update(local_8c,param_2,0x14);
ma_SHA1Update(local_8c,local_c8,0x14);
ma_SHA1Final(param_1,local_8c);
lVar2 = 0;
do {
*(byte *)(param_1 + lVar2) = *(byte *)(param_1 + lVar2) ^ local_a8[lVar2];
lVar2 = lVar2 + 1;
} while (lVar2 != 0x14);
if (*(long *)(in_FS_OFFSET + 0x28) == local_30) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
8,116 |
ftb_find_relevance_add_word
|
eloqsql/storage/myisam/ft_boolean_search.c
|
static int ftb_find_relevance_add_word(MYSQL_FTPARSER_PARAM *param,
const char *word, int len,
MYSQL_FTPARSER_BOOLEAN_INFO *boolean_info __attribute__((unused)))
{
MY_FTB_FIND_PARAM *ftb_param= param->mysql_ftparam;
FT_INFO *ftb= ftb_param->ftb;
FTB_WORD *ftbw;
int a, b, c;
/*
Find right-most element in the array of query words matching this
word from a document.
*/
for (a= 0, b= ftb->queue.elements, c= (a+b)/2; b-a>1; c= (a+b)/2)
{
ftbw= ftb->list[c];
if (ha_compare_text(ftb->charset, (uchar*)word, len,
(uchar*)ftbw->word+1, ftbw->len-1,
(my_bool) (ftbw->flags & FTB_FLAG_TRUNC)) < 0)
b= c;
else
a= c;
}
/*
If there were no words with truncation operator, we iterate to the
beginning of an array until array element is equal to the word from
a document. This is done mainly because the same word may be
mentioned twice (or more) in the query.
In case query has words with truncation operator we must iterate
to the beginning of the array. There may be non-matching query words
between matching word with truncation operator and the right-most
matching element. E.g., if we're looking for 'aaa15' in an array of
'aaa1* aaa14 aaa15 aaa16'.
Worse of that there still may be match even if the binary search
above didn't find matching element. E.g., if we're looking for
'aaa15' in an array of 'aaa1* aaa14 aaa16'. The binary search will
stop at 'aaa16'.
*/
for (; c >= 0; c--)
{
ftbw= ftb->list[c];
if (ha_compare_text(ftb->charset, (uchar*)word, len,
(uchar*)ftbw->word + 1,ftbw->len - 1,
(my_bool)(ftbw->flags & FTB_FLAG_TRUNC)))
{
if (ftb->with_scan & FTB_FLAG_TRUNC)
continue;
else
break;
}
if (ftbw->docid[1] == ftb->info->lastpos)
continue;
ftbw->docid[1]= ftb->info->lastpos;
if (unlikely(_ftb_climb_the_tree(ftb, ftbw, ftb_param->ftsi)))
return 1;
}
return(0);
}
|
O0
|
c
|
ftb_find_relevance_add_word:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x44(%rbp)
movq -0x38(%rbp), %rax
movl 0x80(%rax), %eax
movl %eax, -0x48(%rbp)
movl -0x44(%rbp), %eax
addl -0x48(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x4c(%rbp)
movl -0x48(%rbp), %eax
subl -0x44(%rbp), %eax
cmpl $0x1, %eax
jle 0x65dab
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x4c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
movq -0x40(%rbp), %rcx
addq $0x4d, %rcx
addq $0x1, %rcx
movq -0x40(%rbp), %rax
movl 0x48(%rax), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %r8d
movq -0x40(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x1, %eax
movsbl %al, %r9d
callq 0x7c840
cmpl $0x0, %eax
jge 0x65d8d
movl -0x4c(%rbp), %eax
movl %eax, -0x48(%rbp)
jmp 0x65d93
movl -0x4c(%rbp), %eax
movl %eax, -0x44(%rbp)
jmp 0x65d95
movl -0x44(%rbp), %eax
addl -0x48(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x4c(%rbp)
jmp 0x65d23
jmp 0x65dad
cmpl $0x0, -0x4c(%rbp)
jl 0x65e98
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x4c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
movq -0x40(%rbp), %rcx
addq $0x4d, %rcx
addq $0x1, %rcx
movq -0x40(%rbp), %rax
movl 0x48(%rax), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %r8d
movq -0x40(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x1, %eax
movsbl %al, %r9d
callq 0x7c840
cmpl $0x0, %eax
je 0x65e25
movq -0x38(%rbp), %rax
movzbl 0x344(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x65e23
jmp 0x65e8a
jmp 0x65e98
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x38(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpq 0x170(%rcx), %rax
jne 0x65e40
jmp 0x65e8a
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x170(%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x654d0
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x65e88
movl $0x1, -0x4(%rbp)
jmp 0x65e9f
jmp 0x65e8a
movl -0x4c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x65dad
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
ftb_find_relevance_add_word:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_28], rcx
mov rax, [rbp+var_10]
mov rax, [rax+18h]
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
mov rax, [rax]
mov [rbp+var_38], rax
mov [rbp+var_44], 0
mov rax, [rbp+var_38]
mov eax, [rax+80h]
mov [rbp+var_48], eax
mov eax, [rbp+var_44]
add eax, [rbp+var_48]
mov ecx, 2
cdq
idiv ecx
mov [rbp+var_4C], eax
loc_65D23:
mov eax, [rbp+var_48]
sub eax, [rbp+var_44]
cmp eax, 1
jle short loc_65DAB
mov rax, [rbp+var_38]
mov rax, [rax+20h]
movsxd rcx, [rbp+var_4C]
mov rax, [rax+rcx*8]
mov [rbp+var_40], rax
mov rax, [rbp+var_38]
mov rdi, [rax+10h]
mov rsi, [rbp+var_18]
movsxd rdx, [rbp+var_1C]
mov rcx, [rbp+var_40]
add rcx, 4Dh ; 'M'
add rcx, 1
mov rax, [rbp+var_40]
mov eax, [rax+48h]
sub eax, 1
mov eax, eax
mov r8d, eax
mov rax, [rbp+var_40]
mov eax, [rax+8]
and eax, 1
movsx r9d, al
call ha_compare_text
cmp eax, 0
jge short loc_65D8D
mov eax, [rbp+var_4C]
mov [rbp+var_48], eax
jmp short loc_65D93
loc_65D8D:
mov eax, [rbp+var_4C]
mov [rbp+var_44], eax
loc_65D93:
jmp short $+2
loc_65D95:
mov eax, [rbp+var_44]
add eax, [rbp+var_48]
mov ecx, 2
cdq
idiv ecx
mov [rbp+var_4C], eax
jmp loc_65D23
loc_65DAB:
jmp short $+2
loc_65DAD:
cmp [rbp+var_4C], 0
jl loc_65E98
mov rax, [rbp+var_38]
mov rax, [rax+20h]
movsxd rcx, [rbp+var_4C]
mov rax, [rax+rcx*8]
mov [rbp+var_40], rax
mov rax, [rbp+var_38]
mov rdi, [rax+10h]
mov rsi, [rbp+var_18]
movsxd rdx, [rbp+var_1C]
mov rcx, [rbp+var_40]
add rcx, 4Dh ; 'M'
add rcx, 1
mov rax, [rbp+var_40]
mov eax, [rax+48h]
sub eax, 1
mov eax, eax
mov r8d, eax
mov rax, [rbp+var_40]
mov eax, [rax+8]
and eax, 1
movsx r9d, al
call ha_compare_text
cmp eax, 0
jz short loc_65E25
mov rax, [rbp+var_38]
movzx eax, byte ptr [rax+344h]
and eax, 1
cmp eax, 0
jz short loc_65E23
jmp short loc_65E8A
loc_65E23:
jmp short loc_65E98
loc_65E25:
mov rax, [rbp+var_40]
mov rax, [rax+18h]
mov rcx, [rbp+var_38]
mov rcx, [rcx+8]
cmp rax, [rcx+170h]
jnz short loc_65E40
jmp short loc_65E8A
loc_65E40:
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov rcx, [rax+170h]
mov rax, [rbp+var_40]
mov [rax+18h], rcx
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_40]
mov rax, [rbp+var_30]
mov rdx, [rax+8]
call _ftb_climb_the_tree
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_65E88
mov [rbp+var_4], 1
jmp short loc_65E9F
loc_65E88:
jmp short $+2
loc_65E8A:
mov eax, [rbp+var_4C]
add eax, 0FFFFFFFFh
mov [rbp+var_4C], eax
jmp loc_65DAD
loc_65E98:
mov [rbp+var_4], 0
loc_65E9F:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
|
long long ftb_find_relevance_add_word(long long a1, long long a2, int a3)
{
int v4; // [rsp+4h] [rbp-4Ch]
int v5; // [rsp+8h] [rbp-48h]
int v6; // [rsp+Ch] [rbp-44h]
long long v7; // [rsp+10h] [rbp-40h]
long long v8; // [rsp+10h] [rbp-40h]
long long v9; // [rsp+18h] [rbp-38h]
long long *v10; // [rsp+20h] [rbp-30h]
v10 = *(long long **)(a1 + 24);
v9 = *v10;
v6 = 0;
v5 = *(_DWORD *)(*v10 + 128);
v4 = v5 / 2;
while ( v5 - v6 > 1 )
{
v7 = *(_QWORD *)(*(_QWORD *)(v9 + 32) + 8LL * v4);
if ( (int)ha_compare_text(
*(_QWORD *)(v9 + 16),
a2,
a3,
v7 + 78,
(unsigned int)(*(_DWORD *)(v7 + 72) - 1),
*(_BYTE *)(v7 + 8) & 1) >= 0 )
v6 = v4;
else
v5 = v4;
v4 = (v5 + v6) / 2;
}
while ( v4 >= 0 )
{
v8 = *(_QWORD *)(*(_QWORD *)(v9 + 32) + 8LL * v4);
if ( (unsigned int)ha_compare_text(
*(_QWORD *)(v9 + 16),
a2,
a3,
v8 + 78,
(unsigned int)(*(_DWORD *)(v8 + 72) - 1),
*(_BYTE *)(v8 + 8) & 1) )
{
if ( (*(_BYTE *)(v9 + 836) & 1) == 0 )
break;
}
else if ( *(_QWORD *)(v8 + 24) != *(_QWORD *)(*(_QWORD *)(v9 + 8) + 368LL) )
{
*(_QWORD *)(v8 + 24) = *(_QWORD *)(*(_QWORD *)(v9 + 8) + 368LL);
if ( (unsigned int)ftb_climb_the_tree(v9, v8, (_QWORD *)v10[1]) )
return 1;
}
--v4;
}
return 0;
}
|
ftb_find_relevance_add_word:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV dword ptr [RBP + -0x44],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX + 0x80]
MOV dword ptr [RBP + -0x48],EAX
MOV EAX,dword ptr [RBP + -0x44]
ADD EAX,dword ptr [RBP + -0x48]
MOV ECX,0x2
CDQ
IDIV ECX
MOV dword ptr [RBP + -0x4c],EAX
LAB_00165d23:
MOV EAX,dword ptr [RBP + -0x48]
SUB EAX,dword ptr [RBP + -0x44]
CMP EAX,0x1
JLE 0x00165dab
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x20]
MOVSXD RCX,dword ptr [RBP + -0x4c]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RAX + 0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOVSXD RDX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x40]
ADD RCX,0x4d
ADD RCX,0x1
MOV RAX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RAX + 0x48]
SUB EAX,0x1
MOV EAX,EAX
MOV R8D,EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RAX + 0x8]
AND EAX,0x1
MOVSX R9D,AL
CALL 0x0017c840
CMP EAX,0x0
JGE 0x00165d8d
MOV EAX,dword ptr [RBP + -0x4c]
MOV dword ptr [RBP + -0x48],EAX
JMP 0x00165d93
LAB_00165d8d:
MOV EAX,dword ptr [RBP + -0x4c]
MOV dword ptr [RBP + -0x44],EAX
LAB_00165d93:
JMP 0x00165d95
LAB_00165d95:
MOV EAX,dword ptr [RBP + -0x44]
ADD EAX,dword ptr [RBP + -0x48]
MOV ECX,0x2
CDQ
IDIV ECX
MOV dword ptr [RBP + -0x4c],EAX
JMP 0x00165d23
LAB_00165dab:
JMP 0x00165dad
LAB_00165dad:
CMP dword ptr [RBP + -0x4c],0x0
JL 0x00165e98
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x20]
MOVSXD RCX,dword ptr [RBP + -0x4c]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RAX + 0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOVSXD RDX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x40]
ADD RCX,0x4d
ADD RCX,0x1
MOV RAX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RAX + 0x48]
SUB EAX,0x1
MOV EAX,EAX
MOV R8D,EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RAX + 0x8]
AND EAX,0x1
MOVSX R9D,AL
CALL 0x0017c840
CMP EAX,0x0
JZ 0x00165e25
MOV RAX,qword ptr [RBP + -0x38]
MOVZX EAX,byte ptr [RAX + 0x344]
AND EAX,0x1
CMP EAX,0x0
JZ 0x00165e23
JMP 0x00165e8a
LAB_00165e23:
JMP 0x00165e98
LAB_00165e25:
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RCX + 0x8]
CMP RAX,qword ptr [RCX + 0x170]
JNZ 0x00165e40
JMP 0x00165e8a
LAB_00165e40:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RAX + 0x170]
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX + 0x18],RCX
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x001654d0
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x00165e88
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00165e9f
LAB_00165e88:
JMP 0x00165e8a
LAB_00165e8a:
MOV EAX,dword ptr [RBP + -0x4c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x4c],EAX
JMP 0x00165dad
LAB_00165e98:
MOV dword ptr [RBP + -0x4],0x0
LAB_00165e9f:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
int4 ftb_find_relevance_add_word(long param_1,int8 param_2,int param_3)
{
long *plVar1;
long lVar2;
long lVar3;
int iVar4;
int local_54;
int local_50;
int local_4c;
plVar1 = *(long **)(param_1 + 0x18);
lVar2 = *plVar1;
local_4c = 0;
local_50 = *(int *)(lVar2 + 0x80);
local_54 = local_50;
while (local_54 = local_54 / 2, 1 < local_50 - local_4c) {
lVar3 = *(long *)(*(long *)(lVar2 + 0x20) + (long)local_54 * 8);
iVar4 = ha_compare_text(*(int8 *)(lVar2 + 0x10),param_2,(long)param_3,lVar3 + 0x4e,
*(int *)(lVar3 + 0x48) + -1,(byte)*(int4 *)(lVar3 + 8) & 1);
if (iVar4 < 0) {
local_50 = local_54;
}
else {
local_4c = local_54;
}
local_54 = local_4c + local_50;
}
do {
if (local_54 < 0) {
return 0;
}
lVar3 = *(long *)(*(long *)(lVar2 + 0x20) + (long)local_54 * 8);
iVar4 = ha_compare_text(*(int8 *)(lVar2 + 0x10),param_2,(long)param_3,lVar3 + 0x4e,
*(int *)(lVar3 + 0x48) + -1,(byte)*(int4 *)(lVar3 + 8) & 1);
if (iVar4 == 0) {
if (*(long *)(lVar3 + 0x18) != *(long *)(*(long *)(lVar2 + 8) + 0x170)) {
*(int8 *)(lVar3 + 0x18) = *(int8 *)(*(long *)(lVar2 + 8) + 0x170);
iVar4 = _ftb_climb_the_tree(lVar2,lVar3,plVar1[1]);
if (iVar4 != 0) {
return 1;
}
}
}
else if ((*(byte *)(lVar2 + 0x344) & 1) == 0) {
return 0;
}
local_54 = local_54 + -1;
} while( true );
}
|
|
8,117 |
maria_page_filler_set_normal
|
eloqsql/storage/maria/ma_pagecrc.c
|
my_bool maria_page_filler_set_normal(PAGECACHE_IO_HOOK_ARGS *args)
{
uchar *page= args->page;
#ifdef DBUG_ASSERT_EXISTS
pgcache_page_no_t page_no= args->pageno;
#endif
MARIA_SHARE *share= (MARIA_SHARE *)args->data;
DBUG_ENTER("maria_page_filler_set_normal");
DBUG_ASSERT(page_no != 0); /* Catches some simple bugs */
int4store_aligned(page + share->block_size - CRC_SIZE,
MARIA_NO_CRC_NORMAL_PAGE);
DBUG_RETURN(0);
}
|
O0
|
c
|
maria_page_filler_set_normal:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3f981
jmp 0x3f983
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x7bc(%rcx), %ecx
addq %rcx, %rax
addq $-0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
jmp 0x3f9a8
jmp 0x3f9aa
xorl %eax, %eax
popq %rbp
retq
nop
|
maria_page_filler_set_normal:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov [rbp+var_18], rax
jmp short $+2
loc_3F981:
jmp short $+2
loc_3F983:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_18]
mov ecx, [rcx+7BCh]
add rax, rcx
add rax, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov dword ptr [rax], 0FFFFFFFFh
jmp short $+2
loc_3F9A8:
jmp short $+2
loc_3F9AA:
xor eax, eax
pop rbp
retn
|
long long maria_page_filler_set_normal(_QWORD *a1)
{
*(_DWORD *)(*(unsigned int *)(a1[2] + 1980LL) + *a1 - 4LL) = -1;
return 0LL;
}
|
maria_page_filler_set_normal:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0013f981
LAB_0013f981:
JMP 0x0013f983
LAB_0013f983:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RCX + 0x7bc]
ADD RAX,RCX
ADD RAX,-0x4
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0xffffffff
JMP 0x0013f9a8
LAB_0013f9a8:
JMP 0x0013f9aa
LAB_0013f9aa:
XOR EAX,EAX
POP RBP
RET
|
int8 maria_page_filler_set_normal(long *param_1)
{
*(int4 *)(*param_1 + (ulong)*(uint *)(param_1[2] + 0x7bc) + -4) = 0xffffffff;
return 0;
}
|
|
8,118 |
rw_pr_rdlock
|
eloqsql/mysys/thr_rwlock.c
|
int rw_pr_rdlock(rw_pr_lock_t *rwlock)
{
pthread_mutex_lock(&rwlock->lock);
/*
The fact that we were able to acquire 'lock' mutex means
that there are no active writers and we can acquire rd-lock.
Increment active readers counter to prevent requests for
wr-lock from succeeding and unlock mutex.
*/
rwlock->active_readers++;
pthread_mutex_unlock(&rwlock->lock);
return 0;
}
|
O3
|
c
|
rw_pr_rdlock:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x36260
incl 0x58(%rbx)
movq %rbx, %rdi
callq 0x36220
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
rw_pr_rdlock:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
call _pthread_mutex_lock
inc dword ptr [rbx+58h]
mov rdi, rbx
call _pthread_mutex_unlock
xor eax, eax
add rsp, 8
pop rbx
pop rbp
retn
|
long long rw_pr_rdlock(long long a1)
{
pthread_mutex_lock(a1);
++*(_DWORD *)(a1 + 88);
pthread_mutex_unlock(a1);
return 0LL;
}
|
rw_pr_rdlock:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
CALL 0x00136260
INC dword ptr [RBX + 0x58]
MOV RDI,RBX
CALL 0x00136220
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP RBP
RET
|
int8 rw_pr_rdlock(pthread_mutex_t *param_1)
{
pthread_mutex_lock(param_1);
*(int *)((long)param_1 + 0x58) = *(int *)((long)param_1 + 0x58) + 1;
pthread_mutex_unlock(param_1);
return 0;
}
|
|
8,119 |
thr_reschedule_write_lock
|
eloqsql/mysys/thr_lock.c
|
my_bool thr_reschedule_write_lock(THR_LOCK_DATA *data,
ulong lock_wait_timeout)
{
THR_LOCK *lock=data->lock;
enum thr_lock_type write_lock_type;
DBUG_ENTER("thr_reschedule_write_lock");
mysql_mutex_lock(&lock->mutex);
if (!lock->read_wait.data) /* No waiting read locks */
{
mysql_mutex_unlock(&lock->mutex);
DBUG_RETURN(0);
}
write_lock_type= data->type;
data->type=TL_WRITE_DELAYED;
if (lock->update_status)
(*lock->update_status)(data->status_param);
if (((*data->prev)=data->next)) /* remove from lock-list */
data->next->prev= data->prev;
else
lock->write.last=data->prev;
if ((data->next=lock->write_wait.data)) /* Put first in lock_list */
data->next->prev= &data->next;
else
lock->write_wait.last= &data->next;
data->prev= &lock->write_wait.data;
data->cond=get_cond(); /* This was zero */
lock->write_wait.data=data;
free_all_read_locks(lock,0);
mysql_mutex_unlock(&lock->mutex);
DBUG_RETURN(thr_upgrade_write_delay_lock(data, write_lock_type,
lock_wait_timeout));
}
|
O3
|
c
|
thr_reschedule_write_lock:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq 0x18(%rdi), %r12
leaq 0x18(%r12), %rbx
cmpq $0x0, 0x58(%r12)
jne 0xc3823
movq %rbx, %rdi
callq 0x2a230
cmpq $0x0, 0x60(%r12)
je 0xc3800
movq %r14, -0x38(%rbp)
leaq 0x60(%r12), %r13
movl 0x40(%r15), %eax
movl %eax, -0x2c(%rbp)
movl $0x9, 0x40(%r15)
movq 0xc0(%r12), %rax
testq %rax, %rax
je 0xc36d4
movq 0x28(%r15), %rdi
callq *%rax
leaq 0x8(%r15), %rax
movq 0x8(%r15), %rcx
movq 0x10(%r15), %rdx
movq %rcx, (%rdx)
leaq 0x98(%r12), %rdx
leaq 0x10(%rcx), %rsi
testq %rcx, %rcx
cmoveq %rdx, %rsi
movq 0x10(%r15), %rcx
movq %rcx, (%rsi)
leaq 0x80(%r12), %rcx
movq 0x80(%r12), %rdx
movq %rdx, 0x8(%r15)
leaq 0x88(%r12), %rsi
leaq 0x10(%rdx), %rdi
testq %rdx, %rdx
cmoveq %rsi, %rdi
movq %rax, (%rdi)
movq %rcx, 0x10(%r15)
callq 0xc14ee
addq $0x8, %rax
movq %rax, 0x20(%r15)
movq %r15, 0x80(%r12)
movq 0x60(%r12), %r14
movq 0x78(%r12), %rax
movq %r14, (%rax)
movq 0x78(%r12), %rax
movq %rax, 0x10(%r14)
movq 0x68(%r12), %rax
movq %rax, 0x78(%r12)
movq %r13, 0x68(%r12)
movq 0x20(%r14), %r13
cmpl $0x5, 0x40(%r14)
jne 0xc3778
incl 0xa8(%r12)
movq $0x0, 0x20(%r14)
movq 0x30(%r13), %rdi
testq %rdi, %rdi
jne 0xc379c
movq %r13, %rdi
callq 0x2a630
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0xc3765
jmp 0xc37ae
leaq 0x2eb275(%rip), %rax # 0x3aea18
movq (%rax), %rax
callq *0x170(%rax)
jmp 0xc3789
movq 0x68(%r12), %rax
movq $0x0, (%rax)
cmpq $0x0, 0x60(%r12)
jne 0xc37ce
movq $0x0, 0xa0(%r12)
movq 0x58(%r12), %rdi
testq %rdi, %rdi
movq -0x38(%rbp), %r14
jne 0xc383c
movq %rbx, %rdi
callq 0x2a1f0
movq %r15, %rdi
movl -0x2c(%rbp), %esi
movq %r14, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc31e7
movq 0x58(%r12), %rdi
testq %rdi, %rdi
jne 0xc384e
movq %rbx, %rdi
callq 0x2a1f0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3d03f(%rip), %rsi # 0x100869
movq %rbx, %rdi
movl $0x5de, %edx # imm = 0x5DE
callq 0x312ea
jmp 0xc369d
leaq 0x2eb1d5(%rip), %rax # 0x3aea18
movq (%rax), %rax
callq *0x160(%rax)
jmp 0xc37dc
leaq 0x2eb1c3(%rip), %rax # 0x3aea18
movq (%rax), %rax
callq *0x160(%rax)
jmp 0xc380a
|
thr_reschedule_write_lock:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r14, rsi
mov r15, rdi
mov r12, [rdi+18h]
lea rbx, [r12+18h]
cmp qword ptr [r12+58h], 0
jnz loc_C3823
mov rdi, rbx
call _pthread_mutex_lock
loc_C369D:
cmp qword ptr [r12+60h], 0
jz loc_C3800
mov [rbp+var_38], r14
lea r13, [r12+60h]
mov eax, [r15+40h]
mov [rbp+var_2C], eax
mov dword ptr [r15+40h], 9
mov rax, [r12+0C0h]
test rax, rax
jz short loc_C36D4
mov rdi, [r15+28h]
call rax
loc_C36D4:
lea rax, [r15+8]
mov rcx, [r15+8]
mov rdx, [r15+10h]
mov [rdx], rcx
lea rdx, [r12+98h]
lea rsi, [rcx+10h]
test rcx, rcx
cmovz rsi, rdx
mov rcx, [r15+10h]
mov [rsi], rcx
lea rcx, [r12+80h]
mov rdx, [r12+80h]
mov [r15+8], rdx
lea rsi, [r12+88h]
lea rdi, [rdx+10h]
test rdx, rdx
cmovz rdi, rsi
mov [rdi], rax
mov [r15+10h], rcx
call _my_thread_var
add rax, 8
mov [r15+20h], rax
mov [r12+80h], r15
mov r14, [r12+60h]
mov rax, [r12+78h]
mov [rax], r14
mov rax, [r12+78h]
mov [r14+10h], rax
mov rax, [r12+68h]
mov [r12+78h], rax
mov [r12+68h], r13
loc_C3765:
mov r13, [r14+20h]
cmp dword ptr [r14+40h], 5
jnz short loc_C3778
inc dword ptr [r12+0A8h]
loc_C3778:
mov qword ptr [r14+20h], 0
mov rdi, [r13+30h]
test rdi, rdi
jnz short loc_C379C
loc_C3789:
mov rdi, r13
call _pthread_cond_signal
mov r14, [r14+8]
test r14, r14
jnz short loc_C3765
jmp short loc_C37AE
loc_C379C:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+170h]
jmp short loc_C3789
loc_C37AE:
mov rax, [r12+68h]
mov qword ptr [rax], 0
cmp qword ptr [r12+60h], 0
jnz short loc_C37CE
mov qword ptr [r12+0A0h], 0
loc_C37CE:
mov rdi, [r12+58h]
test rdi, rdi
mov r14, [rbp+var_38]
jnz short loc_C383C
loc_C37DC:
mov rdi, rbx
call _pthread_mutex_unlock
mov rdi, r15
mov esi, [rbp+var_2C]
mov rdx, r14
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp thr_upgrade_write_delay_lock
loc_C3800:
mov rdi, [r12+58h]
test rdi, rdi
jnz short loc_C384E
loc_C380A:
mov rdi, rbx
call _pthread_mutex_unlock
xor eax, eax
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_C3823:
lea rsi, aWorkspaceLlm4b_29; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, rbx
mov edx, 5DEh
call psi_mutex_lock
jmp loc_C369D
loc_C383C:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_C37DC
loc_C384E:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_C380A
|
char thr_reschedule_write_lock(long long a1, long long a2)
{
long long v3; // r12
void ( *v4)(_QWORD); // rax
long long v5; // rax
long long v6; // rcx
_QWORD *v7; // rsi
long long v8; // rdx
long long v9; // rsi
long long *v10; // rdi
long long v11; // rdx
long long v12; // rcx
long long v13; // r14
long long v14; // r13
long long v15; // rdi
long long v16; // rdi
int v19; // [rsp+14h] [rbp-2Ch]
v3 = *(_QWORD *)(a1 + 24);
if ( *(_QWORD *)(v3 + 88) )
psi_mutex_lock(v3 + 24, (long long)"/workspace/llm4binary/github2025/eloqsql/mysys/thr_lock.c", 0x5DEu);
else
pthread_mutex_lock(v3 + 24);
if ( *(_QWORD *)(v3 + 96) )
{
v19 = *(_DWORD *)(a1 + 64);
*(_DWORD *)(a1 + 64) = 9;
v4 = *(void ( **)(_QWORD))(v3 + 192);
if ( v4 )
v4(*(_QWORD *)(a1 + 40));
v5 = a1 + 8;
v6 = *(_QWORD *)(a1 + 8);
**(_QWORD **)(a1 + 16) = v6;
v7 = (_QWORD *)(v6 + 16);
if ( !v6 )
v7 = (_QWORD *)(v3 + 152);
*v7 = *(_QWORD *)(a1 + 16);
v8 = *(_QWORD *)(v3 + 128);
*(_QWORD *)(a1 + 8) = v8;
v9 = v3 + 136;
v10 = (long long *)(v8 + 16);
if ( !v8 )
v10 = (long long *)(v3 + 136);
*v10 = v5;
*(_QWORD *)(a1 + 16) = v3 + 128;
*(_QWORD *)(a1 + 32) = my_thread_var() + 8;
*(_QWORD *)(v3 + 128) = a1;
v13 = *(_QWORD *)(v3 + 96);
**(_QWORD **)(v3 + 120) = v13;
*(_QWORD *)(v13 + 16) = *(_QWORD *)(v3 + 120);
*(_QWORD *)(v3 + 120) = *(_QWORD *)(v3 + 104);
*(_QWORD *)(v3 + 104) = v3 + 96;
do
{
v14 = *(_QWORD *)(v13 + 32);
if ( *(_DWORD *)(v13 + 64) == 5 )
++*(_DWORD *)(v3 + 168);
*(_QWORD *)(v13 + 32) = 0LL;
v15 = *(_QWORD *)(v14 + 48);
if ( v15 )
((void ( *)(long long, long long, long long, long long))PSI_server[46])(v15, v9, v11, v12);
pthread_cond_signal(v14);
v13 = *(_QWORD *)(v13 + 8);
}
while ( v13 );
**(_QWORD **)(v3 + 104) = 0LL;
if ( !*(_QWORD *)(v3 + 96) )
*(_QWORD *)(v3 + 160) = 0LL;
v16 = *(_QWORD *)(v3 + 88);
if ( v16 )
((void ( *)(long long, long long, long long, long long))PSI_server[44])(v16, v9, v11, v12);
pthread_mutex_unlock(v3 + 24);
return thr_upgrade_write_delay_lock(a1, v19, a2);
}
else
{
if ( *(_QWORD *)(v3 + 88) )
PSI_server[44]();
pthread_mutex_unlock(v3 + 24);
return 0;
}
}
|
thr_reschedule_write_lock:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R14,RSI
MOV R15,RDI
MOV R12,qword ptr [RDI + 0x18]
LEA RBX,[R12 + 0x18]
CMP qword ptr [R12 + 0x58],0x0
JNZ 0x001c3823
MOV RDI,RBX
CALL 0x0012a230
LAB_001c369d:
CMP qword ptr [R12 + 0x60],0x0
JZ 0x001c3800
MOV qword ptr [RBP + -0x38],R14
LEA R13,[R12 + 0x60]
MOV EAX,dword ptr [R15 + 0x40]
MOV dword ptr [RBP + -0x2c],EAX
MOV dword ptr [R15 + 0x40],0x9
MOV RAX,qword ptr [R12 + 0xc0]
TEST RAX,RAX
JZ 0x001c36d4
MOV RDI,qword ptr [R15 + 0x28]
CALL RAX
LAB_001c36d4:
LEA RAX,[R15 + 0x8]
MOV RCX,qword ptr [R15 + 0x8]
MOV RDX,qword ptr [R15 + 0x10]
MOV qword ptr [RDX],RCX
LEA RDX,[R12 + 0x98]
LEA RSI,[RCX + 0x10]
TEST RCX,RCX
CMOVZ RSI,RDX
MOV RCX,qword ptr [R15 + 0x10]
MOV qword ptr [RSI],RCX
LEA RCX,[R12 + 0x80]
MOV RDX,qword ptr [R12 + 0x80]
MOV qword ptr [R15 + 0x8],RDX
LEA RSI,[R12 + 0x88]
LEA RDI,[RDX + 0x10]
TEST RDX,RDX
CMOVZ RDI,RSI
MOV qword ptr [RDI],RAX
MOV qword ptr [R15 + 0x10],RCX
CALL 0x001c14ee
ADD RAX,0x8
MOV qword ptr [R15 + 0x20],RAX
MOV qword ptr [R12 + 0x80],R15
MOV R14,qword ptr [R12 + 0x60]
MOV RAX,qword ptr [R12 + 0x78]
MOV qword ptr [RAX],R14
MOV RAX,qword ptr [R12 + 0x78]
MOV qword ptr [R14 + 0x10],RAX
MOV RAX,qword ptr [R12 + 0x68]
MOV qword ptr [R12 + 0x78],RAX
MOV qword ptr [R12 + 0x68],R13
LAB_001c3765:
MOV R13,qword ptr [R14 + 0x20]
CMP dword ptr [R14 + 0x40],0x5
JNZ 0x001c3778
INC dword ptr [R12 + 0xa8]
LAB_001c3778:
MOV qword ptr [R14 + 0x20],0x0
MOV RDI,qword ptr [R13 + 0x30]
TEST RDI,RDI
JNZ 0x001c379c
LAB_001c3789:
MOV RDI,R13
CALL 0x0012a630
MOV R14,qword ptr [R14 + 0x8]
TEST R14,R14
JNZ 0x001c3765
JMP 0x001c37ae
LAB_001c379c:
LEA RAX,[0x4aea18]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x170]
JMP 0x001c3789
LAB_001c37ae:
MOV RAX,qword ptr [R12 + 0x68]
MOV qword ptr [RAX],0x0
CMP qword ptr [R12 + 0x60],0x0
JNZ 0x001c37ce
MOV qword ptr [R12 + 0xa0],0x0
LAB_001c37ce:
MOV RDI,qword ptr [R12 + 0x58]
TEST RDI,RDI
MOV R14,qword ptr [RBP + -0x38]
JNZ 0x001c383c
LAB_001c37dc:
MOV RDI,RBX
CALL 0x0012a1f0
MOV RDI,R15
MOV ESI,dword ptr [RBP + -0x2c]
MOV RDX,R14
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001c31e7
LAB_001c3800:
MOV RDI,qword ptr [R12 + 0x58]
TEST RDI,RDI
JNZ 0x001c384e
LAB_001c380a:
MOV RDI,RBX
CALL 0x0012a1f0
XOR EAX,EAX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001c3823:
LEA RSI,[0x200869]
MOV RDI,RBX
MOV EDX,0x5de
CALL 0x001312ea
JMP 0x001c369d
LAB_001c383c:
LEA RAX,[0x4aea18]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x001c37dc
LAB_001c384e:
LEA RAX,[0x4aea18]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x001c380a
|
int8 thr_reschedule_write_lock(long param_1,int8 param_2)
{
pthread_mutex_t *__mutex;
int4 uVar1;
long lVar2;
pthread_cond_t *__cond;
long lVar3;
int8 uVar4;
int8 *puVar5;
long *plVar6;
lVar2 = *(long *)(param_1 + 0x18);
__mutex = (pthread_mutex_t *)(lVar2 + 0x18);
if (*(long *)(lVar2 + 0x58) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/mysys/thr_lock.c",0x5de);
}
if (*(long *)(lVar2 + 0x60) != 0) {
uVar1 = *(int4 *)(param_1 + 0x40);
*(int4 *)(param_1 + 0x40) = 9;
if (*(code **)(lVar2 + 0xc0) != (code *)0x0) {
(**(code **)(lVar2 + 0xc0))(*(int8 *)(param_1 + 0x28));
}
lVar3 = *(long *)(param_1 + 8);
**(long **)(param_1 + 0x10) = lVar3;
puVar5 = (int8 *)(lVar3 + 0x10);
if (lVar3 == 0) {
puVar5 = (int8 *)(lVar2 + 0x98);
}
*puVar5 = *(int8 *)(param_1 + 0x10);
lVar3 = *(long *)(lVar2 + 0x80);
*(long *)(param_1 + 8) = lVar3;
plVar6 = (long *)(lVar3 + 0x10);
if (lVar3 == 0) {
plVar6 = (long *)(lVar2 + 0x88);
}
*plVar6 = param_1 + 8;
*(long *)(param_1 + 0x10) = lVar2 + 0x80;
lVar3 = _my_thread_var();
*(long *)(param_1 + 0x20) = lVar3 + 8;
*(long *)(lVar2 + 0x80) = param_1;
lVar3 = *(long *)(lVar2 + 0x60);
**(long **)(lVar2 + 0x78) = lVar3;
*(int8 *)(lVar3 + 0x10) = *(int8 *)(lVar2 + 0x78);
*(int8 *)(lVar2 + 0x78) = *(int8 *)(lVar2 + 0x68);
*(long *)(lVar2 + 0x68) = lVar2 + 0x60;
do {
__cond = *(pthread_cond_t **)(lVar3 + 0x20);
if (*(int *)(lVar3 + 0x40) == 5) {
*(int *)(lVar2 + 0xa8) = *(int *)(lVar2 + 0xa8) + 1;
}
*(int8 *)(lVar3 + 0x20) = 0;
if (__cond[1].__align != 0) {
(**(code **)(PSI_server + 0x170))();
}
pthread_cond_signal(__cond);
lVar3 = *(long *)(lVar3 + 8);
} while (lVar3 != 0);
**(int8 **)(lVar2 + 0x68) = 0;
if (*(long *)(lVar2 + 0x60) == 0) {
*(int8 *)(lVar2 + 0xa0) = 0;
}
if (*(long *)(lVar2 + 0x58) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
uVar4 = thr_upgrade_write_delay_lock(param_1,uVar1,param_2);
return uVar4;
}
if (*(long *)(lVar2 + 0x58) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
return 0;
}
|
|
8,120 |
js_reflect_get
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_reflect_get(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue obj, prop, receiver;
JSAtom atom;
JSValue ret;
obj = argv[0];
prop = argv[1];
if (JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT)
return JS_ThrowTypeErrorNotAnObject(ctx);
if (argc > 2)
receiver = argv[2];
else
receiver = obj;
atom = JS_ValueToAtom(ctx, prop);
if (unlikely(atom == JS_ATOM_NULL))
return JS_EXCEPTION;
ret = JS_GetPropertyInternal(ctx, obj, atom, receiver, FALSE);
JS_FreeAtom(ctx, atom);
return ret;
}
|
O1
|
c
|
js_reflect_get:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%r8), %r14
cmpl $-0x1, %r14d
jne 0x128d1
movq (%r8), %r15
movq 0x10(%r8), %rsi
movq 0x18(%r8), %rdx
movq %r15, %r12
movq %r14, %r13
cmpl $0x3, %ecx
jl 0x12885
movq 0x20(%r8), %r12
movq 0x28(%r8), %r13
movq %rbx, %rdi
callq 0x2347f
testl %eax, %eax
je 0x12903
movl %eax, %ebp
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %eax, %ecx
movq %r12, %r8
movq %r13, %r9
pushq $0x0
pushq $0x0
callq 0x2238f
popq %rcx
popq %rsi
movq %rax, %r15
movq %rdx, %r14
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1fbc4
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
andq %r15, %rax
movl %r15d, %r15d
jmp 0x128eb
leaq 0x8b045(%rip), %rsi # 0x9d91d
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21953
pushq $0x6
popq %r14
xorl %eax, %eax
orq %rax, %r15
movq %r15, %rax
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x6
popq %r14
xorl %r15d, %r15d
jmp 0x128e9
|
js_reflect_get:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
mov r14, [r8+8]
cmp r14d, 0FFFFFFFFh
jnz short loc_128D1
mov r15, [r8]
mov rsi, [r8+10h]
mov rdx, [r8+18h]
mov r12, r15
mov r13, r14
cmp ecx, 3
jl short loc_12885
mov r12, [r8+20h]
mov r13, [r8+28h]
loc_12885:
mov rdi, rbx
call JS_ValueToAtom
test eax, eax
jz short loc_12903
mov ebp, eax
mov rdi, rbx
mov rsi, r15
mov rdx, r14
mov ecx, eax
mov r8, r12
mov r9, r13
push 0
push 0
call JS_GetPropertyInternal2
pop rcx
pop rsi
mov r15, rax
mov r14, rdx
mov rdi, rbx
mov esi, ebp
call JS_FreeAtom
mov rax, 0FFFFFFFF00000000h
and rax, r15
mov r15d, r15d
jmp short loc_128EB
loc_128D1:
lea rsi, aOperandPrototy+20h; "not an object"
xor r15d, r15d
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
push 6
pop r14
loc_128E9:
xor eax, eax
loc_128EB:
or r15, rax
mov rax, r15
mov rdx, r14
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_12903:
push 6
pop r14
xor r15d, r15d
jmp short loc_128E9
|
unsigned long long js_reflect_get(long long a1, long long a2, int a3, int a4, long long *a5, int a6)
{
long long v6; // r15
long long v7; // r12
long long v8; // r13
unsigned int v9; // eax
unsigned int v10; // ebp
unsigned long long v11; // rax
long long PropertyInternal2; // r15
if ( (unsigned int)a5[1] != -1 )
{
PropertyInternal2 = 0LL;
JS_ThrowTypeError(a1, (unsigned int)"not an object", a3, a4, (_DWORD)a5, a6);
LABEL_7:
v11 = 0LL;
return v11 | PropertyInternal2;
}
v6 = *a5;
v7 = *a5;
LODWORD(v8) = -1;
if ( a4 >= 3 )
{
v7 = a5[4];
v8 = a5[5];
}
v9 = JS_ValueToAtom(a1, a5[2], a5[3]);
if ( !v9 )
{
PropertyInternal2 = 0LL;
goto LABEL_7;
}
v10 = v9;
PropertyInternal2 = JS_GetPropertyInternal2(a1, v6, -1, v9, v7, v8, 0LL, 0);
JS_FreeAtom(a1, v10);
v11 = PropertyInternal2 & 0xFFFFFFFF00000000LL;
PropertyInternal2 = (unsigned int)PropertyInternal2;
return v11 | PropertyInternal2;
}
|
js_reflect_get:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R14,qword ptr [R8 + 0x8]
CMP R14D,-0x1
JNZ 0x001128d1
MOV R15,qword ptr [R8]
MOV RSI,qword ptr [R8 + 0x10]
MOV RDX,qword ptr [R8 + 0x18]
MOV R12,R15
MOV R13,R14
CMP ECX,0x3
JL 0x00112885
MOV R12,qword ptr [R8 + 0x20]
MOV R13,qword ptr [R8 + 0x28]
LAB_00112885:
MOV RDI,RBX
CALL 0x0012347f
TEST EAX,EAX
JZ 0x00112903
MOV EBP,EAX
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
MOV ECX,EAX
MOV R8,R12
MOV R9,R13
PUSH 0x0
PUSH 0x0
CALL 0x0012238f
POP RCX
POP RSI
MOV R15,RAX
MOV R14,RDX
MOV RDI,RBX
MOV ESI,EBP
CALL 0x0011fbc4
MOV RAX,-0x100000000
AND RAX,R15
MOV R15D,R15D
JMP 0x001128eb
LAB_001128d1:
LEA RSI,[0x19d91d]
XOR R15D,R15D
MOV RDI,RBX
XOR EAX,EAX
CALL 0x00121953
PUSH 0x6
POP R14
LAB_001128e9:
XOR EAX,EAX
LAB_001128eb:
OR R15,RAX
MOV RAX,R15
MOV RDX,R14
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00112903:
PUSH 0x6
POP R14
XOR R15D,R15D
JMP 0x001128e9
|
int1 [16]
js_reflect_get(int8 param_1,int8 param_2,int8 param_3,int param_4,
int8 *param_5)
{
int8 uVar1;
int iVar2;
ulong uVar3;
int8 uVar4;
int8 uVar5;
int8 uVar6;
ulong uVar7;
int1 auVar8 [16];
int8 uVar9;
uVar6 = param_5[1];
if ((int)uVar6 == -1) {
uVar1 = *param_5;
uVar4 = uVar1;
uVar5 = uVar6;
if (2 < param_4) {
uVar4 = param_5[4];
uVar5 = param_5[5];
}
iVar2 = JS_ValueToAtom(param_1,param_5[2],param_5[3]);
if (iVar2 != 0) {
uVar9 = 0;
auVar8 = JS_GetPropertyInternal2(param_1,uVar1,uVar6,iVar2,uVar4,uVar5,0,0);
uVar6 = auVar8._8_8_;
JS_FreeAtom(param_1,iVar2,uVar6,uVar9);
uVar3 = auVar8._0_8_ & 0xffffffff00000000;
uVar7 = auVar8._0_8_ & 0xffffffff;
goto LAB_001128eb;
}
}
else {
JS_ThrowTypeError(param_1,"not an object");
}
uVar6 = 6;
uVar7 = 0;
uVar3 = 0;
LAB_001128eb:
auVar8._8_8_ = uVar6;
auVar8._0_8_ = uVar7 | uVar3;
return auVar8;
}
|
|
8,121 |
js_reflect_get
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_reflect_get(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue obj, prop, receiver;
JSAtom atom;
JSValue ret;
obj = argv[0];
prop = argv[1];
if (JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT)
return JS_ThrowTypeErrorNotAnObject(ctx);
if (argc > 2)
receiver = argv[2];
else
receiver = obj;
atom = JS_ValueToAtom(ctx, prop);
if (unlikely(atom == JS_ATOM_NULL))
return JS_EXCEPTION;
ret = JS_GetPropertyInternal(ctx, obj, atom, receiver, FALSE);
JS_FreeAtom(ctx, atom);
return ret;
}
|
O3
|
c
|
js_reflect_get:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%r8), %r14
cmpl $-0x1, %r14d
jne 0x12f7d
movq (%r8), %r15
movq 0x10(%r8), %rsi
movq 0x18(%r8), %rdx
movq %r15, %r12
movq %r14, %r13
cmpl $0x3, %ecx
jl 0x12f31
movq 0x20(%r8), %r12
movq 0x28(%r8), %r13
movq %rbx, %rdi
callq 0x23ad1
testl %eax, %eax
je 0x12faf
movl %eax, %ebp
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %eax, %ecx
movq %r12, %r8
movq %r13, %r9
pushq $0x0
pushq $0x0
callq 0x22c0f
popq %rcx
popq %rsi
movq %rax, %r15
movq %rdx, %r14
movq %rbx, %rdi
movl %ebp, %esi
callq 0x202f5
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
andq %r15, %rax
movl %r15d, %r15d
jmp 0x12f97
leaq 0x8d969(%rip), %rsi # 0xa08ed
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2214f
pushq $0x6
popq %r14
xorl %eax, %eax
orq %rax, %r15
movq %r15, %rax
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x6
popq %r14
xorl %r15d, %r15d
jmp 0x12f95
|
js_reflect_get:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
mov r14, [r8+8]
cmp r14d, 0FFFFFFFFh
jnz short loc_12F7D
mov r15, [r8]
mov rsi, [r8+10h]
mov rdx, [r8+18h]
mov r12, r15
mov r13, r14
cmp ecx, 3
jl short loc_12F31
mov r12, [r8+20h]
mov r13, [r8+28h]
loc_12F31:
mov rdi, rbx
call JS_ValueToAtom
test eax, eax
jz short loc_12FAF
mov ebp, eax
mov rdi, rbx
mov rsi, r15
mov rdx, r14
mov ecx, eax
mov r8, r12
mov r9, r13
push 0
push 0
call JS_GetPropertyInternal2
pop rcx
pop rsi
mov r15, rax
mov r14, rdx
mov rdi, rbx
mov esi, ebp
call JS_FreeAtom
mov rax, 0FFFFFFFF00000000h
and rax, r15
mov r15d, r15d
jmp short loc_12F97
loc_12F7D:
lea rsi, aOperandPrototy+20h; "not an object"
xor r15d, r15d
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
push 6
pop r14
loc_12F95:
xor eax, eax
loc_12F97:
or r15, rax
mov rax, r15
mov rdx, r14
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_12FAF:
push 6
pop r14
xor r15d, r15d
jmp short loc_12F95
|
unsigned long long js_reflect_get(long long a1, long long a2, int a3, int a4, long long *a5, int a6)
{
long long v6; // r15
long long v7; // r12
long long v8; // r13
unsigned int v9; // eax
unsigned int v10; // ebp
unsigned long long v11; // rax
long long PropertyInternal2; // r15
if ( (unsigned int)a5[1] != -1 )
{
PropertyInternal2 = 0LL;
JS_ThrowTypeError(a1, (unsigned int)"not an object", a3, a4, (_DWORD)a5, a6);
LABEL_7:
v11 = 0LL;
return v11 | PropertyInternal2;
}
v6 = *a5;
v7 = *a5;
LODWORD(v8) = -1;
if ( a4 >= 3 )
{
v7 = a5[4];
v8 = a5[5];
}
v9 = JS_ValueToAtom(a1, a5[2], a5[3]);
if ( !v9 )
{
PropertyInternal2 = 0LL;
goto LABEL_7;
}
v10 = v9;
PropertyInternal2 = JS_GetPropertyInternal2(a1, v6, -1, v9, v7, v8, 0LL, 0);
JS_FreeAtom(a1, v10);
v11 = PropertyInternal2 & 0xFFFFFFFF00000000LL;
PropertyInternal2 = (unsigned int)PropertyInternal2;
return v11 | PropertyInternal2;
}
|
js_reflect_get:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R14,qword ptr [R8 + 0x8]
CMP R14D,-0x1
JNZ 0x00112f7d
MOV R15,qword ptr [R8]
MOV RSI,qword ptr [R8 + 0x10]
MOV RDX,qword ptr [R8 + 0x18]
MOV R12,R15
MOV R13,R14
CMP ECX,0x3
JL 0x00112f31
MOV R12,qword ptr [R8 + 0x20]
MOV R13,qword ptr [R8 + 0x28]
LAB_00112f31:
MOV RDI,RBX
CALL 0x00123ad1
TEST EAX,EAX
JZ 0x00112faf
MOV EBP,EAX
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
MOV ECX,EAX
MOV R8,R12
MOV R9,R13
PUSH 0x0
PUSH 0x0
CALL 0x00122c0f
POP RCX
POP RSI
MOV R15,RAX
MOV R14,RDX
MOV RDI,RBX
MOV ESI,EBP
CALL 0x001202f5
MOV RAX,-0x100000000
AND RAX,R15
MOV R15D,R15D
JMP 0x00112f97
LAB_00112f7d:
LEA RSI,[0x1a08ed]
XOR R15D,R15D
MOV RDI,RBX
XOR EAX,EAX
CALL 0x0012214f
PUSH 0x6
POP R14
LAB_00112f95:
XOR EAX,EAX
LAB_00112f97:
OR R15,RAX
MOV RAX,R15
MOV RDX,R14
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00112faf:
PUSH 0x6
POP R14
XOR R15D,R15D
JMP 0x00112f95
|
int1 [16]
js_reflect_get(int8 param_1,int8 param_2,int8 param_3,int param_4,
int8 *param_5)
{
int8 uVar1;
int iVar2;
ulong uVar3;
int8 uVar4;
int8 uVar5;
int8 uVar6;
ulong uVar7;
int1 auVar8 [16];
int8 uVar9;
uVar6 = param_5[1];
if ((int)uVar6 == -1) {
uVar1 = *param_5;
uVar4 = uVar1;
uVar5 = uVar6;
if (2 < param_4) {
uVar4 = param_5[4];
uVar5 = param_5[5];
}
iVar2 = JS_ValueToAtom(param_1,param_5[2],param_5[3]);
if (iVar2 != 0) {
uVar9 = 0;
auVar8 = JS_GetPropertyInternal2(param_1,uVar1,uVar6,iVar2,uVar4,uVar5,0,0);
uVar6 = auVar8._8_8_;
JS_FreeAtom(param_1,iVar2,uVar6,uVar9);
uVar3 = auVar8._0_8_ & 0xffffffff00000000;
uVar7 = auVar8._0_8_ & 0xffffffff;
goto LAB_00112f97;
}
}
else {
JS_ThrowTypeError(param_1,"not an object");
}
uVar6 = 6;
uVar7 = 0;
uVar3 = 0;
LAB_00112f97:
auVar8._8_8_ = uVar6;
auVar8._0_8_ = uVar7 | uVar3;
return auVar8;
}
|
|
8,122 |
testing::internal::FormatTimeInMillisAsSeconds[abi:cxx11](long)
|
AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest.cc
|
std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
::std::stringstream ss;
// For the exact N seconds, makes sure output has a trailing decimal point.
// Sets precision so that we won't have many trailing zeros (e.g., 300 ms
// will be just 0.3, 410 ms 0.41, and so on)
ss << std::fixed
<< std::setprecision(
ms % 1000 == 0 ? 0 : (ms % 100 == 0 ? 1 : (ms % 10 == 0 ? 2 : 3)))
<< std::showpoint;
ss << (static_cast<double>(ms) * 1e-3);
return ss.str();
}
|
O0
|
cpp
|
testing::internal::FormatTimeInMillisAsSeconds[abi:cxx11](long):
subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x1d0(%rsp)
movq %rsi, 0x1c8(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x14490
leaq 0x50(%rsp), %rdi
leaq 0x1cb36(%rip), %rsi # 0xe9490
callq 0x14210
movq %rax, 0x28(%rsp)
jmp 0xcc966
movq 0x1c8(%rsp), %rax
movl $0x3e8, %ecx # imm = 0x3E8
cqto
idivq %rcx
cmpq $0x0, %rdx
jne 0xcc986
xorl %eax, %eax
movl %eax, 0x14(%rsp)
jmp 0xcc9d8
movq 0x1c8(%rsp), %rax
movl $0x64, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
jne 0xcc9a9
movl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0xcc9d0
movq 0x1c8(%rsp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movl $0x3, %eax
movl $0x2, %ecx
cmpq $0x0, %rdx
cmovel %ecx, %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %edi
callq 0xe5510
movl %eax, 0xc(%rsp)
jmp 0xcc9e7
movq 0x28(%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, 0x30(%rsp)
movl 0x30(%rsp), %esi
callq 0x14b70
movq %rax, (%rsp)
jmp 0xcca03
movq (%rsp), %rdi
leaq 0x1caa2(%rip), %rsi # 0xe94b0
callq 0x14210
jmp 0xcca15
leaq 0x50(%rsp), %rdi
cvtsi2sdq 0x1c8(%rsp), %xmm0
movsd 0x45c44(%rip), %xmm1 # 0x112670
mulsd %xmm1, %xmm0
callq 0x14db0
jmp 0xcca37
movq 0x18(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x14d10
jmp 0xcca48
leaq 0x40(%rsp), %rdi
callq 0x14500
movq 0x20(%rsp), %rax
addq $0x1d8, %rsp # imm = 0x1D8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x14500
movq 0x38(%rsp), %rdi
callq 0x14c80
nopw %cs:(%rax,%rax)
|
_ZN7testing8internal27FormatTimeInMillisAsSecondsB5cxx11El:
sub rsp, 1D8h
mov [rsp+1D8h+var_1C0], rdi
mov rax, rdi
mov [rsp+1D8h+var_1B8], rax
mov [rsp+1D8h+var_8], rdi
mov [rsp+1D8h+var_10], rsi
lea rdi, [rsp+1D8h+var_198]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(void)
lea rdi, [rsp+1D8h+var_188]
lea rsi, _ZSt5fixedRSt8ios_base; std::fixed(std::ios_base &)
call __ZNSolsEPFRSt8ios_baseS0_E; std::ostream::operator<<(std::ios_base & (*)(std::ios_base &))
mov [rsp+1D8h+var_1B0], rax
jmp short $+2
loc_CC966:
mov rax, [rsp+1D8h+var_10]
mov ecx, 3E8h
cqo
idiv rcx
cmp rdx, 0
jnz short loc_CC986
xor eax, eax
mov [rsp+1D8h+var_1C4], eax
jmp short loc_CC9D8
loc_CC986:
mov rax, [rsp+1D8h+var_10]
mov ecx, 64h ; 'd'
cqo
idiv rcx
cmp rdx, 0
jnz short loc_CC9A9
mov eax, 1
mov [rsp+1D8h+var_1C8], eax
jmp short loc_CC9D0
loc_CC9A9:
mov rax, [rsp+1D8h+var_10]
mov ecx, 0Ah
cqo
idiv rcx
mov eax, 3
mov ecx, 2
cmp rdx, 0
cmovz eax, ecx
mov [rsp+1D8h+var_1C8], eax
loc_CC9D0:
mov eax, [rsp+1D8h+var_1C8]
mov [rsp+1D8h+var_1C4], eax
loc_CC9D8:
mov edi, [rsp+1D8h+var_1C4]; int
call _ZSt12setprecisioni; std::setprecision(int)
mov [rsp+1D8h+var_1CC], eax
jmp short $+2
loc_CC9E7:
mov rdi, [rsp+1D8h+var_1B0]
mov eax, [rsp+1D8h+var_1CC]
mov [rsp+1D8h+var_1A8], eax
mov esi, [rsp+1D8h+var_1A8]
call __ZStlsIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_St13_Setprecision; std::operator<<<char,std::char_traits<char>>(std::ostream &,std::_Setprecision)
mov [rsp+1D8h+var_1D8], rax
jmp short $+2
loc_CCA03:
mov rdi, [rsp+1D8h+var_1D8]
lea rsi, _ZSt9showpointRSt8ios_base; std::showpoint(std::ios_base &)
call __ZNSolsEPFRSt8ios_baseS0_E; std::ostream::operator<<(std::ios_base & (*)(std::ios_base &))
jmp short $+2
loc_CCA15:
lea rdi, [rsp+1D8h+var_188]
cvtsi2sd xmm0, [rsp+1D8h+var_10]
movsd xmm1, cs:qword_112670
mulsd xmm0, xmm1
call __ZNSolsEd; std::ostream::operator<<(double)
jmp short $+2
loc_CCA37:
mov rdi, [rsp+1D8h+var_1C0]
lea rsi, [rsp+1D8h+var_198]
call __ZNKRSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEE3strEv; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::str(void)
jmp short $+2
loc_CCA48:
lea rdi, [rsp+1D8h+var_198]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
mov rax, [rsp+1D8h+var_1B8]
add rsp, 1D8h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_30], rcx
mov [rsp+arg_2C], eax
lea rdi, [rsp+arg_38]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
mov rdi, [rsp+arg_30]
call __Unwind_Resume
|
long long testing::internal::FormatTimeInMillisAsSeconds[abi:cxx11](long long a1, long long a2)
{
unsigned int v2; // eax
int v3; // eax
long long v5; // [rsp+0h] [rbp-1D8h]
int v6; // [rsp+10h] [rbp-1C8h]
long long v7; // [rsp+28h] [rbp-1B0h]
_BYTE v8[16]; // [rsp+40h] [rbp-198h] BYREF
_BYTE v9[376]; // [rsp+50h] [rbp-188h] BYREF
long long v10; // [rsp+1C8h] [rbp-10h]
long long v11; // [rsp+1D0h] [rbp-8h]
v11 = a1;
v10 = a2;
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(v8);
v7 = std::ostream::operator<<(v9, std::fixed);
if ( v10 % 1000 )
{
if ( v10 % 100 )
{
v3 = 3;
if ( !(v10 % 10) )
v3 = 2;
v6 = v3;
}
else
{
v6 = 1;
}
v2 = std::setprecision(v6);
}
else
{
v2 = std::setprecision(0);
}
v5 = std::operator<<<char,std::char_traits<char>>(v7, v2);
std::ostream::operator<<(v5, std::showpoint);
std::ostream::operator<<(v9, (double)(int)v10 * 0.001);
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::str(a1, v8);
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream(v8);
return a1;
}
|
FormatTimeInMillisAsSeconds[abi:cxx11]:
SUB RSP,0x1d8
MOV qword ptr [RSP + 0x18],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x1d0],RDI
MOV qword ptr [RSP + 0x1c8],RSI
LEA RDI,[RSP + 0x40]
CALL 0x00114490
LEA RDI,[RSP + 0x50]
LAB_001cc953:
LEA RSI,[0x1e9490]
CALL 0x00114210
MOV qword ptr [RSP + 0x28],RAX
JMP 0x001cc966
LAB_001cc966:
MOV RAX,qword ptr [RSP + 0x1c8]
MOV ECX,0x3e8
CQO
IDIV RCX
CMP RDX,0x0
JNZ 0x001cc986
XOR EAX,EAX
MOV dword ptr [RSP + 0x14],EAX
JMP 0x001cc9d8
LAB_001cc986:
MOV RAX,qword ptr [RSP + 0x1c8]
MOV ECX,0x64
CQO
IDIV RCX
CMP RDX,0x0
JNZ 0x001cc9a9
MOV EAX,0x1
MOV dword ptr [RSP + 0x10],EAX
JMP 0x001cc9d0
LAB_001cc9a9:
MOV RAX,qword ptr [RSP + 0x1c8]
MOV ECX,0xa
CQO
IDIV RCX
MOV EAX,0x3
MOV ECX,0x2
CMP RDX,0x0
CMOVZ EAX,ECX
MOV dword ptr [RSP + 0x10],EAX
LAB_001cc9d0:
MOV EAX,dword ptr [RSP + 0x10]
MOV dword ptr [RSP + 0x14],EAX
LAB_001cc9d8:
MOV EDI,dword ptr [RSP + 0x14]
CALL 0x001e5510
MOV dword ptr [RSP + 0xc],EAX
JMP 0x001cc9e7
LAB_001cc9e7:
MOV RDI,qword ptr [RSP + 0x28]
MOV EAX,dword ptr [RSP + 0xc]
MOV dword ptr [RSP + 0x30],EAX
MOV ESI,dword ptr [RSP + 0x30]
CALL 0x00114b70
MOV qword ptr [RSP],RAX
JMP 0x001cca03
LAB_001cca03:
MOV RDI,qword ptr [RSP]
LEA RSI,[0x1e94b0]
CALL 0x00114210
JMP 0x001cca15
LAB_001cca15:
LEA RDI,[RSP + 0x50]
CVTSI2SD XMM0,qword ptr [RSP + 0x1c8]
MOVSD XMM1,qword ptr [0x00212670]
MULSD XMM0,XMM1
CALL 0x00114db0
JMP 0x001cca37
LAB_001cca37:
MOV RDI,qword ptr [RSP + 0x18]
LEA RSI,[RSP + 0x40]
CALL 0x00114d10
LAB_001cca46:
JMP 0x001cca48
LAB_001cca48:
LEA RDI,[RSP + 0x40]
CALL 0x00114500
MOV RAX,qword ptr [RSP + 0x20]
ADD RSP,0x1d8
RET
|
/* testing::internal::FormatTimeInMillisAsSeconds[abi:cxx11](long) */
internal * __thiscall
testing::internal::FormatTimeInMillisAsSeconds_abi_cxx11_(internal *this,long param_1)
{
int4 uVar1;
int8 uVar2;
ostream *this_00;
int local_1c8;
int local_1c4;
stringstream local_198 [16];
ostream local_188 [376];
long local_10;
internal *local_8;
local_10 = param_1;
local_8 = this;
std::__cxx11::stringstream::stringstream(local_198);
/* try { // try from 001cc953 to 001cca45 has its CatchHandler @ 001cca5f */
uVar2 = std::ostream::operator<<(local_188,std::fixed);
if (local_10 % 1000 == 0) {
local_1c4 = 0;
}
else {
if (local_10 % 100 == 0) {
local_1c8 = 1;
}
else {
local_1c8 = 3;
if (local_10 % 10 == 0) {
local_1c8 = 2;
}
}
local_1c4 = local_1c8;
}
uVar1 = std::setprecision(local_1c4);
this_00 = std::operator<<(uVar2,uVar1);
std::ostream::operator<<(this_00,std::showpoint);
std::ostream::operator<<(local_188,(double)local_10 * DAT_00212670);
std::__cxx11::stringstream::str();
std::__cxx11::stringstream::~stringstream(local_198);
return this;
}
|
|
8,123 |
my_fcvt
|
eloqsql/strings/dtoa.c
|
size_t my_fcvt(double x, int precision, char *to, my_bool *error)
{
int decpt, sign, len, i;
char *res, *src, *end, *dst= to;
char buf[DTOA_BUFF_SIZE];
DBUG_ASSERT(precision >= 0 && precision < DECIMAL_NOT_SPECIFIED && to != NULL);
res= dtoa(x, 5, precision, &decpt, &sign, &end, buf, sizeof(buf));
if (decpt == DTOA_OVERFLOW)
{
dtoa_free(res, buf, sizeof(buf));
*to++= '0';
*to= '\0';
if (error != NULL)
*error= TRUE;
return 1;
}
src= res;
len= (int)(end - src);
if (sign)
*dst++= '-';
if (decpt <= 0)
{
*dst++= '0';
*dst++= '.';
for (i= decpt; i < 0; i++)
*dst++= '0';
}
for (i= 1; i <= len; i++)
{
*dst++= *src++;
if (i == decpt && i < len)
*dst++= '.';
}
while (i++ <= decpt)
*dst++= '0';
if (precision > 0)
{
if (len <= decpt)
*dst++= '.';
for (i= precision - MY_MAX(0, (len - decpt)); i > 0; i--)
*dst++= '0';
}
*dst= '\0';
if (error != NULL)
*error= FALSE;
dtoa_free(res, buf, sizeof(buf));
return dst - to;
}
|
O3
|
c
|
my_fcvt:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe98, %rsp # imm = 0xE98
movq %rdx, -0xea8(%rbp)
movq %rsi, %r14
movl %edi, %esi
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
leaq -0xe94(%rbp), %r13
leaq -0xe9c(%rbp), %rcx
leaq -0xec0(%rbp), %r8
leaq -0xe90(%rbp), %rbx
movl $0x5, %edi
movl %esi, -0xe98(%rbp)
movq %r13, %rdx
movq %rbx, %r9
callq 0x5910a
movq %rax, %r15
movl (%r13), %r12d
cmpl $0x270f, %r12d # imm = 0x270F
jne 0x58f77
cmpq %rbx, %r15
setae %al
leaq -0x30(%rbp), %rcx
cmpq %r15, %rcx
seta %cl
testb %cl, %al
jne 0x58f53
movq %r15, %rdi
callq 0x243c0
movw $0x30, (%r14)
movl $0x1, %r13d
movq -0xea8(%rbp), %rax
testq %rax, %rax
je 0x590e1
movb $0x1, (%rax)
jmp 0x590e1
movq -0xec0(%rbp), %rbx
movq %r14, %rax
movl %ebx, %r14d
cmpl $0x0, -0xe9c(%rbp)
movq %rax, %r13
je 0x58f97
leaq 0x1(%rax), %r13
movb $0x2d, (%rax)
movq %rax, -0xeb8(%rbp)
subl %r15d, %r14d
testl %r12d, %r12d
movl -0xe98(%rbp), %r8d
jg 0x58ff1
movw $0x2e30, (%r13) # imm = 0x2E30
leaq 0x2(%r13), %rdi
testl %r12d, %r12d
js 0x58fc2
movq %rdi, %r13
jmp 0x58ff1
movl %r12d, %eax
notl %eax
movq %rax, -0xeb0(%rbp)
leaq 0x1(%rax), %rdx
movl $0x30, %esi
callq 0x24180
movl -0xe98(%rbp), %r8d
movq -0xeb0(%rbp), %rax
addq %rax, %r13
addq $0x3, %r13
testl %r14d, %r14d
jle 0x59038
subl %r15d, %ebx
incl %ebx
movl %r14d, %eax
xorl %ecx, %ecx
movq %r13, %rdx
leal 0x1(%rcx), %esi
movb (%r15,%rcx), %dil
incq %r13
movb %dil, (%rdx)
cmpl -0xe94(%rbp), %esi
jne 0x59028
cmpl %r14d, %esi
jge 0x59028
movb $0x2e, 0x1(%rdx)
addq $0x2, %rdx
movq %rdx, %r13
incq %rcx
cmpl %ecx, %eax
jne 0x59000
movl -0xe94(%rbp), %r12d
jmp 0x5903d
movl $0x1, %ebx
cmpl %r12d, %ebx
jg 0x5905a
decl %ebx
movb $0x30, (%r13)
incq %r13
movl -0xe94(%rbp), %r12d
incl %ebx
cmpl %r12d, %ebx
jl 0x59044
testl %r8d, %r8d
jle 0x590a0
cmpl %r14d, %r12d
jl 0x59073
movb $0x2e, (%r13)
incq %r13
movl -0xe94(%rbp), %r12d
subl %r12d, %r14d
cmpl %r8d, %r14d
jge 0x590a0
xorl %ebx, %ebx
testl %r14d, %r14d
cmovgl %r14d, %ebx
notl %ebx
addl %r8d, %ebx
leaq 0x1(%rbx), %rdx
movq %r13, %rdi
movl $0x30, %esi
callq 0x24180
addq %rbx, %r13
incq %r13
movb $0x0, (%r13)
movq -0xea8(%rbp), %rax
testq %rax, %rax
movq -0xeb8(%rbp), %rbx
je 0x590bb
movb $0x0, (%rax)
leaq -0xe90(%rbp), %rax
cmpq %rax, %r15
setae %al
leaq -0x30(%rbp), %rcx
cmpq %r15, %rcx
seta %cl
testb %cl, %al
jne 0x590de
movq %r15, %rdi
callq 0x243c0
subq %rbx, %r13
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x59105
movq %r13, %rax
addq $0xe98, %rsp # imm = 0xE98
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x24350
|
my_fcvt:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0E98h
mov [rbp+var_EA8], rdx
mov r14, rsi
mov esi, edi
mov rax, fs:28h
mov [rbp+var_30], rax
lea r13, [rbp+var_E94]
lea rcx, [rbp+var_E9C]
lea r8, [rbp+var_EC0]
lea rbx, [rbp+var_E90]
mov edi, 5
mov [rbp+var_E98], esi
mov rdx, r13
mov r9, rbx
call dtoa
mov r15, rax
mov r12d, [r13+0]
cmp r12d, 270Fh
jnz short loc_58F77
cmp r15, rbx
setnb al
lea rcx, [rbp+var_30]
cmp rcx, r15
setnbe cl
test al, cl
jnz short loc_58F53
mov rdi, r15
call _free
loc_58F53:
mov word ptr [r14], 30h ; '0'
mov r13d, 1
mov rax, [rbp+var_EA8]
test rax, rax
jz loc_590E1
mov byte ptr [rax], 1
jmp loc_590E1
loc_58F77:
mov rbx, [rbp+var_EC0]
mov rax, r14
mov r14d, ebx
cmp [rbp+var_E9C], 0
mov r13, rax
jz short loc_58F97
lea r13, [rax+1]
mov byte ptr [rax], 2Dh ; '-'
loc_58F97:
mov [rbp+var_EB8], rax
sub r14d, r15d
test r12d, r12d
mov r8d, [rbp+var_E98]
jg short loc_58FF1
mov word ptr [r13+0], 2E30h
lea rdi, [r13+2]
test r12d, r12d
js short loc_58FC2
mov r13, rdi
jmp short loc_58FF1
loc_58FC2:
mov eax, r12d
not eax
mov [rbp+var_EB0], rax
lea rdx, [rax+1]
mov esi, 30h ; '0'
call _memset
mov r8d, [rbp+var_E98]
mov rax, [rbp+var_EB0]
add r13, rax
add r13, 3
loc_58FF1:
test r14d, r14d
jle short loc_59038
sub ebx, r15d
inc ebx
mov eax, r14d
xor ecx, ecx
loc_59000:
mov rdx, r13
lea esi, [rcx+1]
mov dil, [r15+rcx]
inc r13
mov [rdx], dil
cmp esi, [rbp+var_E94]
jnz short loc_59028
cmp esi, r14d
jge short loc_59028
mov byte ptr [rdx+1], 2Eh ; '.'
add rdx, 2
mov r13, rdx
loc_59028:
inc rcx
cmp eax, ecx
jnz short loc_59000
mov r12d, [rbp+var_E94]
jmp short loc_5903D
loc_59038:
mov ebx, 1
loc_5903D:
cmp ebx, r12d
jg short loc_5905A
dec ebx
loc_59044:
mov byte ptr [r13+0], 30h ; '0'
inc r13
mov r12d, [rbp+var_E94]
inc ebx
cmp ebx, r12d
jl short loc_59044
loc_5905A:
test r8d, r8d
jle short loc_590A0
cmp r12d, r14d
jl short loc_59073
mov byte ptr [r13+0], 2Eh ; '.'
inc r13
mov r12d, [rbp+var_E94]
loc_59073:
sub r14d, r12d
cmp r14d, r8d
jge short loc_590A0
xor ebx, ebx
test r14d, r14d
cmovg ebx, r14d
not ebx
add ebx, r8d
lea rdx, [rbx+1]
mov rdi, r13
mov esi, 30h ; '0'
call _memset
add r13, rbx
inc r13
loc_590A0:
mov byte ptr [r13+0], 0
mov rax, [rbp+var_EA8]
test rax, rax
mov rbx, [rbp+var_EB8]
jz short loc_590BB
mov byte ptr [rax], 0
loc_590BB:
lea rax, [rbp+var_E90]
cmp r15, rax
setnb al
lea rcx, [rbp+var_30]
cmp rcx, r15
setnbe cl
test al, cl
jnz short loc_590DE
mov rdi, r15
call _free
loc_590DE:
sub r13, rbx
loc_590E1:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_59105
mov rax, r13
add rsp, 0E98h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_59105:
call ___stack_chk_fail
|
_BYTE * my_fcvt(unsigned int a1, _WORD *a2, _BYTE *a3)
{
long long v4; // rsi
unsigned long long v5; // r15
int v6; // r12d
long long v7; // r13
int v8; // ebx
_BYTE *v9; // rax
int v10; // r14d
_BYTE *v11; // r13
int v12; // r14d
int v13; // r8d
int v14; // ebx
long long v15; // rcx
_BYTE *v16; // rdx
int v17; // ebx
int v18; // r14d
int v19; // ebx
long long v20; // rbx
_BYTE *v21; // rbx
long long v23; // [rsp+0h] [rbp-EC0h] BYREF
_BYTE *v24; // [rsp+8h] [rbp-EB8h]
long long v25; // [rsp+10h] [rbp-EB0h]
_BYTE *v26; // [rsp+18h] [rbp-EA8h]
int v27; // [rsp+24h] [rbp-E9Ch] BYREF
int v28; // [rsp+28h] [rbp-E98h]
int v29; // [rsp+2Ch] [rbp-E94h] BYREF
_BYTE v30[3680]; // [rsp+30h] [rbp-E90h] BYREF
_QWORD v31[6]; // [rsp+E90h] [rbp-30h] BYREF
v26 = a3;
v4 = a1;
v31[0] = __readfsqword(0x28u);
v28 = a1;
v5 = dtoa(5LL, a1, &v29, &v27, &v23, v30);
v6 = v29;
if ( v29 == 9999 )
{
if ( (unsigned long long)v31 <= v5 || v5 < (unsigned long long)v30 )
free(v5, a1);
*a2 = 48;
v7 = 1LL;
if ( v26 )
*v26 = 1;
}
else
{
v8 = v23;
v9 = a2;
v10 = v23;
v11 = v9;
if ( v27 )
{
v11 = v9 + 1;
*v9 = 45;
}
v24 = v9;
v12 = v10 - v5;
v13 = v28;
if ( v6 <= 0 )
{
*(_WORD *)v11 = 11824;
if ( v6 < 0 )
{
v25 = (unsigned int)~v6;
v4 = 48LL;
memset(v11 + 2, 48LL, v25 + 1);
v13 = v28;
v11 += v25 + 3;
}
else
{
v11 += 2;
}
}
if ( v12 <= 0 )
{
v14 = 1;
}
else
{
v14 = v8 - v5 + 1;
v15 = 0LL;
do
{
v16 = v11;
v4 = (unsigned int)(v15 + 1);
++v11;
*v16 = *(_BYTE *)(v5 + v15);
if ( (_DWORD)v4 == v29 && (int)v4 < v12 )
{
v16[1] = 46;
v11 = v16 + 2;
}
++v15;
}
while ( v12 != (_DWORD)v15 );
v6 = v29;
}
if ( v14 <= v6 )
{
v17 = v14 - 1;
do
{
*v11++ = 48;
v6 = v29;
++v17;
}
while ( v17 < v29 );
}
if ( v13 > 0 )
{
if ( v6 >= v12 )
{
*v11++ = 46;
v6 = v29;
}
v18 = v12 - v6;
if ( v18 < v13 )
{
v19 = 0;
if ( v18 > 0 )
v19 = v18;
v20 = (unsigned int)(v13 + ~v19);
v4 = 48LL;
memset(v11, 48LL, v20 + 1);
v11 += v20 + 1;
}
}
*v11 = 0;
v21 = v24;
if ( v26 )
*v26 = 0;
if ( (unsigned long long)v31 <= v5 || v5 < (unsigned long long)v30 )
free(v5, v4);
return (_BYTE *)(v11 - v21);
}
return (_BYTE *)v7;
}
|
my_fcvt:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xe98
MOV qword ptr [RBP + -0xea8],RDX
MOV R14,RSI
MOV ESI,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
LEA R13,[RBP + -0xe94]
LEA RCX,[RBP + -0xe9c]
LEA R8,[RBP + -0xec0]
LEA RBX,[RBP + -0xe90]
MOV EDI,0x5
MOV dword ptr [RBP + -0xe98],ESI
MOV RDX,R13
MOV R9,RBX
CALL 0x0015910a
MOV R15,RAX
MOV R12D,dword ptr [R13]
CMP R12D,0x270f
JNZ 0x00158f77
CMP R15,RBX
SETNC AL
LEA RCX,[RBP + -0x30]
CMP RCX,R15
SETA CL
TEST AL,CL
JNZ 0x00158f53
MOV RDI,R15
CALL 0x001243c0
LAB_00158f53:
MOV word ptr [R14],0x30
MOV R13D,0x1
MOV RAX,qword ptr [RBP + -0xea8]
TEST RAX,RAX
JZ 0x001590e1
MOV byte ptr [RAX],0x1
JMP 0x001590e1
LAB_00158f77:
MOV RBX,qword ptr [RBP + -0xec0]
MOV RAX,R14
MOV R14D,EBX
CMP dword ptr [RBP + -0xe9c],0x0
MOV R13,RAX
JZ 0x00158f97
LEA R13,[RAX + 0x1]
MOV byte ptr [RAX],0x2d
LAB_00158f97:
MOV qword ptr [RBP + -0xeb8],RAX
SUB R14D,R15D
TEST R12D,R12D
MOV R8D,dword ptr [RBP + -0xe98]
JG 0x00158ff1
MOV word ptr [R13],0x2e30
LEA RDI,[R13 + 0x2]
TEST R12D,R12D
JS 0x00158fc2
MOV R13,RDI
JMP 0x00158ff1
LAB_00158fc2:
MOV EAX,R12D
NOT EAX
MOV qword ptr [RBP + -0xeb0],RAX
LEA RDX,[RAX + 0x1]
MOV ESI,0x30
CALL 0x00124180
MOV R8D,dword ptr [RBP + -0xe98]
MOV RAX,qword ptr [RBP + -0xeb0]
ADD R13,RAX
ADD R13,0x3
LAB_00158ff1:
TEST R14D,R14D
JLE 0x00159038
SUB EBX,R15D
INC EBX
MOV EAX,R14D
XOR ECX,ECX
LAB_00159000:
MOV RDX,R13
LEA ESI,[RCX + 0x1]
MOV DIL,byte ptr [R15 + RCX*0x1]
INC R13
MOV byte ptr [RDX],DIL
CMP ESI,dword ptr [RBP + -0xe94]
JNZ 0x00159028
CMP ESI,R14D
JGE 0x00159028
MOV byte ptr [RDX + 0x1],0x2e
ADD RDX,0x2
MOV R13,RDX
LAB_00159028:
INC RCX
CMP EAX,ECX
JNZ 0x00159000
MOV R12D,dword ptr [RBP + -0xe94]
JMP 0x0015903d
LAB_00159038:
MOV EBX,0x1
LAB_0015903d:
CMP EBX,R12D
JG 0x0015905a
DEC EBX
LAB_00159044:
MOV byte ptr [R13],0x30
INC R13
MOV R12D,dword ptr [RBP + -0xe94]
INC EBX
CMP EBX,R12D
JL 0x00159044
LAB_0015905a:
TEST R8D,R8D
JLE 0x001590a0
CMP R12D,R14D
JL 0x00159073
MOV byte ptr [R13],0x2e
INC R13
MOV R12D,dword ptr [RBP + -0xe94]
LAB_00159073:
SUB R14D,R12D
CMP R14D,R8D
JGE 0x001590a0
XOR EBX,EBX
TEST R14D,R14D
CMOVG EBX,R14D
NOT EBX
ADD EBX,R8D
LEA RDX,[RBX + 0x1]
MOV RDI,R13
MOV ESI,0x30
CALL 0x00124180
ADD R13,RBX
INC R13
LAB_001590a0:
MOV byte ptr [R13],0x0
MOV RAX,qword ptr [RBP + -0xea8]
TEST RAX,RAX
MOV RBX,qword ptr [RBP + -0xeb8]
JZ 0x001590bb
MOV byte ptr [RAX],0x0
LAB_001590bb:
LEA RAX,[RBP + -0xe90]
CMP R15,RAX
SETNC AL
LEA RCX,[RBP + -0x30]
CMP RCX,R15
SETA CL
TEST AL,CL
JNZ 0x001590de
MOV RDI,R15
CALL 0x001243c0
LAB_001590de:
SUB R13,RBX
LAB_001590e1:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00159105
MOV RAX,R13
ADD RSP,0xe98
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00159105:
CALL 0x00124350
|
long my_fcvt(int param_1,int2 *param_2,int1 *param_3)
{
long *__ptr;
int iVar1;
uint uVar2;
uint uVar3;
long lVar4;
int2 *puVar5;
int2 *__s;
int iVar6;
long in_FS_OFFSET;
int local_ec8 [2];
int2 *local_ec0;
ulong local_eb8;
int1 *local_eb0;
int local_ea4;
int local_ea0;
uint local_e9c;
long local_e98 [460];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
local_eb0 = param_3;
local_ea0 = param_1;
__ptr = (long *)dtoa(5,param_1,&local_e9c,&local_ea4,local_ec8,local_e98);
uVar3 = local_e9c;
if (local_e9c == 9999) {
if (__ptr < local_e98 || &local_38 <= __ptr) {
free(__ptr);
}
*param_2 = 0x30;
lVar4 = 1;
if (local_eb0 != (int1 *)0x0) {
*local_eb0 = 1;
}
}
else {
puVar5 = param_2;
if (local_ea4 != 0) {
puVar5 = (int2 *)((long)param_2 + 1);
*(int1 *)param_2 = 0x2d;
}
iVar6 = local_ec8[0] - (int)__ptr;
__s = puVar5;
local_ec0 = param_2;
if ((int)local_e9c < 1) {
*puVar5 = 0x2e30;
__s = puVar5 + 1;
if ((int)local_e9c < 0) {
local_eb8 = (ulong)~local_e9c;
memset(__s,0x30,local_eb8 + 1);
__s = (int2 *)((long)puVar5 + local_eb8 + 3);
}
}
if (iVar6 < 1) {
iVar1 = 1;
}
else {
iVar1 = (local_ec8[0] - (int)__ptr) + 1;
lVar4 = 0;
puVar5 = __s;
do {
uVar3 = (int)lVar4 + 1;
__s = (int2 *)((long)puVar5 + 1);
*(int1 *)puVar5 = *(int1 *)((long)__ptr + lVar4);
if ((uVar3 == local_e9c) && ((int)uVar3 < iVar6)) {
*(int1 *)((long)puVar5 + 1) = 0x2e;
__s = puVar5 + 1;
}
lVar4 = lVar4 + 1;
puVar5 = __s;
uVar3 = local_e9c;
} while (iVar6 != (int)lVar4);
}
if (iVar1 <= (int)uVar3) {
iVar1 = iVar1 + -1;
do {
*(int1 *)__s = 0x30;
__s = (int2 *)((long)__s + 1);
iVar1 = iVar1 + 1;
uVar3 = local_e9c;
} while (iVar1 < (int)local_e9c);
}
if (0 < local_ea0) {
if (iVar6 <= (int)uVar3) {
*(int1 *)__s = 0x2e;
__s = (int2 *)((long)__s + 1);
uVar3 = local_e9c;
}
uVar3 = iVar6 - uVar3;
if ((int)uVar3 < local_ea0) {
uVar2 = 0;
if (0 < (int)uVar3) {
uVar2 = uVar3;
}
uVar3 = ~uVar2 + local_ea0;
memset(__s,0x30,(ulong)uVar3 + 1);
__s = (int2 *)((long)__s + (ulong)uVar3 + 1);
}
}
puVar5 = local_ec0;
*(int1 *)__s = 0;
if (local_eb0 != (int1 *)0x0) {
*local_eb0 = 0;
}
if (__ptr < local_e98 || &local_38 <= __ptr) {
free(__ptr);
}
lVar4 = (long)__s - (long)puVar5;
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return lVar4;
}
|
|
8,124 |
crc32_pclmul
|
eloqsql/mysys/crc32/crc32_x86.c
|
unsigned int crc32_pclmul(unsigned int crc32, const void *buf, size_t len)
{
return ~crcr32_calc_pclmulqdq(buf, (uint32_t)len, ~crc32, ðer_crc32_clmul);
}
|
O3
|
c
|
crc32_pclmul:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %fs:0x28, %rax
movq %rax, -0x18(%rbp)
testl %ebx, %ebx
je 0x2fe09
notl %edi
movd %edi, %xmm2
cmpl $0x1f, %ebx
jbe 0x2fe23
movdqu (%rsi), %xmm1
pxor %xmm2, %xmm1
pushq $0x10
popq %rax
movl $0xccaa009e, %ecx # imm = 0xCCAA009E
movq %rcx, %xmm0
movdqa 0xa943b(%rip), %xmm2 # 0xd9150
movl %eax, %ecx
movdqu (%rsi,%rcx), %xmm3
movdqa %xmm1, %xmm4
pclmulqdq $0x1, %xmm0, %xmm4
pxor %xmm3, %xmm4
pclmulqdq $0x10, %xmm2, %xmm1
pxor %xmm4, %xmm1
leal 0x10(%rax), %ecx
addl $0x20, %eax
cmpl %ebx, %eax
movl %ecx, %eax
jbe 0x2fd15
cmpl %ebx, %ecx
jae 0x2fd9c
leal -0x10(%rbx), %eax
movdqu (%rsi,%rax), %xmm2
andl $0xf, %ebx
leaq 0xb116a(%rip), %rax # 0xe0ec0
movdqu (%rbx,%rax), %xmm0
movdqa %xmm1, %xmm3
pshufb %xmm0, %xmm3
pxor 0xa93f4(%rip), %xmm0 # 0xd9160
pshufb %xmm0, %xmm1
pblendvb %xmm0, %xmm2, %xmm1
movl $0xccaa009e, %eax # imm = 0xCCAA009E
movq %rax, %xmm0
pclmulqdq $0x10, %xmm3, %xmm0
pxor %xmm1, %xmm0
pclmulqdq $0x10, 0xa93bc(%rip), %xmm3 # 0xd9150
pxor %xmm0, %xmm3
movdqa %xmm3, %xmm1
movl $0xccaa009e, %eax # imm = 0xCCAA009E
movq %rax, %xmm0
pclmulqdq $0x0, %xmm1, %xmm0
psrldq $0x8, %xmm1 # xmm1 = xmm1[8,9,10,11,12,13,14,15],zero,zero,zero,zero,zero,zero,zero,zero
pxor %xmm0, %xmm1
movdqa %xmm1, %xmm2
psllq $0x20, %xmm2
pclmulqdq $0x10, 0xa93a8(%rip), %xmm2 # 0xd9170
pxor %xmm1, %xmm2
pxor %xmm0, %xmm0
pblendw $0xfc, %xmm2, %xmm0 # xmm0 = xmm0[0,1],xmm2[2,3,4,5,6,7]
movabsq $0x1f7011640, %rax # imm = 0x1F7011640
movq %rax, %xmm1
pclmulqdq $0x0, %xmm0, %xmm1
pxor %xmm0, %xmm1
movq %xmm1, %xmm0 # xmm0 = xmm1[0],zero
pclmulqdq $0x10, 0xa9383(%rip), %xmm0 # 0xd9180
pxor %xmm2, %xmm0
pextrd $0x2, %xmm0, %edi
notl %edi
movq %fs:0x28, %rax
cmpq -0x18(%rbp), %rax
jne 0x2fe3a
movl %edi, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x10, %ebx
je 0x2fe3f
jb 0x2fe4c
movdqu (%rsi), %xmm1
pxor %xmm2, %xmm1
pushq $0x10
popq %rcx
jmp 0x2fd40
callq 0x29270
movdqu (%rsi), %xmm1
pxor %xmm2, %xmm1
jmp 0x2fd9c
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %r14
movaps %xmm0, (%r14)
movl %ebx, %edx
andl $0xf, %edx
pushq $0x10
popq %rcx
movq %r14, %rdi
movdqa %xmm2, -0x40(%rbp)
callq 0x29420
movdqa -0x40(%rbp), %xmm1
pxor (%r14), %xmm1
cmpl $0x4, %ebx
jae 0x2fea0
pushq $0x8
popq %rax
subl %ebx, %eax
andl $0xf, %eax
leaq 0xb30e6(%rip), %rcx # 0xe2f70
subq %rax, %rcx
movdqu 0x10(%rcx), %xmm0
movdqa %xmm1, %xmm2
pshufb %xmm0, %xmm2
jmp 0x2fdcc
pushq $0x10
popq %rax
subl %ebx, %eax
andl $0x1f, %eax
leaq 0xb30c1(%rip), %rcx # 0xe2f70
subq %rax, %rcx
movdqu 0x10(%rcx), %xmm0
pshufb %xmm0, %xmm1
jmp 0x2fd9c
nop
|
crc32_pclmul:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 30h
mov rbx, rdx
mov rax, fs:28h
mov [rbp+var_18], rax
test ebx, ebx
jz loc_2FE09
not edi
movd xmm2, edi
cmp ebx, 1Fh
jbe loc_2FE23
movdqu xmm1, xmmword ptr [rsi]
pxor xmm1, xmm2
push 10h
pop rax
mov ecx, 0CCAA009Eh
movq xmm0, rcx
movdqa xmm2, cs:xmmword_D9150
loc_2FD15:
mov ecx, eax
movdqu xmm3, xmmword ptr [rsi+rcx]
movdqa xmm4, xmm1
pclmulqdq xmm4, xmm0, 1
pxor xmm4, xmm3
pclmulqdq xmm1, xmm2, 10h
pxor xmm1, xmm4
lea ecx, [rax+10h]
add eax, 20h ; ' '
cmp eax, ebx
mov eax, ecx
jbe short loc_2FD15
loc_2FD40:
cmp ecx, ebx
jnb short loc_2FD9C
lea eax, [rbx-10h]
movdqu xmm2, xmmword ptr [rsi+rax]
and ebx, 0Fh
lea rax, crcr32_calc_pclmulqdq_shf_table
movdqu xmm0, xmmword ptr [rbx+rax]
movdqa xmm3, xmm1
pshufb xmm3, xmm0
pxor xmm0, cs:xmmword_D9160
pshufb xmm1, xmm0
pblendvb xmm1, xmm2
mov eax, 0CCAA009Eh
movq xmm0, rax
pclmulqdq xmm0, xmm3, 10h
pxor xmm0, xmm1
pclmulqdq xmm3, cs:xmmword_D9150, 10h
pxor xmm3, xmm0
movdqa xmm1, xmm3
loc_2FD9C:
mov eax, 0CCAA009Eh
movq xmm0, rax
pclmulqdq xmm0, xmm1, 0
psrldq xmm1, 8
pxor xmm1, xmm0
movdqa xmm2, xmm1
psllq xmm2, 20h ; ' '
pclmulqdq xmm2, cs:xmmword_D9170, 10h
pxor xmm2, xmm1
loc_2FDCC:
pxor xmm0, xmm0
pblendw xmm0, xmm2, 0FCh
mov rax, 1F7011640h
movq xmm1, rax
pclmulqdq xmm1, xmm0, 0
pxor xmm1, xmm0
movq xmm0, xmm1
pclmulqdq xmm0, cs:xmmword_D9180, 10h
pxor xmm0, xmm2
pextrd edi, xmm0, 2
not edi
loc_2FE09:
mov rax, fs:28h
cmp rax, [rbp+var_18]
jnz short loc_2FE3A
mov eax, edi
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_2FE23:
cmp ebx, 10h
jz short loc_2FE3F
jb short loc_2FE4C
movdqu xmm1, xmmword ptr [rsi]
pxor xmm1, xmm2
push 10h
pop rcx
jmp loc_2FD40
loc_2FE3A:
call ___stack_chk_fail
loc_2FE3F:
movdqu xmm1, xmmword ptr [rsi]
pxor xmm1, xmm2
jmp loc_2FD9C
loc_2FE4C:
xorps xmm0, xmm0
lea r14, [rbp+var_30]
movaps xmmword ptr [r14], xmm0
mov edx, ebx
and edx, 0Fh
push 10h
pop rcx
mov rdi, r14
movdqa [rbp+var_40], xmm2
call ___memcpy_chk
movdqa xmm1, [rbp+var_40]
pxor xmm1, xmmword ptr [r14]
cmp ebx, 4
jnb short loc_2FEA0
push 8
pop rax
sub eax, ebx
and eax, 0Fh
lea rcx, xmm_shift_left_crc_xmm_shift_tab
sub rcx, rax
movdqu xmm0, xmmword ptr [rcx+10h]
movdqa xmm2, xmm1
pshufb xmm2, xmm0
jmp loc_2FDCC
loc_2FEA0:
push 10h
pop rax
sub eax, ebx
and eax, 1Fh
lea rcx, xmm_shift_left_crc_xmm_shift_tab
sub rcx, rax
movdqu xmm0, xmmword ptr [rcx+10h]
pshufb xmm1, xmm0
jmp loc_2FD9C
|
long long crc32_pclmul(unsigned int a1, const __m128i *a2, unsigned int a3)
{
__m128i v4; // xmm2
unsigned int v6; // eax
unsigned int v12; // ecx
bool v13; // cc
__m128i v14; // xmm0
__m128i v16; // xmm0
__m128i v17; // xmm1
__m128i v23; // xmm1
__m128i v26; // xmm2
__m128i v33; // xmm1
__m128i v34; // [rsp+0h] [rbp-40h] BYREF
__m128i v35; // [rsp+10h] [rbp-30h] BYREF
unsigned long long v36; // [rsp+28h] [rbp-18h]
v36 = __readfsqword(0x28u);
if ( a3 )
{
v4 = _mm_cvtsi32_si128(~a1);
if ( a3 > 0x1F )
{
_XMM1 = _mm_xor_si128(_mm_loadu_si128(a2), v4);
v6 = 1;
_XMM0 = 0xCCAA009EuLL;
_XMM2 = _mm_load_si128((const __m128i *)&xmmword_D9150);
do
{
_XMM4 = _XMM1;
__asm
{
pclmulqdq xmm4, xmm0, 1
pclmulqdq xmm1, xmm2, 10h
}
_XMM1 = _mm_xor_si128(_XMM1, _mm_xor_si128(_XMM4, _mm_loadu_si128(&a2[v6])));
v12 = v6 * 16 + 16;
v13 = v6 * 16 + 32 <= a3;
++v6;
}
while ( v13 );
LABEL_5:
if ( v12 < a3 )
{
v14 = _mm_loadu_si128((const __m128i *)((char *)&crcr32_calc_pclmulqdq_shf_table + (a3 & 0xF)));
_XMM3 = _mm_shuffle_epi8(_XMM1, v14);
v16 = _mm_xor_si128(v14, (__m128i)xmmword_D9160);
v17 = _mm_blendv_epi8(
_mm_shuffle_epi8(_XMM1, v16),
_mm_loadu_si128((const __m128i *)((char *)a2 + a3 - 16)),
v16);
_XMM0 = 0xCCAA009EuLL;
__asm
{
pclmulqdq xmm0, xmm3, 10h
pclmulqdq xmm3, cs:xmmword_D9150, 10h
}
_XMM1 = _mm_xor_si128(_XMM3, _mm_xor_si128(_XMM0, v17));
}
goto LABEL_7;
}
if ( a3 == 16 )
{
_XMM1 = _mm_xor_si128(_mm_loadu_si128(a2), v4);
}
else
{
if ( a3 >= 0x10 )
{
_XMM1 = _mm_xor_si128(_mm_loadu_si128(a2), v4);
v12 = 16;
goto LABEL_5;
}
v35 = 0LL;
v34 = v4;
__memcpy_chk(&v35, a2, a3 & 0xF, 16LL);
v33 = _mm_xor_si128(_mm_load_si128(&v34), v35);
if ( a3 < 4 )
{
v26 = _mm_shuffle_epi8(
v33,
_mm_loadu_si128((const __m128i *)((char *)&xmm_shift_left_crc_xmm_shift_tab
- ((8 - (_BYTE)a3) & 0xF)
+ 16)));
goto LABEL_8;
}
_XMM1 = _mm_shuffle_epi8(
v33,
_mm_loadu_si128((const __m128i *)((char *)&xmm_shift_left_crc_xmm_shift_tab
- ((16 - (_BYTE)a3) & 0x1F)
+ 16)));
}
LABEL_7:
_XMM0 = 0xCCAA009EuLL;
__asm { pclmulqdq xmm0, xmm1, 0 }
v23 = _mm_xor_si128(_mm_srli_si128(_XMM1, 8), _XMM0);
_XMM2 = _mm_slli_epi64(v23, 0x20u);
__asm { pclmulqdq xmm2, cs:xmmword_D9170, 10h }
v26 = _mm_xor_si128(_XMM2, v23);
LABEL_8:
_XMM0 = _mm_blend_epi16((__m128i)0LL, v26, 252);
_XMM1 = 0x1F7011640uLL;
__asm { pclmulqdq xmm1, xmm0, 0 }
_XMM0 = _mm_move_epi64(_mm_xor_si128(_XMM1, _XMM0));
__asm { pclmulqdq xmm0, cs:xmmword_D9180, 10h }
return (unsigned int)~_mm_extract_epi32(_mm_xor_si128(_XMM0, v26), 2);
}
return a1;
}
|
crc32_pclmul:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RBX,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
TEST EBX,EBX
JZ 0x0012fe09
NOT EDI
MOVD XMM2,EDI
CMP EBX,0x1f
JBE 0x0012fe23
MOVDQU XMM1,xmmword ptr [RSI]
PXOR XMM1,XMM2
PUSH 0x10
POP RAX
MOV ECX,0xccaa009e
MOVQ XMM0,RCX
MOVDQA XMM2,xmmword ptr [0x001d9150]
LAB_0012fd15:
MOV ECX,EAX
MOVDQU XMM3,xmmword ptr [RSI + RCX*0x1]
MOVDQA XMM4,XMM1
PCLMULHQLQDQ XMM4,XMM0
PXOR XMM4,XMM3
PCLMULLQHQDQ XMM1,XMM2
PXOR XMM1,XMM4
LEA ECX,[RAX + 0x10]
ADD EAX,0x20
CMP EAX,EBX
MOV EAX,ECX
JBE 0x0012fd15
LAB_0012fd40:
CMP ECX,EBX
JNC 0x0012fd9c
LEA EAX,[RBX + -0x10]
MOVDQU XMM2,xmmword ptr [RSI + RAX*0x1]
AND EBX,0xf
LEA RAX,[0x1e0ec0]
MOVDQU XMM0,xmmword ptr [RBX + RAX*0x1]
MOVDQA XMM3,XMM1
PSHUFB XMM3,XMM0
PXOR XMM0,xmmword ptr [0x001d9160]
PSHUFB XMM1,XMM0
PBLENDVB XMM1,XMM2
MOV EAX,0xccaa009e
MOVQ XMM0,RAX
PCLMULLQHQDQ XMM0,XMM3
PXOR XMM0,XMM1
PCLMULQDQ XMM3,xmmword ptr [0x001d9150],0x10
PXOR XMM3,XMM0
MOVDQA XMM1,XMM3
LAB_0012fd9c:
MOV EAX,0xccaa009e
MOVQ XMM0,RAX
PCLMULLQLQDQ XMM0,XMM1
PSRLDQ XMM1,0x8
PXOR XMM1,XMM0
MOVDQA XMM2,XMM1
PSLLQ XMM2,0x20
PCLMULQDQ XMM2,xmmword ptr [0x001d9170],0x10
PXOR XMM2,XMM1
LAB_0012fdcc:
PXOR XMM0,XMM0
PBLENDW XMM0,XMM2,0xfc
MOV RAX,0x1f7011640
MOVQ XMM1,RAX
PCLMULLQLQDQ XMM1,XMM0
PXOR XMM1,XMM0
MOVQ XMM0,XMM1
PCLMULQDQ XMM0,xmmword ptr [0x001d9180],0x10
PXOR XMM0,XMM2
PEXTRD EDI,XMM0,0x2
NOT EDI
LAB_0012fe09:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x18]
JNZ 0x0012fe3a
MOV EAX,EDI
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_0012fe23:
CMP EBX,0x10
JZ 0x0012fe3f
JC 0x0012fe4c
MOVDQU XMM1,xmmword ptr [RSI]
PXOR XMM1,XMM2
PUSH 0x10
POP RCX
JMP 0x0012fd40
LAB_0012fe3a:
CALL 0x00129270
LAB_0012fe3f:
MOVDQU XMM1,xmmword ptr [RSI]
PXOR XMM1,XMM2
JMP 0x0012fd9c
LAB_0012fe4c:
XORPS XMM0,XMM0
LEA R14,[RBP + -0x30]
MOVAPS xmmword ptr [R14],XMM0
MOV EDX,EBX
AND EDX,0xf
PUSH 0x10
POP RCX
MOV RDI,R14
MOVDQA xmmword ptr [RBP + -0x40],XMM2
CALL 0x00129420
MOVDQA XMM1,xmmword ptr [RBP + -0x40]
PXOR XMM1,xmmword ptr [R14]
CMP EBX,0x4
JNC 0x0012fea0
PUSH 0x8
POP RAX
SUB EAX,EBX
AND EAX,0xf
LEA RCX,[0x1e2f70]
SUB RCX,RAX
MOVDQU XMM0,xmmword ptr [RCX + 0x10]
MOVDQA XMM2,XMM1
PSHUFB XMM2,XMM0
JMP 0x0012fdcc
LAB_0012fea0:
PUSH 0x10
POP RAX
SUB EAX,EBX
AND EAX,0x1f
LEA RCX,[0x1e2f70]
SUB RCX,RAX
MOVDQU XMM0,xmmword ptr [RCX + 0x10]
PSHUFB XMM1,XMM0
JMP 0x0012fd9c
|
/* WARNING: Removing unreachable block (ram,0x0012fdf3) */
/* WARNING: Removing unreachable block (ram,0x0012fdbe) */
/* WARNING: Removing unreachable block (ram,0x0012fd8a) */
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
uint crc32_pclmul(uint param_1,int1 (*param_2) [16],uint param_3)
{
int1 auVar1 [16];
int1 auVar2 [16];
int1 auVar3 [16];
int1 auVar4 [16];
int1 auVar5 [16];
int1 auVar6 [16];
int1 auVar7 [16];
int1 auVar8 [16];
int1 auVar9 [16];
uint uVar10;
uint uVar11;
uint uVar12;
long in_FS_OFFSET;
int1 auVar13 [16];
int1 auVar14 [16];
int1 auVar15 [16];
int1 auVar16 [16];
int8 local_38;
int8 uStack_30;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
if (param_3 == 0) goto LAB_0012fe09;
auVar15 = ZEXT416(~param_1);
if (param_3 < 0x20) {
if (param_3 == 0x10) {
auVar15 = *param_2 ^ auVar15;
goto LAB_0012fd9c;
}
if (0xf < param_3) {
auVar15 = *param_2 ^ auVar15;
uVar12 = 0x10;
goto LAB_0012fd40;
}
local_38 = 0;
uStack_30 = 0;
__memcpy_chk(&local_38,param_2,param_3 & 0xf,0x10);
auVar13._8_8_ = uStack_30;
auVar13._0_8_ = local_38;
if (3 < param_3) {
auVar15 = pshufb(auVar15 ^ auVar13,
*(int1 (*) [16])
(xmm_shift_left_crc_xmm_shift_tab + (0x10 - (ulong)(0x10 - param_3 & 0x1f)))
);
goto LAB_0012fd9c;
}
auVar15 = pshufb(auVar15 ^ auVar13,
*(int1 (*) [16])
(xmm_shift_left_crc_xmm_shift_tab + (0x10 - (ulong)(8 - param_3 & 0xf))));
}
else {
auVar15 = *param_2 ^ auVar15;
uVar10 = 0x10;
do {
auVar14._8_8_ = 0;
auVar14._0_8_ = auVar15._8_8_;
auVar13 = (int1 [16])0x0;
for (uVar12 = 0; uVar12 < 0x40; uVar12 = uVar12 + 1) {
if ((auVar14 & (int1 [16])0x1 << uVar12) != (int1 [16])0x0) {
auVar13 = auVar13 ^ ZEXT816(0xccaa009e) << uVar12;
}
}
auVar16._8_8_ = 0;
auVar16._0_8_ = auVar15._0_8_;
auVar3._8_8_ = 0;
auVar3._0_8_ = _UNK_001d9158;
auVar15 = (int1 [16])0x0;
for (uVar12 = 0; uVar12 < 0x40; uVar12 = uVar12 + 1) {
if ((auVar16 & (int1 [16])0x1 << uVar12) != (int1 [16])0x0) {
auVar15 = auVar15 ^ auVar3 << uVar12;
}
}
auVar15 = auVar15 ^ auVar13 ^ *(int1 (*) [16])(*param_2 + uVar10);
uVar12 = uVar10 + 0x10;
uVar11 = uVar10 + 0x20;
uVar10 = uVar12;
} while (uVar11 <= param_3);
LAB_0012fd40:
if (uVar12 < param_3) {
auVar16 = pshufb(auVar15,*(int1 (*) [16])
(crcr32_calc_pclmulqdq_shf_table + (param_3 & 0xf)));
auVar13 = *(int1 (*) [16])(crcr32_calc_pclmulqdq_shf_table + (param_3 & 0xf)) ^
_DAT_001d9160;
auVar15 = pshufb(auVar15,auVar13);
auVar14 = pblendvb(auVar15,*(int1 (*) [16])(*param_2 + (param_3 - 0x10)),auVar13);
auVar15._8_8_ = 0;
auVar15._0_8_ = auVar16._8_8_;
auVar13 = (int1 [16])0x0;
for (uVar12 = 0; uVar12 < 0x40; uVar12 = uVar12 + 1) {
if ((ZEXT816(0xccaa009e) & (int1 [16])0x1 << uVar12) != (int1 [16])0x0) {
auVar13 = auVar13 ^ auVar15 << uVar12;
}
}
auVar4._8_8_ = 0;
auVar4._0_8_ = auVar16._0_8_;
auVar7._8_8_ = 0;
auVar7._0_8_ = _UNK_001d9158;
auVar15 = (int1 [16])0x0;
for (uVar12 = 0; uVar12 < 0x40; uVar12 = uVar12 + 1) {
if ((auVar4 & (int1 [16])0x1 << uVar12) != (int1 [16])0x0) {
auVar15 = auVar15 ^ auVar7 << uVar12;
}
}
auVar15 = auVar15 ^ auVar13 ^ auVar14;
}
LAB_0012fd9c:
auVar1._8_8_ = 0;
auVar1._0_8_ = auVar15._0_8_;
auVar13 = (int1 [16])0x0;
for (uVar12 = 0; uVar12 < 0x40; uVar12 = uVar12 + 1) {
if ((ZEXT816(0xccaa009e) & (int1 [16])0x1 << uVar12) != (int1 [16])0x0) {
auVar13 = auVar13 ^ auVar1 << uVar12;
}
}
auVar13 = auVar15 >> 0x40 ^ auVar13;
auVar5._8_8_ = 0;
auVar5._0_8_ = auVar13._0_8_ << 0x20;
auVar8._8_8_ = 0;
auVar8._0_8_ = _UNK_001d9178;
auVar15 = (int1 [16])0x0;
for (uVar12 = 0; uVar12 < 0x40; uVar12 = uVar12 + 1) {
if ((auVar5 & (int1 [16])0x1 << uVar12) != (int1 [16])0x0) {
auVar15 = auVar15 ^ auVar8 << uVar12;
}
}
auVar15 = auVar15 ^ auVar13;
}
auVar14 = pblendw((int1 [16])0x0,auVar15,0xfc);
auVar2._8_8_ = 0;
auVar2._0_8_ = auVar14._0_8_;
auVar13 = (int1 [16])0x0;
for (uVar12 = 0; uVar12 < 0x40; uVar12 = uVar12 + 1) {
if ((ZEXT816(0x1f7011640) & (int1 [16])0x1 << uVar12) != (int1 [16])0x0) {
auVar13 = auVar13 ^ auVar2 << uVar12;
}
}
auVar6._8_8_ = 0;
auVar6._0_8_ = auVar13._0_8_ ^ auVar14._0_8_;
auVar9._8_8_ = 0;
auVar9._0_8_ = _UNK_001d9188;
auVar13 = (int1 [16])0x0;
for (uVar12 = 0; uVar12 < 0x40; uVar12 = uVar12 + 1) {
if ((auVar6 & (int1 [16])0x1 << uVar12) != (int1 [16])0x0) {
auVar13 = auVar13 ^ auVar9 << uVar12;
}
}
param_1 = ~(auVar13._8_4_ ^ auVar15._8_4_);
LAB_0012fe09:
if (*(long *)(in_FS_OFFSET + 0x28) != local_20) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
}
|
|
8,125 |
nglog::LogDestination::RemoveLogSink(nglog::LogSink*)
|
ng-log[P]ng-log/src/logging.cc
|
inline void LogDestination::RemoveLogSink(LogSink* destination) {
// Prevent any subtle race conditions by wrapping a mutex lock around
// all this stuff.
SinkLock l{sink_mutex_};
// This doesn't keep the sinks in order, but who cares?
if (sinks_) {
sinks_->erase(std::remove(sinks_->begin(), sinks_->end(), destination),
sinks_->end());
}
}
|
O2
|
cpp
|
nglog::LogDestination::RemoveLogSink(nglog::LogSink*):
pushq %rbx
subq $0x10, %rsp
movq %rdi, 0x8(%rsp)
leaq 0x2036d(%rip), %rdi # 0x3c258
callq 0x2856e
movq 0x20359(%rip), %rbx # 0x3c250
testq %rbx, %rbx
je 0x1bf23
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
leaq 0x8(%rsp), %rdx
callq 0x1ce08
movq 0x2033c(%rip), %rcx # 0x3c250
movq 0x8(%rcx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1cdb4
leaq 0x2032e(%rip), %rdi # 0x3c258
callq 0x14f80
addq $0x10, %rsp
popq %rbx
retq
jmp 0x1bf37
movq %rax, %rbx
leaq 0x20317(%rip), %rdi # 0x3c258
callq 0x14f80
movq %rbx, %rdi
callq 0x155d0
|
_ZN5nglog14LogDestination13RemoveLogSinkEPNS_7LogSinkE:
push rbx
sub rsp, 10h
mov [rsp+18h+var_10], rdi
lea rdi, _ZN5nglog14LogDestination11sink_mutex_E; this
call _ZNSt22__shared_mutex_pthread4lockEv; std::__shared_mutex_pthread::lock(void)
mov rbx, cs:_ZN5nglog14LogDestination6sinks_E; nglog::LogDestination::sinks_
test rbx, rbx
jz short loc_1BF23
mov rdi, [rbx]
mov rsi, [rbx+8]
lea rdx, [rsp+18h+var_10]
call _ZSt11__remove_ifIN9__gnu_cxx17__normal_iteratorIPPN5nglog7LogSinkESt6vectorIS4_SaIS4_EEEENS0_5__ops16_Iter_equals_valIKS4_EEET_SE_SE_T0_; std::__remove_if<__gnu_cxx::__normal_iterator<nglog::LogSink **,std::vector<nglog::LogSink *>>,__gnu_cxx::__ops::_Iter_equals_val<nglog::LogSink * const>>(__gnu_cxx::__normal_iterator<nglog::LogSink **,std::vector<nglog::LogSink *>>,__gnu_cxx::__normal_iterator<nglog::LogSink **,std::vector<nglog::LogSink *>>,__gnu_cxx::__ops::_Iter_equals_val<nglog::LogSink * const>)
mov rcx, cs:_ZN5nglog14LogDestination6sinks_E; nglog::LogDestination::sinks_
mov rdx, [rcx+8]
mov rdi, rbx
mov rsi, rax
call _ZNSt6vectorIPN5nglog7LogSinkESaIS2_EE5eraseEN9__gnu_cxx17__normal_iteratorIPKS2_S4_EES9_; std::vector<nglog::LogSink *>::erase(__gnu_cxx::__normal_iterator<nglog::LogSink * const*,std::vector<nglog::LogSink *>>,__gnu_cxx::__normal_iterator<nglog::LogSink * const*,std::vector<nglog::LogSink *>>)
loc_1BF23:
lea rdi, _ZN5nglog14LogDestination11sink_mutex_E; nglog::LogDestination::sink_mutex_
call _pthread_rwlock_unlock
add rsp, 10h
pop rbx
retn
jmp short $+2
loc_1BF37:
mov rbx, rax
lea rdi, _ZN5nglog14LogDestination11sink_mutex_E; nglog::LogDestination::sink_mutex_
call _pthread_rwlock_unlock
mov rdi, rbx
call __Unwind_Resume
|
long long nglog::LogDestination::RemoveLogSink(nglog::LogDestination *this, nglog::LogSink *a2)
{
long long v2; // rbx
long long v3; // rax
nglog::LogDestination *v5; // [rsp+8h] [rbp-10h] BYREF
v5 = this;
std::__shared_mutex_pthread::lock((std::__shared_mutex_pthread *)&nglog::LogDestination::sink_mutex_);
v2 = nglog::LogDestination::sinks_;
if ( nglog::LogDestination::sinks_ )
{
v3 = std::__remove_if<__gnu_cxx::__normal_iterator<nglog::LogSink **,std::vector<nglog::LogSink *>>,__gnu_cxx::__ops::_Iter_equals_val<nglog::LogSink * const>>(
*(_QWORD *)nglog::LogDestination::sinks_,
*(_QWORD *)(nglog::LogDestination::sinks_ + 8),
&v5);
std::vector<nglog::LogSink *>::erase(v2, v3, *(_QWORD *)(nglog::LogDestination::sinks_ + 8));
}
return pthread_rwlock_unlock(&nglog::LogDestination::sink_mutex_);
}
|
RemoveLogSink:
PUSH RBX
SUB RSP,0x10
MOV qword ptr [RSP + 0x8],RDI
LEA RDI,[0x13c258]
CALL 0x0012856e
MOV RBX,qword ptr [0x0013c250]
TEST RBX,RBX
JZ 0x0011bf23
MOV RDI,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x8]
LAB_0011bf03:
LEA RDX,[RSP + 0x8]
CALL 0x0011ce08
MOV RCX,qword ptr [0x0013c250]
MOV RDX,qword ptr [RCX + 0x8]
LAB_0011bf18:
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0011cdb4
LAB_0011bf23:
LEA RDI,[0x13c258]
CALL 0x00114f80
ADD RSP,0x10
POP RBX
RET
|
/* nglog::LogDestination::RemoveLogSink(nglog::LogSink*) */
void nglog::LogDestination::RemoveLogSink(LogSink *param_1)
{
int8 uVar1;
vector<nglog::LogSink*,std::allocator<nglog::LogSink*>> *pvVar2;
LogSink *local_10;
local_10 = param_1;
std::__shared_mutex_pthread::lock((__shared_mutex_pthread *)sink_mutex_);
pvVar2 = sinks_;
if (sinks_ != (vector<nglog::LogSink*,std::allocator<nglog::LogSink*>> *)0x0) {
/* try { // try from 0011bf03 to 0011bf0c has its CatchHandler @ 0011bf37 */
uVar1 = std::
__remove_if<__gnu_cxx::__normal_iterator<nglog::LogSink**,std::vector<nglog::LogSink*,std::allocator<nglog::LogSink*>>>,__gnu_cxx::__ops::_Iter_equals_val<nglog::LogSink*const>>
(*(int8 *)sinks_,*(int8 *)(sinks_ + 8),&local_10);
/* try { // try from 0011bf18 to 0011bf22 has its CatchHandler @ 0011bf35 */
std::vector<nglog::LogSink*,std::allocator<nglog::LogSink*>>::erase
(pvVar2,uVar1,*(int8 *)(sinks_ + 8));
}
pthread_rwlock_unlock((pthread_rwlock_t *)sink_mutex_);
return;
}
|
|
8,126 |
mysql_stat@libmariadbclient_18
|
eloqsql/libmariadb/libmariadb/mariadb_lib.c
|
char * STDCALL
mysql_stat(MYSQL *mysql)
{
if (ma_simple_command(mysql, COM_STATISTICS,0,0,0,0))
return mysql->net.last_error;
mysql->net.read_pos[mysql->packet_length]=0; /* End of stat string */
if (!mysql->net.read_pos[0])
{
SET_CLIENT_ERROR(mysql, CR_WRONG_HOST_INFO , SQLSTATE_UNKNOWN, 0);
return mysql->net.last_error;
}
return((char*) mysql->net.read_pos);
}
|
O3
|
c
|
mysql_stat@libmariadbclient_18:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x4d0(%rdi), %rax
movl $0x9, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq *0x10(%rax)
testl %eax, %eax
je 0x23075
addq $0x97, %rbx
movq %rbx, %r14
jmp 0x230e3
movq 0x20(%rbx), %rax
movq 0x358(%rbx), %rcx
movb $0x0, (%rax,%rcx)
movq 0x20(%rbx), %r14
cmpb $0x0, (%r14)
jne 0x230e3
movl $0x7d9, 0x90(%rbx) # imm = 0x7D9
leaq 0x297(%rbx), %rdi
leaq 0x28caa(%rip), %rax # 0x4bd50
movq (%rax), %rsi
movl $0x5, %edx
callq 0x172d0
xorl %r15d, %r15d
movb %r15b, 0x29c(%rbx)
leaq 0x97(%rbx), %r14
leaq 0x28c95(%rip), %rax # 0x4bd60
movq 0x48(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
movq %r14, %rdi
callq 0x172d0
movb %r15b, 0x296(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
mysql_stat@libmariadbclient_18:
push rbp; Alternative name is 'mysql_stat'
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdi
mov rax, [rdi+4D0h]
mov esi, 9
xor edx, edx
xor ecx, ecx
xor r8d, r8d
xor r9d, r9d
call qword ptr [rax+10h]
test eax, eax
jz short loc_23075
add rbx, 97h
mov r14, rbx
jmp short loc_230E3
loc_23075:
mov rax, [rbx+20h]
mov rcx, [rbx+358h]
mov byte ptr [rax+rcx], 0
mov r14, [rbx+20h]
cmp byte ptr [r14], 0
jnz short loc_230E3
mov dword ptr [rbx+90h], 7D9h
lea rdi, [rbx+297h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r15d, r15d
mov [rbx+29Ch], r15b
lea r14, [rbx+97h]
lea rax, client_errors
mov rsi, [rax+48h]
mov edx, 1FFh
mov rdi, r14
call _strncpy
mov [rbx+296h], r15b
loc_230E3:
mov rax, r14
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
_BYTE * mysql_stat_libmariadbclient_18(long long a1)
{
long long v1; // rax
_BYTE *v2; // r14
if ( (*(unsigned int ( **)(long long, long long, _QWORD, _QWORD, _QWORD, _QWORD, long long))(*(_QWORD *)(a1 + 1232)
+ 16LL))(
a1,
9LL,
0LL,
0LL,
0LL,
0LL,
v1) )
{
return (_BYTE *)(a1 + 151);
}
*(_BYTE *)(*(_QWORD *)(a1 + 32) + *(_QWORD *)(a1 + 856)) = 0;
v2 = *(_BYTE **)(a1 + 32);
if ( !*v2 )
{
*(_DWORD *)(a1 + 144) = 2009;
strncpy(a1 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 668) = 0;
v2 = (_BYTE *)(a1 + 151);
strncpy(a1 + 151, client_errors[9], 511LL);
*(_BYTE *)(a1 + 662) = 0;
}
return v2;
}
|
mysql_stat:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x4d0]
MOV ESI,0x9
XOR EDX,EDX
XOR ECX,ECX
XOR R8D,R8D
XOR R9D,R9D
CALL qword ptr [RAX + 0x10]
TEST EAX,EAX
JZ 0x00123075
ADD RBX,0x97
MOV R14,RBX
JMP 0x001230e3
LAB_00123075:
MOV RAX,qword ptr [RBX + 0x20]
MOV RCX,qword ptr [RBX + 0x358]
MOV byte ptr [RAX + RCX*0x1],0x0
MOV R14,qword ptr [RBX + 0x20]
CMP byte ptr [R14],0x0
JNZ 0x001230e3
MOV dword ptr [RBX + 0x90],0x7d9
LEA RDI,[RBX + 0x297]
LEA RAX,[0x14bd50]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x001172d0
XOR R15D,R15D
MOV byte ptr [RBX + 0x29c],R15B
LEA R14,[RBX + 0x97]
LEA RAX,[0x14bd60]
MOV RSI,qword ptr [RAX + 0x48]
MOV EDX,0x1ff
MOV RDI,R14
CALL 0x001172d0
MOV byte ptr [RBX + 0x296],R15B
LAB_001230e3:
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
char * mysql_stat(long param_1)
{
int iVar1;
char *__dest;
iVar1 = (**(code **)(*(long *)(param_1 + 0x4d0) + 0x10))(param_1,9,0,0,0,0);
if (iVar1 == 0) {
*(int1 *)(*(long *)(param_1 + 0x20) + *(long *)(param_1 + 0x358)) = 0;
__dest = *(char **)(param_1 + 0x20);
if (*__dest == '\0') {
*(int4 *)(param_1 + 0x90) = 0x7d9;
strncpy((char *)(param_1 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x29c) = 0;
__dest = (char *)(param_1 + 0x97);
strncpy(__dest,PTR_s_Wrong_host_info_0014bda8,0x1ff);
*(int1 *)(param_1 + 0x296) = 0;
}
}
else {
__dest = (char *)(param_1 + 0x97);
}
return __dest;
}
|
|
8,127 |
clip_image_encode
|
llama.cpp/examples/llava/clip.cpp
|
bool clip_image_encode(struct clip_ctx * ctx, const int n_threads, clip_image_f32 * img, float * vec) {
if (!ctx->has_vision_encoder) {
LOG_ERR("%s: This gguf file seems to have no vision encoder\n", __func__);
return false;
}
clip_image_f32_batch imgs{};
imgs.size = 1;
imgs.data = img;
return clip_image_batch_encode(ctx, n_threads, &imgs, vec);
}
|
O3
|
cpp
|
clip_image_encode:
pushq %rbx
subq $0x10, %rsp
cmpb $0x0, 0x1(%rdi)
je 0x25c1f
movq %rsp, %rax
movq $0x1, 0x8(%rax)
movq %rdx, (%rax)
movq %rax, %rdx
callq 0x1c400
movl %eax, %ebx
jmp 0x25c4b
movq 0x38362(%rip), %rax # 0x5df88
cmpl $0x4, (%rax)
jg 0x25c49
leaq 0x2943d(%rip), %rsi # 0x4f06f
leaq 0x2946f(%rip), %rdx # 0x4f0a8
xorl %ebx, %ebx
movl $0x4, %edi
xorl %eax, %eax
callq 0x235eb
jmp 0x25c4b
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
|
clip_image_encode:
push rbx
sub rsp, 10h
cmp byte ptr [rdi+1], 0
jz short loc_25C1F
mov rax, rsp
mov qword ptr [rax+8], 1
mov [rax], rdx
mov rdx, rax
call _clip_image_batch_encode
mov ebx, eax
jmp short loc_25C4B
loc_25C1F:
mov rax, cs:g_logger_state_ptr
cmp dword ptr [rax], 4
jg short loc_25C49
lea rsi, aSThisGgufFileS; "%s: This gguf file seems to have no vis"...
lea rdx, aClipImageEncod_0; "clip_image_encode"
xor ebx, ebx
mov edi, 4
xor eax, eax
call _ZL17clip_log_internal14ggml_log_levelPKcz; clip_log_internal(ggml_log_level,char const*,...)
jmp short loc_25C4B
loc_25C49:
xor ebx, ebx
loc_25C4B:
mov eax, ebx
add rsp, 10h
pop rbx
retn
|
long long clip_image_encode(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
unsigned int v14; // ebx
_QWORD v16[3]; // [rsp+0h] [rbp-18h] BYREF
if ( *(_BYTE *)(a1 + 1) )
{
v16[1] = 1LL;
v16[0] = a3;
return (unsigned int)clip_image_batch_encode(a1, a2, v16);
}
else
{
v14 = 0;
if ( g_logger_state <= 4 )
clip_log_internal(
4u,
(long long)"%s: This gguf file seems to have no vision encoder\n",
(long long)"clip_image_encode",
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14);
}
return v14;
}
|
clip_image_encode:
PUSH RBX
SUB RSP,0x10
CMP byte ptr [RDI + 0x1],0x0
JZ 0x00125c1f
MOV RAX,RSP
MOV qword ptr [RAX + 0x8],0x1
MOV qword ptr [RAX],RDX
MOV RDX,RAX
CALL 0x0011c400
MOV EBX,EAX
JMP 0x00125c4b
LAB_00125c1f:
MOV RAX,qword ptr [0x0015df88]
CMP dword ptr [RAX],0x4
JG 0x00125c49
LEA RSI,[0x14f06f]
LEA RDX,[0x14f0a8]
XOR EBX,EBX
MOV EDI,0x4
XOR EAX,EAX
CALL 0x001235eb
JMP 0x00125c4b
LAB_00125c49:
XOR EBX,EBX
LAB_00125c4b:
MOV EAX,EBX
ADD RSP,0x10
POP RBX
RET
|
int4 clip_image_encode(long param_1,int8 param_2,int8 param_3)
{
int4 uVar1;
int8 local_18;
int8 local_10;
if (*(char *)(param_1 + 1) == '\0') {
if (*(int *)PTR_g_logger_state_0015df88 < 5) {
uVar1 = 0;
clip_log_internal(4,"%s: This gguf file seems to have no vision encoder\n","clip_image_encode"
);
}
else {
uVar1 = 0;
}
}
else {
local_10 = 1;
local_18 = param_3;
uVar1 = clip_image_batch_encode(param_1,param_2,&local_18);
}
return uVar1;
}
|
|
8,128 |
minja::Context::make(minja::Value&&, std::shared_ptr<minja::Context> const&)
|
monkey531[P]llama/common/minja.hpp
|
inline std::shared_ptr<Context> Context::make(Value && values, const std::shared_ptr<Context> & parent) {
return std::make_shared<Context>(values.is_null() ? Value::object() : std::move(values), parent);
}
|
O3
|
cpp
|
minja::Context::make(minja::Value&&, std::shared_ptr<minja::Context> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq 0x10(%rsi), %rdx
movq 0x20(%rsi), %rax
movq %rax, %rcx
orq %rdx, %rcx
sete %cl
cmpb $0x0, 0x40(%rsi)
movq %rdi, %rbx
sete %sil
andb %cl, %sil
movq 0x30(%r15), %rcx
testq %rcx, %rcx
sete %bpl
andb %sil, %bpl
cmpb $0x1, %bpl
jne 0x9f014
movl $0x30, %edi
callq 0x1b9f0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x8d456(%rip), %rcx # 0x12c438
addq $0x10, %rcx
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
leaq 0x10(%rsp), %rsi
movq %rax, 0x8(%rsi)
movq %rcx, (%rsi)
leaq 0x20(%rsp), %rdi
callq 0x919dc
jmp 0x9f090
leaq 0x40(%r15), %rdi
xorps %xmm0, %xmm0
leaq 0x60(%rsp), %r12
movaps %xmm0, -0x40(%r12)
movq %rdx, -0x30(%r12)
movq 0x18(%r15), %rdx
xorl %r13d, %r13d
movq %r13, 0x18(%r15)
movq %rdx, -0x28(%r12)
movq %r13, 0x10(%r15)
movq %rax, -0x20(%r12)
movq 0x28(%r15), %rax
movq %r13, 0x28(%r15)
movq %rax, -0x18(%r12)
movq %r13, 0x20(%r15)
movq %rcx, -0x10(%r12)
movq 0x38(%r15), %rax
movq %r13, 0x38(%r15)
movq %rax, -0x8(%r12)
movq %r13, 0x30(%r15)
movups (%rdi), %xmm0
movaps %xmm0, (%r12)
xorl %esi, %esi
callq 0x5b4ca
movb $0x0, 0x40(%r15)
movq %r13, 0x48(%r15)
movq %r12, %rdi
movl $0x1, %esi
callq 0x5b4ca
leaq 0xf(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x9f3da
leaq 0x60(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x5b4ca
movq %r14, %rdi
callq 0x60938
movq -0x8(%r14), %rdi
testq %rdi, %rdi
je 0x9f0ca
callq 0x70324
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x9f0d9
callq 0x70324
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x9f0e8
callq 0x70324
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x9f11e
movq 0x8ee87(%rip), %rax # 0x12df80
cmpb $0x0, (%rax)
je 0x9f109
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x9f113
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x9f11e
movq (%rdi), %rax
callq *0x18(%rax)
testb %bpl, %bpl
je 0x9f132
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x9f132
callq 0x70324
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x88eac
testb %bpl, %bpl
je 0x9f165
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x9f165
callq 0x70324
movq %rbx, %rdi
callq 0x1c1e0
nop
|
_ZN5minja7Context4makeEONS_5ValueERKSt10shared_ptrIS0_E:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov r14, rdx
mov r15, rsi
mov rdx, [rsi+10h]
mov rax, [rsi+20h]
mov rcx, rax
or rcx, rdx
setz cl
cmp byte ptr [rsi+40h], 0
mov rbx, rdi
setz sil
and sil, cl
mov rcx, [r15+30h]
test rcx, rcx
setz bpl
and bpl, sil
cmp bpl, 1
jnz short loc_9F014
mov edi, 30h ; '0'; unsigned __int64
call __Znwm; operator new(ulong)
mov rcx, 100000001h
mov [rax+8], rcx
lea rcx, _ZTVSt23_Sp_counted_ptr_inplaceIN8nlohmann16json_abi_v3_11_311ordered_mapINS1_10basic_jsonIS2_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEN5minja5ValueESt4lessISE_ESaISt4pairIKSE_SG_EEEESaISN_ELN9__gnu_cxx12_Lock_policyE2EE; `vtable for'std::_Sp_counted_ptr_inplace<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::allocator<std::pair<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,minja::Value>>>,std::allocator<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::allocator<std::pair<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,minja::Value>>>>,(__gnu_cxx::_Lock_policy)2>
add rcx, 10h
mov [rax], rcx
lea rcx, [rax+10h]
xorps xmm0, xmm0
movups xmmword ptr [rax+10h], xmm0
mov qword ptr [rax+20h], 0
lea rsi, [rsp+0A8h+var_98]
mov [rsi+8], rax
mov [rsi], rcx
lea rdi, [rsp+0A8h+var_88]
call _ZN5minja5ValueC2ERKSt10shared_ptrIN8nlohmann16json_abi_v3_11_311ordered_mapINS3_10basic_jsonIS4_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEES0_St4lessISG_ESaISt4pairIKSG_S0_EEEEE; minja::Value::Value(std::shared_ptr<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::allocator<std::pair<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,minja::Value>>>> const&)
jmp short loc_9F090
loc_9F014:
lea rdi, [r15+40h]
xorps xmm0, xmm0
lea r12, [rsp+0A8h+var_48]
movaps xmmword ptr [r12-40h], xmm0
mov [r12-30h], rdx
mov rdx, [r15+18h]
xor r13d, r13d
mov [r15+18h], r13
mov [r12-28h], rdx
mov [r15+10h], r13
mov [r12-20h], rax
mov rax, [r15+28h]
mov [r15+28h], r13
mov [r12-18h], rax
mov [r15+20h], r13
mov [r12-10h], rcx
mov rax, [r15+38h]
mov [r15+38h], r13
mov [r12-8], rax
mov [r15+30h], r13
movups xmm0, xmmword ptr [rdi]
movaps xmmword ptr [r12], xmm0
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 byte ptr [r15+40h], 0
mov [r15+48h], r13
mov rdi, r12
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
loc_9F090:
lea rsi, [rsp+0A8h+var_99]
lea rdx, [rsp+0A8h+var_88]
mov rdi, rbx
mov rcx, r14
call _ZNSt12__shared_ptrIN5minja7ContextELN9__gnu_cxx12_Lock_policyE2EEC2ISaIS1_EJNS0_5ValueERKSt10shared_ptrIS1_EEEESt20_Sp_alloc_shared_tagIT_EDpOT0_; std::__shared_ptr<minja::Context,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<minja::Context>,minja::Value,std::shared_ptr<minja::Context> const&>(std::_Sp_alloc_shared_tag<std::allocator<minja::Context>>,minja::Value,std::shared_ptr<minja::Context> const&)
lea r14, [rsp+0A8h+var_48]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [r14-8]
test rdi, rdi
jz short loc_9F0CA
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9F0CA:
mov rdi, [rsp+0A8h+var_60]
test rdi, rdi
jz short loc_9F0D9
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9F0D9:
mov rdi, [rsp+0A8h+var_70]
test rdi, rdi
jz short loc_9F0E8
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9F0E8:
mov rdi, [rsp+0A8h+var_80]
test rdi, rdi
jz short loc_9F11E
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_9F109
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_9F113
loc_9F109:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_9F113:
cmp eax, 1
jnz short loc_9F11E
mov rax, [rdi]
call qword ptr [rax+18h]
loc_9F11E:
test bpl, bpl
jz short loc_9F132
mov rdi, [rsp+0A8h+var_90]
test rdi, rdi
jz short loc_9F132
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9F132:
mov rax, rbx
add rsp, 78h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rdi, [rsp+arg_18]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
test bpl, bpl
jz short loc_9F165
mov rdi, [rsp+arg_10]
test rdi, rdi
jz short loc_9F165
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9F165:
mov rdi, rbx
call __Unwind_Resume
|
long long minja::Context::make(long long a1, long long a2, long long a3)
{
__int128 v4; // rax
long long v6; // rcx
bool v7; // bp
long long v8; // rax
volatile signed __int32 *v9; // rax
volatile signed __int32 *v10; // rax
long long v11; // rdi
signed __int32 v12; // eax
char v14; // [rsp+Fh] [rbp-99h] BYREF
long long v15; // [rsp+10h] [rbp-98h] BYREF
volatile signed __int32 *v16; // [rsp+18h] [rbp-90h]
__int128 v17; // [rsp+20h] [rbp-88h] BYREF
long long v18; // [rsp+30h] [rbp-78h]
volatile signed __int32 *v19; // [rsp+38h] [rbp-70h]
long long v20; // [rsp+40h] [rbp-68h]
volatile signed __int32 *v21; // [rsp+48h] [rbp-60h]
long long v22; // [rsp+50h] [rbp-58h]
volatile signed __int32 *v23; // [rsp+58h] [rbp-50h]
_OWORD v24[4]; // [rsp+60h] [rbp-48h] BYREF
*((_QWORD *)&v4 + 1) = *(_QWORD *)(a2 + 16);
*(_QWORD *)&v4 = *(_QWORD *)(a2 + 32);
v6 = *(_QWORD *)(a2 + 48);
v7 = v4 == 0 && *(_BYTE *)(a2 + 64) == 0 && v6 == 0;
if ( v7 )
{
v8 = operator new(0x30uLL);
*(_QWORD *)(v8 + 8) = 0x100000001LL;
*(_QWORD *)v8 = &`vtable for'std::_Sp_counted_ptr_inplace<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>,std::allocator<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>>,(__gnu_cxx::_Lock_policy)2>
+ 2;
*(_OWORD *)(v8 + 16) = 0LL;
*(_QWORD *)(v8 + 32) = 0LL;
v16 = (volatile signed __int32 *)v8;
v15 = v8 + 16;
minja::Value::Value((long long)&v17, &v15);
}
else
{
v17 = 0LL;
v18 = *((_QWORD *)&v4 + 1);
*((_QWORD *)&v4 + 1) = *(_QWORD *)(a2 + 24);
*(_QWORD *)(a2 + 24) = 0LL;
v19 = (volatile signed __int32 *)*((_QWORD *)&v4 + 1);
*(_QWORD *)(a2 + 16) = 0LL;
v20 = v4;
v9 = *(volatile signed __int32 **)(a2 + 40);
*(_QWORD *)(a2 + 40) = 0LL;
v21 = v9;
*(_QWORD *)(a2 + 32) = 0LL;
v22 = v6;
v10 = *(volatile signed __int32 **)(a2 + 56);
*(_QWORD *)(a2 + 56) = 0LL;
v23 = v10;
*(_QWORD *)(a2 + 48) = 0LL;
v24[0] = *(_OWORD *)(a2 + 64);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)(a2 + 64));
*(_BYTE *)(a2 + 64) = 0;
*(_QWORD *)(a2 + 72) = 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 *)v24);
}
std::__shared_ptr<minja::Context,(__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<minja::Context>,minja::Value,std::shared_ptr<minja::Context> const&>(
a1,
&v14,
&v17,
a3);
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 *)v24);
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(v24);
if ( v23 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v23);
if ( v21 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v21);
if ( v19 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v19);
v11 = *((_QWORD *)&v17 + 1);
if ( *((_QWORD *)&v17 + 1) )
{
if ( _libc_single_threaded )
{
v12 = *(_DWORD *)(*((_QWORD *)&v17 + 1) + 12LL);
*(_DWORD *)(*((_QWORD *)&v17 + 1) + 12LL) = v12 - 1;
}
else
{
v12 = _InterlockedExchangeAdd((volatile signed __int32 *)(*((_QWORD *)&v17 + 1) + 12LL), 0xFFFFFFFF);
}
if ( v12 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v11 + 24LL))(v11, 0LL);
}
if ( v7 && v16 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v16);
return a1;
}
|
make:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV R14,RDX
MOV R15,RSI
MOV RDX,qword ptr [RSI + 0x10]
MOV RAX,qword ptr [RSI + 0x20]
MOV RCX,RAX
OR RCX,RDX
SETZ CL
CMP byte ptr [RSI + 0x40],0x0
MOV RBX,RDI
SETZ SIL
AND SIL,CL
MOV RCX,qword ptr [R15 + 0x30]
TEST RCX,RCX
SETZ BPL
AND BPL,SIL
CMP BPL,0x1
JNZ 0x0019f014
MOV EDI,0x30
CALL 0x0011b9f0
MOV RCX,0x100000001
MOV qword ptr [RAX + 0x8],RCX
LEA RCX,[0x22c438]
ADD RCX,0x10
MOV qword ptr [RAX],RCX
LEA RCX,[RAX + 0x10]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX + 0x10],XMM0
MOV qword ptr [RAX + 0x20],0x0
LEA RSI,[RSP + 0x10]
MOV qword ptr [RSI + 0x8],RAX
MOV qword ptr [RSI],RCX
LEA RDI,[RSP + 0x20]
CALL 0x001919dc
JMP 0x0019f090
LAB_0019f014:
LEA RDI,[R15 + 0x40]
XORPS XMM0,XMM0
LEA R12,[RSP + 0x60]
MOVAPS xmmword ptr [R12 + -0x40],XMM0
MOV qword ptr [R12 + -0x30],RDX
MOV RDX,qword ptr [R15 + 0x18]
XOR R13D,R13D
MOV qword ptr [R15 + 0x18],R13
MOV qword ptr [R12 + -0x28],RDX
MOV qword ptr [R15 + 0x10],R13
MOV qword ptr [R12 + -0x20],RAX
MOV RAX,qword ptr [R15 + 0x28]
MOV qword ptr [R15 + 0x28],R13
MOV qword ptr [R12 + -0x18],RAX
MOV qword ptr [R15 + 0x20],R13
MOV qword ptr [R12 + -0x10],RCX
MOV RAX,qword ptr [R15 + 0x38]
MOV qword ptr [R15 + 0x38],R13
MOV qword ptr [R12 + -0x8],RAX
MOV qword ptr [R15 + 0x30],R13
MOVUPS XMM0,xmmword ptr [RDI]
MOVAPS xmmword ptr [R12],XMM0
XOR ESI,ESI
CALL 0x0015b4ca
MOV byte ptr [R15 + 0x40],0x0
MOV qword ptr [R15 + 0x48],R13
MOV RDI,R12
MOV ESI,0x1
CALL 0x0015b4ca
LAB_0019f090:
LEA RSI,[RSP + 0xf]
LEA RDX,[RSP + 0x20]
MOV RDI,RBX
MOV RCX,R14
CALL 0x0019f3da
LAB_0019f0a5:
LEA R14,[RSP + 0x60]
MOV RDI,R14
XOR ESI,ESI
CALL 0x0015b4ca
MOV RDI,R14
CALL 0x00160938
MOV RDI,qword ptr [R14 + -0x8]
TEST RDI,RDI
JZ 0x0019f0ca
CALL 0x00170324
LAB_0019f0ca:
MOV RDI,qword ptr [RSP + 0x48]
TEST RDI,RDI
JZ 0x0019f0d9
CALL 0x00170324
LAB_0019f0d9:
MOV RDI,qword ptr [RSP + 0x38]
TEST RDI,RDI
JZ 0x0019f0e8
CALL 0x00170324
LAB_0019f0e8:
MOV RDI,qword ptr [RSP + 0x28]
TEST RDI,RDI
JZ 0x0019f11e
MOV RAX,qword ptr [0x0022df80]
CMP byte ptr [RAX],0x0
JZ 0x0019f109
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x0019f113
LAB_0019f109:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_0019f113:
CMP EAX,0x1
JNZ 0x0019f11e
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_0019f11e:
TEST BPL,BPL
JZ 0x0019f132
MOV RDI,qword ptr [RSP + 0x18]
TEST RDI,RDI
JZ 0x0019f132
CALL 0x00170324
LAB_0019f132:
MOV RAX,RBX
ADD RSP,0x78
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* minja::Context::make(minja::Value&&, std::shared_ptr<minja::Context> const&) */
Context * __thiscall minja::Context::make(Context *this,Value *param_1,shared_ptr *param_2)
{
int *piVar1;
Value VVar2;
long lVar3;
long lVar4;
long lVar5;
int iVar6;
int1 local_99;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_98;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_90;
int8 local_88;
long *plStack_80;
long local_78;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_70;
long local_68;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_60;
long local_58;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_50;
int8 local_48;
int8 uStack_40;
lVar3 = *(long *)(param_1 + 0x10);
lVar4 = *(long *)(param_1 + 0x20);
VVar2 = param_1[0x40];
lVar5 = *(long *)(param_1 + 0x30);
if (lVar5 != 0 || (VVar2 != (Value)0x0 || (lVar4 != 0 || lVar3 != 0))) {
local_88 = 0;
plStack_80 = (long *)0x0;
local_70 = *(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(param_1 + 0x18);
*(int8 *)(param_1 + 0x18) = 0;
*(int8 *)(param_1 + 0x10) = 0;
local_60 = *(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(param_1 + 0x28);
*(int8 *)(param_1 + 0x28) = 0;
*(int8 *)(param_1 + 0x20) = 0;
local_50 = *(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(param_1 + 0x38);
*(int8 *)(param_1 + 0x38) = 0;
*(int8 *)(param_1 + 0x30) = 0;
local_48 = *(int8 *)(param_1 + 0x40);
uStack_40 = *(int8 *)(param_1 + 0x48);
local_78 = lVar3;
local_68 = lVar4;
local_58 = lVar5;
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(param_1 + 0x40,0));
param_1[0x40] = (Value)0x0;
*(int8 *)(param_1 + 0x48) = 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>
::assert_invariant(SUB81(&local_48,0));
}
else {
local_90 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)operator_new(0x30);
*(int8 *)(local_90 + 8) = 0x100000001;
*(int ***)local_90 = &PTR___Sp_counted_ptr_inplace_0022c448;
local_98 = local_90 + 0x10;
*(int8 *)(local_90 + 0x10) = 0;
*(int8 *)(local_90 + 0x18) = 0;
*(int8 *)(local_90 + 0x20) = 0;
Value::Value((Value *)&local_88,(shared_ptr *)&local_98);
}
/* try { // try from 0019f090 to 0019f0a4 has its CatchHandler @ 0019f144 */
std::__shared_ptr<minja::Context,(__gnu_cxx::_Lock_policy)2>::
__shared_ptr<std::allocator<minja::Context>,minja::Value,std::shared_ptr<minja::Context>const&>
((__shared_ptr<minja::Context,(__gnu_cxx::_Lock_policy)2> *)this,&local_99,&local_88,
param_2);
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_48,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_48);
if (local_50 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_50);
}
if (local_60 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_60);
}
if (local_70 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_70);
}
if (plStack_80 != (long *)0x0) {
if (*PTR___libc_single_threaded_0022df80 == '\0') {
LOCK();
piVar1 = (int *)((long)plStack_80 + 0xc);
iVar6 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar6 = *(int *)((long)plStack_80 + 0xc);
*(int *)((long)plStack_80 + 0xc) = iVar6 + -1;
}
if (iVar6 == 1) {
(**(code **)(*plStack_80 + 0x18))();
}
}
if ((lVar5 == 0 && (VVar2 == (Value)0x0 && (lVar4 == 0 && lVar3 == 0))) &&
(local_90 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0)) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_90);
}
return this;
}
|
|
8,129 |
char* mujoco::sample_util::strcpy_arr<1000ul>(char (&) [1000ul], char const*)
|
aimrt_mujoco_sim/_deps/mujoco-src/simulate/array_safety.h
|
static inline char* strcpy_arr(char (&dest)[N], const char* src) {
{
std::size_t i = 0;
for (; src[i] && i < N - 1; ++i) {
dest[i] = src[i];
}
dest[i] = '\0';
}
return &dest[0];
}
|
O0
|
c
|
char* mujoco::sample_util::strcpy_arr<1000ul>(char (&) [1000ul], char const*):
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq $0x0, -0x18(%rsp)
movq -0x10(%rsp), %rcx
movq -0x18(%rsp), %rdx
xorl %eax, %eax
cmpb $0x0, (%rcx,%rdx)
movb %al, -0x19(%rsp)
je 0x3a2ea9
cmpq $0x12b, -0x18(%rsp) # imm = 0x12B
setb %al
movb %al, -0x19(%rsp)
movb -0x19(%rsp), %al
testb $0x1, %al
jne 0x3a2eb3
jmp 0x3a2edd
movq -0x10(%rsp), %rax
movq -0x18(%rsp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rsp), %rax
movq -0x18(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x3a2e83
movq -0x8(%rsp), %rax
movq -0x18(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
|
_ZN6mujoco11sample_utilL10strcpy_arrILm300EEEPcRAT__cPKc:
mov [rsp+var_8], rdi
mov [rsp+var_10], rsi
mov [rsp+var_18], 0
loc_3A2E83:
mov rcx, [rsp+var_10]
mov rdx, [rsp+var_18]
xor eax, eax
cmp byte ptr [rcx+rdx], 0
mov [rsp+var_19], al
jz short loc_3A2EA9
cmp [rsp+var_18], 12Bh
setb al
mov [rsp+var_19], al
loc_3A2EA9:
mov al, [rsp+var_19]
test al, 1
jnz short loc_3A2EB3
jmp short loc_3A2EDD
loc_3A2EB3:
mov rax, [rsp+var_10]
mov rcx, [rsp+var_18]
mov dl, [rax+rcx]
mov rax, [rsp+var_8]
mov rcx, [rsp+var_18]
mov [rax+rcx], dl
mov rax, [rsp+var_18]
add rax, 1
mov [rsp+var_18], rax
jmp short loc_3A2E83
loc_3A2EDD:
mov rax, [rsp+var_8]
mov rcx, [rsp+var_18]
mov byte ptr [rax+rcx], 0
mov rax, [rsp+var_8]
retn
|
long long mujoco::sample_util::strcpy_arr<300ul>(long long a1, long long a2)
{
bool v3; // [rsp+1h] [rbp-19h]
unsigned long long i; // [rsp+2h] [rbp-18h]
for ( i = 0LL; ; ++i )
{
v3 = 0;
if ( *(_BYTE *)(a2 + i) )
v3 = i < 0x12B;
if ( !v3 )
break;
*(_BYTE *)(a1 + i) = *(_BYTE *)(a2 + i);
}
*(_BYTE *)(a1 + i) = 0;
return a1;
}
|
_M_conjure_hashtable:
MOV qword ptr [RSP + -0x8],RDI
MOV RAX,qword ptr [RSP + -0x8]
RET
|
/* std::__detail::_Insert_base<std::__cxx11::string, std::__cxx11::string,
std::allocator<std::__cxx11::string >, std::__detail::_Identity,
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, true, true>
>::_M_conjure_hashtable() */
_Insert_base<std::__cxx11::string,std::__cxx11::string,std::allocator<std::__cxx11::string>,std::__detail::_Identity,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,true,true>>
* __thiscall
std::__detail::
_Insert_base<std::__cxx11::string,std::__cxx11::string,std::allocator<std::__cxx11::string>,std::__detail::_Identity,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,true,true>>
::_M_conjure_hashtable
(_Insert_base<std::__cxx11::string,std::__cxx11::string,std::allocator<std::__cxx11::string>,std::__detail::_Identity,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,true,true>>
*this)
{
return this;
}
|
|
8,130 |
parseParameters(int, char**)
|
EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/src/MainCache.cpp
|
bool parseParameters(int argc, char **argv) {
// Read Parameters
for (int i = 1; i < argc; ++i) {
if (argv[i][0] == '-') {
switch (argv[i][1]) {
case 'v':
verbose = 1;
break;
case 's':
isSingleStep = 1;
break;
default:
return false;
}
} else {
if (traceFilePath == nullptr) {
traceFilePath = argv[i];
} else {
return false;
}
}
}
if (traceFilePath == nullptr) {
return false;
}
return true;
}
|
O0
|
cpp
|
parseParameters(int, char**):
movl %edi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x1, -0x14(%rsp)
movl -0x14(%rsp), %eax
cmpl -0x8(%rsp), %eax
jge 0x6994
movq -0x10(%rsp), %rax
movslq -0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x6958
movq -0x10(%rsp), %rax
movslq -0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsbl 0x1(%rax), %eax
movl %eax, -0x18(%rsp)
subl $0x73, %eax
je 0x6946
jmp 0x6932
movl -0x18(%rsp), %eax
subl $0x76, %eax
jne 0x694f
jmp 0x693d
movb $0x1, 0x986d(%rip) # 0x101b1
jmp 0x6956
movb $0x1, 0x9865(%rip) # 0x101b2
jmp 0x6956
movb $0x0, -0x1(%rsp)
jmp 0x69aa
jmp 0x6982
cmpq $0x0, 0x9858(%rip) # 0x101b8
jne 0x6979
movq -0x10(%rsp), %rax
movslq -0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x9841(%rip) # 0x101b8
jmp 0x6980
movb $0x0, -0x1(%rsp)
jmp 0x69aa
jmp 0x6982
jmp 0x6984
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x68f1
cmpq $0x0, 0x981c(%rip) # 0x101b8
jne 0x69a5
movb $0x0, -0x1(%rsp)
jmp 0x69aa
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
|
_Z15parseParametersiPPc:
mov [rsp+var_8], edi
mov [rsp+var_10], rsi
mov [rsp+var_14], 1
loc_68F1:
mov eax, [rsp+var_14]
cmp eax, [rsp+var_8]
jge loc_6994
mov rax, [rsp+var_10]
movsxd rcx, [rsp+var_14]
mov rax, [rax+rcx*8]
movsx eax, byte ptr [rax]
cmp eax, 2Dh ; '-'
jnz short loc_6958
mov rax, [rsp+var_10]
movsxd rcx, [rsp+var_14]
mov rax, [rax+rcx*8]
movsx eax, byte ptr [rax+1]
mov [rsp+var_18], eax
sub eax, 73h ; 's'
jz short loc_6946
jmp short $+2
loc_6932:
mov eax, [rsp+var_18]
sub eax, 76h ; 'v'
jnz short loc_694F
jmp short $+2
loc_693D:
mov cs:verbose, 1
jmp short loc_6956
loc_6946:
mov cs:isSingleStep, 1
jmp short loc_6956
loc_694F:
mov [rsp+var_1], 0
jmp short loc_69AA
loc_6956:
jmp short loc_6982
loc_6958:
cmp cs:traceFilePath, 0
jnz short loc_6979
mov rax, [rsp+var_10]
movsxd rcx, [rsp+var_14]
mov rax, [rax+rcx*8]
mov cs:traceFilePath, rax
jmp short loc_6980
loc_6979:
mov [rsp+var_1], 0
jmp short loc_69AA
loc_6980:
jmp short $+2
loc_6982:
jmp short $+2
loc_6984:
mov eax, [rsp+var_14]
add eax, 1
mov [rsp+var_14], eax
jmp loc_68F1
loc_6994:
cmp cs:traceFilePath, 0
jnz short loc_69A5
mov [rsp+var_1], 0
jmp short loc_69AA
loc_69A5:
mov [rsp+var_1], 1
loc_69AA:
mov al, [rsp+var_1]
and al, 1
retn
|
bool parseParameters(int a1, char **a2)
{
int v3; // [rsp+0h] [rbp-18h]
int i; // [rsp+4h] [rbp-14h]
for ( i = 1; i < a1; ++i )
{
if ( *a2[i] == 45 )
{
v3 = a2[i][1];
if ( v3 == 115 )
{
isSingleStep = 1;
}
else
{
if ( v3 != 118 )
return 0;
verbose = 1;
}
}
else
{
if ( traceFilePath )
return 0;
traceFilePath = (long long)a2[i];
}
}
return traceFilePath != 0;
}
|
parseParameters:
MOV dword ptr [RSP + -0x8],EDI
MOV qword ptr [RSP + -0x10],RSI
MOV dword ptr [RSP + -0x14],0x1
LAB_001068f1:
MOV EAX,dword ptr [RSP + -0x14]
CMP EAX,dword ptr [RSP + -0x8]
JGE 0x00106994
MOV RAX,qword ptr [RSP + -0x10]
MOVSXD RCX,dword ptr [RSP + -0x14]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2d
JNZ 0x00106958
MOV RAX,qword ptr [RSP + -0x10]
MOVSXD RCX,dword ptr [RSP + -0x14]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOVSX EAX,byte ptr [RAX + 0x1]
MOV dword ptr [RSP + -0x18],EAX
SUB EAX,0x73
JZ 0x00106946
JMP 0x00106932
LAB_00106932:
MOV EAX,dword ptr [RSP + -0x18]
SUB EAX,0x76
JNZ 0x0010694f
JMP 0x0010693d
LAB_0010693d:
MOV byte ptr [0x001101b1],0x1
JMP 0x00106956
LAB_00106946:
MOV byte ptr [0x001101b2],0x1
JMP 0x00106956
LAB_0010694f:
MOV byte ptr [RSP + -0x1],0x0
JMP 0x001069aa
LAB_00106956:
JMP 0x00106982
LAB_00106958:
CMP qword ptr [0x001101b8],0x0
JNZ 0x00106979
MOV RAX,qword ptr [RSP + -0x10]
MOVSXD RCX,dword ptr [RSP + -0x14]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [0x001101b8],RAX
JMP 0x00106980
LAB_00106979:
MOV byte ptr [RSP + -0x1],0x0
JMP 0x001069aa
LAB_00106980:
JMP 0x00106982
LAB_00106982:
JMP 0x00106984
LAB_00106984:
MOV EAX,dword ptr [RSP + -0x14]
ADD EAX,0x1
MOV dword ptr [RSP + -0x14],EAX
JMP 0x001068f1
LAB_00106994:
CMP qword ptr [0x001101b8],0x0
JNZ 0x001069a5
MOV byte ptr [RSP + -0x1],0x0
JMP 0x001069aa
LAB_001069a5:
MOV byte ptr [RSP + -0x1],0x1
LAB_001069aa:
MOV AL,byte ptr [RSP + -0x1]
AND AL,0x1
RET
|
/* parseParameters(int, char**) */
int8 parseParameters(int param_1,char **param_2)
{
uint uVar1;
ulong uVar2;
uint local_14;
int1 local_1;
local_14 = 1;
do {
uVar2 = (ulong)local_14;
if (param_1 <= (int)local_14) {
if (traceFilePath == (char *)0x0) {
local_1 = 0;
}
else {
local_1 = 1;
}
LAB_001069aa:
return CONCAT71((int7)(uVar2 >> 8),local_1);
}
uVar2 = (ulong)(uint)(int)*param_2[(int)local_14];
if ((int)*param_2[(int)local_14] == 0x2d) {
if (param_2[(int)local_14][1] == 0x73) {
isSingleStep = 1;
}
else {
uVar1 = (int)param_2[(int)local_14][1] - 0x76;
uVar2 = (ulong)uVar1;
if (uVar1 != 0) {
local_1 = 0;
goto LAB_001069aa;
}
verbose = 1;
}
}
else {
if (traceFilePath != (char *)0x0) {
local_1 = 0;
goto LAB_001069aa;
}
traceFilePath = param_2[(int)local_14];
}
local_14 = local_14 + 1;
} while( true );
}
|
|
8,131 |
parseParameters(int, char**)
|
EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/src/MainCache.cpp
|
bool parseParameters(int argc, char **argv) {
// Read Parameters
for (int i = 1; i < argc; ++i) {
if (argv[i][0] == '-') {
switch (argv[i][1]) {
case 'v':
verbose = 1;
break;
case 's':
isSingleStep = 1;
break;
default:
return false;
}
} else {
if (traceFilePath == nullptr) {
traceFilePath = argv[i];
} else {
return false;
}
}
}
if (traceFilePath == nullptr) {
return false;
}
return true;
}
|
O2
|
cpp
|
parseParameters(int, char**):
movq 0x4b4d(%rip), %rdx # 0x8180
movslq %edi, %rax
pushq $0x1
popq %rcx
cmpq %rax, %rcx
jge 0x367b
movq (%rsi,%rcx,8), %rdi
cmpb $0x2d, (%rdi)
jne 0x365e
movzbl 0x1(%rdi), %edi
cmpl $0x73, %edi
je 0x366f
cmpl $0x76, %edi
jne 0x3682
movb $0x1, 0x4b1d(%rip) # 0x8179
jmp 0x3676
testq %rdx, %rdx
jne 0x3682
movq %rdi, 0x4b16(%rip) # 0x8180
movq %rdi, %rdx
jmp 0x3676
movb $0x1, 0x4b04(%rip) # 0x817a
incq %rcx
jmp 0x3639
testq %rdx, %rdx
setne %al
retq
xorl %eax, %eax
retq
|
_Z15parseParametersiPPc:
mov rdx, cs:traceFilePath
movsxd rax, edi
push 1
pop rcx
loc_3639:
cmp rcx, rax
jge short loc_367B
mov rdi, [rsi+rcx*8]
cmp byte ptr [rdi], 2Dh ; '-'
jnz short loc_365E
movzx edi, byte ptr [rdi+1]
cmp edi, 73h ; 's'
jz short loc_366F
cmp edi, 76h ; 'v'
jnz short loc_3682
mov cs:verbose, 1
jmp short loc_3676
loc_365E:
test rdx, rdx
jnz short loc_3682
mov cs:traceFilePath, rdi
mov rdx, rdi
jmp short loc_3676
loc_366F:
mov cs:isSingleStep, 1
loc_3676:
inc rcx
jmp short loc_3639
loc_367B:
test rdx, rdx
setnz al
retn
loc_3682:
xor eax, eax
retn
|
bool parseParameters(int a1, char **a2)
{
long long v2; // rdx
long long v3; // rax
long long i; // rcx
char *v5; // rdi
int v6; // edi
v2 = traceFilePath;
v3 = a1;
for ( i = 1LL; ; ++i )
{
if ( i >= v3 )
return v2 != 0;
v5 = a2[i];
if ( *v5 != 45 )
break;
v6 = (unsigned __int8)v5[1];
if ( v6 == 115 )
{
isSingleStep = 1;
}
else
{
if ( v6 != 118 )
return 0;
verbose = 1;
}
LABEL_10:
;
}
if ( !v2 )
{
traceFilePath = (long long)a2[i];
v2 = (long long)v5;
goto LABEL_10;
}
return 0;
}
|
parseParameters:
MOV RDX,qword ptr [0x00108180]
MOVSXD RAX,EDI
PUSH 0x1
POP RCX
LAB_00103639:
CMP RCX,RAX
JGE 0x0010367b
MOV RDI,qword ptr [RSI + RCX*0x8]
CMP byte ptr [RDI],0x2d
JNZ 0x0010365e
MOVZX EDI,byte ptr [RDI + 0x1]
CMP EDI,0x73
JZ 0x0010366f
CMP EDI,0x76
JNZ 0x00103682
MOV byte ptr [0x00108179],0x1
JMP 0x00103676
LAB_0010365e:
TEST RDX,RDX
JNZ 0x00103682
MOV qword ptr [0x00108180],RDI
MOV RDX,RDI
JMP 0x00103676
LAB_0010366f:
MOV byte ptr [0x0010817a],0x1
LAB_00103676:
INC RCX
JMP 0x00103639
LAB_0010367b:
TEST RDX,RDX
SETNZ AL
RET
LAB_00103682:
XOR EAX,EAX
RET
|
/* parseParameters(int, char**) */
int8 parseParameters(int param_1,char **param_2)
{
char *pcVar1;
long lVar2;
char *pcVar3;
char *pcVar4;
lVar2 = 1;
pcVar3 = traceFilePath;
do {
if (param_1 <= lVar2) {
return CONCAT71((int7)(int3)((uint)param_1 >> 8),pcVar3 != (char *)0x0);
}
pcVar4 = param_2[lVar2];
if (*pcVar4 == '-') {
pcVar1 = traceFilePath;
if (pcVar4[1] == 's') {
isSingleStep = 1;
pcVar4 = pcVar3;
}
else {
if (pcVar4[1] != 'v') {
return 0;
}
verbose = 1;
pcVar4 = pcVar3;
}
}
else {
pcVar1 = pcVar4;
if (pcVar3 != (char *)0x0) {
return 0;
}
}
traceFilePath = pcVar1;
lVar2 = lVar2 + 1;
pcVar3 = pcVar4;
} while( true );
}
|
|
8,132 |
emit_label
|
bluesky950520[P]quickjs/quickjs.c
|
static int emit_label(JSParseState *s, int label)
{
if (label >= 0) {
emit_op(s, OP_label);
emit_u32(s, label);
s->cur_func->label_slots[label].pos = s->cur_func->byte_code.size;
return s->cur_func->byte_code.size - 4;
} else {
return -1;
}
}
|
O2
|
c
|
emit_label:
testl %esi, %esi
js 0x59d72
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl $0xb5, %esi
callq 0x535cb
movq %r14, %rdi
movl %ebx, %esi
callq 0x59f8e
movq 0x90(%r14), %rax
movl 0x140(%rax), %ecx
movq 0x170(%rax), %rax
movl %ebx, %edx
imulq $0x18, %rdx, %rdx
movl %ecx, 0x4(%rax,%rdx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
emit_label:
test esi, esi
js short locret_59D72
push r14
push rbx
push rax
mov ebx, esi
mov r14, rdi
mov esi, 0B5h
call emit_op
mov rdi, r14
mov esi, ebx
call emit_u32
mov rax, [r14+90h]
mov ecx, [rax+140h]
mov rax, [rax+170h]
mov edx, ebx
imul rdx, 18h
mov [rax+rdx+4], ecx
add rsp, 8
pop rbx
pop r14
locret_59D72:
retn
|
long long emit_label(long long a1, int a2)
{
long long v2; // rax
int v3; // ecx
long long result; // rax
if ( a2 >= 0 )
{
emit_op(a1, 181);
emit_u32(a1, (unsigned int)a2);
v2 = *(_QWORD *)(a1 + 144);
v3 = *(_DWORD *)(v2 + 320);
result = *(_QWORD *)(v2 + 368);
*(_DWORD *)(result + 24LL * (unsigned int)a2 + 4) = v3;
}
return result;
}
|
emit_label:
TEST ESI,ESI
JS 0x00159d72
PUSH R14
PUSH RBX
PUSH RAX
MOV EBX,ESI
MOV R14,RDI
MOV ESI,0xb5
CALL 0x001535cb
MOV RDI,R14
MOV ESI,EBX
CALL 0x00159f8e
MOV RAX,qword ptr [R14 + 0x90]
MOV ECX,dword ptr [RAX + 0x140]
MOV RAX,qword ptr [RAX + 0x170]
MOV EDX,EBX
IMUL RDX,RDX,0x18
MOV dword ptr [RAX + RDX*0x1 + 0x4],ECX
ADD RSP,0x8
POP RBX
POP R14
LAB_00159d72:
RET
|
void emit_label(long param_1,uint param_2)
{
if (-1 < (int)param_2) {
emit_op(param_1,0xb5);
emit_u32(param_1,param_2);
*(int4 *)(*(long *)(*(long *)(param_1 + 0x90) + 0x170) + 4 + (ulong)param_2 * 0x18) =
*(int4 *)(*(long *)(param_1 + 0x90) + 0x140);
}
return;
}
|
|
8,133 |
ma_crypt_set_data_pagecache_callbacks
|
eloqsql/storage/maria/ma_crypt.c
|
void ma_crypt_set_data_pagecache_callbacks(PAGECACHE_FILE *file,
MARIA_SHARE *share
__attribute__((unused)))
{
/* Only use encryption if we have defined it */
if (encryption_key_id_exists(get_encryption_key_id(share)))
{
file->pre_read_hook= ma_crypt_pre_read_hook;
file->post_read_hook= ma_crypt_data_post_read_hook;
file->pre_write_hook= ma_crypt_data_pre_write_hook;
file->post_write_hook= ma_crypt_post_write_hook;
}
}
|
O0
|
c
|
ma_crypt_set_data_pagecache_callbacks:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9ea60
movl %eax, %edi
callq 0x9ef60
cmpl $0x0, %eax
je 0x9ef51
movq -0x8(%rbp), %rax
leaq 0x70(%rip), %rcx # 0x9ef90
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
leaq 0xe1(%rip), %rcx # 0x9f010
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
leaq 0x2b2(%rip), %rcx # 0x9f1f0
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
leaq 0x4a3(%rip), %rcx # 0x9f3f0
movq %rcx, 0x30(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
ma_crypt_set_data_pagecache_callbacks:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rdi, [rbp+var_10]
call get_encryption_key_id
mov edi, eax
call encryption_key_id_exists
cmp eax, 0
jz short loc_9EF51
mov rax, [rbp+var_8]
lea rcx, ma_crypt_pre_read_hook
mov [rax+18h], rcx
mov rax, [rbp+var_8]
lea rcx, ma_crypt_data_post_read_hook
mov [rax+20h], rcx
mov rax, [rbp+var_8]
lea rcx, ma_crypt_data_pre_write_hook
mov [rax+28h], rcx
mov rax, [rbp+var_8]
lea rcx, ma_crypt_post_write_hook
mov [rax+30h], rcx
loc_9EF51:
add rsp, 10h
pop rbp
retn
|
long long ma_crypt_set_data_pagecache_callbacks(_QWORD *a1, long long a2)
{
unsigned int encryption_key_id; // eax
long long result; // rax
encryption_key_id = get_encryption_key_id(a2);
result = encryption_key_id_exists(encryption_key_id);
if ( (_DWORD)result )
{
a1[3] = ma_crypt_pre_read_hook;
a1[4] = ma_crypt_data_post_read_hook;
a1[5] = ma_crypt_data_pre_write_hook;
result = (long long)a1;
a1[6] = ma_crypt_post_write_hook;
}
return result;
}
|
ma_crypt_set_data_pagecache_callbacks:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0019ea60
MOV EDI,EAX
CALL 0x0019ef60
CMP EAX,0x0
JZ 0x0019ef51
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x19ef90]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x19f010]
MOV qword ptr [RAX + 0x20],RCX
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x19f1f0]
MOV qword ptr [RAX + 0x28],RCX
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x19f3f0]
MOV qword ptr [RAX + 0x30],RCX
LAB_0019ef51:
ADD RSP,0x10
POP RBP
RET
|
void ma_crypt_set_data_pagecache_callbacks(long param_1,int8 param_2)
{
int4 uVar1;
int iVar2;
uVar1 = get_encryption_key_id(param_2);
iVar2 = encryption_key_id_exists(uVar1);
if (iVar2 != 0) {
*(code **)(param_1 + 0x18) = ma_crypt_pre_read_hook;
*(code **)(param_1 + 0x20) = ma_crypt_data_post_read_hook;
*(code **)(param_1 + 0x28) = ma_crypt_data_pre_write_hook;
*(code **)(param_1 + 0x30) = ma_crypt_post_write_hook;
}
return;
}
|
|
8,134 |
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::append_exponent(char*, int)
|
monkey531[P]llama/common/json.hpp
|
inline char* append_exponent(char* buf, int e)
{
JSON_ASSERT(e > -1000);
JSON_ASSERT(e < 1000);
if (e < 0)
{
e = -e;
*buf++ = '-';
}
else
{
*buf++ = '+';
}
auto k = static_cast<std::uint32_t>(e);
if (k < 10)
{
// Always print at least two digits in the exponent.
// This is for compatibility with printf("%g").
*buf++ = '0';
*buf++ = static_cast<char>('0' + k);
}
else if (k < 100)
{
*buf++ = static_cast<char>('0' + k / 10);
k %= 10;
*buf++ = static_cast<char>('0' + k);
}
else
{
*buf++ = static_cast<char>('0' + k / 100);
k %= 100;
*buf++ = static_cast<char>('0' + k / 10);
k %= 10;
*buf++ = static_cast<char>('0' + k);
}
return buf;
}
|
O2
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::append_exponent(char*, int):
pushq %rax
cmpl $0xfffffc18, %esi # imm = 0xFFFFFC18
jle 0x88838
cmpl $0x3e8, %esi # imm = 0x3E8
jge 0x88854
movl %esi, %ecx
shrl $0x1f, %ecx
addb %cl, %cl
addb $0x2b, %cl
movl %esi, %eax
negl %eax
cmovsl %esi, %eax
movb %cl, (%rdi)
cmpl $0x9, %eax
ja 0x887e6
leaq 0x2(%rdi), %rdx
movb $0x30, 0x1(%rdi)
jmp 0x88801
cmpl $0x63, %eax
ja 0x88805
movzbl %al, %eax
movb $0xa, %cl
divb %cl
movl %eax, %ecx
movzbl %ah, %eax
orb $0x30, %cl
leaq 0x2(%rdi), %rdx
movb %cl, 0x1(%rdi)
pushq $0x3
jmp 0x8882b
movw $0x64, %cx
xorl %edx, %edx
divw %cx
addb $0x30, %al
movb %al, 0x1(%rdi)
movzbl %dl, %eax
movb $0xa, %cl
divb %cl
movl %eax, %ecx
movzbl %ah, %eax
orb $0x30, %cl
leaq 0x3(%rdi), %rdx
movb %cl, 0x2(%rdi)
pushq $0x4
popq %rcx
orb $0x30, %al
addq %rcx, %rdi
movb %al, (%rdx)
movq %rdi, %rax
popq %rcx
retq
leaq 0x293a7(%rip), %rdi # 0xb1be6
leaq 0x238fa(%rip), %rdx # 0xac140
leaq 0x2ed5a(%rip), %rcx # 0xb75a7
movl $0x45ae, %esi # imm = 0x45AE
jmp 0x8886e
leaq 0x2938b(%rip), %rdi # 0xb1be6
leaq 0x238de(%rip), %rdx # 0xac140
leaq 0x2ed48(%rip), %rcx # 0xb75b1
movl $0x45af, %esi # imm = 0x45AF
xorl %eax, %eax
callq 0x24e90
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl15append_exponentEPci:
push rax
cmp esi, 0FFFFFC18h
jle loc_88838
cmp esi, 3E8h
jge loc_88854
mov ecx, esi
shr ecx, 1Fh
add cl, cl
add cl, 2Bh ; '+'
mov eax, esi
neg eax
cmovs eax, esi
mov [rdi], cl
cmp eax, 9
ja short loc_887E6
lea rdx, [rdi+2]
mov byte ptr [rdi+1], 30h ; '0'
jmp short loc_88801
loc_887E6:
cmp eax, 63h ; 'c'
ja short loc_88805
movzx eax, al
mov cl, 0Ah
div cl
mov ecx, eax
movzx eax, ah
or cl, 30h
lea rdx, [rdi+2]
mov [rdi+1], cl
loc_88801:
push 3
jmp short loc_8882B
loc_88805:
mov cx, 64h ; 'd'
xor edx, edx
div cx
add al, 30h ; '0'
mov [rdi+1], al
movzx eax, dl
mov cl, 0Ah
div cl
mov ecx, eax
movzx eax, ah
or cl, 30h
lea rdx, [rdi+3]
mov [rdi+2], cl
push 4
loc_8882B:
pop rcx
or al, 30h
add rdi, rcx
mov [rdx], al
mov rax, rdi
pop rcx
retn
loc_88838:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aE1000; "e > -1000"
mov esi, 45AEh
jmp short loc_8886E
loc_88854:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aE1000_0; "e < 1000"
mov esi, 45AFh
loc_8886E:
xor eax, eax
call _ggml_abort
nop
|
long long nlohmann::json_abi_v3_11_3::detail::dtoa_impl::append_exponent(
nlohmann::json_abi_v3_11_3::detail::dtoa_impl *this,
char *a2)
{
unsigned int v2; // eax
_BYTE *v3; // rdx
char v4; // cl
char v5; // cl
long long v7; // [rsp-10h] [rbp-10h]
if ( (int)a2 <= -1000 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17838LL,
"GGML_ASSERT(%s) failed",
"e > -1000");
}
else
{
if ( (int)a2 < 1000 )
{
v2 = -(int)a2;
if ( (int)a2 > 0 )
v2 = (unsigned int)a2;
*(_BYTE *)this = 2 * ((int)a2 < 0) + 43;
if ( v2 > 9 )
{
if ( v2 > 0x63 )
{
*((_BYTE *)this + 1) = (unsigned __int16)v2 / 0x64u + 48;
v5 = (unsigned __int16)v2 % 0x64u / 0xA;
LOBYTE(v2) = (unsigned __int16)v2 % 0x64u % 0xA;
v3 = (char *)this + 3;
*((_BYTE *)this + 2) = v5 | 0x30;
v7 = 4LL;
goto LABEL_11;
}
v4 = (unsigned __int8)v2 / 0xAu;
LOBYTE(v2) = (unsigned __int8)v2 % 0xAu;
v3 = (char *)this + 2;
*((_BYTE *)this + 1) = v4 | 0x30;
}
else
{
v3 = (char *)this + 2;
*((_BYTE *)this + 1) = 48;
}
v7 = 3LL;
LABEL_11:
*v3 = v2 | 0x30;
return (long long)this + v7;
}
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17839LL,
"GGML_ASSERT(%s) failed",
"e < 1000");
}
return nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)3>::construct<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>>("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp");
}
|
append_exponent:
PUSH RAX
CMP ESI,0xfffffc18
JLE 0x00188838
CMP ESI,0x3e8
JGE 0x00188854
MOV ECX,ESI
SHR ECX,0x1f
ADD CL,CL
ADD CL,0x2b
MOV EAX,ESI
NEG EAX
CMOVS EAX,ESI
MOV byte ptr [RDI],CL
CMP EAX,0x9
JA 0x001887e6
LEA RDX,[RDI + 0x2]
MOV byte ptr [RDI + 0x1],0x30
JMP 0x00188801
LAB_001887e6:
CMP EAX,0x63
JA 0x00188805
MOVZX EAX,AL
MOV CL,0xa
DIV CL
MOV ECX,EAX
MOVZX EAX,AH
OR CL,0x30
LEA RDX,[RDI + 0x2]
MOV byte ptr [RDI + 0x1],CL
LAB_00188801:
PUSH 0x3
JMP 0x0018882b
LAB_00188805:
MOV CX,0x64
XOR EDX,EDX
DIV CX
ADD AL,0x30
MOV byte ptr [RDI + 0x1],AL
MOVZX EAX,DL
MOV CL,0xa
DIV CL
MOV ECX,EAX
MOVZX EAX,AH
OR CL,0x30
LEA RDX,[RDI + 0x3]
MOV byte ptr [RDI + 0x2],CL
PUSH 0x4
LAB_0018882b:
POP RCX
OR AL,0x30
ADD RDI,RCX
MOV byte ptr [RDX],AL
MOV RAX,RDI
POP RCX
RET
LAB_00188838:
LEA RDI,[0x1b1be6]
LEA RDX,[0x1ac140]
LEA RCX,[0x1b75a7]
MOV ESI,0x45ae
JMP 0x0018886e
LAB_00188854:
LEA RDI,[0x1b1be6]
LEA RDX,[0x1ac140]
LEA RCX,[0x1b75b1]
MOV ESI,0x45af
LAB_0018886e:
XOR EAX,EAX
CALL 0x00124e90
|
/* nlohmann::json_abi_v3_11_3::detail::dtoa_impl::append_exponent(char*, int) */
char * nlohmann::json_abi_v3_11_3::detail::dtoa_impl::append_exponent(char *param_1,int param_2)
{
byte bVar2;
uint uVar1;
char *pcVar3;
ushort uVar4;
byte *pbVar5;
int8 uVar6;
long lStack_10;
if (param_2 < -999) {
pcVar3 = "e > -1000";
uVar6 = 0x45ae;
LAB_0018886e:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",uVar6,
"GGML_ASSERT(%s) failed",pcVar3);
}
if (999 < param_2) {
pcVar3 = "e < 1000";
uVar6 = 0x45af;
goto LAB_0018886e;
}
uVar1 = -param_2;
if (0 < param_2) {
uVar1 = param_2;
}
*param_1 = (char)(param_2 >> 0x1f) * -2 + '+';
if (uVar1 < 10) {
param_1[1] = '0';
}
else {
if (99 < uVar1) {
uVar4 = (ushort)((uVar1 & 0xffff) % 100);
param_1[1] = (char)((uVar1 & 0xffff) / 100) + '0';
bVar2 = (byte)(uVar4 % 10);
pbVar5 = (byte *)(param_1 + 3);
param_1[2] = (byte)(uVar4 / 10) | 0x30;
lStack_10 = 4;
goto LAB_0018882b;
}
uVar4 = (ushort)uVar1 & 0xff;
uVar1 = (uint)(byte)(uVar4 % 10);
param_1[1] = (byte)(uVar4 / 10) | 0x30;
}
pbVar5 = (byte *)(param_1 + 2);
bVar2 = (byte)uVar1;
lStack_10 = 3;
LAB_0018882b:
*pbVar5 = bVar2 | 0x30;
return param_1 + lStack_10;
}
|
|
8,135 |
coro::net::tls::client::handshake(std::chrono::duration<long, std::ratio<1l, 1000l>>) (.resume)
|
AlayaLite/build_O3/_deps/libcoro-src/src/net/tls/client.cpp
|
auto client::handshake(std::chrono::milliseconds timeout) -> coro::task<connection_status>
{
m_tls_info.m_tls_ptr = tls_unique_ptr{SSL_new(m_tls_ctx->native_handle())};
if (m_tls_info.m_tls_ptr == nullptr)
{
co_return connection_status::resource_allocation_failed;
}
auto* tls = m_tls_info.m_tls_ptr.get();
if (auto r = SSL_set_fd(tls, m_socket.native_handle()); r == 0)
{
co_return connection_status::set_fd_failure;
}
if (m_tls_info.m_tls_connection_type == tls_connection_type::connect)
{
SSL_set_connect_state(tls);
}
else // ssl_connection_type::accept
{
SSL_set_accept_state(tls);
}
int r{0};
ERR_clear_error();
while ((r = SSL_connect(tls)) != 1)
{
poll_op op{poll_op::read_write};
int err = SSL_get_error(tls, r);
if (err == SSL_ERROR_WANT_WRITE)
{
op = poll_op::write;
}
else if (err == SSL_ERROR_WANT_READ)
{
op = poll_op::read;
}
else
{
// char error_buffer[256];
// ERR_error_string(err, error_buffer);
// std::cerr << "ssl_handleshake error=[" << error_buffer << "]\n";
co_return connection_status::handshake_failed;
}
// TODO: adjust timeout based on elapsed time so far.
auto pstatus = co_await m_io_scheduler->poll(m_socket, op, timeout);
switch (pstatus)
{
case poll_status::timeout:
co_return connection_status::timeout;
case poll_status::error:
co_return connection_status::poll_error;
case poll_status::closed:
co_return connection_status::unexpected_close;
default:
// Event triggered, continue handshake.
break;
}
}
co_return connection_status::connected;
}
|
O3
|
cpp
|
coro::net::tls::client::handshake(std::chrono::duration<long, std::ratio<1l, 1000l>>) (.resume):
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x68(%rdi)
jne 0xcce88
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0xcce88
callq *0x8(%rdi)
addq $0x18, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0xcd388
movq %rax, %rdi
callq 0x1f2c3
nop
|
_ZN4coro3net3tls6client9handshakeENSt6chrono8durationIlSt5ratioILl1ELl1000EEEE_cleanup:
push rbx
mov rbx, rdi
cmp byte ptr [rdi+68h], 1
jnz short loc_CCE88
mov rdi, [rbx+30h]
test rdi, rdi
jz short loc_CCE88
call qword ptr [rdi+8]
loc_CCE88:
add rbx, 18h
mov rdi, rbx
pop rbx
jmp _ZNSt8__detail9__variant16_Variant_storageILb0EJN4coro6detail7promiseINS2_3net3tls17connection_statusEE18unset_return_valueES7_NSt15__exception_ptr13exception_ptrEEED2Ev; std::__detail::__variant::_Variant_storage<false,coro::detail::promise<coro::net::tls::connection_status>::unset_return_value,coro::net::tls::connection_status,std::__exception_ptr::exception_ptr>::~_Variant_storage()
mov rdi, rax
call __clang_call_terminate
|
long long coro::net::tls::client::handshake(long long a1)
{
long long v2; // rdi
if ( *(_BYTE *)(a1 + 104) == 1 )
{
v2 = *(_QWORD *)(a1 + 48);
if ( v2 )
(*(void (**)(void))(v2 + 8))();
}
return std::__detail::__variant::_Variant_storage<false,coro::detail::promise<coro::net::tls::connection_status>::unset_return_value,coro::net::tls::connection_status,std::__exception_ptr::exception_ptr>::~_Variant_storage(a1 + 24);
}
|
_ZN4coro3net3tls6client9handshakeENSt6chrono8durationIlSt5ratioILl1ELl1000EEEE.cleanup:
PUSH RBX
MOV RBX,RDI
CMP byte ptr [RDI + 0x68],0x1
JNZ 0x001cce88
MOV RDI,qword ptr [RBX + 0x30]
TEST RDI,RDI
JZ 0x001cce88
LAB_001cce85:
CALL qword ptr [RDI + 0x8]
LAB_001cce88:
ADD RBX,0x18
MOV RDI,RBX
POP RBX
JMP 0x001cd388
|
void _ZN4coro3net3tls6client9handshakeENSt6chrono8durationIlSt5ratioILl1ELl1000EEEE_cleanup
(EVP_PKEY_CTX *ctx)
{
if ((ctx[0x68] == (EVP_PKEY_CTX)0x1) && (*(long *)(ctx + 0x30) != 0)) {
/* try { // try from 001cce85 to 001cce87 has its CatchHandler @ 001cce95 */
(**(code **)(*(long *)(ctx + 0x30) + 8))();
}
std::__detail::__variant::
_Variant_storage<false,coro::detail::promise<coro::net::tls::connection_status>::unset_return_value,coro::net::tls::connection_status,std::__exception_ptr::exception_ptr>
::~_Variant_storage((_Variant_storage<false,coro::detail::promise<coro::net::tls::connection_status>::unset_return_value,coro::net::tls::connection_status,std::__exception_ptr::exception_ptr>
*)(ctx + 0x18));
return;
}
|
|
8,136 |
test_connect
|
eloqsql/libmariadb/unittest/libmariadb/my_test.h
|
MYSQL *test_connect(struct my_tests_st *test)
{
MYSQL *mysql;
int i= 0, rc;
int timeout= 10;
my_bool truncation_report= 1;
if (!(mysql = mysql_init(NULL))) {
BAIL_OUT("Not enough memory available - mysql_init failed");
}
mysql_options(mysql, MYSQL_REPORT_DATA_TRUNCATION, &truncation_report);
mysql_options(mysql, MYSQL_OPT_CONNECT_TIMEOUT, &timeout);
if (plugindir)
mysql_options(mysql, MYSQL_PLUGIN_DIR, plugindir);
/* option handling */
if (test && test->options) {
while (test->options[i].option)
{
if (mysql_options(mysql, test->options[i].option, test->options[i].value)) {
diag("Couldn't set option %d. Error (%d) %s", test->options[i].option,
mysql_errno(mysql), mysql_error(mysql));
mysql_close(mysql);
return(NULL);
}
i++;
}
}
if (!(my_test_connect(mysql, hostname, username, password,
schema, port, socketname, (test) ? test->connect_flags:0)))
{
diag("Couldn't establish connection to server %s. Error (%d): %s",
hostname, mysql_errno(mysql), mysql_error(mysql));
mysql_close(mysql);
return(NULL);
}
/* Clear sql_mode when establishing a new connection. */
rc= mysql_query(mysql, "SET sql_mode=''");
if (rc)
{
diag("Error (%d): %s (%d) in %s line %d", rc, mysql_error(mysql),
mysql_errno(mysql), __FILE__, __LINE__);
return(NULL);
}
return(mysql);
}
|
O3
|
c
|
test_connect:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0xa, -0x20(%rbp)
movb $0x1, -0x19(%rbp)
xorl %edi, %edi
callq 0x18025
testq %rax, %rax
je 0x141cf
movq %rax, %rbx
leaq -0x19(%rbp), %rdx
movq %rax, %rdi
movl $0x13, %esi
callq 0x1c291
leaq -0x20(%rbp), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1c291
movq 0x34e01(%rip), %rdx # 0x48e68
testq %rdx, %rdx
je 0x14079
movq %rbx, %rdi
movl $0x16, %esi
callq 0x1c291
testq %r14, %r14
je 0x140c0
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x140ba
movl (%rax), %esi
testl %esi, %esi
je 0x140ba
movl $0x10, %r15d
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x1c291
testl %eax, %eax
jne 0x14184
movq 0x20(%r14), %rax
movl (%rax,%r15), %esi
addq %r15, %rax
addq $0x10, %r15
testl %esi, %esi
jne 0x14093
movq 0x18(%r14), %rax
jmp 0x140c2
xorl %eax, %eax
movq 0x34d67(%rip), %rsi # 0x48e30
movq 0x34d68(%rip), %rdx # 0x48e38
movq 0x34d69(%rip), %rcx # 0x48e40
movq 0x34d6a(%rip), %r8 # 0x48e48
movl 0x34d6b(%rip), %r9d # 0x48e50
movq %rbx, %rdi
pushq %rax
pushq 0x34d69(%rip) # 0x48e58
callq 0x141dd
addq $0x10, %rsp
testq %rax, %rax
je 0x14151
leaq 0x20215(%rip), %rsi # 0x34319
movq %rbx, %rdi
callq 0x1a309
testl %eax, %eax
je 0x141c1
movl %eax, %r14d
movq %rbx, %rdi
callq 0x1c382
movq %rax, %r15
movq %rbx, %rdi
callq 0x1c36d
leaq 0x20094(%rip), %rdi # 0x341c5
leaq 0x1ff70(%rip), %r8 # 0x340a8
xorl %ebx, %ebx
movl %r14d, %esi
movq %r15, %rdx
movl %eax, %ecx
movl $0x22a, %r9d # imm = 0x22A
xorl %eax, %eax
callq 0x14bff
jmp 0x141c1
movq 0x34cd8(%rip), %r14 # 0x48e30
movq %rbx, %rdi
callq 0x1c36d
movl %eax, %r15d
movq %rbx, %rdi
callq 0x1c382
leaq 0x2016c(%rip), %rdi # 0x342de
movq %r14, %rsi
movl %r15d, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x14bff
jmp 0x141b7
movq 0x20(%r14), %rax
movl -0x10(%rax,%r15), %r14d
movq %rbx, %rdi
callq 0x1c36d
movl %eax, %r15d
movq %rbx, %rdi
callq 0x1c382
leaq 0x20111(%rip), %rdi # 0x342b8
movl %r14d, %esi
movl %r15d, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x14bff
movq %rbx, %rdi
callq 0x19d7c
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x200b2(%rip), %rdi # 0x34288
xorl %eax, %eax
callq 0x14b48
|
test_connect:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14, rdi
mov [rbp+var_20], 0Ah
mov [rbp+var_19], 1
xor edi, edi
call mysql_init
test rax, rax
jz loc_141CF
mov rbx, rax
lea rdx, [rbp+var_19]
mov rdi, rax
mov esi, 13h
call mysql_options
lea rdx, [rbp+var_20]
mov rdi, rbx
xor esi, esi
call mysql_options
mov rdx, cs:plugindir
test rdx, rdx
jz short loc_14079
mov rdi, rbx
mov esi, 16h
call mysql_options
loc_14079:
test r14, r14
jz short loc_140C0
mov rax, [r14+20h]
test rax, rax
jz short loc_140BA
mov esi, [rax]
test esi, esi
jz short loc_140BA
mov r15d, 10h
loc_14093:
mov rdx, [rax+8]
mov rdi, rbx
call mysql_options
test eax, eax
jnz loc_14184
mov rax, [r14+20h]
mov esi, [rax+r15]
add rax, r15
add r15, 10h
test esi, esi
jnz short loc_14093
loc_140BA:
mov rax, [r14+18h]
jmp short loc_140C2
loc_140C0:
xor eax, eax
loc_140C2:
mov rsi, cs:hostname
mov rdx, cs:username
mov rcx, cs:password
mov r8, cs:schema
mov r9d, cs:port
mov rdi, rbx
push rax
push cs:socketname
call my_test_connect
add rsp, 10h
test rax, rax
jz short loc_14151
lea rsi, aSetSqlMode; "SET sql_mode=''"
mov rdi, rbx
call mysql_query
test eax, eax
jz loc_141C1
mov r14d, eax
mov rdi, rbx
call mysql_error
mov r15, rax
mov rdi, rbx
call mysql_errno
lea rdi, aErrorDSDInSLin; "Error (%d): %s (%d) in %s line %d"
lea r8, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eloqsq"...
xor ebx, ebx
mov esi, r14d
mov rdx, r15
mov ecx, eax
mov r9d, 22Ah
xor eax, eax
call diag
jmp short loc_141C1
loc_14151:
mov r14, cs:hostname
mov rdi, rbx
call mysql_errno
mov r15d, eax
mov rdi, rbx
call mysql_error
lea rdi, aCouldnTEstabli; "Couldn't establish connection to server"...
mov rsi, r14
mov edx, r15d
mov rcx, rax
xor eax, eax
call diag
jmp short loc_141B7
loc_14184:
mov rax, [r14+20h]
mov r14d, [rax+r15-10h]
mov rdi, rbx
call mysql_errno
mov r15d, eax
mov rdi, rbx
call mysql_error
lea rdi, aCouldnTSetOpti; "Couldn't set option %d. Error (%d) %s"
mov esi, r14d
mov edx, r15d
mov rcx, rax
xor eax, eax
call diag
loc_141B7:
mov rdi, rbx
call mysql_close
xor ebx, ebx
loc_141C1:
mov rax, rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_141CF:
lea rdi, aNotEnoughMemor; "Not enough memory available - mysql_ini"...
xor eax, eax
call BAIL_OUT
|
long long test_connect(long long a1, int a2)
{
long long v2; // rax
long long v3; // rax
int v4; // edx
int v5; // ecx
int v6; // r8d
int v7; // r9d
long long v8; // rbx
unsigned int *v9; // rax
long long v10; // rsi
long long v11; // r15
long long v12; // rax
long long v13; // rax
int v14; // eax
int v15; // r14d
int v16; // r15d
int v17; // eax
int v18; // r14d
int v19; // r15d
int v20; // eax
int v21; // r8d
int v22; // r9d
int v23; // r14d
int v24; // r15d
int v25; // eax
int v26; // r8d
int v27; // r9d
int v29; // [rsp+0h] [rbp-20h] BYREF
int v30; // [rsp+4h] [rbp-1Ch] BYREF
v30 = HIDWORD(v2);
v29 = 10;
HIBYTE(v30) = 1;
v3 = mysql_init(0LL);
if ( !v3 )
BAIL_OUT((unsigned int)"Not enough memory available - mysql_init failed", a2, v4, v5, v6, v7, v29);
v8 = v3;
mysql_options(v3, 19LL, (char *)&v30 + 3);
mysql_options(v8, 0LL, &v29);
if ( plugindir )
mysql_options(v8, 22LL, plugindir);
if ( a1 )
{
v9 = *(unsigned int **)(a1 + 32);
if ( v9 )
{
v10 = *v9;
if ( (_DWORD)v10 )
{
v11 = 16LL;
while ( !(unsigned int)mysql_options(v8, v10, *((_QWORD *)v9 + 1)) )
{
v12 = *(_QWORD *)(a1 + 32);
v10 = *(unsigned int *)(v12 + v11);
v9 = (unsigned int *)(v11 + v12);
v11 += 16LL;
if ( !(_DWORD)v10 )
goto LABEL_10;
}
v23 = *(_DWORD *)(*(_QWORD *)(a1 + 32) + v11 - 16);
v24 = mysql_errno(v8);
v25 = mysql_error(v8);
diag((unsigned int)"Couldn't set option %d. Error (%d) %s", v23, v24, v25, v26, v27);
goto LABEL_17;
}
}
LABEL_10:
v13 = *(_QWORD *)(a1 + 24);
}
else
{
v13 = 0LL;
}
if ( !my_test_connect(v8, hostname, username, password, schema, port, socketname, v13) )
{
v18 = hostname;
v19 = mysql_errno(v8);
v20 = mysql_error(v8);
diag((unsigned int)"Couldn't establish connection to server %s. Error (%d): %s", v18, v19, v20, v21, v22);
LABEL_17:
mysql_close(v8);
return 0LL;
}
v14 = mysql_query(v8, "SET sql_mode=''");
if ( v14 )
{
v15 = v14;
v16 = mysql_error(v8);
v17 = mysql_errno(v8);
v8 = 0LL;
diag(
(unsigned int)"Error (%d): %s (%d) in %s line %d",
v15,
v16,
v17,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/my_test.h",
554);
}
return v8;
}
|
test_connect:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RDI
MOV dword ptr [RBP + -0x20],0xa
MOV byte ptr [RBP + -0x19],0x1
XOR EDI,EDI
CALL 0x00118025
TEST RAX,RAX
JZ 0x001141cf
MOV RBX,RAX
LEA RDX,[RBP + -0x19]
MOV RDI,RAX
MOV ESI,0x13
CALL 0x0011c291
LEA RDX,[RBP + -0x20]
MOV RDI,RBX
XOR ESI,ESI
CALL 0x0011c291
MOV RDX,qword ptr [0x00148e68]
TEST RDX,RDX
JZ 0x00114079
MOV RDI,RBX
MOV ESI,0x16
CALL 0x0011c291
LAB_00114079:
TEST R14,R14
JZ 0x001140c0
MOV RAX,qword ptr [R14 + 0x20]
TEST RAX,RAX
JZ 0x001140ba
MOV ESI,dword ptr [RAX]
TEST ESI,ESI
JZ 0x001140ba
MOV R15D,0x10
LAB_00114093:
MOV RDX,qword ptr [RAX + 0x8]
MOV RDI,RBX
CALL 0x0011c291
TEST EAX,EAX
JNZ 0x00114184
MOV RAX,qword ptr [R14 + 0x20]
MOV ESI,dword ptr [RAX + R15*0x1]
ADD RAX,R15
ADD R15,0x10
TEST ESI,ESI
JNZ 0x00114093
LAB_001140ba:
MOV RAX,qword ptr [R14 + 0x18]
JMP 0x001140c2
LAB_001140c0:
XOR EAX,EAX
LAB_001140c2:
MOV RSI,qword ptr [0x00148e30]
MOV RDX,qword ptr [0x00148e38]
MOV RCX,qword ptr [0x00148e40]
MOV R8,qword ptr [0x00148e48]
MOV R9D,dword ptr [0x00148e50]
MOV RDI,RBX
PUSH RAX
PUSH qword ptr [0x00148e58]
CALL 0x001141dd
ADD RSP,0x10
TEST RAX,RAX
JZ 0x00114151
LEA RSI,[0x134319]
MOV RDI,RBX
CALL 0x0011a309
TEST EAX,EAX
JZ 0x001141c1
MOV R14D,EAX
MOV RDI,RBX
CALL 0x0011c382
MOV R15,RAX
MOV RDI,RBX
CALL 0x0011c36d
LEA RDI,[0x1341c5]
LEA R8,[0x1340a8]
XOR EBX,EBX
MOV ESI,R14D
MOV RDX,R15
MOV ECX,EAX
MOV R9D,0x22a
XOR EAX,EAX
CALL 0x00114bff
JMP 0x001141c1
LAB_00114151:
MOV R14,qword ptr [0x00148e30]
MOV RDI,RBX
CALL 0x0011c36d
MOV R15D,EAX
MOV RDI,RBX
CALL 0x0011c382
LEA RDI,[0x1342de]
MOV RSI,R14
MOV EDX,R15D
MOV RCX,RAX
XOR EAX,EAX
CALL 0x00114bff
JMP 0x001141b7
LAB_00114184:
MOV RAX,qword ptr [R14 + 0x20]
MOV R14D,dword ptr [RAX + R15*0x1 + -0x10]
MOV RDI,RBX
CALL 0x0011c36d
MOV R15D,EAX
MOV RDI,RBX
CALL 0x0011c382
LEA RDI,[0x1342b8]
MOV ESI,R14D
MOV EDX,R15D
MOV RCX,RAX
XOR EAX,EAX
CALL 0x00114bff
LAB_001141b7:
MOV RDI,RBX
CALL 0x00119d7c
XOR EBX,EBX
LAB_001141c1:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001141cf:
LEA RDI,[0x134288]
XOR EAX,EAX
CALL 0x00114b48
|
long test_connect(long param_1)
{
int iVar1;
int4 uVar2;
int4 uVar3;
int8 in_RAX;
long lVar4;
int *piVar5;
int8 uVar6;
int8 uVar7;
long lVar8;
int4 local_28;
int4 uStack_24;
_local_28 = CONCAT44((int)((ulong)in_RAX >> 0x20),10);
_local_28 = CONCAT17(1,_local_28);
lVar4 = mysql_init(0);
if (lVar4 == 0) {
/* WARNING: Subroutine does not return */
BAIL_OUT("Not enough memory available - mysql_init failed");
}
mysql_options(lVar4,0x13,(long)&uStack_24 + 3);
mysql_options(lVar4,0,&local_28);
if (plugindir != 0) {
mysql_options(lVar4,0x16);
}
if (param_1 == 0) {
uVar6 = 0;
}
else {
piVar5 = *(int **)(param_1 + 0x20);
if ((piVar5 != (int *)0x0) && (iVar1 = *piVar5, iVar1 != 0)) {
lVar8 = 0x10;
do {
iVar1 = mysql_options(lVar4,iVar1,*(int8 *)(piVar5 + 2));
if (iVar1 != 0) {
uVar2 = *(int4 *)(*(long *)(param_1 + 0x20) + -0x10 + lVar8);
uVar3 = mysql_errno(lVar4);
uVar6 = mysql_error(lVar4);
diag("Couldn\'t set option %d. Error (%d) %s",uVar2,uVar3,uVar6);
goto LAB_001141b7;
}
iVar1 = *(int *)(*(long *)(param_1 + 0x20) + lVar8);
piVar5 = (int *)(*(long *)(param_1 + 0x20) + lVar8);
lVar8 = lVar8 + 0x10;
} while (iVar1 != 0);
}
uVar6 = *(int8 *)(param_1 + 0x18);
}
lVar8 = my_test_connect(lVar4,hostname,username,password,schema,port,socketname,uVar6);
uVar6 = hostname;
if (lVar8 == 0) {
uVar2 = mysql_errno(lVar4);
uVar7 = mysql_error(lVar4);
diag("Couldn\'t establish connection to server %s. Error (%d): %s",uVar6,uVar2,uVar7);
LAB_001141b7:
mysql_close(lVar4);
lVar4 = 0;
}
else {
iVar1 = mysql_query(lVar4,"SET sql_mode=\'\'");
if (iVar1 != 0) {
uVar6 = mysql_error(lVar4);
uVar2 = mysql_errno(lVar4);
lVar4 = 0;
diag("Error (%d): %s (%d) in %s line %d",iVar1,uVar6,uVar2,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/my_test.h",0x22a
);
}
}
return lVar4;
}
|
|
8,137 |
js_async_module_execution_fulfilled
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_async_module_execution_fulfilled(JSContext *ctx, JSValueConst this_val,
int argc, JSValueConst *argv, int magic, JSValue *func_data)
{
JSModuleDef *module = JS_VALUE_GET_PTR(func_data[0]);
ExecModuleList exec_list_s, *exec_list = &exec_list_s;
int i;
if (module->status == JS_MODULE_STATUS_EVALUATED) {
assert(module->eval_has_exception);
return JS_UNDEFINED;
}
assert(module->status == JS_MODULE_STATUS_EVALUATING_ASYNC);
assert(!module->eval_has_exception);
assert(module->async_evaluation);
module->async_evaluation = FALSE;
js_set_module_evaluated(ctx, module);
exec_list->tab = NULL;
exec_list->count = 0;
exec_list->size = 0;
if (gather_available_ancestors(ctx, module, exec_list) < 0) {
js_free(ctx, exec_list->tab);
return JS_EXCEPTION;
}
/* sort by increasing async_evaluation timestamp */
rqsort(exec_list->tab, exec_list->count, sizeof(exec_list->tab[0]),
exec_module_list_cmp, NULL);
for(i = 0; i < exec_list->count; i++) {
JSModuleDef *m = exec_list->tab[i];
if (m->status == JS_MODULE_STATUS_EVALUATED) {
assert(m->eval_has_exception);
} else if (m->has_tla) {
js_execute_async_module(ctx, m);
} else {
JSValue error;
if (js_execute_sync_module(ctx, m, &error) < 0) {
JSValue m_obj = JS_NewModuleValue(ctx, m);
js_async_module_execution_rejected(ctx, JS_UNDEFINED,
1, (JSValueConst *)&error, 0,
&m_obj);
JS_FreeValue(ctx, m_obj);
JS_FreeValue(ctx, error);
} else {
js_set_module_evaluated(ctx, m);
}
}
}
js_free(ctx, exec_list->tab);
return JS_UNDEFINED;
}
|
O2
|
c
|
js_async_module_execution_fulfilled:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x80(%rsp), %rax
movq (%rax), %r14
movzbl 0x83(%r14), %eax
shll $0x18, %eax
cmpl $0x5000000, %eax # imm = 0x5000000
jne 0x40673
pushq $0x3
popq %r15
jmp 0x40792
movq %rdi, %rbx
andl $0x0, 0xac(%r14)
movq %r14, %rsi
callq 0x408ec
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %r15
movaps %xmm0, (%r15)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x40949
movq (%r15), %r14
testl %eax, %eax
js 0x40783
movslq 0x38(%rsp), %r15
leaq 0x394(%rip), %rcx # 0x40a4b
xorl %r13d, %r13d
pushq $0x8
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
xorl %r8d, %r8d
callq 0x1a3ec
testl %r15d, %r15d
movl $0x0, %r12d
cmovgl %r15d, %r12d
leaq 0x10(%rsp), %r15
cmpq %r13, %r12
je 0x4077f
movq (%r14,%r13,8), %rbp
movl 0x80(%rbp), %eax
movl %eax, %ecx
andl $0xff000000, %ecx # imm = 0xFF000000
cmpl $0x5000000, %ecx # imm = 0x5000000
je 0x40777
movq %rbx, %rdi
testb %al, %al
je 0x40711
movq %rbp, %rsi
callq 0x40423
jmp 0x40772
movq %rbp, %rsi
movq %r15, %rdx
callq 0x40544
testl %eax, %eax
js 0x4072d
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x408ec
jmp 0x40772
incl (%rbp)
movq %rbp, 0x20(%rsp)
movq $-0x3, 0x28(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r15, %r8
callq 0x407a6
movq %rbx, %rdi
movq %rbp, %rsi
pushq $-0x3
popq %rdx
callq 0x1bbce
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x1bbce
leaq 0x10(%rsp), %r15
incq %r13
jmp 0x406dd
pushq $0x3
jmp 0x40785
pushq $0x6
popq %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1ae1e
xorl %eax, %eax
movq %r15, %rdx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
js_async_module_execution_fulfilled:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov rax, [rsp+78h+arg_0]
mov r14, [rax]
movzx eax, byte ptr [r14+83h]
shl eax, 18h
cmp eax, 5000000h
jnz short loc_40673
push 3
pop r15
jmp loc_40792
loc_40673:
mov rbx, rdi
and dword ptr [r14+0ACh], 0
mov rsi, r14
call js_set_module_evaluated
xorps xmm0, xmm0
lea r15, [rsp+78h+var_48]
movaps xmmword ptr [r15], xmm0
mov rdi, rbx
mov rsi, r14
mov rdx, r15
call gather_available_ancestors
mov r14, [r15]
test eax, eax
js loc_40783
movsxd r15, [rsp+78h+var_40]
lea rcx, exec_module_list_cmp
xor r13d, r13d
push 8
pop rdx
mov rdi, r14
mov rsi, r15
xor r8d, r8d
call rqsort
test r15d, r15d
mov r12d, 0
cmovg r12d, r15d
lea r15, [rsp+78h+var_68]
loc_406DD:
cmp r12, r13
jz loc_4077F
mov rbp, [r14+r13*8]
mov eax, [rbp+80h]
mov ecx, eax
and ecx, 0FF000000h
cmp ecx, 5000000h
jz short loc_40777
mov rdi, rbx
test al, al
jz short loc_40711
mov rsi, rbp
call js_execute_async_module
jmp short loc_40772
loc_40711:
mov rsi, rbp
mov rdx, r15
call js_execute_sync_module
test eax, eax
js short loc_4072D
mov rdi, rbx
mov rsi, rbp
call js_set_module_evaluated
jmp short loc_40772
loc_4072D:
inc dword ptr [rbp+0]
mov [rsp+78h+var_58], rbp
mov [rsp+78h+var_50], 0FFFFFFFFFFFFFFFDh
lea rax, [rsp+78h+var_58]
mov [rsp+78h+var_78], rax
mov rdi, rbx
mov r8, r15
call js_async_module_execution_rejected
mov rdi, rbx
mov rsi, rbp
push 0FFFFFFFFFFFFFFFDh
pop rdx
call JS_FreeValue
mov rsi, [rsp+78h+var_68]
mov rdx, [rsp+78h+var_60]
mov rdi, rbx
call JS_FreeValue
loc_40772:
lea r15, [rsp+78h+var_68]
loc_40777:
inc r13
jmp loc_406DD
loc_4077F:
push 3
jmp short loc_40785
loc_40783:
push 6
loc_40785:
pop r15
mov rdi, rbx
mov rsi, r14
call js_free
loc_40792:
xor eax, eax
mov rdx, r15
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long js_async_module_execution_fulfilled(
long long a1,
double a2,
__m128 a3,
__m128 a4,
__m128 a5,
double a6,
double a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
long long a12,
long long a13,
long long a14,
long long *a15)
{
long long v15; // r14
int v16; // eax
long long v17; // r14
int v18; // r15d
long long v19; // r13
double v20; // xmm4_8
double v21; // xmm5_8
long long v22; // r12
_DWORD *v23; // rbp
int v24; // eax
_QWORD *v25; // rsi
int v26; // edx
int v27; // ecx
int v28; // r9d
long long v30[2]; // [rsp+10h] [rbp-68h] BYREF
_QWORD v31[2]; // [rsp+20h] [rbp-58h] BYREF
__int128 v32; // [rsp+30h] [rbp-48h] BYREF
v15 = *a15;
if ( *(unsigned __int8 *)(*a15 + 131) << 24 != 83886080 )
{
*(_DWORD *)(v15 + 172) = 0;
js_set_module_evaluated(a1, v15);
v32 = 0LL;
v16 = gather_available_ancestors(a1, v15, &v32);
v17 = v32;
if ( v16 >= 0 )
{
v18 = DWORD2(v32);
v19 = 0LL;
rqsort(
v32,
SDWORD2(v32),
8LL,
(long long ( *)(unsigned long long, unsigned long long, long long))exec_module_list_cmp,
0LL);
v22 = 0LL;
if ( v18 > 0 )
v22 = (unsigned int)v18;
while ( v22 != v19 )
{
v23 = *(_DWORD **)(v17 + 8 * v19);
v24 = v23[32];
if ( (v24 & 0xFF000000) != 0x5000000 )
{
if ( (_BYTE)v24 )
{
js_execute_async_module(a1, *(_QWORD *)(v17 + 8 * v19), (__m128)0LL, a3, a4, a5, v20, v21, a8, a9);
}
else
{
v25 = *(_QWORD **)(v17 + 8 * v19);
if ( (int)js_execute_sync_module(a1, v25, (long long)v30, (__m128)0LL, a3, a4, a5, v20, v21, a8, a9) < 0 )
{
++*v23;
v31[0] = v23;
v31[1] = -3LL;
js_async_module_execution_rejected(a1, (int)v25, v26, v27, (int)v30, v28, (long long)v31);
JS_FreeValue(a1, (long long)v23, -3LL);
JS_FreeValue(a1, v30[0], v30[1]);
}
else
{
js_set_module_evaluated(a1, v23);
}
}
}
++v19;
}
}
js_free(a1, v17);
}
return 0LL;
}
|
js_async_module_execution_fulfilled:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV RAX,qword ptr [RSP + 0x80]
MOV R14,qword ptr [RAX]
MOVZX EAX,byte ptr [R14 + 0x83]
SHL EAX,0x18
CMP EAX,0x5000000
JNZ 0x00140673
PUSH 0x3
POP R15
JMP 0x00140792
LAB_00140673:
MOV RBX,RDI
AND dword ptr [R14 + 0xac],0x0
MOV RSI,R14
CALL 0x001408ec
XORPS XMM0,XMM0
LEA R15,[RSP + 0x30]
MOVAPS xmmword ptr [R15],XMM0
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
CALL 0x00140949
MOV R14,qword ptr [R15]
TEST EAX,EAX
JS 0x00140783
MOVSXD R15,dword ptr [RSP + 0x38]
LEA RCX,[0x140a4b]
XOR R13D,R13D
PUSH 0x8
POP RDX
MOV RDI,R14
MOV RSI,R15
XOR R8D,R8D
CALL 0x0011a3ec
TEST R15D,R15D
MOV R12D,0x0
CMOVG R12D,R15D
LEA R15,[RSP + 0x10]
LAB_001406dd:
CMP R12,R13
JZ 0x0014077f
MOV RBP,qword ptr [R14 + R13*0x8]
MOV EAX,dword ptr [RBP + 0x80]
MOV ECX,EAX
AND ECX,0xff000000
CMP ECX,0x5000000
JZ 0x00140777
MOV RDI,RBX
TEST AL,AL
JZ 0x00140711
MOV RSI,RBP
CALL 0x00140423
JMP 0x00140772
LAB_00140711:
MOV RSI,RBP
MOV RDX,R15
CALL 0x00140544
TEST EAX,EAX
JS 0x0014072d
MOV RDI,RBX
MOV RSI,RBP
CALL 0x001408ec
JMP 0x00140772
LAB_0014072d:
INC dword ptr [RBP]
MOV qword ptr [RSP + 0x20],RBP
MOV qword ptr [RSP + 0x28],-0x3
LEA RAX,[RSP + 0x20]
MOV qword ptr [RSP],RAX
MOV RDI,RBX
MOV R8,R15
CALL 0x001407a6
MOV RDI,RBX
MOV RSI,RBP
PUSH -0x3
POP RDX
CALL 0x0011bbce
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x18]
MOV RDI,RBX
CALL 0x0011bbce
LAB_00140772:
LEA R15,[RSP + 0x10]
LAB_00140777:
INC R13
JMP 0x001406dd
LAB_0014077f:
PUSH 0x3
JMP 0x00140785
LAB_00140783:
PUSH 0x6
LAB_00140785:
POP R15
MOV RDI,RBX
MOV RSI,R14
CALL 0x0011ae1e
LAB_00140792:
XOR EAX,EAX
MOV RDX,R15
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int1 [16] js_async_module_execution_fulfilled(int8 param_1)
{
long lVar1;
int *piVar2;
int1 auVar3 [16];
ulong uVar4;
int iVar5;
ulong uVar6;
ulong uVar7;
long *in_stack_00000008;
ulong uStack_80;
int8 local_68;
int8 local_60;
int *local_58;
int8 local_50;
long local_48;
ulong uStack_40;
lVar1 = *in_stack_00000008;
if (*(char *)(lVar1 + 0x83) == '\x05') {
uStack_80 = 3;
}
else {
*(int4 *)(lVar1 + 0xac) = 0;
js_set_module_evaluated(param_1,lVar1);
local_48 = 0;
uStack_40 = 0;
iVar5 = gather_available_ancestors(param_1,lVar1,&local_48);
uVar4 = uStack_40;
lVar1 = local_48;
if (iVar5 < 0) {
uStack_80 = 6;
}
else {
iVar5 = (int)uStack_40;
uVar7 = 0;
rqsort(local_48,(long)(int)uStack_40,8,exec_module_list_cmp,0);
uVar6 = 0;
if (0 < iVar5) {
uVar6 = uVar4 & 0xffffffff;
}
for (; uVar6 != uVar7; uVar7 = uVar7 + 1) {
piVar2 = *(int **)(lVar1 + uVar7 * 8);
if ((piVar2[0x20] & 0xff000000U) != 0x5000000) {
if ((char)piVar2[0x20] == '\0') {
iVar5 = js_execute_sync_module(param_1,piVar2,&local_68);
if (iVar5 < 0) {
*piVar2 = *piVar2 + 1;
local_50 = 0xfffffffffffffffd;
local_58 = piVar2;
js_async_module_execution_rejected(param_1);
JS_FreeValue(param_1,piVar2,0xfffffffffffffffd);
JS_FreeValue(param_1,local_68,local_60);
}
else {
js_set_module_evaluated(param_1,piVar2);
}
}
else {
js_execute_async_module(param_1,piVar2);
}
}
}
uStack_80 = 3;
}
js_free(param_1,lVar1);
}
auVar3._8_8_ = 0;
auVar3._0_8_ = uStack_80;
return auVar3 << 0x40;
}
|
|
8,138 |
my_printv_error
|
eloqsql/mysys/my_error.c
|
void my_printv_error(uint error, const char *format, myf MyFlags, va_list ap)
{
char ebuff[ERRMSGSIZE];
DBUG_ENTER("my_printv_error");
DBUG_PRINT("my", ("nr: %d MyFlags: %lu errno: %d format: %s",
error, MyFlags, errno, format));
(void) my_vsnprintf(ebuff, sizeof(ebuff), format, ap);
(*error_handler_hook)(error, ebuff, MyFlags);
DBUG_VOID_RETURN;
}
|
O0
|
c
|
my_printv_error:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movl %edi, -0x214(%rbp)
movq %rsi, -0x220(%rbp)
movq %rdx, -0x228(%rbp)
movq %rcx, -0x230(%rbp)
jmp 0xefde5
leaq -0x210(%rbp), %rdi
movq -0x220(%rbp), %rdx
movq -0x230(%rbp), %rcx
movl $0x200, %esi # imm = 0x200
callq 0x14d2c0
leaq 0x1cfdd5(%rip), %rax # 0x2bfbe0
movq (%rax), %rax
movl -0x214(%rbp), %edi
leaq -0x210(%rbp), %rsi
movq -0x228(%rbp), %rdx
callq *%rax
jmp 0xefe26
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xefe41
addq $0x230, %rsp # imm = 0x230
popq %rbp
retq
callq 0x2a270
nopw %cs:(%rax,%rax)
|
my_printv_error:
push rbp
mov rbp, rsp
sub rsp, 230h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_214], edi
mov [rbp+var_220], rsi
mov [rbp+var_228], rdx
mov [rbp+var_230], rcx
jmp short $+2
loc_EFDE5:
lea rdi, [rbp+var_210]
mov rdx, [rbp+var_220]
mov rcx, [rbp+var_230]
mov esi, 200h
call my_vsnprintf
lea rax, error_handler_hook
mov rax, [rax]
mov edi, [rbp+var_214]
lea rsi, [rbp+var_210]
mov rdx, [rbp+var_228]
call rax
jmp short $+2
loc_EFE26:
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_EFE41
add rsp, 230h
pop rbp
retn
loc_EFE41:
call ___stack_chk_fail
|
unsigned long long my_printv_error(long long a1, long long a2, long long a3, long long a4)
{
_BYTE v5[520]; // [rsp+20h] [rbp-210h] BYREF
unsigned long long v6; // [rsp+228h] [rbp-8h]
v6 = __readfsqword(0x28u);
my_vsnprintf(v5, 512LL, a2, a4);
error_handler_hook();
return __readfsqword(0x28u);
}
|
my_printv_error:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x230
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x214],EDI
MOV qword ptr [RBP + -0x220],RSI
MOV qword ptr [RBP + -0x228],RDX
MOV qword ptr [RBP + -0x230],RCX
JMP 0x001efde5
LAB_001efde5:
LEA RDI,[RBP + -0x210]
MOV RDX,qword ptr [RBP + -0x220]
MOV RCX,qword ptr [RBP + -0x230]
MOV ESI,0x200
CALL 0x0024d2c0
LEA RAX,[0x3bfbe0]
MOV RAX,qword ptr [RAX]
MOV EDI,dword ptr [RBP + -0x214]
LEA RSI,[RBP + -0x210]
MOV RDX,qword ptr [RBP + -0x228]
CALL RAX
JMP 0x001efe26
LAB_001efe26:
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001efe41
ADD RSP,0x230
POP RBP
RET
LAB_001efe41:
CALL 0x0012a270
|
void my_printv_error(int4 param_1,int8 param_2,int8 param_3,int8 param_4)
{
long in_FS_OFFSET;
int1 local_218 [520];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
my_vsnprintf(local_218,0x200,param_2,param_4);
(*(code *)error_handler_hook)(param_1,local_218,param_3);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
8,139 |
Draw
|
r3d/examples/skybox.c
|
void Draw(void)
{
R3D_Begin(camera);
for (int x = 0; x < 7; x++) {
for (int y = 0; y < 7; y++) {
R3D_DrawMesh(sphere, materials[y * 7 + x], MatrixTranslate(x - 3, y - 3, 0.0f));
}
}
R3D_End();
}
|
O3
|
c
|
Draw:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movups 0x175e6a(%rip), %xmm0 # 0x181d04
movups %xmm0, 0x1c(%rsp)
movups 0x175e52(%rip), %xmm0 # 0x181cf8
movups %xmm0, 0x10(%rsp)
movups 0x175e36(%rip), %xmm0 # 0x181ce8
movups %xmm0, (%rsp)
callq 0xc3ffc
leaq 0x17563e(%rip), %r15 # 0x181500
leaq -0x54(%rbp), %rbx
xorl %esi, %esi
movabsq $0x3f80000000000000, %r12 # imm = 0x3F80000000000000
movl $0x3f800000, %edi # imm = 0x3F800000
xorps %xmm1, %xmm1
leaq 0x17559f(%rip), %r14 # 0x181480
xorl %eax, %eax
movq %rax, -0x38(%rbp)
addl $-0x3, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x2c(%rbp)
movq %r15, -0x40(%rbp)
xorl %r13d, %r13d
leal -0x3(%r13), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movq $0x3f800000, -0x80(%rbp) # imm = 0x3F800000
movl %esi, -0x78(%rbp)
movss -0x2c(%rbp), %xmm2
movss %xmm2, -0x74(%rbp)
movq %r12, -0x70(%rbp)
movl %esi, -0x68(%rbp)
movss %xmm0, -0x64(%rbp)
movq $0x0, -0x60(%rbp)
movl %edi, -0x58(%rbp)
movups %xmm1, (%rbx)
movl %edi, -0x44(%rbp)
movl $0xf, %ecx
movq %rsp, %rdi
movq %r14, %rsi
rep movsq (%rsi), %es:(%rdi)
movups -0x80(%rbp), %xmm0
movups -0x70(%rbp), %xmm1
movups -0x60(%rbp), %xmm2
movups -0x50(%rbp), %xmm3
movups %xmm3, 0xd0(%rsp)
movups %xmm2, 0xc0(%rsp)
movups %xmm1, 0xb0(%rsp)
movups %xmm0, 0xa0(%rsp)
movq 0x20(%r15), %rax
movq %rax, 0x98(%rsp)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x88(%rsp)
movups %xmm0, 0x78(%rsp)
callq 0xcddff
movl $0x3f800000, %edi # imm = 0x3F800000
xorps %xmm1, %xmm1
xorl %esi, %esi
incq %r13
addq $0x118, %r15 # imm = 0x118
cmpq $0x7, %r13
jne 0xbefd
movq -0x38(%rbp), %rax
incq %rax
movq -0x40(%rbp), %r15
addq $0x28, %r15
cmpq $0x7, %rax
jne 0xbee3
addq $0x138, %rsp # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc585e
|
Draw:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 138h
movups xmm0, cs:xmmword_181CF8+0Ch
movups [rsp+160h+var_144], xmm0
movups xmm0, cs:xmmword_181CF8
movups xmmword ptr [rsp+10h], xmm0
movups xmm0, cs:camera
movups [rsp+160h+var_160], xmm0
call R3D_Begin
lea r15, materials
lea rbx, [rbp+var_60+0Ch]
xor esi, esi
mov r12, 3F80000000000000h
mov edi, 3F800000h
xorps xmm1, xmm1
lea r14, sphere
xor eax, eax
loc_BEE3:
mov [rbp+var_38], rax
add eax, 0FFFFFFFDh
xorps xmm0, xmm0
cvtsi2ss xmm0, eax
movss [rbp+var_2C], xmm0
mov [rbp+var_40], r15
xor r13d, r13d
loc_BEFD:
lea eax, [r13-3]
xorps xmm0, xmm0
cvtsi2ss xmm0, eax
mov qword ptr [rbp+var_80], 3F800000h
mov dword ptr [rbp+var_80+8], esi
movss xmm2, [rbp+var_2C]
movss dword ptr [rbp+var_80+0Ch], xmm2
mov qword ptr [rbp+var_70], r12
mov dword ptr [rbp+var_70+8], esi
movss dword ptr [rbp+var_70+0Ch], xmm0
mov qword ptr [rbp+var_60], 0
mov dword ptr [rbp+var_60+8], edi
movups xmmword ptr [rbx], xmm1
mov [rbp+var_44], edi
mov ecx, 0Fh
mov rdi, rsp
mov rsi, r14
rep movsq
movups xmm0, [rbp+var_80]
movups xmm1, [rbp+var_70]
movups xmm2, [rbp+var_60]
movups xmm3, xmmword ptr [rbp-50h]
movups [rsp+160h+var_90], xmm3
movups [rsp+160h+var_A0], xmm2
movups [rsp+160h+var_B0], xmm1
movups [rsp+160h+var_C0], xmm0
mov rax, [r15+20h]
mov [rsp+160h+var_C8], rax
movups xmm0, xmmword ptr [r15]
movups xmm1, xmmword ptr [r15+10h]
movups [rsp+160h+var_D8], xmm1
movups [rsp+160h+var_E8], xmm0
call R3D_DrawMesh
mov edi, 3F800000h
xorps xmm1, xmm1
xor esi, esi
inc r13
add r15, 118h
cmp r13, 7
jnz loc_BEFD
mov rax, [rbp+var_38]
inc rax
mov r15, [rbp+var_40]
add r15, 28h ; '('
cmp rax, 7
jnz loc_BEE3
add rsp, 138h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp R3D_End
|
long long Draw(int a1, int a2, int a3, int a4, int a5, int a6)
{
int v6; // edx
int v7; // r8d
int v8; // r9d
_QWORD *v9; // r15
__int128 v10; // xmm1
long long v11; // rax
long long i; // r13
__int128 v13; // xmm0
_BYTE v15[120]; // [rsp+0h] [rbp-160h] BYREF
__int128 v16; // [rsp+78h] [rbp-E8h] BYREF
long long v17; // [rsp+98h] [rbp-C8h]
__int128 v18; // [rsp+A0h] [rbp-C0h]
__int128 v19; // [rsp+B0h] [rbp-B0h]
__m256i v20; // [rsp+C0h] [rbp-A0h]
__int128 v21; // [rsp+E0h] [rbp-80h]
__int128 v22; // [rsp+F0h] [rbp-70h]
__m256i v23; // [rsp+100h] [rbp-60h]
_QWORD *v24; // [rsp+120h] [rbp-40h]
long long v25; // [rsp+128h] [rbp-38h]
float v26; // [rsp+134h] [rbp-2Ch]
*(_DWORD *)&v15[40] = *(_DWORD *)&algn_181D08[8];
R3D_Begin(
a1,
a2,
a3,
a4,
a5,
a6,
camera,
xmmword_181CF8,
(unsigned long long)(*(unsigned __int128 *)((char *)&xmmword_181CF8 + 12) >> 32),
*(_QWORD *)&v15[40]);
v9 = &materials;
v10 = 0LL;
v11 = 0LL;
do
{
v25 = v11;
v26 = (float)(v11 - 3);
v24 = v9;
for ( i = 0LL; i != 7; ++i )
{
*(_QWORD *)&v21 = 1065353216LL;
DWORD2(v21) = 0;
*((float *)&v21 + 3) = v26;
*(_QWORD *)&v22 = 0x3F80000000000000LL;
DWORD2(v22) = 0;
*((float *)&v22 + 3) = (float)(i - 3);
v23.m256i_i64[0] = 0LL;
v23.m256i_i32[2] = 1065353216;
*(_OWORD *)((char *)&v23.m256i_u64[1] + 4) = v10;
v23.m256i_i32[7] = 1065353216;
qmemcpy(v15, &sphere, sizeof(v15));
v20 = v23;
v19 = v22;
v18 = v21;
v17 = v9[4];
v13 = *(_OWORD *)v9;
R3D_DrawMesh(
(unsigned int)&v16,
(unsigned int)&sphere + 120,
v6,
0,
v7,
v8,
v15[0],
*(_DWORD *)&v15[8],
*(_DWORD *)&v15[16],
*(_DWORD *)&v15[24],
*(_DWORD *)&v15[32],
*(_DWORD *)&v15[40],
*(_DWORD *)&v15[48],
*(_DWORD *)&v15[56],
*(_DWORD *)&v15[64],
*(_DWORD *)&v15[72],
*(_DWORD *)&v15[80],
*(_DWORD *)&v15[88],
*(_DWORD *)&v15[96],
*(_DWORD *)&v15[104],
*(_DWORD *)&v15[112],
v13,
DWORD2(v13),
*((_OWORD *)v9 + 1),
v9[3],
v17,
0);
v10 = 0LL;
v9 += 35;
}
v11 = v25 + 1;
v9 = v24 + 5;
}
while ( v25 != 6 );
return R3D_End(1065353216LL, 0LL, *(double *)&v13, 0.0);
}
|
Draw:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x138
MOVUPS XMM0,xmmword ptr [0x00281d04]
MOVUPS xmmword ptr [RSP + 0x1c],XMM0
MOVUPS XMM0,xmmword ptr [0x00281cf8]
MOVUPS xmmword ptr [RSP + 0x10],XMM0
MOVUPS XMM0,xmmword ptr [0x00281ce8]
MOVUPS xmmword ptr [RSP],XMM0
CALL 0x001c3ffc
LEA R15,[0x281500]
LEA RBX,[RBP + -0x54]
XOR ESI,ESI
MOV R12,0x3f80000000000000
MOV EDI,0x3f800000
XORPS XMM1,XMM1
LEA R14,[0x281480]
XOR EAX,EAX
LAB_0010bee3:
MOV qword ptr [RBP + -0x38],RAX
ADD EAX,-0x3
XORPS XMM0,XMM0
CVTSI2SS XMM0,EAX
MOVSS dword ptr [RBP + -0x2c],XMM0
MOV qword ptr [RBP + -0x40],R15
XOR R13D,R13D
LAB_0010befd:
LEA EAX,[R13 + -0x3]
XORPS XMM0,XMM0
CVTSI2SS XMM0,EAX
MOV qword ptr [RBP + -0x80],0x3f800000
MOV dword ptr [RBP + -0x78],ESI
MOVSS XMM2,dword ptr [RBP + -0x2c]
MOVSS dword ptr [RBP + -0x74],XMM2
MOV qword ptr [RBP + -0x70],R12
MOV dword ptr [RBP + -0x68],ESI
MOVSS dword ptr [RBP + -0x64],XMM0
MOV qword ptr [RBP + -0x60],0x0
MOV dword ptr [RBP + -0x58],EDI
MOVUPS xmmword ptr [RBX],XMM1
MOV dword ptr [RBP + -0x44],EDI
MOV ECX,0xf
MOV RDI,RSP
MOV RSI,R14
MOVSQ.REP RDI,RSI
MOVUPS XMM0,xmmword ptr [RBP + -0x80]
MOVUPS XMM1,xmmword ptr [RBP + -0x70]
MOVUPS XMM2,xmmword ptr [RBP + -0x60]
MOVUPS XMM3,xmmword ptr [RBP + -0x50]
MOVUPS xmmword ptr [RSP + 0xd0],XMM3
MOVUPS xmmword ptr [RSP + 0xc0],XMM2
MOVUPS xmmword ptr [RSP + 0xb0],XMM1
MOVUPS xmmword ptr [RSP + 0xa0],XMM0
MOV RAX,qword ptr [R15 + 0x20]
MOV qword ptr [RSP + 0x98],RAX
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS XMM1,xmmword ptr [R15 + 0x10]
MOVUPS xmmword ptr [RSP + 0x88],XMM1
MOVUPS xmmword ptr [RSP + 0x78],XMM0
CALL 0x001cddff
MOV EDI,0x3f800000
XORPS XMM1,XMM1
XOR ESI,ESI
INC R13
ADD R15,0x118
CMP R13,0x7
JNZ 0x0010befd
MOV RAX,qword ptr [RBP + -0x38]
INC RAX
MOV R15,qword ptr [RBP + -0x40]
ADD R15,0x28
CMP RAX,0x7
JNZ 0x0010bee3
ADD RSP,0x138
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001c585e
|
void Draw(void)
{
long lVar1;
int8 *puVar2;
int8 *puVar3;
long lVar4;
int1 *puVar5;
byte bVar6;
int8 local_168 [15];
int4 local_f0;
int4 uStack_ec;
int4 uStack_e8;
int4 uStack_e4;
int4 local_e0;
int4 uStack_dc;
int4 uStack_d8;
int4 uStack_d4;
int8 local_d0;
int8 local_c8;
int8 uStack_c0;
int8 local_b8;
int8 uStack_b0;
int4 local_a8;
int4 uStack_a4;
int4 uStack_a0;
int4 uStack_9c;
int4 local_98;
int4 uStack_94;
int4 uStack_90;
int4 uStack_8c;
int8 local_88;
int4 uStack_80;
float fStack_7c;
int8 local_78;
int4 uStack_70;
float fStack_6c;
int8 local_68;
int4 uStack_60;
int8 uStack_5c;
int8 uStack_54;
int4 uStack_4c;
int4 *local_48;
long local_40;
float local_34;
bVar6 = 0;
local_168[4]._0_4_ = camera._32_4_;
local_168._36_8_ = camera._36_8_;
local_168[2] = camera._16_8_;
local_168[3]._0_4_ = camera._24_4_;
local_168[3]._4_4_ = camera._28_4_;
local_168[0]._0_4_ = camera._0_4_;
local_168[0]._4_4_ = camera._4_4_;
local_168[1]._0_4_ = camera._8_4_;
local_168[1]._4_4_ = camera._12_4_;
R3D_Begin();
puVar5 = materials;
lVar1 = 0;
do {
local_34 = (float)((int)lVar1 + -3);
lVar4 = 0;
local_48 = (int4 *)puVar5;
local_40 = lVar1;
do {
fStack_6c = (float)((int)lVar4 + -3);
local_88 = 0x3f800000;
uStack_80 = 0;
fStack_7c = local_34;
local_78 = 0x3f80000000000000;
uStack_70 = 0;
local_68 = 0;
uStack_60 = 0x3f800000;
uStack_5c = 0;
uStack_54 = 0;
uStack_4c = 0x3f800000;
puVar2 = &sphere;
puVar3 = local_168;
for (lVar1 = 0xf; lVar1 != 0; lVar1 = lVar1 + -1) {
*puVar3 = *puVar2;
puVar2 = puVar2 + (ulong)bVar6 * -2 + 1;
puVar3 = puVar3 + (ulong)bVar6 * -2 + 1;
}
uStack_c0 = CONCAT44(fStack_7c,uStack_80);
uStack_b0 = CONCAT44(fStack_6c,uStack_70);
local_98 = uStack_5c._4_4_;
uStack_94 = (int4)uStack_54;
uStack_90 = uStack_54._4_4_;
uStack_8c = uStack_4c;
local_a8 = (int4)local_68;
uStack_a4 = local_68._4_4_;
uStack_a0 = uStack_60;
uStack_9c = (int4)uStack_5c;
local_b8 = local_78;
local_c8 = local_88;
local_d0 = *(int8 *)((long)puVar5 + 0x20);
local_f0 = *(int4 *)puVar5;
uStack_ec = *(int4 *)((long)puVar5 + 4);
uStack_e8 = *(int4 *)((long)puVar5 + 8);
uStack_e4 = *(int4 *)((long)puVar5 + 0xc);
local_e0 = *(int4 *)((long)puVar5 + 0x10);
uStack_dc = *(int4 *)((long)puVar5 + 0x14);
uStack_d8 = *(int4 *)((long)puVar5 + 0x18);
uStack_d4 = *(int4 *)((long)puVar5 + 0x1c);
R3D_DrawMesh();
lVar4 = lVar4 + 1;
puVar5 = (int1 *)((long)puVar5 + 0x118);
} while (lVar4 != 7);
lVar1 = local_40 + 1;
puVar5 = (int1 *)(local_48 + 10);
} while (lVar1 != 7);
R3D_End();
return;
}
|
|
8,140 |
mysql_refresh_start_internal
|
eloqsql/libmariadb/libmariadb/mariadb_async.c
|
static void
mysql_refresh_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_refresh,
(parms->mysql, parms->refresh_options),
parms->mysql,
int,
r_int)
}
|
O0
|
c
|
mysql_refresh_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 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x473f0
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_refresh_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+480h]
mov rax, [rax+28h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rdi, [rax]
mov rax, [rbp+var_10]
mov esi, [rax+8]
call mysql_refresh
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_refresh_start_internal(long long a1)
{
_DWORD *result; // rax
_DWORD *v2; // [rsp+0h] [rbp-20h]
v2 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)a1 + 1152LL) + 40LL);
v2[2] = mysql_refresh(*(_QWORD *)a1, *(_DWORD *)(a1 + 8));
result = v2;
*v2 = 0;
return result;
}
|
mysql_refresh_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 + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RAX + 0x8]
CALL 0x001473f0
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_refresh_start_internal(long *param_1)
{
int4 *puVar1;
int4 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_refresh(*param_1,(int)param_1[1]);
puVar1[2] = uVar2;
*puVar1 = 0;
return;
}
|
|
8,141 |
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>::get_binary() const
|
monkey531[P]llama/common/json.hpp
|
const binary_t& get_binary() const
{
if (!is_binary())
{
JSON_THROW(type_error::create(302, detail::concat("type must be binary, but is ", type_name()), this));
}
return *get_ptr<const binary_t*>();
}
|
O2
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::get_binary() const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x8, (%rdi)
jne 0x8eaeb
movq 0x8(%r14), %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x24470
movq %rax, %rbx
movq %r14, %rdi
callq 0x4efc4
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x327b1(%rip), %rsi # 0xc12be
leaq 0x10(%rsp), %rdi
callq 0x6eebf
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x12e, %esi # imm = 0x12E
movq %r14, %rcx
callq 0x6edd2
xorl %ebp, %ebp
leaq 0x7b410(%rip), %rsi # 0x109f48
leaq -0x42feb(%rip), %rdx # 0x4bb54
movq %rbx, %rdi
callq 0x24f80
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x25298
testb %bpl, %bpl
jne 0x8eb5e
jmp 0x8eb66
movq %rax, %r14
movq %rbx, %rdi
callq 0x246a0
movq %r14, %rdi
callq 0x25010
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10get_binaryEv:
push rbp; char
push r14; int
push rbx; int
sub rsp, 30h
mov r14, rdi
cmp byte ptr [rdi], 8
jnz short loc_8EAEB
mov rax, [r14+8]
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_8EAEB:
push 20h ; ' '
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aTypeMustBeBina; "type must be binary, but is "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA29_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(char const(&)[29],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 12Eh; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rdi, [rsp+48h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_8EB5E
jmp short loc_8EB66
mov r14, rax
loc_8EB5E:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_8EB66:
mov rdi, r14
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::get_binary(
long long a1)
{
nlohmann::json_abi_v3_11_3::detail::type_error *exception; // rbx
const char *v3; // [rsp+8h] [rbp-40h] BYREF
_BYTE v4[56]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 != 8 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::type_error *)__cxa_allocate_exception(0x20uLL);
v3 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(
(long long)v4,
(long long)"type must be binary, but is ",
&v3);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
302,
(long long)v4);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return *(_QWORD *)(a1 + 8);
}
|
get_binary:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
CMP byte ptr [RDI],0x8
JNZ 0x0018eaeb
MOV RAX,qword ptr [R14 + 0x8]
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_0018eaeb:
PUSH 0x20
POP RDI
CALL 0x00124470
MOV RBX,RAX
MOV RDI,R14
CALL 0x0014efc4
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_0018eb06:
LEA RSI,[0x1c12be]
LEA RDI,[RSP + 0x10]
CALL 0x0016eebf
MOV BPL,0x1
LAB_0018eb1a:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x12e
MOV RCX,R14
CALL 0x0016edd2
XOR EBP,EBP
LEA RSI,[0x209f48]
LEA RDX,[0x14bb54]
MOV RDI,RBX
CALL 0x00124f80
|
/* 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>::get_binary() const */
int8 __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::get_binary(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this)
{
int8 uVar1;
char *local_40;
detail local_38 [32];
if (*this == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x8) {
return *(int8 *)(this + 8);
}
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name(this);
/* try { // try from 0018eb06 to 0018eb16 has its CatchHandler @ 0018eb5b */
detail::concat<std::__cxx11::string,char_const(&)[29],char_const*>
(local_38,"type must be binary, but is ",&local_40);
/* try { // try from 0018eb1a to 0018eb46 has its CatchHandler @ 0018eb47 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar1,0x12e,local_38,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::type_error::typeinfo,detail::exception::~exception);
}
|
|
8,142 |
serial_cpp::Serial::SerialImpl::flush()
|
ami-iit[P]serial_cpp/src/impl/unix.cc
|
void
Serial::SerialImpl::flush ()
{
if (is_open_ == false) {
throw PortNotOpenedException ("Serial::flush");
}
tcdrain (fd_);
}
|
O0
|
cpp
|
serial_cpp::Serial::SerialImpl::flush():
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb 0x2c(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xac11
movl $0x28, %edi
callq 0x31a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
leaq 0x59ee(%rip), %rsi # 0x105ca
callq 0xcca0
jmp 0xabe3
movq -0x28(%rbp), %rdi
leaq 0xc112(%rip), %rsi # 0x16d00
leaq 0x21eb(%rip), %rdx # 0xcde0
callq 0x35b0
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3240
jmp 0xac23
movq -0x20(%rbp), %rax
movl 0x28(%rax), %edi
callq 0x3600
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x35d0
nopl (%rax)
|
_ZN10serial_cpp6Serial10SerialImpl5flushEv:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
mov al, [rax+2Ch]
and al, 1
movzx eax, al
cmp eax, 0
jnz short loc_AC11
mov edi, 28h ; '('; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rbp+var_28], rax
lea rsi, aSerialFlush; "Serial::flush"
call _ZN10serial_cpp22PortNotOpenedExceptionC2EPKc; serial_cpp::PortNotOpenedException::PortNotOpenedException(char const*)
jmp short $+2
loc_ABE3:
mov rdi, [rbp+var_28]; void *
lea rsi, _ZTIN10serial_cpp22PortNotOpenedExceptionE; lptinfo
lea rdx, _ZN10serial_cpp22PortNotOpenedExceptionD2Ev; void (*)(void *)
call ___cxa_throw
mov rdi, [rbp+var_28]; void *
mov rcx, rax
mov eax, edx
mov [rbp+var_10], rcx
mov [rbp+var_14], eax
call ___cxa_free_exception
jmp short loc_AC23
loc_AC11:
mov rax, [rbp+var_20]
mov edi, [rax+28h]
call _tcdrain
add rsp, 30h
pop rbp
retn
loc_AC23:
mov rdi, [rbp+var_10]
call __Unwind_Resume
|
long long serial_cpp::Serial::SerialImpl::flush(serial_cpp::Serial::SerialImpl *this)
{
serial_cpp::PortNotOpenedException *exception; // [rsp+8h] [rbp-28h]
if ( (*((_BYTE *)this + 44) & 1) == 0 )
{
exception = (serial_cpp::PortNotOpenedException *)__cxa_allocate_exception(0x28uLL);
serial_cpp::PortNotOpenedException::PortNotOpenedException(exception, "Serial::flush");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'serial_cpp::PortNotOpenedException,
serial_cpp::PortNotOpenedException::~PortNotOpenedException);
}
return tcdrain(*((unsigned int *)this + 10));
}
|
flush:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
MOV AL,byte ptr [RAX + 0x2c]
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JNZ 0x0010ac11
MOV EDI,0x28
CALL 0x001031a0
MOV RDI,RAX
MOV RAX,RDI
MOV qword ptr [RBP + -0x28],RAX
LAB_0010abd5:
LEA RSI,[0x1105ca]
CALL 0x0010cca0
LAB_0010abe1:
JMP 0x0010abe3
LAB_0010abe3:
MOV RDI,qword ptr [RBP + -0x28]
LEA RSI,[0x116d00]
LEA RDX,[0x10cde0]
CALL 0x001035b0
LAB_0010ac11:
MOV RAX,qword ptr [RBP + -0x20]
MOV EDI,dword ptr [RAX + 0x28]
CALL 0x00103600
ADD RSP,0x30
POP RBP
RET
|
/* serial_cpp::Serial::SerialImpl::flush() */
void __thiscall serial_cpp::Serial::SerialImpl::flush(SerialImpl *this)
{
PortNotOpenedException *this_00;
if (((byte)this[0x2c] & 1) == 0) {
this_00 = (PortNotOpenedException *)__cxa_allocate_exception(0x28);
/* try { // try from 0010abd5 to 0010abe0 has its CatchHandler @ 0010abfa */
PortNotOpenedException::PortNotOpenedException(this_00,"Serial::flush");
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,&PortNotOpenedException::typeinfo,
PortNotOpenedException::~PortNotOpenedException);
}
tcdrain(*(int *)(this + 0x28));
return;
}
|
|
8,143 |
expand_fast_array
|
bluesky950520[P]quickjs/quickjs.c
|
static int expand_fast_array(JSContext *ctx, JSObject *p, uint32_t new_len)
{
uint32_t new_size;
size_t slack;
JSValue *new_array_prop;
/* XXX: potential arithmetic overflow */
new_size = max_int(new_len, p->u.array.u1.size * 3 / 2);
new_array_prop = js_realloc2(ctx, p->u.array.u.values, sizeof(JSValue) * new_size, &slack);
if (!new_array_prop)
return -1;
new_size += slack / sizeof(*new_array_prop);
p->u.array.u.values = new_array_prop;
p->u.array.u1.size = new_size;
return 0;
}
|
O1
|
c
|
expand_fast_array:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x30(%rsi), %eax
leal (%rax,%rax,2), %r14d
shrl %r14d
cmpl %r14d, %edx
cmovgl %edx, %r14d
movq 0x38(%rsi), %rsi
movq %r14, %rdx
shlq $0x4, %rdx
movq %rsp, %rcx
callq 0x1cc0f
testq %rax, %rax
je 0x3dbff
movq (%rsp), %rcx
shrq $0x4, %rcx
addl %ecx, %r14d
movq %rax, 0x38(%rbx)
movl %r14d, 0x30(%rbx)
xorl %eax, %eax
jmp 0x3dc04
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
expand_fast_array:
push r14
push rbx
push rax
mov rbx, rsi
mov eax, [rsi+30h]
lea r14d, [rax+rax*2]
shr r14d, 1
cmp edx, r14d
cmovg r14d, edx
mov rsi, [rsi+38h]
mov rdx, r14
shl rdx, 4
mov rcx, rsp
call js_realloc2
test rax, rax
jz short loc_3DBFF
mov rcx, [rsp+18h+var_18]
shr rcx, 4
add r14d, ecx
mov [rbx+38h], rax
mov [rbx+30h], r14d
xor eax, eax
jmp short loc_3DC04
loc_3DBFF:
mov eax, 0FFFFFFFFh
loc_3DC04:
add rsp, 8
pop rbx
pop r14
retn
|
long long expand_fast_array(long long a1, long long a2, int a3)
{
unsigned long long v3; // rax
long long v4; // r14
long long v5; // rax
int v6; // r14d
unsigned long long v8[3]; // [rsp+0h] [rbp-18h] BYREF
v8[0] = v3;
v4 = (unsigned int)(3 * *(_DWORD *)(a2 + 48)) >> 1;
if ( a3 > (int)v4 )
v4 = (unsigned int)a3;
v5 = js_realloc2(a1, *(_QWORD *)(a2 + 56), 16 * v4, v8);
if ( !v5 )
return 0xFFFFFFFFLL;
v6 = (v8[0] >> 4) + v4;
*(_QWORD *)(a2 + 56) = v5;
*(_DWORD *)(a2 + 48) = v6;
return 0LL;
}
| |||
8,144 |
expand_fast_array
|
bluesky950520[P]quickjs/quickjs.c
|
static int expand_fast_array(JSContext *ctx, JSObject *p, uint32_t new_len)
{
uint32_t new_size;
size_t slack;
JSValue *new_array_prop;
/* XXX: potential arithmetic overflow */
new_size = max_int(new_len, p->u.array.u1.size * 3 / 2);
new_array_prop = js_realloc2(ctx, p->u.array.u.values, sizeof(JSValue) * new_size, &slack);
if (!new_array_prop)
return -1;
new_size += slack / sizeof(*new_array_prop);
p->u.array.u.values = new_array_prop;
p->u.array.u1.size = new_size;
return 0;
}
|
O2
|
c
|
expand_fast_array:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
imull $0x3, 0x30(%rsi), %r14d
shrl %r14d
cmpl %r14d, %edx
cmovgl %edx, %r14d
movq 0x38(%rsi), %rsi
movq %r14, %rdx
shlq $0x4, %rdx
movq %rsp, %rcx
callq 0x172b1
testq %rax, %rax
je 0x363ea
movq (%rsp), %rcx
shrq $0x4, %rcx
addl %ecx, %r14d
movq %rax, 0x38(%rbx)
movl %r14d, 0x30(%rbx)
xorl %eax, %eax
jmp 0x363ed
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
expand_fast_array:
push r14
push rbx
push rax
mov rbx, rsi
imul r14d, [rsi+30h], 3
shr r14d, 1
cmp edx, r14d
cmovg r14d, edx
mov rsi, [rsi+38h]
mov rdx, r14
shl rdx, 4
mov rcx, rsp
call js_realloc2
test rax, rax
jz short loc_363EA
mov rcx, [rsp+18h+var_18]
shr rcx, 4
add r14d, ecx
mov [rbx+38h], rax
mov [rbx+30h], r14d
xor eax, eax
jmp short loc_363ED
loc_363EA:
push 0FFFFFFFFFFFFFFFFh
pop rax
loc_363ED:
add rsp, 8
pop rbx
pop r14
retn
|
long long expand_fast_array(long long a1, long long a2, int a3)
{
unsigned long long v3; // rax
long long v4; // r14
long long v5; // rax
int v6; // r14d
unsigned long long v8[3]; // [rsp+0h] [rbp-18h] BYREF
v8[0] = v3;
v4 = (unsigned int)(3 * *(_DWORD *)(a2 + 48)) >> 1;
if ( a3 > (int)v4 )
v4 = (unsigned int)a3;
v5 = js_realloc2(a1, *(_QWORD *)(a2 + 56), 16 * v4, v8);
if ( !v5 )
return -1LL;
v6 = (v8[0] >> 4) + v4;
*(_QWORD *)(a2 + 56) = v5;
*(_DWORD *)(a2 + 48) = v6;
return 0LL;
}
|
expand_fast_array:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
IMUL R14D,dword ptr [RSI + 0x30],0x3
SHR R14D,0x1
CMP EDX,R14D
CMOVG R14D,EDX
MOV RSI,qword ptr [RSI + 0x38]
MOV RDX,R14
SHL RDX,0x4
MOV RCX,RSP
CALL 0x001172b1
TEST RAX,RAX
JZ 0x001363ea
MOV RCX,qword ptr [RSP]
SHR RCX,0x4
ADD R14D,ECX
MOV qword ptr [RBX + 0x38],RAX
MOV dword ptr [RBX + 0x30],R14D
XOR EAX,EAX
JMP 0x001363ed
LAB_001363ea:
PUSH -0x1
POP RAX
LAB_001363ed:
ADD RSP,0x8
POP RBX
POP R14
RET
|
int8 expand_fast_array(int8 param_1,long param_2,uint param_3)
{
ulong in_RAX;
long lVar1;
int8 uVar2;
uint uVar3;
ulong uVar4;
ulong local_18;
uVar3 = (uint)(*(int *)(param_2 + 0x30) * 3) >> 1;
uVar4 = (ulong)uVar3;
if ((int)uVar3 < (int)param_3) {
uVar4 = (ulong)param_3;
}
local_18 = in_RAX;
lVar1 = js_realloc2(param_1,*(int8 *)(param_2 + 0x38),uVar4 << 4,&local_18);
if (lVar1 == 0) {
uVar2 = 0xffffffffffffffff;
}
else {
*(long *)(param_2 + 0x38) = lVar1;
*(int *)(param_2 + 0x30) = (int)uVar4 + (int)(local_18 >> 4);
uVar2 = 0;
}
return uVar2;
}
|
|
8,145 |
expand_fast_array
|
bluesky950520[P]quickjs/quickjs.c
|
static int expand_fast_array(JSContext *ctx, JSObject *p, uint32_t new_len)
{
uint32_t new_size;
size_t slack;
JSValue *new_array_prop;
/* XXX: potential arithmetic overflow */
new_size = max_int(new_len, p->u.array.u1.size * 3 / 2);
new_array_prop = js_realloc2(ctx, p->u.array.u.values, sizeof(JSValue) * new_size, &slack);
if (!new_array_prop)
return -1;
new_size += slack / sizeof(*new_array_prop);
p->u.array.u.values = new_array_prop;
p->u.array.u1.size = new_size;
return 0;
}
|
O3
|
c
|
expand_fast_array:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x30(%rsi), %eax
leal (%rax,%rax,2), %r14d
shrl %r14d
cmpl %r14d, %edx
cmovgl %edx, %r14d
movq 0x38(%rsi), %rsi
movq %r14, %rdx
shlq $0x4, %rdx
movq %rsp, %rcx
callq 0x1d4fa
testq %rax, %rax
je 0x3f251
movq (%rsp), %rcx
shrq $0x4, %rcx
addl %ecx, %r14d
movq %rax, 0x38(%rbx)
movl %r14d, 0x30(%rbx)
xorl %eax, %eax
jmp 0x3f256
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
expand_fast_array:
push r14
push rbx
push rax
mov rbx, rsi
mov eax, [rsi+30h]
lea r14d, [rax+rax*2]
shr r14d, 1
cmp edx, r14d
cmovg r14d, edx
mov rsi, [rsi+38h]
mov rdx, r14
shl rdx, 4
mov rcx, rsp
call js_realloc2
test rax, rax
jz short loc_3F251
mov rcx, [rsp+18h+var_18]
shr rcx, 4
add r14d, ecx
mov [rbx+38h], rax
mov [rbx+30h], r14d
xor eax, eax
jmp short loc_3F256
loc_3F251:
mov eax, 0FFFFFFFFh
loc_3F256:
add rsp, 8
pop rbx
pop r14
retn
|
long long expand_fast_array(long long a1, long long a2, int a3)
{
unsigned long long v3; // rax
long long v4; // r14
long long v5; // rax
int v6; // r14d
unsigned long long v8[3]; // [rsp+0h] [rbp-18h] BYREF
v8[0] = v3;
v4 = (unsigned int)(3 * *(_DWORD *)(a2 + 48)) >> 1;
if ( a3 > (int)v4 )
v4 = (unsigned int)a3;
v5 = js_realloc2(a1, *(_QWORD *)(a2 + 56), 16 * v4, v8);
if ( !v5 )
return 0xFFFFFFFFLL;
v6 = (v8[0] >> 4) + v4;
*(_QWORD *)(a2 + 56) = v5;
*(_DWORD *)(a2 + 48) = v6;
return 0LL;
}
|
expand_fast_array:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV EAX,dword ptr [RSI + 0x30]
LEA R14D,[RAX + RAX*0x2]
SHR R14D,0x1
CMP EDX,R14D
CMOVG R14D,EDX
MOV RSI,qword ptr [RSI + 0x38]
MOV RDX,R14
SHL RDX,0x4
MOV RCX,RSP
CALL 0x0011d4fa
TEST RAX,RAX
JZ 0x0013f251
MOV RCX,qword ptr [RSP]
SHR RCX,0x4
ADD R14D,ECX
MOV qword ptr [RBX + 0x38],RAX
MOV dword ptr [RBX + 0x30],R14D
XOR EAX,EAX
JMP 0x0013f256
LAB_0013f251:
MOV EAX,0xffffffff
LAB_0013f256:
ADD RSP,0x8
POP RBX
POP R14
RET
|
int8 expand_fast_array(int8 param_1,long param_2,uint param_3)
{
ulong in_RAX;
long lVar1;
int8 uVar2;
uint uVar3;
ulong uVar4;
ulong local_18;
uVar3 = (uint)(*(int *)(param_2 + 0x30) * 3) >> 1;
uVar4 = (ulong)uVar3;
if ((int)uVar3 < (int)param_3) {
uVar4 = (ulong)param_3;
}
local_18 = in_RAX;
lVar1 = js_realloc2(param_1,*(int8 *)(param_2 + 0x38),uVar4 << 4,&local_18);
if (lVar1 == 0) {
uVar2 = 0xffffffff;
}
else {
*(long *)(param_2 + 0x38) = lVar1;
*(int *)(param_2 + 0x30) = (int)uVar4 + (int)(local_18 >> 4);
uVar2 = 0;
}
return uVar2;
}
|
|
8,146 |
deflateStateCheck
|
3fs/build_O3/src/apache-arrow-cpp/cpp/zlib_ep-prefix/src/zlib_ep/deflate.c
|
local int deflateStateCheck(strm)
z_streamp strm;
{
deflate_state *s;
if (strm == Z_NULL ||
strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0)
return 1;
s = strm->state;
if (s == Z_NULL || s->strm != strm || (s->status != INIT_STATE &&
#ifdef GZIP
s->status != GZIP_STATE &&
#endif
s->status != EXTRA_STATE &&
s->status != NAME_STATE &&
s->status != COMMENT_STATE &&
s->status != HCRC_STATE &&
s->status != BUSY_STATE &&
s->status != FINISH_STATE))
return 1;
return 0;
}
|
O3
|
c
|
deflateStateCheck:
movl $0x1, %eax
testq %rdi, %rdi
je 0x4478
cmpq $0x0, 0x40(%rdi)
je 0x4478
cmpq $0x0, 0x48(%rdi)
je 0x4478
movq 0x38(%rdi), %rcx
testq %rcx, %rcx
je 0x4478
cmpq %rdi, (%rcx)
je 0x4479
retq
movl 0x8(%rcx), %ecx
leal -0x39(%rcx), %edx
cmpl $0x38, %edx
ja 0x4497
movabsq $0x100400400011001, %rsi # imm = 0x100400400011001
btq %rdx, %rsi
jae 0x4497
xorl %eax, %eax
retq
cmpl $0x29a, %ecx # imm = 0x29A
je 0x4494
cmpl $0x2a, %ecx
jne 0x4478
jmp 0x4494
|
deflateStateCheck:
mov eax, 1
test rdi, rdi
jz short locret_4478
cmp qword ptr [rdi+40h], 0
jz short locret_4478
cmp qword ptr [rdi+48h], 0
jz short locret_4478
mov rcx, [rdi+38h]
test rcx, rcx
jz short locret_4478
cmp [rcx], rdi
jz short loc_4479
locret_4478:
retn
loc_4479:
mov ecx, [rcx+8]
lea edx, [rcx-39h]
cmp edx, 38h ; '8'
ja short loc_4497
mov rsi, 100400400011001h
bt rsi, rdx
jnb short loc_4497
loc_4494:
xor eax, eax
retn
loc_4497:
cmp ecx, 29Ah
jz short loc_4494
cmp ecx, 2Ah ; '*'
jnz short locret_4478
jmp short loc_4494
|
long long deflateStateCheck(_QWORD *a1)
{
long long result; // rax
long long v2; // rcx
int v3; // ecx
unsigned long long v4; // rdx
long long v5; // rsi
result = 1LL;
if ( a1 )
{
if ( a1[8] )
{
if ( a1[9] )
{
v2 = a1[7];
if ( v2 )
{
if ( *(_QWORD **)v2 == a1 )
{
v3 = *(_DWORD *)(v2 + 8);
v4 = (unsigned int)(v3 - 57);
if ( (unsigned int)v4 <= 0x38 )
{
v5 = 0x100400400011001LL;
if ( _bittest64(&v5, v4) )
return 0LL;
}
if ( v3 == 666 || v3 == 42 )
return 0LL;
}
}
}
}
}
return result;
}
|
deflateStateCheck:
MOV EAX,0x1
TEST RDI,RDI
JZ 0x00104478
CMP qword ptr [RDI + 0x40],0x0
JZ 0x00104478
CMP qword ptr [RDI + 0x48],0x0
JZ 0x00104478
MOV RCX,qword ptr [RDI + 0x38]
TEST RCX,RCX
JZ 0x00104478
CMP qword ptr [RCX],RDI
JZ 0x00104479
LAB_00104478:
RET
LAB_00104479:
MOV ECX,dword ptr [RCX + 0x8]
LEA EDX,[RCX + -0x39]
CMP EDX,0x38
JA 0x00104497
MOV RSI,0x100400400011001
BT RSI,RDX
JNC 0x00104497
LAB_00104494:
XOR EAX,EAX
RET
LAB_00104497:
CMP ECX,0x29a
JZ 0x00104494
CMP ECX,0x2a
JNZ 0x00104478
JMP 0x00104494
|
int8 deflateStateCheck(long param_1)
{
int iVar1;
long *plVar2;
if ((((param_1 != 0) && (*(long *)(param_1 + 0x40) != 0)) && (*(long *)(param_1 + 0x48) != 0)) &&
((plVar2 = *(long **)(param_1 + 0x38), plVar2 != (long *)0x0 && (*plVar2 == param_1)))) {
iVar1 = (int)plVar2[1];
if (((iVar1 - 0x39U < 0x39) &&
((0x100400400011001U >> ((ulong)(iVar1 - 0x39U) & 0x3f) & 1) != 0)) ||
((iVar1 == 0x29a || (iVar1 == 0x2a)))) {
return 0;
}
}
return 1;
}
|
|
8,147 |
Delimiter::get_data_length(char const*, char const*) const
|
eloqsql/client/mariadb-conv.cc
|
size_t get_data_length(const char *str, const char *end) const
{
const char *str0= str;
for ( ; str < end; str++)
{
if (is_delimiter(*str))
break;
}
return str - str0;
}
|
O0
|
cpp
|
Delimiter::get_data_length(char const*, char const*) const:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x26e46
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl (%rax), %esi
callq 0x26d90
testb $0x1, %al
jne 0x26e34
jmp 0x26e36
jmp 0x26e46
jmp 0x26e38
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x26e14
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
_ZNK9Delimiter15get_data_lengthEPKcS1_:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
mov [rbp+var_20], rax
loc_26E14:
mov rax, [rbp+var_10]
cmp rax, [rbp+var_18]
jnb short loc_26E46
mov rdi, [rbp+var_28]; this
mov rax, [rbp+var_10]
movsx esi, byte ptr [rax]; char
call _ZNK9Delimiter12is_delimiterEc; Delimiter::is_delimiter(char)
test al, 1
jnz short loc_26E34
jmp short loc_26E36
loc_26E34:
jmp short loc_26E46
loc_26E36:
jmp short $+2
loc_26E38:
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_26E14
loc_26E46:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_20]
sub rax, rcx
add rsp, 30h
pop rbp
retn
|
long long Delimiter::get_data_length(Delimiter *this, char *a2, char *a3)
{
char *i; // [rsp+20h] [rbp-10h]
for ( i = a2; i < a3 && (Delimiter::is_delimiter(this, *i) & 1) == 0; ++i )
;
return i - a2;
}
|
get_data_length:
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 RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x20],RAX
LAB_00126e14:
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x18]
JNC 0x00126e46
MOV RDI,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOVSX ESI,byte ptr [RAX]
CALL 0x00126d90
TEST AL,0x1
JNZ 0x00126e34
JMP 0x00126e36
LAB_00126e34:
JMP 0x00126e46
LAB_00126e36:
JMP 0x00126e38
LAB_00126e38:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00126e14
LAB_00126e46:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x20]
SUB RAX,RCX
ADD RSP,0x30
POP RBP
RET
|
/* Delimiter::get_data_length(char const*, char const*) const */
long __thiscall Delimiter::get_data_length(Delimiter *this,char *param_1,char *param_2)
{
ulong uVar1;
char *local_18;
local_18 = param_1;
while ((local_18 < param_2 && (uVar1 = is_delimiter(this,*local_18), (uVar1 & 1) == 0))) {
local_18 = local_18 + 1;
}
return (long)local_18 - (long)param_1;
}
|
|
8,148 |
ma_init_alloc_root
|
eloqsql/libmariadb/libmariadb/ma_alloc.c
|
void ma_init_alloc_root(MA_MEM_ROOT *mem_root, size_t block_size, size_t pre_alloc_size)
{
mem_root->free= mem_root->used= mem_root->pre_alloc= 0;
mem_root->min_malloc=32;
mem_root->block_size= (block_size-MALLOC_OVERHEAD-sizeof(MA_USED_MEM)+8);
mem_root->error_handler=0;
mem_root->block_num= 4;
mem_root->first_block_usage= 0;
#if !(defined(HAVE_purify) && defined(EXTRA_DEBUG))
if (pre_alloc_size)
{
if ((mem_root->free = mem_root->pre_alloc=
(MA_USED_MEM*) malloc(pre_alloc_size+ ALIGN_SIZE(sizeof(MA_USED_MEM)))))
{
mem_root->free->size=pre_alloc_size+ALIGN_SIZE(sizeof(MA_USED_MEM));
mem_root->free->left=pre_alloc_size;
mem_root->free->next=0;
}
}
#endif
}
|
O3
|
c
|
ma_init_alloc_root:
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movq $0x20, 0x18(%rdi)
addq $-0x18, %rsi
movq %rsi, 0x20(%rdi)
movq %rax, 0x30(%rdi)
movq $0x4, 0x28(%rdi)
testq %rdx, %rdx
je 0x2086e
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x18(%rdx), %r15
movq %r15, %rdi
callq 0x13600
movq %rax, 0x10(%r14)
movq %rax, (%r14)
testq %rax, %rax
je 0x20864
movq %r15, 0x10(%rax)
movq %rbx, 0x8(%rax)
movq $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
ma_init_alloc_root:
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
xor eax, eax
mov [rdi+10h], rax
mov qword ptr [rdi+18h], 20h ; ' '
add rsi, 0FFFFFFFFFFFFFFE8h
mov [rdi+20h], rsi
mov [rdi+30h], rax
mov qword ptr [rdi+28h], 4
test rdx, rdx
jz short locret_2086E
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdx
mov r14, rdi
lea r15, [rdx+18h]
mov rdi, r15
call _malloc
mov [r14+10h], rax
mov [r14], rax
test rax, rax
jz short loc_20864
mov [rax+10h], r15
mov [rax+8], rbx
mov qword ptr [rax], 0
loc_20864:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
locret_2086E:
retn
|
_QWORD * ma_init_alloc_root(long long a1, long long a2, long long a3)
{
_QWORD *result; // rax
long long v5; // r15
*(_OWORD *)a1 = 0LL;
result = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
*(_QWORD *)(a1 + 24) = 32LL;
*(_QWORD *)(a1 + 32) = a2 - 24;
*(_QWORD *)(a1 + 48) = 0LL;
*(_QWORD *)(a1 + 40) = 4LL;
if ( a3 )
{
v5 = a3 + 24;
result = (_QWORD *)malloc(a3 + 24);
*(_QWORD *)(a1 + 16) = result;
*(_QWORD *)a1 = result;
if ( result )
{
result[2] = v5;
result[1] = a3;
*result = 0LL;
}
}
return result;
}
|
ma_init_alloc_root:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],RAX
MOV qword ptr [RDI + 0x18],0x20
ADD RSI,-0x18
MOV qword ptr [RDI + 0x20],RSI
MOV qword ptr [RDI + 0x30],RAX
MOV qword ptr [RDI + 0x28],0x4
TEST RDX,RDX
JZ 0x0012086e
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RDI
LEA R15,[RDX + 0x18]
MOV RDI,R15
CALL 0x00113600
MOV qword ptr [R14 + 0x10],RAX
MOV qword ptr [R14],RAX
TEST RAX,RAX
JZ 0x00120864
MOV qword ptr [RAX + 0x10],R15
MOV qword ptr [RAX + 0x8],RBX
MOV qword ptr [RAX],0x0
LAB_00120864:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
LAB_0012086e:
RET
|
void ma_init_alloc_root(int8 *param_1,long param_2,long param_3)
{
int8 *puVar1;
*param_1 = 0;
param_1[1] = 0;
param_1[2] = 0;
param_1[3] = 0x20;
param_1[4] = param_2 + -0x18;
param_1[6] = 0;
param_1[5] = 4;
if (param_3 != 0) {
puVar1 = (int8 *)malloc(param_3 + 0x18U);
param_1[2] = puVar1;
*param_1 = puVar1;
if (puVar1 != (int8 *)0x0) {
puVar1[2] = param_3 + 0x18U;
puVar1[1] = param_3;
*puVar1 = 0;
}
}
return;
}
|
|
8,149 |
mi_dpointer
|
eloqsql/storage/myisam/mi_search.c
|
void _mi_dpointer(MI_INFO *info, uchar *buff, my_off_t pos)
{
if (!(info->s->options &
(HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) &&
pos != HA_OFFSET_ERROR)
pos/=info->s->base.pack_reclength;
switch (info->s->rec_reflength) {
#if SIZEOF_OFF_T > 4
case 8: mi_int8store(buff,pos); break;
case 7: mi_int7store(buff,pos); break;
case 6: mi_int6store(buff,pos); break;
case 5: mi_int5store(buff,pos); break;
#else
case 8: *buff++=0;
/* fall through */
case 7: *buff++=0;
/* fall through */
case 6: *buff++=0;
/* fall through */
case 5: *buff++=0;
/* fall through */
#endif
case 4: mi_int4store(buff,pos); break;
case 3: mi_int3store(buff,pos); break;
case 2: mi_int2store(buff,(uint) pos); break;
default: abort(); /* Impossible */
}
}
|
O0
|
c
|
mi_dpointer:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x318(%rax), %rax
andq $0x5, %rax
cmpq $0x0, %rax
jne 0xc0461
cmpq $-0x1, -0x18(%rbp)
je 0xc0461
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x148(%rax), %rcx
movq -0x18(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x338(%rax), %eax
addl $-0x2, %eax
movl %eax, %ecx
movq %rcx, -0x88(%rbp)
subl $0x6, %eax
ja 0xc0748
movq -0x88(%rbp), %rax
leaq 0x9fbdf(%rip), %rcx # 0x160070
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x30(%rbp), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x30(%rbp), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x30(%rbp), %rax
shrq $0x18, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x7(%rax)
movq -0x38(%rbp), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x6(%rax)
movq -0x38(%rbp), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x5(%rax)
movq -0x38(%rbp), %rax
shrq $0x18, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x4(%rax)
jmp 0xc074d
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x6(%rax)
movq -0x40(%rbp), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x5(%rax)
movq -0x40(%rbp), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x40(%rbp), %rax
shrq $0x18, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x48(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x48(%rbp), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x48(%rbp), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
jmp 0xc074d
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x5(%rax)
movq -0x50(%rbp), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x50(%rbp), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x50(%rbp), %rax
shrq $0x18, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x58(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x58(%rbp), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
jmp 0xc074d
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x60(%rbp), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x60(%rbp), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x60(%rbp), %rax
shrq $0x18, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x68(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
jmp 0xc074d
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x70(%rbp), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x70(%rbp), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x70(%rbp), %rax
shrq $0x18, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
jmp 0xc074d
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x78(%rbp), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x78(%rbp), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
jmp 0xc074d
movq -0x18(%rbp), %rax
movl %eax, -0x7c(%rbp)
movl -0x7c(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x7c(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
jmp 0xc074d
callq 0x2a5c0
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_mi_dpointer:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov rax, [rax]
mov rax, [rax+318h]
and rax, 5
cmp rax, 0
jnz short loc_C0461
cmp [rbp+var_18], 0FFFFFFFFFFFFFFFFh
jz short loc_C0461
mov rax, [rbp+var_8]
mov rax, [rax]
mov rcx, [rax+148h]
mov rax, [rbp+var_18]
xor edx, edx
div rcx
mov [rbp+var_18], rax
loc_C0461:
mov rax, [rbp+var_8]
mov rax, [rax]
mov eax, [rax+338h]
add eax, 0FFFFFFFEh; switch 7 cases
mov ecx, eax
mov [rbp+var_88], rcx
sub eax, 6
ja def_C0498; jumptable 00000000000C0498 default case
mov rax, [rbp+var_88]
lea rcx, jpt_C0498
movsxd rax, ds:(jpt_C0498 - 160070h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_C049A:
mov rax, [rbp+var_18]; jumptable 00000000000C0498 case 8
mov [rbp+var_20], rax
mov rax, [rbp+var_18]
shr rax, 20h
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
mov cl, al
mov rax, [rbp+var_10]
mov [rax+3], cl
mov rax, [rbp+var_30]
shr rax, 8
mov cl, al
mov rax, [rbp+var_10]
mov [rax+2], cl
mov rax, [rbp+var_30]
shr rax, 10h
mov cl, al
mov rax, [rbp+var_10]
mov [rax+1], cl
mov rax, [rbp+var_30]
shr rax, 18h
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
mov rax, [rbp+var_20]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov cl, al
mov rax, [rbp+var_10]
mov [rax+7], cl
mov rax, [rbp+var_38]
shr rax, 8
mov cl, al
mov rax, [rbp+var_10]
mov [rax+6], cl
mov rax, [rbp+var_38]
shr rax, 10h
mov cl, al
mov rax, [rbp+var_10]
mov [rax+5], cl
mov rax, [rbp+var_38]
shr rax, 18h
mov cl, al
mov rax, [rbp+var_10]
mov [rax+4], cl
jmp loc_C074D
loc_C0542:
mov rax, [rbp+var_18]; jumptable 00000000000C0498 case 7
mov [rbp+var_40], rax
mov rax, [rbp+var_18]
shr rax, 20h
mov [rbp+var_48], rax
mov rax, [rbp+var_40]
mov cl, al
mov rax, [rbp+var_10]
mov [rax+6], cl
mov rax, [rbp+var_40]
shr rax, 8
mov cl, al
mov rax, [rbp+var_10]
mov [rax+5], cl
mov rax, [rbp+var_40]
shr rax, 10h
mov cl, al
mov rax, [rbp+var_10]
mov [rax+4], cl
mov rax, [rbp+var_40]
shr rax, 18h
mov cl, al
mov rax, [rbp+var_10]
mov [rax+3], cl
mov rax, [rbp+var_48]
mov cl, al
mov rax, [rbp+var_10]
mov [rax+2], cl
mov rax, [rbp+var_48]
shr rax, 8
mov cl, al
mov rax, [rbp+var_10]
mov [rax+1], cl
mov rax, [rbp+var_48]
shr rax, 10h
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
jmp loc_C074D
loc_C05C9:
mov rax, [rbp+var_18]; jumptable 00000000000C0498 case 6
mov [rbp+var_50], rax
mov rax, [rbp+var_18]
shr rax, 20h
mov [rbp+var_58], rax
mov rax, [rbp+var_50]
mov cl, al
mov rax, [rbp+var_10]
mov [rax+5], cl
mov rax, [rbp+var_50]
shr rax, 8
mov cl, al
mov rax, [rbp+var_10]
mov [rax+4], cl
mov rax, [rbp+var_50]
shr rax, 10h
mov cl, al
mov rax, [rbp+var_10]
mov [rax+3], cl
mov rax, [rbp+var_50]
shr rax, 18h
mov cl, al
mov rax, [rbp+var_10]
mov [rax+2], cl
mov rax, [rbp+var_58]
mov cl, al
mov rax, [rbp+var_10]
mov [rax+1], cl
mov rax, [rbp+var_58]
shr rax, 8
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
jmp loc_C074D
loc_C063F:
mov rax, [rbp+var_18]; jumptable 00000000000C0498 case 5
mov [rbp+var_60], rax
mov rax, [rbp+var_18]
shr rax, 20h
mov [rbp+var_68], rax
mov rax, [rbp+var_60]
mov cl, al
mov rax, [rbp+var_10]
mov [rax+4], cl
mov rax, [rbp+var_60]
shr rax, 8
mov cl, al
mov rax, [rbp+var_10]
mov [rax+3], cl
mov rax, [rbp+var_60]
shr rax, 10h
mov cl, al
mov rax, [rbp+var_10]
mov [rax+2], cl
mov rax, [rbp+var_60]
shr rax, 18h
mov cl, al
mov rax, [rbp+var_10]
mov [rax+1], cl
mov rax, [rbp+var_68]
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
jmp loc_C074D
loc_C06A4:
mov rax, [rbp+var_18]; jumptable 00000000000C0498 case 4
mov [rbp+var_70], rax
mov rax, [rbp+var_70]
mov cl, al
mov rax, [rbp+var_10]
mov [rax+3], cl
mov rax, [rbp+var_70]
shr rax, 8
mov cl, al
mov rax, [rbp+var_10]
mov [rax+2], cl
mov rax, [rbp+var_70]
shr rax, 10h
mov cl, al
mov rax, [rbp+var_10]
mov [rax+1], cl
mov rax, [rbp+var_70]
shr rax, 18h
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
jmp short loc_C074D
loc_C06ED:
mov rax, [rbp+var_18]; jumptable 00000000000C0498 case 3
mov [rbp+var_78], rax
mov rax, [rbp+var_78]
mov cl, al
mov rax, [rbp+var_10]
mov [rax+2], cl
mov rax, [rbp+var_78]
shr rax, 8
mov cl, al
mov rax, [rbp+var_10]
mov [rax+1], cl
mov rax, [rbp+var_78]
shr rax, 10h
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
jmp short loc_C074D
loc_C0725:
mov rax, [rbp+var_18]; jumptable 00000000000C0498 case 2
mov [rbp+var_7C], eax
mov eax, [rbp+var_7C]
mov cl, al
mov rax, [rbp+var_10]
mov [rax+1], cl
mov eax, [rbp+var_7C]
shr eax, 8
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
jmp short loc_C074D
def_C0498:
call _abort; jumptable 00000000000C0498 default case
loc_C074D:
add rsp, 90h
pop rbp
retn
|
_BYTE * mi_dpointer(long long a1, _BYTE *a2, unsigned long long a3)
{
unsigned long long v3; // rcx
_BYTE *result; // rax
unsigned long long v5; // [rsp+78h] [rbp-18h]
v5 = a3;
if ( (*(_QWORD *)(*(_QWORD *)a1 + 792LL) & 5LL) == 0 && a3 != -1LL )
{
v3 = *(_QWORD *)(*(_QWORD *)a1 + 328LL);
a3 %= v3;
v5 /= v3;
}
switch ( *(_DWORD *)(*(_QWORD *)a1 + 824LL) )
{
case 2:
a2[1] = v5;
result = a2;
*a2 = BYTE1(v5);
break;
case 3:
a2[2] = v5;
a2[1] = BYTE1(v5);
result = a2;
*a2 = BYTE2(v5);
break;
case 4:
a2[3] = v5;
a2[2] = BYTE1(v5);
a2[1] = BYTE2(v5);
result = a2;
*a2 = BYTE3(v5);
break;
case 5:
a2[4] = v5;
a2[3] = BYTE1(v5);
a2[2] = BYTE2(v5);
a2[1] = BYTE3(v5);
result = a2;
*a2 = BYTE4(v5);
break;
case 6:
a2[5] = v5;
a2[4] = BYTE1(v5);
a2[3] = BYTE2(v5);
a2[2] = BYTE3(v5);
a2[1] = BYTE4(v5);
result = a2;
*a2 = BYTE5(v5);
break;
case 7:
a2[6] = v5;
a2[5] = BYTE1(v5);
a2[4] = BYTE2(v5);
a2[3] = BYTE3(v5);
a2[2] = BYTE4(v5);
a2[1] = BYTE5(v5);
result = a2;
*a2 = BYTE6(v5);
break;
case 8:
a2[3] = BYTE4(v5);
a2[2] = BYTE5(v5);
a2[1] = BYTE6(v5);
*a2 = HIBYTE(v5);
a2[7] = v5;
a2[6] = BYTE1(v5);
a2[5] = BYTE2(v5);
result = a2;
a2[4] = BYTE3(v5);
break;
default:
abort(a1, a2, a3);
}
return result;
}
|
_mi_dpointer:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
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 RAX,qword ptr [RAX + 0x318]
AND RAX,0x5
CMP RAX,0x0
JNZ 0x001c0461
CMP qword ptr [RBP + -0x18],-0x1
JZ 0x001c0461
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RAX + 0x148]
MOV RAX,qword ptr [RBP + -0x18]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x18],RAX
LAB_001c0461:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x338]
ADD EAX,-0x2
MOV ECX,EAX
MOV qword ptr [RBP + -0x88],RCX
SUB EAX,0x6
JA 0x001c0748
MOV RAX,qword ptr [RBP + -0x88]
LEA RCX,[0x260070]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_8:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x20
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x3],CL
MOV RAX,qword ptr [RBP + -0x30]
SHR RAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x2],CL
MOV RAX,qword ptr [RBP + -0x30]
SHR RAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x30]
SHR RAX,0x18
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x7],CL
MOV RAX,qword ptr [RBP + -0x38]
SHR RAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x6],CL
MOV RAX,qword ptr [RBP + -0x38]
SHR RAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x5],CL
MOV RAX,qword ptr [RBP + -0x38]
SHR RAX,0x18
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x4],CL
JMP 0x001c074d
caseD_7:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x20
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x6],CL
MOV RAX,qword ptr [RBP + -0x40]
SHR RAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x5],CL
MOV RAX,qword ptr [RBP + -0x40]
SHR RAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x4],CL
MOV RAX,qword ptr [RBP + -0x40]
SHR RAX,0x18
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x3],CL
MOV RAX,qword ptr [RBP + -0x48]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x2],CL
MOV RAX,qword ptr [RBP + -0x48]
SHR RAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x48]
SHR RAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
JMP 0x001c074d
caseD_6:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x20
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x5],CL
MOV RAX,qword ptr [RBP + -0x50]
SHR RAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x4],CL
MOV RAX,qword ptr [RBP + -0x50]
SHR RAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x3],CL
MOV RAX,qword ptr [RBP + -0x50]
SHR RAX,0x18
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x2],CL
MOV RAX,qword ptr [RBP + -0x58]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x58]
SHR RAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
JMP 0x001c074d
caseD_5:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x20
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x60]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x4],CL
MOV RAX,qword ptr [RBP + -0x60]
SHR RAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x3],CL
MOV RAX,qword ptr [RBP + -0x60]
SHR RAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x2],CL
MOV RAX,qword ptr [RBP + -0x60]
SHR RAX,0x18
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x68]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
JMP 0x001c074d
caseD_4:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x70],RAX
MOV RAX,qword ptr [RBP + -0x70]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x3],CL
MOV RAX,qword ptr [RBP + -0x70]
SHR RAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x2],CL
MOV RAX,qword ptr [RBP + -0x70]
SHR RAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x70]
SHR RAX,0x18
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
JMP 0x001c074d
caseD_3:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x78]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x2],CL
MOV RAX,qword ptr [RBP + -0x78]
SHR RAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x78]
SHR RAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
JMP 0x001c074d
caseD_2:
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x7c],EAX
MOV EAX,dword ptr [RBP + -0x7c]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x1],CL
MOV EAX,dword ptr [RBP + -0x7c]
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
JMP 0x001c074d
default:
CALL 0x0012a5c0
LAB_001c074d:
ADD RSP,0x90
POP RBP
RET
|
void _mi_dpointer(long *param_1,int1 *param_2,ulong param_3)
{
int1 uVar1;
int1 uVar2;
int1 uVar3;
int1 uVar4;
int1 uVar5;
int1 uVar6;
int1 uVar7;
ulong local_20;
local_20 = param_3;
if (((*(ulong *)(*param_1 + 0x318) & 5) == 0) && (param_3 != 0xffffffffffffffff)) {
local_20 = param_3 / *(ulong *)(*param_1 + 0x148);
}
uVar4 = (int1)local_20;
uVar5 = (int1)(local_20 >> 8);
uVar6 = (int1)(local_20 >> 0x10);
uVar7 = (int1)(local_20 >> 0x18);
uVar1 = (int1)(local_20 >> 0x20);
uVar2 = (int1)(local_20 >> 0x28);
uVar3 = (int1)(local_20 >> 0x30);
switch(*(int4 *)(*param_1 + 0x338)) {
case 2:
param_2[1] = uVar4;
*param_2 = uVar5;
break;
case 3:
param_2[2] = uVar4;
param_2[1] = uVar5;
*param_2 = uVar6;
break;
case 4:
param_2[3] = uVar4;
param_2[2] = uVar5;
param_2[1] = uVar6;
*param_2 = uVar7;
break;
case 5:
param_2[4] = uVar4;
param_2[3] = uVar5;
param_2[2] = uVar6;
param_2[1] = uVar7;
*param_2 = uVar1;
break;
case 6:
param_2[5] = uVar4;
param_2[4] = uVar5;
param_2[3] = uVar6;
param_2[2] = uVar7;
param_2[1] = uVar1;
*param_2 = uVar2;
break;
case 7:
param_2[6] = uVar4;
param_2[5] = uVar5;
param_2[4] = uVar6;
param_2[3] = uVar7;
param_2[2] = uVar1;
param_2[1] = uVar2;
*param_2 = uVar3;
break;
case 8:
param_2[3] = uVar1;
param_2[2] = uVar2;
param_2[1] = uVar3;
*param_2 = (char)(local_20 >> 0x38);
param_2[7] = uVar4;
param_2[6] = uVar5;
param_2[5] = uVar6;
param_2[4] = uVar7;
break;
default:
/* WARNING: Subroutine does not return */
abort();
}
return;
}
|
|
8,150 |
my_coll_parser_scan_character_list
|
eloqsql/strings/ctype-uca.c
|
static int
my_coll_parser_scan_character_list(MY_COLL_RULE_PARSER *p,
my_wc_t *pwc, size_t limit,
const char *name)
{
if (my_coll_parser_curr(p)->term != MY_COLL_LEXEM_CHAR)
return my_coll_parser_expected_error(p, MY_COLL_LEXEM_CHAR);
if (!my_coll_rule_expand(pwc, limit, my_coll_parser_curr(p)->code))
return my_coll_parser_too_long_error(p, name);
if (!my_coll_parser_scan_term(p, MY_COLL_LEXEM_CHAR))
return 0;
while (my_coll_parser_curr(p)->term == MY_COLL_LEXEM_CHAR)
{
if (!my_coll_rule_expand(pwc, limit, my_coll_parser_curr(p)->code))
return my_coll_parser_too_long_error(p, name);
my_coll_parser_scan(p);
}
return 1;
}
|
O0
|
c
|
my_coll_parser_scan_character_list:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5f100
cmpl $0x5, (%rax)
je 0x600fc
movq -0x10(%rbp), %rdi
movl $0x5, %esi
callq 0x5fa40
movl %eax, -0x4(%rbp)
jmp 0x601bc
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5f100
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movslq 0x24(%rax), %rdx
callq 0x601d0
cmpl $0x0, %eax
jne 0x6013d
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x60240
movl %eax, -0x4(%rbp)
jmp 0x601bc
movq -0x10(%rbp), %rdi
movl $0x5, %esi
callq 0x5f6d0
cmpl $0x0, %eax
jne 0x60159
movl $0x0, -0x4(%rbp)
jmp 0x601bc
jmp 0x6015b
movq -0x10(%rbp), %rdi
callq 0x5f100
cmpl $0x5, (%rax)
jne 0x601b5
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5f100
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movslq 0x24(%rax), %rdx
callq 0x601d0
cmpl $0x0, %eax
jne 0x601aa
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x60240
movl %eax, -0x4(%rbp)
jmp 0x601bc
movq -0x10(%rbp), %rdi
callq 0x5f8e0
jmp 0x6015b
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_coll_parser_scan_character_list:
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
mov rdi, [rbp+var_10]
call my_coll_parser_curr
cmp dword ptr [rax], 5
jz short loc_600FC
mov rdi, [rbp+var_10]
mov esi, 5
call my_coll_parser_expected_error
mov [rbp+var_4], eax
jmp loc_601BC
loc_600FC:
mov rax, [rbp+var_18]
mov [rbp+var_38], rax
mov rax, [rbp+var_20]
mov [rbp+var_30], rax
mov rdi, [rbp+var_10]
call my_coll_parser_curr
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_30]
movsxd rdx, dword ptr [rax+24h]
call my_coll_rule_expand
cmp eax, 0
jnz short loc_6013D
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
call my_coll_parser_too_long_error
mov [rbp+var_4], eax
jmp short loc_601BC
loc_6013D:
mov rdi, [rbp+var_10]
mov esi, 5
call my_coll_parser_scan_term
cmp eax, 0
jnz short loc_60159
mov [rbp+var_4], 0
jmp short loc_601BC
loc_60159:
jmp short $+2
loc_6015B:
mov rdi, [rbp+var_10]
call my_coll_parser_curr
cmp dword ptr [rax], 5
jnz short loc_601B5
mov rax, [rbp+var_18]
mov [rbp+var_48], rax
mov rax, [rbp+var_20]
mov [rbp+var_40], rax
mov rdi, [rbp+var_10]
call my_coll_parser_curr
mov rdi, [rbp+var_48]
mov rsi, [rbp+var_40]
movsxd rdx, dword ptr [rax+24h]
call my_coll_rule_expand
cmp eax, 0
jnz short loc_601AA
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
call my_coll_parser_too_long_error
mov [rbp+var_4], eax
jmp short loc_601BC
loc_601AA:
mov rdi, [rbp+var_10]
call my_coll_parser_scan
jmp short loc_6015B
loc_601B5:
mov [rbp+var_4], 1
loc_601BC:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
|
long long my_coll_parser_scan_character_list(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // rax
long long v5; // rax
if ( *(_DWORD *)my_coll_parser_curr(a1) == 5 )
{
v4 = my_coll_parser_curr(a1);
if ( (unsigned int)my_coll_rule_expand(a2, a3, *(int *)(v4 + 36)) )
{
if ( (unsigned int)my_coll_parser_scan_term(a1, 5u) )
{
while ( *(_DWORD *)my_coll_parser_curr(a1) == 5 )
{
v5 = my_coll_parser_curr(a1);
if ( !(unsigned int)my_coll_rule_expand(a2, a3, *(int *)(v5 + 36)) )
return (unsigned int)my_coll_parser_too_long_error(a1, a4);
my_coll_parser_scan(a1);
}
return 1;
}
else
{
return 0;
}
}
else
{
return (unsigned int)my_coll_parser_too_long_error(a1, a4);
}
}
else
{
return (unsigned int)my_coll_parser_expected_error(a1, 5u);
}
}
|
my_coll_parser_scan_character_list:
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
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0015f100
CMP dword ptr [RAX],0x5
JZ 0x001600fc
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x5
CALL 0x0015fa40
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001601bc
LAB_001600fc:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0015f100
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x30]
MOVSXD RDX,dword ptr [RAX + 0x24]
CALL 0x001601d0
CMP EAX,0x0
JNZ 0x0016013d
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x00160240
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001601bc
LAB_0016013d:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x5
CALL 0x0015f6d0
CMP EAX,0x0
JNZ 0x00160159
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001601bc
LAB_00160159:
JMP 0x0016015b
LAB_0016015b:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0015f100
CMP dword ptr [RAX],0x5
JNZ 0x001601b5
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0015f100
MOV RDI,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x40]
MOVSXD RDX,dword ptr [RAX + 0x24]
CALL 0x001601d0
CMP EAX,0x0
JNZ 0x001601aa
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x00160240
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001601bc
LAB_001601aa:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0015f8e0
JMP 0x0016015b
LAB_001601b5:
MOV dword ptr [RBP + -0x4],0x1
LAB_001601bc:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
int4
my_coll_parser_scan_character_list
(int8 param_1,int8 param_2,int8 param_3,int8 param_4)
{
int iVar1;
int4 uVar2;
int *piVar3;
long lVar4;
int4 local_c;
piVar3 = (int *)my_coll_parser_curr(param_1);
if (*piVar3 == 5) {
lVar4 = my_coll_parser_curr(param_1);
iVar1 = my_coll_rule_expand(param_2,param_3,(long)*(int *)(lVar4 + 0x24));
if (iVar1 == 0) {
local_c = my_coll_parser_too_long_error(param_1,param_4);
}
else {
iVar1 = my_coll_parser_scan_term(param_1,5);
if (iVar1 == 0) {
local_c = 0;
}
else {
while (piVar3 = (int *)my_coll_parser_curr(param_1), *piVar3 == 5) {
lVar4 = my_coll_parser_curr(param_1);
iVar1 = my_coll_rule_expand(param_2,param_3,(long)*(int *)(lVar4 + 0x24));
if (iVar1 == 0) {
uVar2 = my_coll_parser_too_long_error(param_1,param_4);
return uVar2;
}
my_coll_parser_scan(param_1);
}
local_c = 1;
}
}
}
else {
local_c = my_coll_parser_expected_error(param_1,5);
}
return local_c;
}
|
|
8,151 |
translog_prev_buffer_flush_wait
|
eloqsql/storage/maria/ma_loghandler.c
|
my_bool translog_prev_buffer_flush_wait(struct st_translog_buffer *buffer)
{
TRANSLOG_ADDRESS offset= buffer->offset;
TRANSLOG_FILE *file= buffer->file;
uint8 ver= buffer->ver;
DBUG_ENTER("translog_prev_buffer_flush_wait");
DBUG_PRINT("enter", ("buffer: %p #%u offset: " LSN_FMT " "
"prev sent: " LSN_FMT " prev offset: " LSN_FMT,
buffer, (uint) buffer->buffer_no,
LSN_IN_PARTS(buffer->offset),
LSN_IN_PARTS(buffer->prev_sent_to_disk),
LSN_IN_PARTS(buffer->prev_buffer_offset)));
translog_buffer_lock_assert_owner(buffer);
if (buffer->prev_buffer_offset != buffer->prev_sent_to_disk)
{
do {
mysql_cond_wait(&buffer->prev_sent_to_disk_cond, &buffer->mutex);
if (buffer->file != file || buffer->offset != offset ||
buffer->ver != ver)
DBUG_RETURN(1); /* some the thread flushed the buffer already */
} while(buffer->prev_buffer_offset != buffer->prev_sent_to_disk);
}
DBUG_RETURN(0);
}
|
O0
|
c
|
translog_prev_buffer_flush_wait:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x100010(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x100038(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movb 0x1000d9(%rax), %al
movb %al, -0x21(%rbp)
jmp 0x2ed19
movq -0x10(%rbp), %rax
movq 0x100020(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x1000e0(%rcx), %rax
je 0x2edb7
jmp 0x2ed37
movq -0x10(%rbp), %rdi
addq $0x1000e8, %rdi # imm = 0x1000E8
movq -0x10(%rbp), %rsi
addq $0x100090, %rsi # imm = 0x100090
leaq 0x123c75(%rip), %rdx # 0x1529c9
movl $0xa24, %ecx # imm = 0xA24
callq 0x2edd0
movq -0x10(%rbp), %rax
movq 0x100038(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x2ed93
movq -0x10(%rbp), %rax
movq 0x100010(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x2ed93
movq -0x10(%rbp), %rax
movzbl 0x1000d9(%rax), %eax
movzbl -0x21(%rbp), %ecx
cmpl %ecx, %eax
je 0x2ed9b
jmp 0x2ed95
movb $0x1, -0x1(%rbp)
jmp 0x2edbd
jmp 0x2ed9d
movq -0x10(%rbp), %rax
movq 0x100020(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x1000e0(%rcx), %rax
jne 0x2ed37
jmp 0x2edb7
jmp 0x2edb9
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
translog_prev_buffer_flush_wait:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov rax, [rax+100010h]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
mov rax, [rax+100038h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov al, ds:byte_1000D9[rax]
mov [rbp+var_21], al
jmp short $+2
loc_2ED19:
mov rax, [rbp+var_10]
mov rax, [rax+100020h]
mov rcx, [rbp+var_10]
cmp rax, qword ptr ds:inline_mysql_mutex_unlock_29[rcx]
jz loc_2EDB7
jmp short $+2
loc_2ED37:
mov rdi, [rbp+var_10]
add rdi, 1000E8h
mov rsi, [rbp+var_10]
add rsi, 100090h
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 0A24h
call inline_mysql_cond_wait
mov rax, [rbp+var_10]
mov rax, [rax+100038h]
cmp rax, [rbp+var_20]
jnz short loc_2ED93
mov rax, [rbp+var_10]
mov rax, [rax+100010h]
cmp rax, [rbp+var_18]
jnz short loc_2ED93
mov rax, [rbp+var_10]
movzx eax, ds:byte_1000D9[rax]
movzx ecx, [rbp+var_21]
cmp eax, ecx
jz short loc_2ED9B
loc_2ED93:
jmp short $+2
loc_2ED95:
mov [rbp+var_1], 1
jmp short loc_2EDBD
loc_2ED9B:
jmp short $+2
loc_2ED9D:
mov rax, [rbp+var_10]
mov rax, [rax+100020h]
mov rcx, [rbp+var_10]
cmp rax, qword ptr ds:inline_mysql_mutex_unlock_29[rcx]
jnz short loc_2ED37
jmp short $+2
loc_2EDB7:
jmp short $+2
loc_2EDB9:
mov [rbp+var_1], 0
loc_2EDBD:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
|
char translog_prev_buffer_flush_wait(_QWORD *a1)
{
char v2; // [rsp+Fh] [rbp-21h]
long long v3; // [rsp+10h] [rbp-20h]
long long v4; // [rsp+18h] [rbp-18h]
v4 = a1[131074];
v3 = a1[131079];
v2 = byte_1000D9[(_QWORD)a1];
if ( a1[131076] == *(_QWORD *)((char *)inline_mysql_mutex_unlock_29 + (_QWORD)a1) )
return 0;
while ( 1 )
{
inline_mysql_cond_wait(
a1 + 131101,
a1 + 131090,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
2596LL);
if ( a1[131079] != v3 || a1[131074] != v4 || byte_1000D9[(_QWORD)a1] != v2 )
break;
if ( a1[131076] == *(_QWORD *)((char *)inline_mysql_mutex_unlock_29 + (_QWORD)a1) )
return 0;
}
return 1;
}
|
translog_prev_buffer_flush_wait:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x100010]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x100038]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV AL,byte ptr [RAX + 0x1000d9]
MOV byte ptr [RBP + -0x21],AL
JMP 0x0012ed19
LAB_0012ed19:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x100020]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x1000e0]
JZ 0x0012edb7
JMP 0x0012ed37
LAB_0012ed37:
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x1000e8
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x100090
LEA RDX,[0x2529c9]
MOV ECX,0xa24
CALL 0x0012edd0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x100038]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x0012ed93
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x100010]
CMP RAX,qword ptr [RBP + -0x18]
JNZ 0x0012ed93
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x1000d9]
MOVZX ECX,byte ptr [RBP + -0x21]
CMP EAX,ECX
JZ 0x0012ed9b
LAB_0012ed93:
JMP 0x0012ed95
LAB_0012ed95:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0012edbd
LAB_0012ed9b:
JMP 0x0012ed9d
LAB_0012ed9d:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x100020]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x1000e0]
JNZ 0x0012ed37
JMP 0x0012edb7
LAB_0012edb7:
JMP 0x0012edb9
LAB_0012edb9:
MOV byte ptr [RBP + -0x1],0x0
LAB_0012edbd:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int8 translog_prev_buffer_flush_wait(long param_1)
{
char cVar1;
long lVar2;
long lVar3;
long lVar4;
int1 local_9;
lVar2 = *(long *)(Elf64_Ehdr_00100000.e_ident_pad + param_1 + 7);
lVar3 = *(long *)(Elf64_Ehdr_00100000.e_ident_pad + param_1 + 0x2f);
cVar1 = *(char *)((long)&Elf64_Phdr_ARRAY_00100040[2].p_memsz + param_1 + 1);
lVar4 = *(long *)(Elf64_Ehdr_00100000.e_ident_pad + param_1 + 0x17);
if (lVar4 != *(long *)((long)&Elf64_Phdr_ARRAY_00100040[2].p_align + param_1)) {
do {
inline_mysql_cond_wait
(param_1 + 0x1000e8,param_1 + 0x100090,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",0xa24);
lVar4 = *(long *)(Elf64_Ehdr_00100000.e_ident_pad + param_1 + 0x2f);
if (((lVar4 != lVar3) ||
(lVar4 = *(long *)(Elf64_Ehdr_00100000.e_ident_pad + param_1 + 7), lVar4 != lVar2)) ||
(lVar4 = 0, *(char *)((long)&Elf64_Phdr_ARRAY_00100040[2].p_memsz + param_1 + 1) != cVar1))
{
local_9 = 1;
goto LAB_0012edbd;
}
lVar4 = *(long *)(Elf64_Ehdr_00100000.e_ident_pad + param_1 + 0x17);
} while (lVar4 != *(long *)((long)&Elf64_Phdr_ARRAY_00100040[2].p_align + param_1));
}
local_9 = 0;
LAB_0012edbd:
return CONCAT71((int7)((ulong)lVar4 >> 8),local_9);
}
|
|
8,152 |
bitmap_get_first_set
|
eloqsql/mysys/my_bitmap.c
|
uint bitmap_get_first_set(const MY_BITMAP *map)
{
uint i;
my_bitmap_map *data_ptr= map->bitmap, *end= map->last_word_ptr;
DBUG_ASSERT(map->bitmap);
for (i=0; data_ptr < end; data_ptr++, i++)
if (*data_ptr)
goto found;
if (!(*data_ptr & ~map->last_word_mask))
return MY_BIT_NONE;
found:
return get_first_set(*data_ptr, i);
}
|
O3
|
c
|
bitmap_get_first_set:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
jae 0x9d87a
xorl %eax, %eax
movl (%rcx), %esi
testl %esi, %esi
jne 0x9d885
addq $0x4, %rcx
incl %eax
cmpq %rdx, %rcx
jb 0x9d869
movl (%rcx), %esi
movl 0x18(%rdi), %ecx
notl %ecx
testl %ecx, %esi
je 0x9d8c0
movl %esi, -0x4(%rbp)
xorl %edx, %edx
movl $0x0, %ecx
testb %sil, %sil
jne 0x9d8a8
xorl %ecx, %ecx
leaq -0x3(%rbp), %rdi
movb (%rdi), %sil
addl $0x8, %ecx
incq %rdi
testb %sil, %sil
je 0x9d89a
movzbl %sil, %esi
btl %edx, %esi
leal 0x1(%rdx), %edx
jae 0x9d8ac
shll $0x5, %eax
addl %eax, %ecx
leal (%rdx,%rcx), %eax
decl %eax
jmp 0x9d8c5
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rbp
retq
|
bitmap_get_first_set:
push rbp
mov rbp, rsp
mov rcx, [rdi]
mov rdx, [rdi+8]
xor eax, eax
cmp rcx, rdx
jnb short loc_9D87A
xor eax, eax
loc_9D869:
mov esi, [rcx]
test esi, esi
jnz short loc_9D885
add rcx, 4
inc eax
cmp rcx, rdx
jb short loc_9D869
loc_9D87A:
mov esi, [rcx]
mov ecx, [rdi+18h]
not ecx
test esi, ecx
jz short loc_9D8C0
loc_9D885:
mov [rbp+var_4], esi
xor edx, edx
mov ecx, 0
test sil, sil
jnz short loc_9D8A8
xor ecx, ecx
lea rdi, [rbp+var_4+1]
loc_9D89A:
mov sil, [rdi]
add ecx, 8
inc rdi
test sil, sil
jz short loc_9D89A
loc_9D8A8:
movzx esi, sil
loc_9D8AC:
bt esi, edx
lea edx, [rdx+1]
jnb short loc_9D8AC
shl eax, 5
add ecx, eax
lea eax, [rdx+rcx]
dec eax
jmp short loc_9D8C5
loc_9D8C0:
mov eax, 0FFFFFFFFh
loc_9D8C5:
pop rbp
retn
|
long long bitmap_get_first_set(long long a1)
{
int *v1; // rcx
unsigned long long v2; // rdx
int v3; // eax
int v4; // esi
unsigned int v5; // edx
int v6; // ecx
_BYTE *v7; // rdi
int v10; // [rsp+0h] [rbp-4h] BYREF
v1 = *(int **)a1;
v2 = *(_QWORD *)(a1 + 8);
v3 = 0;
if ( *(_QWORD *)a1 >= v2 )
{
LABEL_5:
v4 = *v1;
if ( (~*(_DWORD *)(a1 + 24) & *v1) == 0 )
return 0xFFFFFFFFLL;
}
else
{
v3 = 0;
while ( 1 )
{
v4 = *v1;
if ( *v1 )
break;
++v1;
++v3;
if ( (unsigned long long)v1 >= v2 )
goto LABEL_5;
}
}
v10 = v4;
v5 = 0;
v6 = 0;
if ( !(_BYTE)v4 )
{
v6 = 0;
v7 = (char *)&v10 + 1;
do
{
LOBYTE(v4) = *v7;
v6 += 8;
++v7;
}
while ( !(_BYTE)v4 );
}
v4 = (unsigned __int8)v4;
while ( !_bittest(&v4, v5++) )
;
return v5 + 32 * v3 + v6 - 1;
}
|
bitmap_get_first_set:
PUSH RBP
MOV RBP,RSP
MOV RCX,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
XOR EAX,EAX
CMP RCX,RDX
JNC 0x0019d87a
XOR EAX,EAX
LAB_0019d869:
MOV ESI,dword ptr [RCX]
TEST ESI,ESI
JNZ 0x0019d885
ADD RCX,0x4
INC EAX
CMP RCX,RDX
JC 0x0019d869
LAB_0019d87a:
MOV ESI,dword ptr [RCX]
MOV ECX,dword ptr [RDI + 0x18]
NOT ECX
TEST ESI,ECX
JZ 0x0019d8c0
LAB_0019d885:
MOV dword ptr [RBP + -0x4],ESI
XOR EDX,EDX
MOV ECX,0x0
TEST SIL,SIL
JNZ 0x0019d8a8
XOR ECX,ECX
LEA RDI,[RBP + -0x3]
LAB_0019d89a:
MOV SIL,byte ptr [RDI]
ADD ECX,0x8
INC RDI
TEST SIL,SIL
JZ 0x0019d89a
LAB_0019d8a8:
MOVZX ESI,SIL
LAB_0019d8ac:
BT ESI,EDX
LEA EDX,[RDX + 0x1]
JNC 0x0019d8ac
SHL EAX,0x5
ADD ECX,EAX
LEA EAX,[RDX + RCX*0x1]
DEC EAX
JMP 0x0019d8c5
LAB_0019d8c0:
MOV EAX,0xffffffff
LAB_0019d8c5:
POP RBP
RET
|
int bitmap_get_first_set(int8 *param_1)
{
byte bVar1;
uint uVar2;
int iVar3;
int iVar4;
uint *puVar5;
uint uVar6;
uint uVar7;
byte *pbVar8;
byte abStack_b [3];
puVar5 = (uint *)*param_1;
iVar3 = 0;
if (puVar5 < (uint *)param_1[1]) {
iVar3 = 0;
do {
uVar7 = *puVar5;
if (uVar7 != 0) goto LAB_0019d885;
puVar5 = puVar5 + 1;
iVar3 = iVar3 + 1;
} while (puVar5 < (uint *)param_1[1]);
}
uVar7 = *puVar5;
if ((uVar7 & ~*(uint *)(param_1 + 3)) == 0) {
iVar3 = -1;
}
else {
LAB_0019d885:
uVar6 = 0;
iVar4 = 0;
if ((char)uVar7 == '\0') {
iVar4 = 0;
pbVar8 = abStack_b;
do {
bVar1 = *pbVar8;
uVar7 = (uint)bVar1;
iVar4 = iVar4 + 8;
pbVar8 = pbVar8 + 1;
} while (bVar1 == 0);
}
do {
uVar2 = uVar6 & 0x1f;
uVar6 = uVar6 + 1;
} while (((uVar7 & 0xff) >> uVar2 & 1) == 0);
iVar3 = uVar6 + iVar4 + iVar3 * 0x20 + -1;
}
return iVar3;
}
|
|
8,153 |
safe_hash_free
|
eloqsql/mysys/my_safehash.c
|
void safe_hash_free(SAFE_HASH *hash)
{
/*
Test if safe_hash_init succeeded. This will also guard us against multiple
free calls.
*/
if (hash->default_value)
{
my_hash_free(&hash->hash);
mysql_rwlock_destroy(&hash->mutex);
hash->default_value=0;
}
}
|
O3
|
c
|
safe_hash_free:
cmpq $0x0, 0x108(%rdi)
je 0xad921
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x98, %rdi
callq 0x98acd
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
jne 0xad922
movq %rbx, %rdi
callq 0xab72c
movq $0x0, 0x108(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2e31ef(%rip), %rax # 0x390b18
movq (%rax), %rax
callq *0x58(%rax)
movq $0x0, 0x90(%rbx)
jmp 0xad908
|
safe_hash_free:
cmp qword ptr [rdi+108h], 0
jz short locret_AD921
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
add rdi, 98h
call my_hash_free
mov rdi, [rbx+90h]
test rdi, rdi
jnz short loc_AD922
loc_AD908:
mov rdi, rbx
call my_rw_destroy
mov qword ptr [rbx+108h], 0
add rsp, 8
pop rbx
pop rbp
locret_AD921:
retn
loc_AD922:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+58h]
mov qword ptr [rbx+90h], 0
jmp short loc_AD908
|
long long safe_hash_free(long long a1)
{
long long v2; // rdi
long long result; // rax
if ( *(_QWORD *)(a1 + 264) )
{
my_hash_free(a1 + 152);
v2 = *(_QWORD *)(a1 + 144);
if ( v2 )
{
((void ( *)(long long))PSI_server[11])(v2);
*(_QWORD *)(a1 + 144) = 0LL;
}
result = my_rw_destroy(a1);
*(_QWORD *)(a1 + 264) = 0LL;
}
return result;
}
|
safe_hash_free:
CMP qword ptr [RDI + 0x108],0x0
JZ 0x001ad921
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
ADD RDI,0x98
CALL 0x00198acd
MOV RDI,qword ptr [RBX + 0x90]
TEST RDI,RDI
JNZ 0x001ad922
LAB_001ad908:
MOV RDI,RBX
CALL 0x001ab72c
MOV qword ptr [RBX + 0x108],0x0
ADD RSP,0x8
POP RBX
POP RBP
LAB_001ad921:
RET
LAB_001ad922:
LEA RAX,[0x490b18]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x58]
MOV qword ptr [RBX + 0x90],0x0
JMP 0x001ad908
|
void safe_hash_free(long param_1)
{
if (*(long *)(param_1 + 0x108) != 0) {
my_hash_free(param_1 + 0x98);
if (*(long *)(param_1 + 0x90) != 0) {
(**(code **)(PSI_server + 0x58))();
*(int8 *)(param_1 + 0x90) = 0;
}
my_rw_destroy(param_1);
*(int8 *)(param_1 + 0x108) = 0;
}
return;
}
|
|
8,154 |
mariadb_reconnect
|
eloqsql/libmariadb/libmariadb/mariadb_lib.c
|
my_bool STDCALL mariadb_reconnect(MYSQL *mysql)
{
MYSQL tmp_mysql;
struct my_hook_data hook_data;
struct mysql_async_context *ctxt= NULL;
LIST *li_stmt= mysql->stmts;
/* check if connection handler is active */
if (IS_CONNHDLR_ACTIVE(mysql))
{
if (mysql->extension->conn_hdlr->plugin && mysql->extension->conn_hdlr->plugin->reconnect)
return(mysql->extension->conn_hdlr->plugin->reconnect(mysql));
}
if (!mysql->options.reconnect ||
(mysql->server_status & SERVER_STATUS_IN_TRANS) || !mysql->host_info)
{
/* Allow reconnect next time */
mysql->server_status&= ~SERVER_STATUS_IN_TRANS;
my_set_error(mysql, CR_SERVER_GONE_ERROR, SQLSTATE_UNKNOWN, 0);
return(1);
}
mysql_init(&tmp_mysql);
tmp_mysql.free_me= 0;
tmp_mysql.options=mysql->options;
if (mysql->extension->conn_hdlr)
{
tmp_mysql.extension->conn_hdlr= mysql->extension->conn_hdlr;
mysql->extension->conn_hdlr= 0;
}
/* don't reread options from configuration files */
tmp_mysql.options.my_cnf_group= tmp_mysql.options.my_cnf_file= NULL;
if (IS_MYSQL_ASYNC_ACTIVE(mysql))
{
ctxt= mysql->options.extension->async_context;
hook_data.orig_mysql= mysql;
hook_data.new_mysql= &tmp_mysql;
hook_data.orig_pvio= mysql->net.pvio;
my_context_install_suspend_resume_hook(ctxt, my_suspend_hook, &hook_data);
}
if (!mysql_real_connect(&tmp_mysql,mysql->host,mysql->user,mysql->passwd,
mysql->db, mysql->port, mysql->unix_socket,
mysql->client_flag | CLIENT_REMEMBER_OPTIONS) ||
mysql_set_character_set(&tmp_mysql, mysql->charset->csname))
{
if (ctxt)
my_context_install_suspend_resume_hook(ctxt, NULL, NULL);
/* don't free options (CONC-118) */
memset(&tmp_mysql.options, 0, sizeof(struct st_mysql_options));
my_set_error(mysql, tmp_mysql.net.last_errno,
tmp_mysql.net.sqlstate,
tmp_mysql.net.last_error);
mysql_close(&tmp_mysql);
return(1);
}
for (;li_stmt;li_stmt= li_stmt->next)
{
MYSQL_STMT *stmt= (MYSQL_STMT *)li_stmt->data;
if (stmt->state != MYSQL_STMT_INITTED)
{
stmt->state= MYSQL_STMT_INITTED;
SET_CLIENT_STMT_ERROR(stmt, CR_SERVER_LOST, SQLSTATE_UNKNOWN, 0);
}
}
tmp_mysql.free_me= mysql->free_me;
tmp_mysql.stmts= mysql->stmts;
mysql->stmts= NULL;
if (ctxt)
my_context_install_suspend_resume_hook(ctxt, NULL, NULL);
/* Don't free options, we moved them to tmp_mysql */
memset(&mysql->options, 0, sizeof(mysql->options));
mysql->free_me=0;
mysql_close(mysql);
*mysql=tmp_mysql;
mysql->net.pvio->mysql= mysql;
#ifdef HAVE_TLS
/* CONC-604: Set new connection handle */
if (mysql_get_ssl_cipher(mysql))
ma_pvio_tls_set_connection(mysql);
#endif
ma_net_clear(&mysql->net);
mysql->affected_rows= ~(unsigned long long) 0;
mysql->info= 0;
return(0);
}
|
O0
|
c
|
mariadb_reconnect:
pushq %rbp
movq %rsp, %rbp
subq $0x560, %rsp # imm = 0x560
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x510(%rbp)
movq $0x0, -0x530(%rbp)
movq -0x510(%rbp), %rax
movq 0x4c8(%rax), %rax
movq %rax, -0x538(%rbp)
movq -0x510(%rbp), %rax
cmpq $0x0, 0x4f0(%rax)
je 0x31144
movq -0x510(%rbp), %rax
movq 0x4f0(%rax), %rax
cmpq $0x0, (%rax)
je 0x31144
movq -0x510(%rbp), %rax
movq 0x4f0(%rax), %rax
movq (%rax), %rax
cmpq $0x0, (%rax)
je 0x31142
movq -0x510(%rbp), %rax
movq 0x4f0(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpq $0x0, 0x78(%rax)
je 0x31142
movq -0x510(%rbp), %rax
movq 0x4f0(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x78(%rax), %rax
movq -0x510(%rbp), %rdi
callq *%rax
movb %al, -0x501(%rbp)
jmp 0x315ed
jmp 0x31144
movq -0x510(%rbp), %rax
cmpb $0x0, 0x43b(%rax)
je 0x3117a
movq -0x510(%rbp), %rax
movl 0x380(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x3117a
movq -0x510(%rbp), %rax
cmpq $0x0, 0x2d8(%rax)
jne 0x311bd
movq -0x510(%rbp), %rax
movl 0x380(%rax), %ecx
andl $-0x2, %ecx
movl %ecx, 0x380(%rax)
movq -0x510(%rbp), %rdi
leaq 0x4fd02(%rip), %rax # 0x80ea0
movq (%rax), %rdx
movl $0x7d6, %esi # imm = 0x7D6
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x307d0
movb $0x1, -0x501(%rbp)
jmp 0x315ed
leaq -0x500(%rbp), %rdi
callq 0x35120
movb $0x0, -0x74(%rbp)
leaq -0x500(%rbp), %rdi
addq $0x390, %rdi # imm = 0x390
movq -0x510(%rbp), %rsi
addq $0x390, %rsi # imm = 0x390
movl $0xf8, %edx
callq 0x14370
movq -0x510(%rbp), %rax
movq 0x4f0(%rax), %rax
cmpq $0x0, (%rax)
je 0x31234
movq -0x510(%rbp), %rax
movq 0x4f0(%rax), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x510(%rbp), %rax
movq 0x4f0(%rax), %rax
movq $0x0, (%rax)
movq $0x0, -0x120(%rbp)
movq $0x0, -0x118(%rbp)
movq -0x510(%rbp), %rax
cmpq $0x0, 0x480(%rax)
je 0x312ef
movq -0x510(%rbp), %rax
movq 0x480(%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0x312ef
movq -0x510(%rbp), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movsbl 0x14(%rax), %eax
cmpl $0x0, %eax
je 0x312ef
movq -0x510(%rbp), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x530(%rbp)
movq -0x510(%rbp), %rax
movq %rax, -0x528(%rbp)
leaq -0x500(%rbp), %rax
movq %rax, -0x520(%rbp)
movq -0x510(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x518(%rbp)
movq -0x530(%rbp), %rdi
leaq 0x6d8d(%rip), %rsi # 0x38070
leaq -0x528(%rbp), %rdx
callq 0x522f0
movq -0x510(%rbp), %rax
movq 0x2b0(%rax), %rsi
movq -0x510(%rbp), %rax
movq 0x2b8(%rax), %rdx
movq -0x510(%rbp), %rax
movq 0x2c0(%rax), %rcx
movq -0x510(%rbp), %rax
movq 0x2e8(%rax), %r8
movq -0x510(%rbp), %rax
movl 0x360(%rax), %r9d
movq -0x510(%rbp), %rax
movq 0x2c8(%rax), %r10
movq -0x510(%rbp), %rdi
movabsq $0x80000000, %rax # imm = 0x80000000
orq 0x368(%rdi), %rax
leaq -0x500(%rbp), %rdi
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x355f0
cmpq $0x0, %rax
je 0x31399
movq -0x510(%rbp), %rax
movq 0x2f0(%rax), %rax
movq 0x8(%rax), %rsi
leaq -0x500(%rbp), %rdi
callq 0x380d0
cmpl $0x0, %eax
je 0x31418
cmpq $0x0, -0x530(%rbp)
je 0x313b6
movq -0x530(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x522f0
leaq -0x500(%rbp), %rdi
addq $0x390, %rdi # imm = 0x390
xorl %esi, %esi
movl $0xf8, %edx
callq 0x14260
movq -0x510(%rbp), %rdi
movl -0x470(%rbp), %esi
leaq -0x500(%rbp), %rdx
addq $0x297, %rdx # imm = 0x297
leaq -0x500(%rbp), %rcx
addq $0x97, %rcx
movb $0x0, %al
callq 0x307d0
leaq -0x500(%rbp), %rdi
callq 0x381f0
movb $0x1, -0x501(%rbp)
jmp 0x315ed
jmp 0x3141a
cmpq $0x0, -0x538(%rbp)
je 0x314e6
movq -0x538(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x540(%rbp)
movq -0x540(%rbp), %rax
cmpl $0x0, 0x50(%rax)
je 0x314cd
movq -0x540(%rbp), %rax
movl $0x0, 0x50(%rax)
movq -0x540(%rbp), %rax
movl $0x7dd, 0x108(%rax) # imm = 0x7DD
movq -0x540(%rbp), %rdi
addq $0x30d, %rdi # imm = 0x30D
leaq 0x4fa21(%rip), %rax # 0x80ea0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x14220
movq -0x540(%rbp), %rax
movb $0x0, 0x312(%rax)
movq -0x540(%rbp), %rdi
addq $0x10c, %rdi # imm = 0x10C
leaq 0x4fa01(%rip), %rax # 0x80eb0
movq 0x68(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x14220
movq -0x540(%rbp), %rax
movb $0x0, 0x30b(%rax)
jmp 0x314cd
jmp 0x314cf
movq -0x538(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x538(%rbp)
jmp 0x3141a
movq -0x510(%rbp), %rax
movb 0x48c(%rax), %al
movb %al, -0x74(%rbp)
movq -0x510(%rbp), %rax
movq 0x4c8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x510(%rbp), %rax
movq $0x0, 0x4c8(%rax)
cmpq $0x0, -0x530(%rbp)
je 0x31537
movq -0x530(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x522f0
movq -0x510(%rbp), %rdi
addq $0x390, %rdi # imm = 0x390
xorl %esi, %esi
movl $0xf8, %edx
callq 0x14260
movq -0x510(%rbp), %rax
movb $0x0, 0x48c(%rax)
movq -0x510(%rbp), %rdi
callq 0x381f0
movq -0x510(%rbp), %rdi
leaq -0x500(%rbp), %rsi
movl $0x4f8, %edx # imm = 0x4F8
callq 0x14370
movq -0x510(%rbp), %rcx
movq -0x510(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x40(%rax)
movq -0x510(%rbp), %rdi
callq 0x35420
cmpq $0x0, %rax
je 0x315b6
movq -0x510(%rbp), %rdi
callq 0x3f040
movq -0x510(%rbp), %rdi
callq 0x602e0
movq -0x510(%rbp), %rax
movq $-0x1, 0x338(%rax)
movq -0x510(%rbp), %rax
movq $0x0, 0x2e0(%rax)
movb $0x0, -0x501(%rbp)
movb -0x501(%rbp), %al
movb %al, -0x541(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x3161a
movb -0x541(%rbp), %al
addq $0x560, %rsp # imm = 0x560
popq %rbp
retq
callq 0x144c0
nop
|
mariadb_reconnect:
push rbp
mov rbp, rsp
sub rsp, 560h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_510], rdi
mov [rbp+var_530], 0
mov rax, [rbp+var_510]
mov rax, [rax+4C8h]
mov [rbp+var_538], rax
mov rax, [rbp+var_510]
cmp qword ptr [rax+4F0h], 0
jz short loc_31144
mov rax, [rbp+var_510]
mov rax, [rax+4F0h]
cmp qword ptr [rax], 0
jz short loc_31144
mov rax, [rbp+var_510]
mov rax, [rax+4F0h]
mov rax, [rax]
cmp qword ptr [rax], 0
jz short loc_31142
mov rax, [rbp+var_510]
mov rax, [rax+4F0h]
mov rax, [rax]
mov rax, [rax]
cmp qword ptr [rax+78h], 0
jz short loc_31142
mov rax, [rbp+var_510]
mov rax, [rax+4F0h]
mov rax, [rax]
mov rax, [rax]
mov rax, [rax+78h]
mov rdi, [rbp+var_510]
call rax
mov [rbp+var_501], al
jmp loc_315ED
loc_31142:
jmp short $+2
loc_31144:
mov rax, [rbp+var_510]
cmp byte ptr [rax+43Bh], 0
jz short loc_3117A
mov rax, [rbp+var_510]
mov eax, [rax+380h]
and eax, 1
cmp eax, 0
jnz short loc_3117A
mov rax, [rbp+var_510]
cmp qword ptr [rax+2D8h], 0
jnz short loc_311BD
loc_3117A:
mov rax, [rbp+var_510]
mov ecx, [rax+380h]
and ecx, 0FFFFFFFEh
mov [rax+380h], ecx
mov rdi, [rbp+var_510]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov esi, 7D6h
xor eax, eax
mov ecx, eax
mov al, 0
call my_set_error
mov [rbp+var_501], 1
jmp loc_315ED
loc_311BD:
lea rdi, [rbp+var_500]
call mysql_init
mov [rbp+var_74], 0
lea rdi, [rbp+var_500]
add rdi, 390h
mov rsi, [rbp+var_510]
add rsi, 390h
mov edx, 0F8h
call _memcpy
mov rax, [rbp+var_510]
mov rax, [rax+4F0h]
cmp qword ptr [rax], 0
jz short loc_31234
mov rax, [rbp+var_510]
mov rax, [rax+4F0h]
mov rcx, [rax]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rax, [rbp+var_510]
mov rax, [rax+4F0h]
mov qword ptr [rax], 0
loc_31234:
mov [rbp+var_120], 0
mov [rbp+var_118], 0
mov rax, [rbp+var_510]
cmp qword ptr [rax+480h], 0
jz loc_312EF
mov rax, [rbp+var_510]
mov rax, [rax+480h]
cmp qword ptr [rax+28h], 0
jz short loc_312EF
mov rax, [rbp+var_510]
mov rax, [rax+480h]
mov rax, [rax+28h]
movsx eax, byte ptr [rax+14h]
cmp eax, 0
jz short loc_312EF
mov rax, [rbp+var_510]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_530], rax
mov rax, [rbp+var_510]
mov [rbp+var_528], rax
lea rax, [rbp+var_500]
mov [rbp+var_520], rax
mov rax, [rbp+var_510]
mov rax, [rax]
mov [rbp+var_518], rax
mov rdi, [rbp+var_530]
lea rsi, my_suspend_hook
lea rdx, [rbp+var_528]
call my_context_install_suspend_resume_hook
loc_312EF:
mov rax, [rbp+var_510]
mov rsi, [rax+2B0h]
mov rax, [rbp+var_510]
mov rdx, [rax+2B8h]
mov rax, [rbp+var_510]
mov rcx, [rax+2C0h]
mov rax, [rbp+var_510]
mov r8, [rax+2E8h]
mov rax, [rbp+var_510]
mov r9d, [rax+360h]
mov rax, [rbp+var_510]
mov r10, [rax+2C8h]
mov rdi, [rbp+var_510]
mov rax, 80000000h
or rax, [rdi+368h]
lea rdi, [rbp+var_500]
mov [rsp+560h+var_560], r10
mov [rsp+560h+var_558], rax
call mysql_real_connect
cmp rax, 0
jz short loc_31399
mov rax, [rbp+var_510]
mov rax, [rax+2F0h]
mov rsi, [rax+8]
lea rdi, [rbp+var_500]
call mysql_set_character_set
cmp eax, 0
jz short loc_31418
loc_31399:
cmp [rbp+var_530], 0
jz short loc_313B6
mov rdi, [rbp+var_530]
xor eax, eax
mov edx, eax
mov rsi, rdx
call my_context_install_suspend_resume_hook
loc_313B6:
lea rdi, [rbp+var_500]
add rdi, 390h
xor esi, esi
mov edx, 0F8h
call _memset
mov rdi, [rbp+var_510]
mov esi, [rbp+var_470]
lea rdx, [rbp+var_500]
add rdx, 297h
lea rcx, [rbp+var_500]
add rcx, 97h
mov al, 0
call my_set_error
lea rdi, [rbp+var_500]
call mysql_close
mov [rbp+var_501], 1
jmp loc_315ED
loc_31418:
jmp short $+2
loc_3141A:
cmp [rbp+var_538], 0
jz loc_314E6
mov rax, [rbp+var_538]
mov rax, [rax+10h]
mov [rbp+var_540], rax
mov rax, [rbp+var_540]
cmp dword ptr [rax+50h], 0
jz loc_314CD
mov rax, [rbp+var_540]
mov dword ptr [rax+50h], 0
mov rax, [rbp+var_540]
mov dword ptr [rax+108h], 7DDh
mov rdi, [rbp+var_540]
add rdi, 30Dh
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_540]
mov byte ptr [rax+312h], 0
mov rdi, [rbp+var_540]
add rdi, 10Ch
lea rax, client_errors
mov rsi, [rax+68h]
mov edx, 200h
call _strncpy
mov rax, [rbp+var_540]
mov byte ptr [rax+30Bh], 0
jmp short $+2
loc_314CD:
jmp short $+2
loc_314CF:
mov rax, [rbp+var_538]
mov rax, [rax+8]
mov [rbp+var_538], rax
jmp loc_3141A
loc_314E6:
mov rax, [rbp+var_510]
mov al, [rax+48Ch]
mov [rbp+var_74], al
mov rax, [rbp+var_510]
mov rax, [rax+4C8h]
mov [rbp+var_38], rax
mov rax, [rbp+var_510]
mov qword ptr [rax+4C8h], 0
cmp [rbp+var_530], 0
jz short loc_31537
mov rdi, [rbp+var_530]
xor eax, eax
mov edx, eax
mov rsi, rdx
call my_context_install_suspend_resume_hook
loc_31537:
mov rdi, [rbp+var_510]
add rdi, 390h
xor esi, esi
mov edx, 0F8h
call _memset
mov rax, [rbp+var_510]
mov byte ptr [rax+48Ch], 0
mov rdi, [rbp+var_510]
call mysql_close
mov rdi, [rbp+var_510]
lea rsi, [rbp+var_500]
mov edx, 4F8h
call _memcpy
mov rcx, [rbp+var_510]
mov rax, [rbp+var_510]
mov rax, [rax]
mov [rax+40h], rcx
mov rdi, [rbp+var_510]
call mysql_get_ssl_cipher
cmp rax, 0
jz short loc_315B6
mov rdi, [rbp+var_510]
call ma_pvio_tls_set_connection
loc_315B6:
mov rdi, [rbp+var_510]
call ma_net_clear
mov rax, [rbp+var_510]
mov qword ptr [rax+338h], 0FFFFFFFFFFFFFFFFh
mov rax, [rbp+var_510]
mov qword ptr [rax+2E0h], 0
mov [rbp+var_501], 0
loc_315ED:
mov al, [rbp+var_501]
mov [rbp+var_541], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_3161A
mov al, [rbp+var_541]
add rsp, 560h
pop rbp
retn
loc_3161A:
call ___stack_chk_fail
|
char mariadb_reconnect(long long a1)
{
long long v2; // [rsp+20h] [rbp-540h]
long long v3; // [rsp+28h] [rbp-538h]
long long v4; // [rsp+30h] [rbp-530h]
_QWORD v5[3]; // [rsp+38h] [rbp-528h] BYREF
long long v6; // [rsp+50h] [rbp-510h]
_BYTE v8[144]; // [rsp+60h] [rbp-500h] BYREF
unsigned int v9; // [rsp+F0h] [rbp-470h]
char v10; // [rsp+F7h] [rbp-469h] BYREF
char v11; // [rsp+2F7h] [rbp-269h] BYREF
_QWORD v12[31]; // [rsp+3F0h] [rbp-170h] BYREF
char v13; // [rsp+4ECh] [rbp-74h]
long long v14; // [rsp+528h] [rbp-38h]
_QWORD *v15; // [rsp+550h] [rbp-10h]
unsigned long long v16; // [rsp+558h] [rbp-8h]
v16 = __readfsqword(0x28u);
v6 = a1;
v4 = 0LL;
v3 = *(_QWORD *)(a1 + 1224);
if ( *(_QWORD *)(a1 + 1264)
&& **(_QWORD **)(v6 + 1264)
&& ***(_QWORD ***)(v6 + 1264)
&& *(_QWORD *)(***(_QWORD ***)(v6 + 1264) + 120LL) )
{
return (*(long long ( **)(long long))(***(_QWORD ***)(v6 + 1264) + 120LL))(v6);
}
if ( *(_BYTE *)(v6 + 1083) && (*(_DWORD *)(v6 + 896) & 1) == 0 && *(_QWORD *)(v6 + 728) )
{
mysql_init(v8);
v13 = 0;
memcpy(v12, v6 + 912, sizeof(v12));
if ( **(_QWORD **)(v6 + 1264) )
{
*v15 = **(_QWORD **)(v6 + 1264);
**(_QWORD **)(v6 + 1264) = 0LL;
}
v12[10] = 0LL;
v12[11] = 0LL;
if ( *(_QWORD *)(v6 + 1152)
&& *(_QWORD *)(*(_QWORD *)(v6 + 1152) + 40LL)
&& *(_BYTE *)(*(_QWORD *)(*(_QWORD *)(v6 + 1152) + 40LL) + 20LL) )
{
v4 = *(_QWORD *)(*(_QWORD *)(v6 + 1152) + 40LL);
v5[0] = v6;
v5[1] = v8;
v5[2] = *(_QWORD *)v6;
my_context_install_suspend_resume_hook(v4, my_suspend_hook, v5);
}
if ( mysql_real_connect(
(unsigned int)v8,
*(_QWORD *)(v6 + 688),
*(_QWORD *)(v6 + 696),
*(_QWORD *)(v6 + 704),
*(_QWORD *)(v6 + 744),
*(_DWORD *)(v6 + 864),
*(_QWORD *)(v6 + 712),
*(_QWORD *)(v6 + 872) | 0x80000000LL)
&& !(unsigned int)mysql_set_character_set(v8, *(_QWORD *)(*(_QWORD *)(v6 + 752) + 8LL)) )
{
while ( v3 )
{
v2 = *(_QWORD *)(v3 + 16);
if ( *(_DWORD *)(v2 + 80) )
{
*(_DWORD *)(v2 + 80) = 0;
*(_DWORD *)(v2 + 264) = 2013;
strncpy(v2 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(v2 + 786) = 0;
strncpy(v2 + 268, client_errors[13], 512LL);
*(_BYTE *)(v2 + 779) = 0;
}
v3 = *(_QWORD *)(v3 + 8);
}
v13 = *(_BYTE *)(v6 + 1164);
v14 = *(_QWORD *)(v6 + 1224);
*(_QWORD *)(v6 + 1224) = 0LL;
if ( v4 )
my_context_install_suspend_resume_hook(v4, 0LL, 0LL);
memset(v6 + 912, 0LL, 248LL);
*(_BYTE *)(v6 + 1164) = 0;
mysql_close(v6);
memcpy(v6, v8, 1272LL);
*(_QWORD *)(*(_QWORD *)v6 + 64LL) = v6;
if ( mysql_get_ssl_cipher(v6) )
ma_pvio_tls_set_connection(v6);
ma_net_clear(v6);
*(_QWORD *)(v6 + 824) = -1LL;
*(_QWORD *)(v6 + 736) = 0LL;
return 0;
}
else
{
if ( v4 )
my_context_install_suspend_resume_hook(v4, 0LL, 0LL);
memset(v12, 0LL, sizeof(v12));
my_set_error(v6, v9, (long long)&v11, (long long)&v10);
mysql_close(v8);
return 1;
}
}
else
{
*(_DWORD *)(v6 + 896) &= ~1u;
my_set_error(v6, 0x7D6u, (long long)SQLSTATE_UNKNOWN, 0LL);
return 1;
}
}
|
mariadb_reconnect:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x560
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x510],RDI
MOV qword ptr [RBP + -0x530],0x0
MOV RAX,qword ptr [RBP + -0x510]
MOV RAX,qword ptr [RAX + 0x4c8]
MOV qword ptr [RBP + -0x538],RAX
MOV RAX,qword ptr [RBP + -0x510]
CMP qword ptr [RAX + 0x4f0],0x0
JZ 0x00131144
MOV RAX,qword ptr [RBP + -0x510]
MOV RAX,qword ptr [RAX + 0x4f0]
CMP qword ptr [RAX],0x0
JZ 0x00131144
MOV RAX,qword ptr [RBP + -0x510]
MOV RAX,qword ptr [RAX + 0x4f0]
MOV RAX,qword ptr [RAX]
CMP qword ptr [RAX],0x0
JZ 0x00131142
MOV RAX,qword ptr [RBP + -0x510]
MOV RAX,qword ptr [RAX + 0x4f0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX]
CMP qword ptr [RAX + 0x78],0x0
JZ 0x00131142
MOV RAX,qword ptr [RBP + -0x510]
MOV RAX,qword ptr [RAX + 0x4f0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x78]
MOV RDI,qword ptr [RBP + -0x510]
CALL RAX
MOV byte ptr [RBP + -0x501],AL
JMP 0x001315ed
LAB_00131142:
JMP 0x00131144
LAB_00131144:
MOV RAX,qword ptr [RBP + -0x510]
CMP byte ptr [RAX + 0x43b],0x0
JZ 0x0013117a
MOV RAX,qword ptr [RBP + -0x510]
MOV EAX,dword ptr [RAX + 0x380]
AND EAX,0x1
CMP EAX,0x0
JNZ 0x0013117a
MOV RAX,qword ptr [RBP + -0x510]
CMP qword ptr [RAX + 0x2d8],0x0
JNZ 0x001311bd
LAB_0013117a:
MOV RAX,qword ptr [RBP + -0x510]
MOV ECX,dword ptr [RAX + 0x380]
AND ECX,0xfffffffe
MOV dword ptr [RAX + 0x380],ECX
MOV RDI,qword ptr [RBP + -0x510]
LEA RAX,[0x180ea0]
MOV RDX,qword ptr [RAX]
MOV ESI,0x7d6
XOR EAX,EAX
MOV ECX,EAX
MOV AL,0x0
CALL 0x001307d0
MOV byte ptr [RBP + -0x501],0x1
JMP 0x001315ed
LAB_001311bd:
LEA RDI,[RBP + -0x500]
CALL 0x00135120
MOV byte ptr [RBP + -0x74],0x0
LEA RDI,[RBP + -0x500]
ADD RDI,0x390
MOV RSI,qword ptr [RBP + -0x510]
ADD RSI,0x390
MOV EDX,0xf8
CALL 0x00114370
MOV RAX,qword ptr [RBP + -0x510]
MOV RAX,qword ptr [RAX + 0x4f0]
CMP qword ptr [RAX],0x0
JZ 0x00131234
MOV RAX,qword ptr [RBP + -0x510]
MOV RAX,qword ptr [RAX + 0x4f0]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x510]
MOV RAX,qword ptr [RAX + 0x4f0]
MOV qword ptr [RAX],0x0
LAB_00131234:
MOV qword ptr [RBP + -0x120],0x0
MOV qword ptr [RBP + -0x118],0x0
MOV RAX,qword ptr [RBP + -0x510]
CMP qword ptr [RAX + 0x480],0x0
JZ 0x001312ef
MOV RAX,qword ptr [RBP + -0x510]
MOV RAX,qword ptr [RAX + 0x480]
CMP qword ptr [RAX + 0x28],0x0
JZ 0x001312ef
MOV RAX,qword ptr [RBP + -0x510]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOVSX EAX,byte ptr [RAX + 0x14]
CMP EAX,0x0
JZ 0x001312ef
MOV RAX,qword ptr [RBP + -0x510]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x530],RAX
MOV RAX,qword ptr [RBP + -0x510]
MOV qword ptr [RBP + -0x528],RAX
LEA RAX,[RBP + -0x500]
MOV qword ptr [RBP + -0x520],RAX
MOV RAX,qword ptr [RBP + -0x510]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x518],RAX
MOV RDI,qword ptr [RBP + -0x530]
LEA RSI,[0x138070]
LEA RDX,[RBP + -0x528]
CALL 0x001522f0
LAB_001312ef:
MOV RAX,qword ptr [RBP + -0x510]
MOV RSI,qword ptr [RAX + 0x2b0]
MOV RAX,qword ptr [RBP + -0x510]
MOV RDX,qword ptr [RAX + 0x2b8]
MOV RAX,qword ptr [RBP + -0x510]
MOV RCX,qword ptr [RAX + 0x2c0]
MOV RAX,qword ptr [RBP + -0x510]
MOV R8,qword ptr [RAX + 0x2e8]
MOV RAX,qword ptr [RBP + -0x510]
MOV R9D,dword ptr [RAX + 0x360]
MOV RAX,qword ptr [RBP + -0x510]
MOV R10,qword ptr [RAX + 0x2c8]
MOV RDI,qword ptr [RBP + -0x510]
MOV RAX,0x80000000
OR RAX,qword ptr [RDI + 0x368]
LEA RDI,[RBP + -0x500]
MOV qword ptr [RSP],R10
MOV qword ptr [RSP + 0x8],RAX
CALL 0x001355f0
CMP RAX,0x0
JZ 0x00131399
MOV RAX,qword ptr [RBP + -0x510]
MOV RAX,qword ptr [RAX + 0x2f0]
MOV RSI,qword ptr [RAX + 0x8]
LEA RDI,[RBP + -0x500]
CALL 0x001380d0
CMP EAX,0x0
JZ 0x00131418
LAB_00131399:
CMP qword ptr [RBP + -0x530],0x0
JZ 0x001313b6
MOV RDI,qword ptr [RBP + -0x530]
XOR EAX,EAX
MOV EDX,EAX
MOV RSI,RDX
CALL 0x001522f0
LAB_001313b6:
LEA RDI,[RBP + -0x500]
ADD RDI,0x390
XOR ESI,ESI
MOV EDX,0xf8
CALL 0x00114260
MOV RDI,qword ptr [RBP + -0x510]
MOV ESI,dword ptr [RBP + -0x470]
LEA RDX,[RBP + -0x500]
ADD RDX,0x297
LEA RCX,[RBP + -0x500]
ADD RCX,0x97
MOV AL,0x0
CALL 0x001307d0
LEA RDI,[RBP + -0x500]
CALL 0x001381f0
MOV byte ptr [RBP + -0x501],0x1
JMP 0x001315ed
LAB_00131418:
JMP 0x0013141a
LAB_0013141a:
CMP qword ptr [RBP + -0x538],0x0
JZ 0x001314e6
MOV RAX,qword ptr [RBP + -0x538]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x540],RAX
MOV RAX,qword ptr [RBP + -0x540]
CMP dword ptr [RAX + 0x50],0x0
JZ 0x001314cd
MOV RAX,qword ptr [RBP + -0x540]
MOV dword ptr [RAX + 0x50],0x0
MOV RAX,qword ptr [RBP + -0x540]
MOV dword ptr [RAX + 0x108],0x7dd
MOV RDI,qword ptr [RBP + -0x540]
ADD RDI,0x30d
LEA RAX,[0x180ea0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00114220
MOV RAX,qword ptr [RBP + -0x540]
MOV byte ptr [RAX + 0x312],0x0
MOV RDI,qword ptr [RBP + -0x540]
ADD RDI,0x10c
LEA RAX,[0x180eb0]
MOV RSI,qword ptr [RAX + 0x68]
MOV EDX,0x200
CALL 0x00114220
MOV RAX,qword ptr [RBP + -0x540]
MOV byte ptr [RAX + 0x30b],0x0
JMP 0x001314cd
LAB_001314cd:
JMP 0x001314cf
LAB_001314cf:
MOV RAX,qword ptr [RBP + -0x538]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x538],RAX
JMP 0x0013141a
LAB_001314e6:
MOV RAX,qword ptr [RBP + -0x510]
MOV AL,byte ptr [RAX + 0x48c]
MOV byte ptr [RBP + -0x74],AL
MOV RAX,qword ptr [RBP + -0x510]
MOV RAX,qword ptr [RAX + 0x4c8]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x510]
MOV qword ptr [RAX + 0x4c8],0x0
CMP qword ptr [RBP + -0x530],0x0
JZ 0x00131537
MOV RDI,qword ptr [RBP + -0x530]
XOR EAX,EAX
MOV EDX,EAX
MOV RSI,RDX
CALL 0x001522f0
LAB_00131537:
MOV RDI,qword ptr [RBP + -0x510]
ADD RDI,0x390
XOR ESI,ESI
MOV EDX,0xf8
CALL 0x00114260
MOV RAX,qword ptr [RBP + -0x510]
MOV byte ptr [RAX + 0x48c],0x0
MOV RDI,qword ptr [RBP + -0x510]
CALL 0x001381f0
MOV RDI,qword ptr [RBP + -0x510]
LEA RSI,[RBP + -0x500]
MOV EDX,0x4f8
CALL 0x00114370
MOV RCX,qword ptr [RBP + -0x510]
MOV RAX,qword ptr [RBP + -0x510]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0x40],RCX
MOV RDI,qword ptr [RBP + -0x510]
CALL 0x00135420
CMP RAX,0x0
JZ 0x001315b6
MOV RDI,qword ptr [RBP + -0x510]
CALL 0x0013f040
LAB_001315b6:
MOV RDI,qword ptr [RBP + -0x510]
CALL 0x001602e0
MOV RAX,qword ptr [RBP + -0x510]
MOV qword ptr [RAX + 0x338],-0x1
MOV RAX,qword ptr [RBP + -0x510]
MOV qword ptr [RAX + 0x2e0],0x0
MOV byte ptr [RBP + -0x501],0x0
LAB_001315ed:
MOV AL,byte ptr [RBP + -0x501]
MOV byte ptr [RBP + -0x541],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0013161a
MOV AL,byte ptr [RBP + -0x541]
ADD RSP,0x560
POP RBP
RET
LAB_0013161a:
CALL 0x001144c0
|
int8 mariadb_reconnect(long *param_1)
{
int iVar1;
long lVar2;
long in_FS_OFFSET;
long local_540;
long local_538;
long *local_530;
int1 *local_528;
long local_520;
long *local_518;
int1 local_509;
int1 local_508 [144];
int4 local_478;
int1 auStack_471 [512];
int1 auStack_271 [249];
int1 auStack_178 [80];
int8 local_128;
int8 local_120;
int1 local_7c;
long local_40;
int8 *local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_538 = 0;
local_540 = param_1[0x99];
local_518 = param_1;
if ((((param_1[0x9e] == 0) || (*(long *)param_1[0x9e] == 0)) || (**(long **)param_1[0x9e] == 0))
|| (*(long *)(**(long **)param_1[0x9e] + 0x78) == 0)) {
if (((*(char *)((long)param_1 + 0x43b) == '\0') || ((*(uint *)(param_1 + 0x70) & 1) != 0)) ||
(param_1[0x5b] == 0)) {
*(uint *)(param_1 + 0x70) = *(uint *)(param_1 + 0x70) & 0xfffffffe;
my_set_error(param_1,0x7d6,SQLSTATE_UNKNOWN,0);
local_509 = 1;
}
else {
mysql_init(local_508);
local_7c = 0;
memcpy(auStack_178,local_518 + 0x72,0xf8);
if (*(long *)local_518[0x9e] != 0) {
*local_18 = *(int8 *)local_518[0x9e];
*(int8 *)local_518[0x9e] = 0;
}
local_128 = 0;
local_120 = 0;
if (((local_518[0x90] != 0) && (*(long *)(local_518[0x90] + 0x28) != 0)) &&
(*(char *)(*(long *)(local_518[0x90] + 0x28) + 0x14) != '\0')) {
local_538 = *(long *)(local_518[0x90] + 0x28);
local_530 = local_518;
local_528 = local_508;
local_520 = *local_518;
my_context_install_suspend_resume_hook(local_538,my_suspend_hook,&local_530);
}
lVar2 = mysql_real_connect(local_508,local_518[0x56],local_518[0x57],local_518[0x58],
local_518[0x5d],(int)local_518[0x6c],local_518[0x59],
local_518[0x6d] | 0x80000000);
if ((lVar2 == 0) || (iVar1 = mysql_set_character_set(local_508), iVar1 != 0)) {
if (local_538 != 0) {
my_context_install_suspend_resume_hook(local_538);
}
memset(auStack_178,0,0xf8);
my_set_error(local_518,local_478,auStack_271,auStack_471);
mysql_close(local_508);
local_509 = 1;
}
else {
for (; local_540 != 0; local_540 = *(long *)(local_540 + 8)) {
lVar2 = *(long *)(local_540 + 0x10);
if (*(int *)(lVar2 + 0x50) != 0) {
*(int4 *)(lVar2 + 0x50) = 0;
*(int4 *)(lVar2 + 0x108) = 0x7dd;
strncpy((char *)(lVar2 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(lVar2 + 0x312) = 0;
strncpy((char *)(lVar2 + 0x10c),PTR_s_Lost_connection_to_server_during_00180f18,0x200);
*(int1 *)(lVar2 + 0x30b) = 0;
}
}
local_7c = *(int1 *)((long)local_518 + 0x48c);
local_40 = local_518[0x99];
local_518[0x99] = 0;
if (local_538 != 0) {
my_context_install_suspend_resume_hook(local_538);
}
memset(local_518 + 0x72,0,0xf8);
*(int1 *)((long)local_518 + 0x48c) = 0;
mysql_close(local_518);
memcpy(local_518,local_508,0x4f8);
*(long **)(*local_518 + 0x40) = local_518;
lVar2 = mysql_get_ssl_cipher(local_518);
if (lVar2 != 0) {
ma_pvio_tls_set_connection(local_518);
}
ma_net_clear(local_518);
local_518[0x67] = -1;
local_518[0x5c] = 0;
local_509 = 0;
}
}
}
else {
local_509 = (**(code **)(**(long **)param_1[0x9e] + 0x78))(param_1);
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),local_509);
}
|
|
8,155 |
mariadb_reconnect
|
eloqsql/libmariadb/libmariadb/mariadb_lib.c
|
my_bool STDCALL mariadb_reconnect(MYSQL *mysql)
{
MYSQL tmp_mysql;
struct my_hook_data hook_data;
struct mysql_async_context *ctxt= NULL;
LIST *li_stmt= mysql->stmts;
/* check if connection handler is active */
if (IS_CONNHDLR_ACTIVE(mysql))
{
if (mysql->extension->conn_hdlr->plugin && mysql->extension->conn_hdlr->plugin->reconnect)
return(mysql->extension->conn_hdlr->plugin->reconnect(mysql));
}
if (!mysql->options.reconnect ||
(mysql->server_status & SERVER_STATUS_IN_TRANS) || !mysql->host_info)
{
/* Allow reconnect next time */
mysql->server_status&= ~SERVER_STATUS_IN_TRANS;
my_set_error(mysql, CR_SERVER_GONE_ERROR, SQLSTATE_UNKNOWN, 0);
return(1);
}
mysql_init(&tmp_mysql);
tmp_mysql.free_me= 0;
tmp_mysql.options=mysql->options;
if (mysql->extension->conn_hdlr)
{
tmp_mysql.extension->conn_hdlr= mysql->extension->conn_hdlr;
mysql->extension->conn_hdlr= 0;
}
/* don't reread options from configuration files */
tmp_mysql.options.my_cnf_group= tmp_mysql.options.my_cnf_file= NULL;
if (IS_MYSQL_ASYNC_ACTIVE(mysql))
{
ctxt= mysql->options.extension->async_context;
hook_data.orig_mysql= mysql;
hook_data.new_mysql= &tmp_mysql;
hook_data.orig_pvio= mysql->net.pvio;
my_context_install_suspend_resume_hook(ctxt, my_suspend_hook, &hook_data);
}
if (!mysql_real_connect(&tmp_mysql,mysql->host,mysql->user,mysql->passwd,
mysql->db, mysql->port, mysql->unix_socket,
mysql->client_flag | CLIENT_REMEMBER_OPTIONS) ||
mysql_set_character_set(&tmp_mysql, mysql->charset->csname))
{
if (ctxt)
my_context_install_suspend_resume_hook(ctxt, NULL, NULL);
/* don't free options (CONC-118) */
memset(&tmp_mysql.options, 0, sizeof(struct st_mysql_options));
my_set_error(mysql, tmp_mysql.net.last_errno,
tmp_mysql.net.sqlstate,
tmp_mysql.net.last_error);
mysql_close(&tmp_mysql);
return(1);
}
for (;li_stmt;li_stmt= li_stmt->next)
{
MYSQL_STMT *stmt= (MYSQL_STMT *)li_stmt->data;
if (stmt->state != MYSQL_STMT_INITTED)
{
stmt->state= MYSQL_STMT_INITTED;
SET_CLIENT_STMT_ERROR(stmt, CR_SERVER_LOST, SQLSTATE_UNKNOWN, 0);
}
}
tmp_mysql.free_me= mysql->free_me;
tmp_mysql.stmts= mysql->stmts;
mysql->stmts= NULL;
if (ctxt)
my_context_install_suspend_resume_hook(ctxt, NULL, NULL);
/* Don't free options, we moved them to tmp_mysql */
memset(&mysql->options, 0, sizeof(mysql->options));
mysql->free_me=0;
mysql_close(mysql);
*mysql=tmp_mysql;
mysql->net.pvio->mysql= mysql;
#ifdef HAVE_TLS
/* CONC-604: Set new connection handle */
if (mysql_get_ssl_cipher(mysql))
ma_pvio_tls_set_connection(mysql);
#endif
ma_net_clear(&mysql->net);
mysql->affected_rows= ~(unsigned long long) 0;
mysql->info= 0;
return(0);
}
|
O3
|
c
|
mariadb_reconnect:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x528, %rsp # imm = 0x528
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq 0x4c8(%rdi), %r14
movq 0x4f0(%rdi), %rax
testq %rax, %rax
je 0x273f9
movq (%rax), %rax
testq %rax, %rax
je 0x273f9
movq (%rax), %rax
testq %rax, %rax
je 0x273f9
movq 0x78(%rax), %rax
testq %rax, %rax
je 0x273f9
movq %fs:0x28, %rcx
cmpq -0x30(%rbp), %rcx
jne 0x27712
movq %rbx, %rdi
addq $0x528, %rsp # imm = 0x528
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
cmpb $0x0, 0x43b(%rbx)
setne %cl
movl 0x380(%rbx), %eax
testb $0x1, %al
sete %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x274ca
cmpq $0x0, 0x2d8(%rbx)
je 0x274ca
leaq 0x390(%rbx), %r15
leaq -0x528(%rbp), %r12
movq %r12, %rdi
callq 0x29915
movb $0x0, 0x48c(%r12)
leaq -0x198(%rbp), %rdi
movl $0xf8, %edx
movq %r15, %rsi
callq 0x143a0
movq 0x4f0(%rbx), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x2747e
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
movq 0x4f0(%rbx), %rax
movq $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x148(%rbp)
movq 0x480(%rbx), %rax
testq %rax, %rax
je 0x274f3
movq 0x28(%rax), %r13
testq %r13, %r13
je 0x274f3
cmpb $0x0, 0x14(%r13)
je 0x274f3
leaq -0x550(%rbp), %rdx
movq %rbx, (%rdx)
movq %r12, 0x8(%rdx)
movq (%rbx), %rax
movq %rax, 0x10(%rdx)
leaq 0x408f(%rip), %rsi # 0x2b54f
movq %r13, %rdi
callq 0x3a0cc
jmp 0x274f6
andl $-0x2, %eax
movl %eax, 0x380(%rbx)
leaq 0x3b516(%rip), %rax # 0x629f0
movq (%rax), %rdx
movq %rbx, %rdi
movl $0x7d6, %esi # imm = 0x7D6
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x26e85
jmp 0x275aa
xorl %r13d, %r13d
movq 0x2b0(%rbx), %rsi
movq 0x2b8(%rbx), %rdx
movq 0x2c0(%rbx), %rcx
movq 0x2e8(%rbx), %r8
movl 0x360(%rbx), %r9d
movl $0x80000000, %eax # imm = 0x80000000
orq 0x368(%rbx), %rax
leaq -0x528(%rbp), %rdi
pushq %rax
pushq 0x2c8(%rbx)
callq 0x29c4e
addq $0x10, %rsp
testq %rax, %rax
je 0x2755c
movq 0x2f0(%rbx), %rax
movq 0x8(%rax), %rsi
leaq -0x528(%rbp), %rdi
callq 0x2b577
testl %eax, %eax
je 0x275d1
testq %r13, %r13
je 0x2756d
movq %r13, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3a0cc
movl $0xf8, %edx
leaq -0x198(%rbp), %rdi
xorl %esi, %esi
callq 0x14270
leaq -0x291(%rbp), %rdx
movl -0x207(%rdx), %esi
leaq -0x491(%rbp), %rcx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x26e85
leaq -0x528(%rbp), %rdi
callq 0x2b66c
movb $0x1, %al
movq %fs:0x28, %rcx
cmpq -0x30(%rbp), %rcx
jne 0x27712
addq $0x528, %rsp # imm = 0x528
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, -0x530(%rbp)
movq %r15, -0x538(%rbp)
testq %r14, %r14
je 0x27656
leaq 0x3b405(%rip), %rax # 0x629f0
movq (%rax), %r12
xorl %r13d, %r13d
movq 0x10(%r14), %r15
cmpl $0x0, 0x50(%r15)
je 0x2764d
movl $0x0, 0x50(%r15)
movl $0x7dd, 0x108(%r15) # imm = 0x7DD
leaq 0x30d(%r15), %rdi
movl $0x5, %edx
movq %r12, %rsi
callq 0x14230
movb %r13b, 0x312(%r15)
leaq 0x10c(%r15), %rdi
leaq 0x3b3c8(%rip), %rax # 0x62a00
movq 0x68(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x14230
movb %r13b, 0x30b(%r15)
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x275f1
movb 0x48c(%rbx), %al
movb %al, -0x9c(%rbp)
movq 0x4c8(%rbx), %rax
movq %rax, -0x60(%rbp)
movq $0x0, 0x4c8(%rbx)
movq -0x530(%rbp), %rdi
testq %rdi, %rdi
je 0x2768d
xorl %esi, %esi
xorl %edx, %edx
callq 0x3a0cc
movl $0xf8, %edx
movq -0x538(%rbp), %rdi
xorl %esi, %esi
callq 0x14270
movb $0x0, 0x48c(%rbx)
movq %rbx, %rdi
callq 0x2b66c
leaq -0x528(%rbp), %rsi
movl $0x4f8, %edx # imm = 0x4F8
movq %rbx, %rdi
callq 0x143a0
movq (%rbx), %rax
movq %rbx, 0x40(%rax)
movq (%rbx), %rax
testq %rax, %rax
je 0x276ed
movq 0x38(%rax), %rdi
testq %rdi, %rdi
je 0x276ed
callq 0x2f0ee
testq %rax, %rax
je 0x276ed
movq %rbx, %rdi
callq 0x2f3aa
movq %rbx, %rdi
callq 0x42888
movq $-0x1, 0x338(%rbx)
movq $0x0, 0x2e0(%rbx)
xorl %eax, %eax
jmp 0x275ac
callq 0x14520
|
mariadb_reconnect:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 528h
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov r14, [rdi+4C8h]
mov rax, [rdi+4F0h]
test rax, rax
jz short loc_273F9
mov rax, [rax]
test rax, rax
jz short loc_273F9
mov rax, [rax]
test rax, rax
jz short loc_273F9
mov rax, [rax+78h]
test rax, rax
jz short loc_273F9
mov rcx, fs:28h
cmp rcx, [rbp+var_30]
jnz loc_27712
mov rdi, rbx
add rsp, 528h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp rax
loc_273F9:
cmp byte ptr [rbx+43Bh], 0
setnz cl
mov eax, [rbx+380h]
test al, 1
setz dl
and dl, cl
cmp dl, 1
jnz loc_274CA
cmp qword ptr [rbx+2D8h], 0
jz loc_274CA
lea r15, [rbx+390h]
lea r12, [rbp+var_528]
mov rdi, r12
call mysql_init
mov byte ptr [r12+48Ch], 0
lea rdi, [rbp+var_198]
mov edx, 0F8h
mov rsi, r15
call _memcpy
mov rax, [rbx+4F0h]
mov rax, [rax]
test rax, rax
jz short loc_2747E
mov rcx, [rbp+var_38]
mov [rcx], rax
mov rax, [rbx+4F0h]
mov qword ptr [rax], 0
loc_2747E:
xorps xmm0, xmm0
movups [rbp+var_148], xmm0
mov rax, [rbx+480h]
test rax, rax
jz short loc_274F3
mov r13, [rax+28h]
test r13, r13
jz short loc_274F3
cmp byte ptr [r13+14h], 0
jz short loc_274F3
lea rdx, [rbp+var_550]
mov [rdx], rbx
mov [rdx+8], r12
mov rax, [rbx]
mov [rdx+10h], rax
lea rsi, my_suspend_hook
mov rdi, r13
call my_context_install_suspend_resume_hook
jmp short loc_274F6
loc_274CA:
and eax, 0FFFFFFFEh
mov [rbx+380h], eax
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov rdi, rbx
mov esi, 7D6h
xor ecx, ecx
xor eax, eax
call my_set_error
jmp loc_275AA
loc_274F3:
xor r13d, r13d
loc_274F6:
mov rsi, [rbx+2B0h]
mov rdx, [rbx+2B8h]
mov rcx, [rbx+2C0h]
mov r8, [rbx+2E8h]
mov r9d, [rbx+360h]
mov eax, 80000000h
or rax, [rbx+368h]
lea rdi, [rbp+var_528]
push rax
push qword ptr [rbx+2C8h]
call mysql_real_connect
add rsp, 10h
test rax, rax
jz short loc_2755C
mov rax, [rbx+2F0h]
mov rsi, [rax+8]
lea rdi, [rbp+var_528]
call mysql_set_character_set
test eax, eax
jz short loc_275D1
loc_2755C:
test r13, r13
jz short loc_2756D
mov rdi, r13
xor esi, esi
xor edx, edx
call my_context_install_suspend_resume_hook
loc_2756D:
mov edx, 0F8h
lea rdi, [rbp+var_198]
xor esi, esi
call _memset
lea rdx, [rbp+var_291]
mov esi, [rdx-207h]
lea rcx, [rbp+var_491]
mov rdi, rbx
xor eax, eax
call my_set_error
lea rdi, [rbp+var_528]
call mysql_close
loc_275AA:
mov al, 1
loc_275AC:
mov rcx, fs:28h
cmp rcx, [rbp+var_30]
jnz loc_27712
add rsp, 528h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_275D1:
mov [rbp+var_530], r13
mov [rbp+var_538], r15
test r14, r14
jz short loc_27656
lea rax, SQLSTATE_UNKNOWN
mov r12, [rax]
xor r13d, r13d
loc_275F1:
mov r15, [r14+10h]
cmp dword ptr [r15+50h], 0
jz short loc_2764D
mov dword ptr [r15+50h], 0
mov dword ptr [r15+108h], 7DDh
lea rdi, [r15+30Dh]
mov edx, 5
mov rsi, r12
call _strncpy
mov [r15+312h], r13b
lea rdi, [r15+10Ch]
lea rax, client_errors
mov rsi, [rax+68h]
mov edx, 200h
call _strncpy
mov [r15+30Bh], r13b
loc_2764D:
mov r14, [r14+8]
test r14, r14
jnz short loc_275F1
loc_27656:
mov al, [rbx+48Ch]
mov [rbp+var_9C], al
mov rax, [rbx+4C8h]
mov [rbp+var_60], rax
mov qword ptr [rbx+4C8h], 0
mov rdi, [rbp+var_530]
test rdi, rdi
jz short loc_2768D
xor esi, esi
xor edx, edx
call my_context_install_suspend_resume_hook
loc_2768D:
mov edx, 0F8h
mov rdi, [rbp+var_538]
xor esi, esi
call _memset
mov byte ptr [rbx+48Ch], 0
mov rdi, rbx
call mysql_close
lea rsi, [rbp+var_528]
mov edx, 4F8h
mov rdi, rbx
call _memcpy
mov rax, [rbx]
mov [rax+40h], rbx
mov rax, [rbx]
test rax, rax
jz short loc_276ED
mov rdi, [rax+38h]
test rdi, rdi
jz short loc_276ED
call ma_pvio_tls_cipher
test rax, rax
jz short loc_276ED
mov rdi, rbx
call ma_pvio_tls_set_connection
loc_276ED:
mov rdi, rbx
call ma_net_clear
mov qword ptr [rbx+338h], 0FFFFFFFFFFFFFFFFh
mov qword ptr [rbx+2E0h], 0
xor eax, eax
jmp loc_275AC
loc_27712:
call ___stack_chk_fail
|
char mariadb_reconnect(_QWORD *a1, long long a2, long long a3)
{
long long v3; // r14
long long **v4; // rax
long long *v5; // rax
long long v6; // rax
long long ( *v7)(_QWORD *, long long, long long, unsigned long long); // rax
int v9; // eax
long long v10; // rax
long long v11; // rax
long long v12; // r13
long long v13; // rcx
long long v14; // r8
long long v15; // r9
char *v16; // r12
long long v17; // r15
_QWORD *v18; // [rsp+0h] [rbp-550h]
_BYTE *v19; // [rsp+8h] [rbp-548h]
long long v20; // [rsp+10h] [rbp-540h]
_BYTE v21[144]; // [rsp+28h] [rbp-528h] BYREF
int v22; // [rsp+B8h] [rbp-498h]
char v23[512]; // [rsp+BFh] [rbp-491h] BYREF
_BYTE v24[249]; // [rsp+2BFh] [rbp-291h] BYREF
_BYTE v25[80]; // [rsp+3B8h] [rbp-198h] BYREF
__int128 v26; // [rsp+408h] [rbp-148h]
char v27; // [rsp+4B4h] [rbp-9Ch]
long long v28; // [rsp+4F0h] [rbp-60h]
_QWORD *v29; // [rsp+518h] [rbp-38h]
unsigned long long v30; // [rsp+520h] [rbp-30h]
v30 = __readfsqword(0x28u);
v3 = a1[153];
v4 = (long long **)a1[158];
if ( v4 )
{
v5 = *v4;
if ( v5 )
{
v6 = *v5;
if ( v6 )
{
v7 = *(long long ( **)(_QWORD *, long long, long long, unsigned long long))(v6 + 120);
if ( v7 )
return v7(a1, a2, a3, __readfsqword(0x28u));
}
}
}
v9 = *((_DWORD *)a1 + 224);
if ( *((_BYTE *)a1 + 1083) == 0 || (v9 & 1) != 0 || !a1[91] )
{
*((_DWORD *)a1 + 224) = v9 & 0xFFFFFFFE;
my_set_error((long long)a1, 2006, (long long)SQLSTATE_UNKNOWN, 0LL);
return 1;
}
mysql_init(v21);
v27 = 0;
memcpy(v25, a1 + 114, 248LL);
v10 = *(_QWORD *)a1[158];
if ( v10 )
{
*v29 = v10;
*(_QWORD *)a1[158] = 0LL;
}
v26 = 0LL;
v11 = a1[144];
if ( v11 && (v12 = *(_QWORD *)(v11 + 40)) != 0 && *(_BYTE *)(v12 + 20) )
{
v18 = a1;
v19 = v21;
v20 = *a1;
((void ( *)(long long, long long ( *)()))my_context_install_suspend_resume_hook)(
v12,
my_suspend_hook);
}
else
{
v12 = 0LL;
}
if ( !mysql_real_connect(
(unsigned int)v21,
a1[86],
a1[87],
a1[88],
a1[93],
*((_DWORD *)a1 + 216),
a1[89],
a1[109] | 0x80000000LL)
|| (unsigned int)mysql_set_character_set(v21, *(_QWORD *)(a1[94] + 8LL)) )
{
if ( v12 )
my_context_install_suspend_resume_hook(v12, 0LL, 0LL, v13, v14, v15, v18, v19, v20);
memset(v25, 0LL, 248LL);
my_set_error((long long)a1, v22, (long long)v24, v23);
mysql_close(v21);
return 1;
}
if ( v3 )
{
v16 = SQLSTATE_UNKNOWN;
do
{
v17 = *(_QWORD *)(v3 + 16);
if ( *(_DWORD *)(v17 + 80) )
{
*(_DWORD *)(v17 + 80) = 0;
*(_DWORD *)(v17 + 264) = 2013;
strncpy(v17 + 781, v16, 5LL);
*(_BYTE *)(v17 + 786) = 0;
strncpy(v17 + 268, client_errors[13], 512LL);
*(_BYTE *)(v17 + 779) = 0;
}
v3 = *(_QWORD *)(v3 + 8);
}
while ( v3 );
}
v27 = *((_BYTE *)a1 + 1164);
v28 = a1[153];
a1[153] = 0LL;
if ( v12 )
my_context_install_suspend_resume_hook(v12, 0LL, 0LL, v13, v14, v15, v18, v19, v20);
memset(a1 + 114, 0LL, 248LL);
*((_BYTE *)a1 + 1164) = 0;
mysql_close(a1);
memcpy(a1, v21, 1272LL);
*(_QWORD *)(*a1 + 64LL) = a1;
if ( *a1 && *(_QWORD *)(*a1 + 56LL) && ma_pvio_tls_cipher() )
ma_pvio_tls_set_connection(a1);
ma_net_clear(a1);
a1[103] = -1LL;
a1[92] = 0LL;
return 0;
}
|
mariadb_reconnect:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x528
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV R14,qword ptr [RDI + 0x4c8]
MOV RAX,qword ptr [RDI + 0x4f0]
TEST RAX,RAX
JZ 0x001273f9
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x001273f9
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x001273f9
MOV RAX,qword ptr [RAX + 0x78]
TEST RAX,RAX
JZ 0x001273f9
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x30]
JNZ 0x00127712
MOV RDI,RBX
ADD RSP,0x528
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP RAX
LAB_001273f9:
CMP byte ptr [RBX + 0x43b],0x0
SETNZ CL
MOV EAX,dword ptr [RBX + 0x380]
TEST AL,0x1
SETZ DL
AND DL,CL
CMP DL,0x1
JNZ 0x001274ca
CMP qword ptr [RBX + 0x2d8],0x0
JZ 0x001274ca
LEA R15,[RBX + 0x390]
LEA R12,[RBP + -0x528]
MOV RDI,R12
CALL 0x00129915
MOV byte ptr [R12 + 0x48c],0x0
LEA RDI,[RBP + -0x198]
MOV EDX,0xf8
MOV RSI,R15
CALL 0x001143a0
MOV RAX,qword ptr [RBX + 0x4f0]
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x0012747e
MOV RCX,qword ptr [RBP + -0x38]
MOV qword ptr [RCX],RAX
MOV RAX,qword ptr [RBX + 0x4f0]
MOV qword ptr [RAX],0x0
LAB_0012747e:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBP + -0x148],XMM0
MOV RAX,qword ptr [RBX + 0x480]
TEST RAX,RAX
JZ 0x001274f3
MOV R13,qword ptr [RAX + 0x28]
TEST R13,R13
JZ 0x001274f3
CMP byte ptr [R13 + 0x14],0x0
JZ 0x001274f3
LEA RDX,[RBP + -0x550]
MOV qword ptr [RDX],RBX
MOV qword ptr [RDX + 0x8],R12
MOV RAX,qword ptr [RBX]
MOV qword ptr [RDX + 0x10],RAX
LEA RSI,[0x12b54f]
MOV RDI,R13
CALL 0x0013a0cc
JMP 0x001274f6
LAB_001274ca:
AND EAX,0xfffffffe
MOV dword ptr [RBX + 0x380],EAX
LEA RAX,[0x1629f0]
MOV RDX,qword ptr [RAX]
MOV RDI,RBX
MOV ESI,0x7d6
XOR ECX,ECX
XOR EAX,EAX
CALL 0x00126e85
JMP 0x001275aa
LAB_001274f3:
XOR R13D,R13D
LAB_001274f6:
MOV RSI,qword ptr [RBX + 0x2b0]
MOV RDX,qword ptr [RBX + 0x2b8]
MOV RCX,qword ptr [RBX + 0x2c0]
MOV R8,qword ptr [RBX + 0x2e8]
MOV R9D,dword ptr [RBX + 0x360]
MOV EAX,0x80000000
OR RAX,qword ptr [RBX + 0x368]
LEA RDI,[RBP + -0x528]
PUSH RAX
PUSH qword ptr [RBX + 0x2c8]
CALL 0x00129c4e
ADD RSP,0x10
TEST RAX,RAX
JZ 0x0012755c
MOV RAX,qword ptr [RBX + 0x2f0]
MOV RSI,qword ptr [RAX + 0x8]
LEA RDI,[RBP + -0x528]
CALL 0x0012b577
TEST EAX,EAX
JZ 0x001275d1
LAB_0012755c:
TEST R13,R13
JZ 0x0012756d
MOV RDI,R13
XOR ESI,ESI
XOR EDX,EDX
CALL 0x0013a0cc
LAB_0012756d:
MOV EDX,0xf8
LEA RDI,[RBP + -0x198]
XOR ESI,ESI
CALL 0x00114270
LEA RDX,[RBP + -0x291]
MOV ESI,dword ptr [RDX + -0x207]
LEA RCX,[RBP + -0x491]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x00126e85
LEA RDI,[RBP + -0x528]
CALL 0x0012b66c
LAB_001275aa:
MOV AL,0x1
LAB_001275ac:
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x30]
JNZ 0x00127712
ADD RSP,0x528
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001275d1:
MOV qword ptr [RBP + -0x530],R13
MOV qword ptr [RBP + -0x538],R15
TEST R14,R14
JZ 0x00127656
LEA RAX,[0x1629f0]
MOV R12,qword ptr [RAX]
XOR R13D,R13D
LAB_001275f1:
MOV R15,qword ptr [R14 + 0x10]
CMP dword ptr [R15 + 0x50],0x0
JZ 0x0012764d
MOV dword ptr [R15 + 0x50],0x0
MOV dword ptr [R15 + 0x108],0x7dd
LEA RDI,[R15 + 0x30d]
MOV EDX,0x5
MOV RSI,R12
CALL 0x00114230
MOV byte ptr [R15 + 0x312],R13B
LEA RDI,[R15 + 0x10c]
LEA RAX,[0x162a00]
MOV RSI,qword ptr [RAX + 0x68]
MOV EDX,0x200
CALL 0x00114230
MOV byte ptr [R15 + 0x30b],R13B
LAB_0012764d:
MOV R14,qword ptr [R14 + 0x8]
TEST R14,R14
JNZ 0x001275f1
LAB_00127656:
MOV AL,byte ptr [RBX + 0x48c]
MOV byte ptr [RBP + -0x9c],AL
MOV RAX,qword ptr [RBX + 0x4c8]
MOV qword ptr [RBP + -0x60],RAX
MOV qword ptr [RBX + 0x4c8],0x0
MOV RDI,qword ptr [RBP + -0x530]
TEST RDI,RDI
JZ 0x0012768d
XOR ESI,ESI
XOR EDX,EDX
CALL 0x0013a0cc
LAB_0012768d:
MOV EDX,0xf8
MOV RDI,qword ptr [RBP + -0x538]
XOR ESI,ESI
CALL 0x00114270
MOV byte ptr [RBX + 0x48c],0x0
MOV RDI,RBX
CALL 0x0012b66c
LEA RSI,[RBP + -0x528]
MOV EDX,0x4f8
MOV RDI,RBX
CALL 0x001143a0
MOV RAX,qword ptr [RBX]
MOV qword ptr [RAX + 0x40],RBX
MOV RAX,qword ptr [RBX]
TEST RAX,RAX
JZ 0x001276ed
MOV RDI,qword ptr [RAX + 0x38]
TEST RDI,RDI
JZ 0x001276ed
CALL 0x0012f0ee
TEST RAX,RAX
JZ 0x001276ed
MOV RDI,RBX
CALL 0x0012f3aa
LAB_001276ed:
MOV RDI,RBX
CALL 0x00142888
MOV qword ptr [RBX + 0x338],-0x1
MOV qword ptr [RBX + 0x2e0],0x0
XOR EAX,EAX
JMP 0x001275ac
LAB_00127712:
CALL 0x00114520
|
int8 mariadb_reconnect(long *param_1)
{
long *plVar1;
code *UNRECOVERED_JUMPTABLE;
int *__src;
int iVar2;
int8 uVar3;
long lVar4;
long lVar5;
long lVar6;
long in_FS_OFFSET;
int1 local_530 [144];
int4 local_4a0;
int1 local_499 [512];
int1 local_299 [249];
int1 local_1a0 [80];
int8 local_150;
int8 uStack_148;
int1 local_a4;
long local_68;
long *local_40;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
lVar5 = param_1[0x99];
if (((((long *)param_1[0x9e] != (long *)0x0) &&
(plVar1 = *(long **)param_1[0x9e], plVar1 != (long *)0x0)) && (lVar6 = *plVar1, lVar6 != 0))
&& (UNRECOVERED_JUMPTABLE = *(code **)(lVar6 + 0x78), UNRECOVERED_JUMPTABLE != (code *)0x0)) {
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
/* WARNING: Could not recover jumptable at 0x001273f7. Too many branches */
/* WARNING: Treating indirect jump as call */
uVar3 = (*UNRECOVERED_JUMPTABLE)(param_1);
return uVar3;
}
goto LAB_00127712;
}
if (((*(uint *)(param_1 + 0x70) & 1) == 0 && *(char *)((long)param_1 + 0x43b) != '\0') &&
(param_1[0x5b] != 0)) {
mysql_init(local_530);
local_a4 = 0;
memcpy(local_1a0,param_1 + 0x72,0xf8);
if (*(long *)param_1[0x9e] != 0) {
*local_40 = *(long *)param_1[0x9e];
*(int8 *)param_1[0x9e] = 0;
}
local_150 = 0;
uStack_148 = 0;
if (((param_1[0x90] == 0) || (lVar6 = *(long *)(param_1[0x90] + 0x28), lVar6 == 0)) ||
(*(char *)(lVar6 + 0x14) == '\0')) {
lVar6 = 0;
}
else {
my_context_install_suspend_resume_hook(lVar6,my_suspend_hook);
}
lVar4 = mysql_real_connect(local_530,param_1[0x56],param_1[0x57],param_1[0x58],param_1[0x5d],
(int)param_1[0x6c],param_1[0x59],param_1[0x6d] | 0x80000000);
if ((lVar4 == 0) ||
(iVar2 = mysql_set_character_set(local_530), __src = SQLSTATE_UNKNOWN, iVar2 != 0)) {
if (lVar6 != 0) {
my_context_install_suspend_resume_hook(lVar6,0,0);
}
memset(local_1a0,0,0xf8);
my_set_error(param_1,local_4a0,local_299,local_499);
mysql_close(local_530);
goto LAB_001275aa;
}
for (; lVar5 != 0; lVar5 = *(long *)(lVar5 + 8)) {
lVar4 = *(long *)(lVar5 + 0x10);
if (*(int *)(lVar4 + 0x50) != 0) {
*(int4 *)(lVar4 + 0x50) = 0;
*(int4 *)(lVar4 + 0x108) = 0x7dd;
strncpy((char *)(lVar4 + 0x30d),__src,5);
*(int1 *)(lVar4 + 0x312) = 0;
strncpy((char *)(lVar4 + 0x10c),PTR_s_Lost_connection_to_server_during_00162a68,0x200);
*(int1 *)(lVar4 + 0x30b) = 0;
}
}
local_a4 = *(int1 *)((long)param_1 + 0x48c);
local_68 = param_1[0x99];
param_1[0x99] = 0;
if (lVar6 != 0) {
my_context_install_suspend_resume_hook(lVar6,0,0);
}
memset(param_1 + 0x72,0,0xf8);
*(int1 *)((long)param_1 + 0x48c) = 0;
mysql_close(param_1);
memcpy(param_1,local_530,0x4f8);
*(long **)(*param_1 + 0x40) = param_1;
if (((*param_1 != 0) && (*(long *)(*param_1 + 0x38) != 0)) &&
(lVar5 = ma_pvio_tls_cipher(), lVar5 != 0)) {
ma_pvio_tls_set_connection(param_1);
}
ma_net_clear(param_1);
param_1[0x67] = -1;
param_1[0x5c] = 0;
uVar3 = 0;
}
else {
*(uint *)(param_1 + 0x70) = *(uint *)(param_1 + 0x70) & 0xfffffffe;
my_set_error(param_1,0x7d6,SQLSTATE_UNKNOWN,0);
LAB_001275aa:
uVar3 = 1;
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return uVar3;
}
LAB_00127712:
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
8,156 |
js_dataview_setValue
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_dataview_setValue(JSContext *ctx,
JSValue this_obj,
int argc, JSValue *argv, int class_id)
{
JSTypedArray *ta;
JSArrayBuffer *abuf;
BOOL littleEndian, is_swap;
int size;
uint8_t *ptr;
uint64_t v64;
uint32_t v;
uint64_t pos;
JSValue val;
ta = JS_GetOpaque2(ctx, this_obj, JS_CLASS_DATAVIEW);
if (!ta)
return JS_EXCEPTION;
size = 1 << typed_array_size_log2(class_id);
if (JS_ToIndex(ctx, &pos, argv[0]))
return JS_EXCEPTION;
val = argv[1];
v = 0; /* avoid warning */
v64 = 0; /* avoid warning */
if (class_id <= JS_CLASS_UINT32_ARRAY) {
if (JS_ToUint32(ctx, &v, val))
return JS_EXCEPTION;
} else
if (class_id <= JS_CLASS_BIG_UINT64_ARRAY) {
if (JS_ToBigInt64(ctx, (int64_t *)&v64, val))
return JS_EXCEPTION;
} else {
double d;
if (JS_ToFloat64(ctx, &d, val))
return JS_EXCEPTION;
if (class_id == JS_CLASS_FLOAT16_ARRAY) {
v = tofp16(d);
} else if (class_id == JS_CLASS_FLOAT32_ARRAY) {
union {
float f;
uint32_t i;
} u;
u.f = d;
v = u.i;
} else {
JSFloat64Union u;
u.d = d;
v64 = u.u64;
}
}
littleEndian = argc > 2 && JS_ToBool(ctx, argv[2]);
is_swap = littleEndian ^ !is_be();
abuf = ta->buffer->u.array_buffer;
if (abuf->detached)
return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
// order matters: this check should come before the next one
if ((pos + size) > ta->length)
return JS_ThrowRangeError(ctx, "out of bound");
// test262 expects a TypeError for this and V8, in its infinite wisdom,
// throws a "detached array buffer" exception, but IMO that doesn't make
// sense because the buffer is not in fact detached, it's still there
if ((int64_t)ta->offset + ta->length > abuf->byte_length)
return JS_ThrowTypeError(ctx, "out of bound");
ptr = abuf->data + ta->offset + pos;
switch(class_id) {
case JS_CLASS_INT8_ARRAY:
case JS_CLASS_UINT8_ARRAY:
*ptr = v;
break;
case JS_CLASS_INT16_ARRAY:
case JS_CLASS_UINT16_ARRAY:
case JS_CLASS_FLOAT16_ARRAY:
if (is_swap)
v = bswap16(v);
put_u16(ptr, v);
break;
case JS_CLASS_INT32_ARRAY:
case JS_CLASS_UINT32_ARRAY:
case JS_CLASS_FLOAT32_ARRAY:
if (is_swap)
v = bswap32(v);
put_u32(ptr, v);
break;
case JS_CLASS_BIG_INT64_ARRAY:
case JS_CLASS_BIG_UINT64_ARRAY:
case JS_CLASS_FLOAT64_ARRAY:
if (is_swap)
v64 = bswap64(v64);
put_u64(ptr, v64);
break;
default:
abort();
}
return JS_UNDEFINED;
}
|
O0
|
c
|
js_dataview_setValue:
subq $0xb8, %rsp
movq %rsi, 0x98(%rsp)
movq %rdx, 0xa0(%rsp)
movq %rdi, 0x90(%rsp)
movl %ecx, 0x8c(%rsp)
movq %r8, 0x80(%rsp)
movl %r9d, 0x7c(%rsp)
movq 0x90(%rsp), %rdi
movq 0x98(%rsp), %rsi
movq 0xa0(%rsp), %rdx
movl $0x21, %ecx
callq 0x370f0
movq %rax, 0x70(%rsp)
cmpq $0x0, 0x70(%rsp)
jne 0xe391e
movl $0x0, 0xa8(%rsp)
movq $0x6, 0xb0(%rsp)
jmp 0xe3cfb
movl 0x7c(%rsp), %eax
subl $0x15, %eax
movslq %eax, %rcx
leaq 0x27950(%rip), %rax # 0x10b27f
movzbl (%rax,%rcx), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, 0x5c(%rsp)
movq 0x90(%rsp), %rdi
movq 0x80(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
leaq 0x38(%rsp), %rsi
callq 0x37e80
cmpl $0x0, %eax
je 0xe3980
movl $0x0, 0xa8(%rsp)
movq $0x6, 0xb0(%rsp)
jmp 0xe3cfb
movq 0x80(%rsp), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x28(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x30(%rsp)
movl $0x0, 0x44(%rsp)
movq $0x0, 0x48(%rsp)
cmpl $0x1b, 0x7c(%rsp)
jg 0xe39f4
movq 0x90(%rsp), %rdi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
leaq 0x44(%rsp), %rsi
callq 0x4c680
cmpl $0x0, %eax
je 0xe39ef
movl $0x0, 0xa8(%rsp)
movq $0x6, 0xb0(%rsp)
jmp 0xe3cfb
jmp 0xe3ad2
cmpl $0x1d, 0x7c(%rsp)
jg 0xe3a3d
movq 0x90(%rsp), %rdi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
leaq 0x48(%rsp), %rsi
callq 0x37bf0
cmpl $0x0, %eax
je 0xe3a38
movl $0x0, 0xa8(%rsp)
movq $0x6, 0xb0(%rsp)
jmp 0xe3cfb
jmp 0xe3ad0
movq 0x90(%rsp), %rdi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
leaq 0x20(%rsp), %rsi
callq 0x372c0
cmpl $0x0, %eax
je 0xe3a7a
movl $0x0, 0xa8(%rsp)
movq $0x6, 0xb0(%rsp)
jmp 0xe3cfb
cmpl $0x1e, 0x7c(%rsp)
jne 0xe3a95
movsd 0x20(%rsp), %xmm0
callq 0x5ffa0
movzwl %ax, %eax
movl %eax, 0x44(%rsp)
jmp 0xe3ace
cmpl $0x1f, 0x7c(%rsp)
jne 0xe3ab6
movsd 0x20(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0xe3acc
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x48(%rsp)
jmp 0xe3ace
jmp 0xe3ad0
jmp 0xe3ad2
xorl %eax, %eax
cmpl $0x2, 0x8c(%rsp)
movb %al, 0xf(%rsp)
jle 0xe3b09
movq 0x90(%rsp), %rdi
movq 0x80(%rsp), %rax
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
callq 0x37270
cmpl $0x0, %eax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
movl %eax, 0x8(%rsp)
callq 0x2b9a0
movb %al, %cl
movl 0x8(%rsp), %eax
cmpb $0x0, %cl
setne %cl
xorb $-0x1, %cl
andb $0x1, %cl
movzbl %cl, %ecx
xorl %ecx, %eax
movl %eax, 0x60(%rsp)
movq 0x70(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x30(%rax), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
cmpb $0x0, 0x8(%rax)
je 0xe3b7d
movq 0x90(%rsp), %rdi
callq 0x56e80
movq %rax, 0xa8(%rsp)
movq %rdx, 0xb0(%rsp)
jmp 0xe3cfb
movq 0x38(%rsp), %rax
movslq 0x5c(%rsp), %rcx
addq %rcx, %rax
movq 0x70(%rsp), %rcx
movl 0x24(%rcx), %ecx
cmpq %rcx, %rax
jbe 0xe3bc2
movq 0x90(%rsp), %rdi
leaq 0x2c4bd(%rip), %rsi # 0x110063
movb $0x0, %al
callq 0x283b0
movq %rax, 0xa8(%rsp)
movq %rdx, 0xb0(%rsp)
jmp 0xe3cfb
movq 0x70(%rsp), %rax
movl 0x20(%rax), %eax
movq 0x70(%rsp), %rcx
movl 0x24(%rcx), %ecx
addq %rcx, %rax
movq 0x68(%rsp), %rcx
movslq (%rcx), %rcx
cmpq %rcx, %rax
jle 0xe3c0d
movq 0x90(%rsp), %rdi
leaq 0x2c472(%rip), %rsi # 0x110063
movb $0x0, %al
callq 0x2c040
movq %rax, 0xa8(%rsp)
movq %rdx, 0xb0(%rsp)
jmp 0xe3cfb
movq 0x68(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x70(%rsp), %rcx
movl 0x20(%rcx), %ecx
addq %rcx, %rax
movq 0x38(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x50(%rsp)
movl 0x7c(%rsp), %eax
addl $-0x16, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0xa, %eax
ja 0xe3cdf
movq (%rsp), %rax
leaq 0x27575(%rip), %rcx # 0x10b1c4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x44(%rsp), %eax
movb %al, %cl
movq 0x50(%rsp), %rax
movb %cl, (%rax)
jmp 0xe3ce4
cmpl $0x0, 0x60(%rsp)
je 0xe3c81
movl 0x44(%rsp), %eax
movzwl %ax, %edi
callq 0x78290
movzwl %ax, %eax
movl %eax, 0x44(%rsp)
movq 0x50(%rsp), %rdi
movl 0x44(%rsp), %eax
movzwl %ax, %esi
callq 0x78b50
jmp 0xe3ce4
cmpl $0x0, 0x60(%rsp)
je 0xe3ca8
movl 0x44(%rsp), %edi
callq 0x78b70
movl %eax, 0x44(%rsp)
movq 0x50(%rsp), %rdi
movl 0x44(%rsp), %esi
callq 0x66fb0
jmp 0xe3ce4
cmpl $0x0, 0x60(%rsp)
je 0xe3cce
movq 0x48(%rsp), %rdi
callq 0x78190
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xe3e40
jmp 0xe3ce4
callq 0xe090
movl $0x0, 0xa8(%rsp)
movq $0x3, 0xb0(%rsp)
movq 0xa8(%rsp), %rax
movq 0xb0(%rsp), %rdx
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
|
js_dataview_setValue:
sub rsp, 0B8h
mov [rsp+0B8h+var_20], rsi
mov [rsp+0B8h+var_18], rdx
mov [rsp+0B8h+var_28], rdi
mov [rsp+0B8h+var_2C], ecx
mov [rsp+0B8h+var_38], r8
mov [rsp+0B8h+var_3C], r9d
mov rdi, [rsp+0B8h+var_28]
mov rsi, [rsp+0B8h+var_20]
mov rdx, [rsp+0B8h+var_18]
mov ecx, 21h ; '!'
call JS_GetOpaque2
mov [rsp+0B8h+var_48], rax
cmp [rsp+0B8h+var_48], 0
jnz short loc_E391E
mov dword ptr [rsp+0B8h+var_10], 0
mov [rsp+0B8h+var_8], 6
jmp loc_E3CFB
loc_E391E:
mov eax, [rsp+0B8h+var_3C]
sub eax, 15h
movsxd rcx, eax
lea rax, typed_array_size_log2
movzx ecx, byte ptr [rax+rcx]
mov eax, 1
shl eax, cl
mov [rsp+0B8h+var_5C], eax
mov rdi, [rsp+0B8h+var_28]
mov rax, [rsp+0B8h+var_38]
mov rdx, [rax]
mov rcx, [rax+8]
lea rsi, [rsp+0B8h+var_80]
call JS_ToIndex
cmp eax, 0
jz short loc_E3980
mov dword ptr [rsp+0B8h+var_10], 0
mov [rsp+0B8h+var_8], 6
jmp loc_E3CFB
loc_E3980:
mov rax, [rsp+0B8h+var_38]
mov rcx, [rax+10h]
mov [rsp+0B8h+var_90], rcx
mov rax, [rax+18h]
mov [rsp+0B8h+var_88], rax
mov [rsp+0B8h+var_74], 0
mov [rsp+0B8h+var_70], 0
cmp [rsp+0B8h+var_3C], 1Bh
jg short loc_E39F4
mov rdi, [rsp+0B8h+var_28]
mov rdx, [rsp+0B8h+var_90]
mov rcx, [rsp+0B8h+var_88]
lea rsi, [rsp+0B8h+var_74]
call JS_ToUint32_0
cmp eax, 0
jz short loc_E39EF
mov dword ptr [rsp+0B8h+var_10], 0
mov [rsp+0B8h+var_8], 6
jmp loc_E3CFB
loc_E39EF:
jmp loc_E3AD2
loc_E39F4:
cmp [rsp+0B8h+var_3C], 1Dh
jg short loc_E3A3D
mov rdi, [rsp+0B8h+var_28]
mov rdx, [rsp+0B8h+var_90]
mov rcx, [rsp+0B8h+var_88]
lea rsi, [rsp+0B8h+var_70]
call JS_ToBigInt64
cmp eax, 0
jz short loc_E3A38
mov dword ptr [rsp+0B8h+var_10], 0
mov [rsp+0B8h+var_8], 6
jmp loc_E3CFB
loc_E3A38:
jmp loc_E3AD0
loc_E3A3D:
mov rdi, [rsp+0B8h+var_28]
mov rdx, [rsp+0B8h+var_90]
mov rcx, [rsp+0B8h+var_88]
lea rsi, [rsp+0B8h+var_98]
call JS_ToFloat64
cmp eax, 0
jz short loc_E3A7A
mov dword ptr [rsp+0B8h+var_10], 0
mov [rsp+0B8h+var_8], 6
jmp loc_E3CFB
loc_E3A7A:
cmp [rsp+0B8h+var_3C], 1Eh
jnz short loc_E3A95
movsd xmm0, [rsp+0B8h+var_98]
call tofp16
movzx eax, ax
mov [rsp+0B8h+var_74], eax
jmp short loc_E3ACE
loc_E3A95:
cmp [rsp+0B8h+var_3C], 1Fh
jnz short loc_E3AB6
movsd xmm0, [rsp+0B8h+var_98]
cvtsd2ss xmm0, xmm0
movss [rsp+0B8h+var_9C], xmm0
mov eax, [rsp+0B8h+var_9C]
mov [rsp+0B8h+var_74], eax
jmp short loc_E3ACC
loc_E3AB6:
movsd xmm0, [rsp+0B8h+var_98]
movsd [rsp+0B8h+var_A8], xmm0
mov rax, [rsp+0B8h+var_A8]
mov [rsp+0B8h+var_70], rax
loc_E3ACC:
jmp short $+2
loc_E3ACE:
jmp short $+2
loc_E3AD0:
jmp short $+2
loc_E3AD2:
xor eax, eax
cmp [rsp+0B8h+var_2C], 2
mov [rsp+0B8h+var_A9], al
jle short loc_E3B09
mov rdi, [rsp+0B8h+var_28]
mov rax, [rsp+0B8h+var_38]
mov rsi, [rax+20h]
mov rdx, [rax+28h]
call JS_ToBool
cmp eax, 0
setnz al
mov [rsp+0B8h+var_A9], al
loc_E3B09:
mov al, [rsp+0B8h+var_A9]
and al, 1
movzx eax, al
mov [rsp+0B8h+var_54], eax
mov eax, [rsp+0B8h+var_54]
mov [rsp+0B8h+var_B0], eax
call is_be_0
mov cl, al
mov eax, [rsp+0B8h+var_B0]
cmp cl, 0
setnz cl
xor cl, 0FFh
and cl, 1
movzx ecx, cl
xor eax, ecx
mov [rsp+0B8h+var_58], eax
mov rax, [rsp+0B8h+var_48]
mov rax, [rax+18h]
mov rax, [rax+30h]
mov [rsp+0B8h+var_50], rax
mov rax, [rsp+0B8h+var_50]
cmp byte ptr [rax+8], 0
jz short loc_E3B7D
mov rdi, [rsp+0B8h+var_28]
call JS_ThrowTypeErrorDetachedArrayBuffer
mov [rsp+0B8h+var_10], rax
mov [rsp+0B8h+var_8], rdx
jmp loc_E3CFB
loc_E3B7D:
mov rax, [rsp+0B8h+var_80]
movsxd rcx, [rsp+0B8h+var_5C]
add rax, rcx
mov rcx, [rsp+0B8h+var_48]
mov ecx, [rcx+24h]
cmp rax, rcx
jbe short loc_E3BC2
mov rdi, [rsp+0B8h+var_28]
lea rsi, aOutOfBound; "out of bound"
mov al, 0
call JS_ThrowRangeError
mov [rsp+0B8h+var_10], rax
mov [rsp+0B8h+var_8], rdx
jmp loc_E3CFB
loc_E3BC2:
mov rax, [rsp+0B8h+var_48]
mov eax, [rax+20h]
mov rcx, [rsp+0B8h+var_48]
mov ecx, [rcx+24h]
add rax, rcx
mov rcx, [rsp+0B8h+var_50]
movsxd rcx, dword ptr [rcx]
cmp rax, rcx
jle short loc_E3C0D
mov rdi, [rsp+0B8h+var_28]
lea rsi, aOutOfBound; "out of bound"
mov al, 0
call JS_ThrowTypeError
mov [rsp+0B8h+var_10], rax
mov [rsp+0B8h+var_8], rdx
jmp loc_E3CFB
loc_E3C0D:
mov rax, [rsp+0B8h+var_50]
mov rax, [rax+10h]
mov rcx, [rsp+0B8h+var_48]
mov ecx, [rcx+20h]
add rax, rcx
mov rcx, [rsp+0B8h+var_80]
add rax, rcx
mov [rsp+0B8h+var_68], rax
mov eax, [rsp+0B8h+var_3C]
add eax, 0FFFFFFEAh; switch 11 cases
mov ecx, eax
mov [rsp+0B8h+var_B8], rcx
sub eax, 0Ah
ja def_E3C56; jumptable 00000000000E3C56 default case
mov rax, [rsp+0B8h+var_B8]
lea rcx, jpt_E3C56
movsxd rax, ds:(jpt_E3C56 - 10B1C4h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_E3C58:
mov eax, [rsp+0B8h+var_74]; jumptable 00000000000E3C56 cases 22,23
mov cl, al
mov rax, [rsp+0B8h+var_68]
mov [rax], cl
jmp short loc_E3CE4
loc_E3C67:
cmp [rsp+0B8h+var_58], 0; jumptable 00000000000E3C56 cases 24,25,30
jz short loc_E3C81
mov eax, [rsp+0B8h+var_74]
movzx edi, ax
call bswap16
movzx eax, ax
mov [rsp+0B8h+var_74], eax
loc_E3C81:
mov rdi, [rsp+0B8h+var_68]
mov eax, [rsp+0B8h+var_74]
movzx esi, ax
call put_u16
jmp short loc_E3CE4
loc_E3C94:
cmp [rsp+0B8h+var_58], 0; jumptable 00000000000E3C56 cases 26,27,31
jz short loc_E3CA8
mov edi, [rsp+0B8h+var_74]
call bswap32
mov [rsp+0B8h+var_74], eax
loc_E3CA8:
mov rdi, [rsp+0B8h+var_68]
mov esi, [rsp+0B8h+var_74]
call put_u32
jmp short loc_E3CE4
loc_E3CB8:
cmp [rsp+0B8h+var_58], 0; jumptable 00000000000E3C56 cases 28,29,32
jz short loc_E3CCE
mov rdi, [rsp+0B8h+var_70]
call bswap64
mov [rsp+0B8h+var_70], rax
loc_E3CCE:
mov rdi, [rsp+0B8h+var_68]
mov rsi, [rsp+0B8h+var_70]
call put_u64
jmp short loc_E3CE4
def_E3C56:
call _abort; jumptable 00000000000E3C56 default case
loc_E3CE4:
mov dword ptr [rsp+0B8h+var_10], 0
mov [rsp+0B8h+var_8], 3
loc_E3CFB:
mov rax, [rsp+0B8h+var_10]
mov rdx, [rsp+0B8h+var_8]
add rsp, 0B8h
retn
|
long long js_dataview_setValue(
long long a1,
long long a2,
long long a3,
int a4,
long long a5,
int a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14)
{
double v14; // xmm4_8
double v15; // xmm5_8
const char *v16; // rdi
unsigned long long *v17; // rsi
long long v18; // rdx
_BOOL8 v19; // rcx
long long v20; // r8
long long v21; // r9
__m128 v22; // xmm4
__m128 v23; // xmm5
long long v24; // rdx
unsigned long long v25; // rcx
long long v26; // rdx
long long v27; // rcx
long long v28; // rdx
char v30; // [rsp+0h] [rbp-B8h]
bool v31; // [rsp+Fh] [rbp-A9h]
double v32; // [rsp+20h] [rbp-98h] BYREF
_DWORD *v33; // [rsp+28h] [rbp-90h]
long long v34; // [rsp+30h] [rbp-88h]
unsigned long long v35; // [rsp+38h] [rbp-80h] BYREF
int v36; // [rsp+44h] [rbp-74h] BYREF
unsigned long long v37; // [rsp+48h] [rbp-70h] BYREF
_WORD *v38; // [rsp+50h] [rbp-68h]
int v39; // [rsp+5Ch] [rbp-5Ch]
BOOL v40; // [rsp+60h] [rbp-58h]
int v41; // [rsp+64h] [rbp-54h]
int *v42; // [rsp+68h] [rbp-50h]
long long Opaque2; // [rsp+70h] [rbp-48h]
int v44; // [rsp+7Ch] [rbp-3Ch]
long long v45; // [rsp+80h] [rbp-38h]
int v46; // [rsp+8Ch] [rbp-2Ch]
const char *v47; // [rsp+90h] [rbp-28h]
long long v48; // [rsp+98h] [rbp-20h]
long long v49; // [rsp+A0h] [rbp-18h]
long long v50; // [rsp+A8h] [rbp-10h]
long long v51; // [rsp+B0h] [rbp-8h]
v48 = a2;
v49 = a3;
v47 = (const char *)a1;
v46 = a4;
v45 = a5;
v44 = a6;
Opaque2 = JS_GetOpaque2(a1, a2, a3, 0x21u);
if ( Opaque2 )
{
v39 = 1 << typed_array_size_log2[v44 - 21];
if ( (unsigned int)JS_ToIndex(
(long long)v47,
&v35,
*(_DWORD **)v45,
*(_QWORD *)(v45 + 8),
a7,
a8,
a9,
a10,
v14,
v15,
a13,
a14) )
{
LODWORD(v50) = 0;
v51 = 6LL;
}
else
{
v33 = *(_DWORD **)(v45 + 16);
v34 = *(_QWORD *)(v45 + 24);
v36 = 0;
v37 = 0LL;
if ( v44 > 27 )
{
if ( v44 > 29 )
{
v16 = v47;
v17 = (unsigned long long *)&v32;
if ( (unsigned int)JS_ToFloat64((long long)v47, (long long)&v32, v33, v34) )
{
LODWORD(v50) = 0;
v51 = 6LL;
return v50;
}
if ( v44 == 30 )
{
a7 = (__m128)*(unsigned long long *)&v32;
v36 = (unsigned __int16)tofp16(v32);
}
else
{
a7 = (__m128)*(unsigned long long *)&v32;
if ( v44 == 31 )
{
a7.m128_f32[0] = v32;
v36 = a7.m128_i32[0];
}
else
{
v37 = *(_QWORD *)&v32;
}
}
}
else
{
v16 = v47;
v17 = &v37;
if ( (unsigned int)JS_ToBigInt64((long long)v47, (long long)&v37, v33, v34) )
{
LODWORD(v50) = 0;
v51 = 6LL;
return v50;
}
}
}
else
{
v16 = v47;
v17 = (unsigned long long *)&v36;
if ( (unsigned int)JS_ToUint32_0((long long)v47, (long long)&v36, v33, v34) )
{
LODWORD(v50) = 0;
v51 = 6LL;
return v50;
}
}
v31 = 0;
if ( v46 > 2 )
{
v16 = v47;
v17 = *(unsigned long long **)(v45 + 32);
v31 = (unsigned int)JS_ToBool((long long)v47, v17, *(_QWORD *)(v45 + 40)) != 0;
}
v41 = v31;
v19 = is_be_0() == 0;
v40 = v19 ^ v31;
v42 = *(int **)(*(_QWORD *)(Opaque2 + 24) + 48LL);
if ( *((_BYTE *)v42 + 8) )
{
v50 = JS_ThrowTypeErrorDetachedArrayBuffer(
(long long)v47,
a7,
a8,
a9,
a10,
v22,
v23,
a13,
a14,
(long long)v17,
v18,
v19,
v20,
v21);
v51 = v24;
}
else
{
v25 = *(unsigned int *)(Opaque2 + 36);
if ( v39 + v35 <= v25 )
{
v27 = *v42;
if ( (long long)(*(unsigned int *)(Opaque2 + 36) + (unsigned long long)*(unsigned int *)(Opaque2 + 32)) <= v27 )
{
v38 = (_WORD *)(v35 + *(unsigned int *)(Opaque2 + 32) + *((_QWORD *)v42 + 2));
switch ( v44 )
{
case 22:
case 23:
*(_BYTE *)v38 = v36;
break;
case 24:
case 25:
case 30:
if ( v40 )
v36 = (unsigned __int16)bswap16(v36);
put_u16(v38, v36);
break;
case 26:
case 27:
case 31:
if ( v40 )
v36 = bswap32(v36);
put_u32(v38, v36);
break;
case 28:
case 29:
case 32:
if ( v40 )
v37 = bswap64(v37);
put_u64(v38, v37);
break;
default:
abort(v16);
}
LODWORD(v50) = 0;
v51 = 3LL;
}
else
{
v50 = JS_ThrowTypeError(
(long long)v47,
(long long)"out of bound",
v18,
v27,
v20,
v21,
a7,
a8,
a9,
a10,
v22,
v23,
a13,
a14,
v30);
v51 = v28;
}
}
else
{
v50 = JS_ThrowRangeError(
(long long)v47,
(long long)"out of bound",
v18,
v25,
v20,
v21,
a7,
a8,
a9,
a10,
v22,
v23,
a13,
a14,
v30);
v51 = v26;
}
}
}
}
else
{
LODWORD(v50) = 0;
v51 = 6LL;
}
return v50;
}
|
js_dataview_setValue:
SUB RSP,0xb8
MOV qword ptr [RSP + 0x98],RSI
MOV qword ptr [RSP + 0xa0],RDX
MOV qword ptr [RSP + 0x90],RDI
MOV dword ptr [RSP + 0x8c],ECX
MOV qword ptr [RSP + 0x80],R8
MOV dword ptr [RSP + 0x7c],R9D
MOV RDI,qword ptr [RSP + 0x90]
MOV RSI,qword ptr [RSP + 0x98]
MOV RDX,qword ptr [RSP + 0xa0]
MOV ECX,0x21
CALL 0x001370f0
MOV qword ptr [RSP + 0x70],RAX
CMP qword ptr [RSP + 0x70],0x0
JNZ 0x001e391e
MOV dword ptr [RSP + 0xa8],0x0
MOV qword ptr [RSP + 0xb0],0x6
JMP 0x001e3cfb
LAB_001e391e:
MOV EAX,dword ptr [RSP + 0x7c]
SUB EAX,0x15
MOVSXD RCX,EAX
LEA RAX,[0x20b27f]
MOVZX ECX,byte ptr [RAX + RCX*0x1]
MOV EAX,0x1
SHL EAX,CL
MOV dword ptr [RSP + 0x5c],EAX
MOV RDI,qword ptr [RSP + 0x90]
MOV RAX,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [RAX]
MOV RCX,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x38]
CALL 0x00137e80
CMP EAX,0x0
JZ 0x001e3980
MOV dword ptr [RSP + 0xa8],0x0
MOV qword ptr [RSP + 0xb0],0x6
JMP 0x001e3cfb
LAB_001e3980:
MOV RAX,qword ptr [RSP + 0x80]
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 dword ptr [RSP + 0x44],0x0
MOV qword ptr [RSP + 0x48],0x0
CMP dword ptr [RSP + 0x7c],0x1b
JG 0x001e39f4
MOV RDI,qword ptr [RSP + 0x90]
MOV RDX,qword ptr [RSP + 0x28]
MOV RCX,qword ptr [RSP + 0x30]
LEA RSI,[RSP + 0x44]
CALL 0x0014c680
CMP EAX,0x0
JZ 0x001e39ef
MOV dword ptr [RSP + 0xa8],0x0
MOV qword ptr [RSP + 0xb0],0x6
JMP 0x001e3cfb
LAB_001e39ef:
JMP 0x001e3ad2
LAB_001e39f4:
CMP dword ptr [RSP + 0x7c],0x1d
JG 0x001e3a3d
MOV RDI,qword ptr [RSP + 0x90]
MOV RDX,qword ptr [RSP + 0x28]
MOV RCX,qword ptr [RSP + 0x30]
LEA RSI,[RSP + 0x48]
CALL 0x00137bf0
CMP EAX,0x0
JZ 0x001e3a38
MOV dword ptr [RSP + 0xa8],0x0
MOV qword ptr [RSP + 0xb0],0x6
JMP 0x001e3cfb
LAB_001e3a38:
JMP 0x001e3ad0
LAB_001e3a3d:
MOV RDI,qword ptr [RSP + 0x90]
MOV RDX,qword ptr [RSP + 0x28]
MOV RCX,qword ptr [RSP + 0x30]
LEA RSI,[RSP + 0x20]
CALL 0x001372c0
CMP EAX,0x0
JZ 0x001e3a7a
MOV dword ptr [RSP + 0xa8],0x0
MOV qword ptr [RSP + 0xb0],0x6
JMP 0x001e3cfb
LAB_001e3a7a:
CMP dword ptr [RSP + 0x7c],0x1e
JNZ 0x001e3a95
MOVSD XMM0,qword ptr [RSP + 0x20]
CALL 0x0015ffa0
MOVZX EAX,AX
MOV dword ptr [RSP + 0x44],EAX
JMP 0x001e3ace
LAB_001e3a95:
CMP dword ptr [RSP + 0x7c],0x1f
JNZ 0x001e3ab6
MOVSD XMM0,qword ptr [RSP + 0x20]
CVTSD2SS XMM0,XMM0
MOVSS dword ptr [RSP + 0x1c],XMM0
MOV EAX,dword ptr [RSP + 0x1c]
MOV dword ptr [RSP + 0x44],EAX
JMP 0x001e3acc
LAB_001e3ab6:
MOVSD XMM0,qword ptr [RSP + 0x20]
MOVSD qword ptr [RSP + 0x10],XMM0
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x48],RAX
LAB_001e3acc:
JMP 0x001e3ace
LAB_001e3ace:
JMP 0x001e3ad0
LAB_001e3ad0:
JMP 0x001e3ad2
LAB_001e3ad2:
XOR EAX,EAX
CMP dword ptr [RSP + 0x8c],0x2
MOV byte ptr [RSP + 0xf],AL
JLE 0x001e3b09
MOV RDI,qword ptr [RSP + 0x90]
MOV RAX,qword ptr [RSP + 0x80]
MOV RSI,qword ptr [RAX + 0x20]
MOV RDX,qword ptr [RAX + 0x28]
CALL 0x00137270
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RSP + 0xf],AL
LAB_001e3b09:
MOV AL,byte ptr [RSP + 0xf]
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RSP + 0x64],EAX
MOV EAX,dword ptr [RSP + 0x64]
MOV dword ptr [RSP + 0x8],EAX
CALL 0x0012b9a0
MOV CL,AL
MOV EAX,dword ptr [RSP + 0x8]
CMP CL,0x0
SETNZ CL
XOR CL,0xff
AND CL,0x1
MOVZX ECX,CL
XOR EAX,ECX
MOV dword ptr [RSP + 0x60],EAX
MOV RAX,qword ptr [RSP + 0x70]
MOV RAX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RSP + 0x68],RAX
MOV RAX,qword ptr [RSP + 0x68]
CMP byte ptr [RAX + 0x8],0x0
JZ 0x001e3b7d
MOV RDI,qword ptr [RSP + 0x90]
CALL 0x00156e80
MOV qword ptr [RSP + 0xa8],RAX
MOV qword ptr [RSP + 0xb0],RDX
JMP 0x001e3cfb
LAB_001e3b7d:
MOV RAX,qword ptr [RSP + 0x38]
MOVSXD RCX,dword ptr [RSP + 0x5c]
ADD RAX,RCX
MOV RCX,qword ptr [RSP + 0x70]
MOV ECX,dword ptr [RCX + 0x24]
CMP RAX,RCX
JBE 0x001e3bc2
MOV RDI,qword ptr [RSP + 0x90]
LEA RSI,[0x210063]
MOV AL,0x0
CALL 0x001283b0
MOV qword ptr [RSP + 0xa8],RAX
MOV qword ptr [RSP + 0xb0],RDX
JMP 0x001e3cfb
LAB_001e3bc2:
MOV RAX,qword ptr [RSP + 0x70]
MOV EAX,dword ptr [RAX + 0x20]
MOV RCX,qword ptr [RSP + 0x70]
MOV ECX,dword ptr [RCX + 0x24]
ADD RAX,RCX
MOV RCX,qword ptr [RSP + 0x68]
MOVSXD RCX,dword ptr [RCX]
CMP RAX,RCX
JLE 0x001e3c0d
MOV RDI,qword ptr [RSP + 0x90]
LEA RSI,[0x210063]
MOV AL,0x0
CALL 0x0012c040
MOV qword ptr [RSP + 0xa8],RAX
MOV qword ptr [RSP + 0xb0],RDX
JMP 0x001e3cfb
LAB_001e3c0d:
MOV RAX,qword ptr [RSP + 0x68]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RSP + 0x70]
MOV ECX,dword ptr [RCX + 0x20]
ADD RAX,RCX
MOV RCX,qword ptr [RSP + 0x38]
ADD RAX,RCX
MOV qword ptr [RSP + 0x50],RAX
MOV EAX,dword ptr [RSP + 0x7c]
ADD EAX,-0x16
MOV ECX,EAX
MOV qword ptr [RSP],RCX
SUB EAX,0xa
JA 0x001e3cdf
MOV RAX,qword ptr [RSP]
LEA RCX,[0x20b1c4]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_16:
MOV EAX,dword ptr [RSP + 0x44]
MOV CL,AL
MOV RAX,qword ptr [RSP + 0x50]
MOV byte ptr [RAX],CL
JMP 0x001e3ce4
caseD_18:
CMP dword ptr [RSP + 0x60],0x0
JZ 0x001e3c81
MOV EAX,dword ptr [RSP + 0x44]
MOVZX EDI,AX
CALL 0x00178290
MOVZX EAX,AX
MOV dword ptr [RSP + 0x44],EAX
LAB_001e3c81:
MOV RDI,qword ptr [RSP + 0x50]
MOV EAX,dword ptr [RSP + 0x44]
MOVZX ESI,AX
CALL 0x00178b50
JMP 0x001e3ce4
caseD_1a:
CMP dword ptr [RSP + 0x60],0x0
JZ 0x001e3ca8
MOV EDI,dword ptr [RSP + 0x44]
CALL 0x00178b70
MOV dword ptr [RSP + 0x44],EAX
LAB_001e3ca8:
MOV RDI,qword ptr [RSP + 0x50]
MOV ESI,dword ptr [RSP + 0x44]
CALL 0x00166fb0
JMP 0x001e3ce4
caseD_1c:
CMP dword ptr [RSP + 0x60],0x0
JZ 0x001e3cce
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x00178190
MOV qword ptr [RSP + 0x48],RAX
LAB_001e3cce:
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x48]
CALL 0x001e3e40
JMP 0x001e3ce4
default:
CALL 0x0010e090
LAB_001e3ce4:
MOV dword ptr [RSP + 0xa8],0x0
MOV qword ptr [RSP + 0xb0],0x3
LAB_001e3cfb:
MOV RAX,qword ptr [RSP + 0xa8]
MOV RDX,qword ptr [RSP + 0xb0]
ADD RSP,0xb8
RET
|
int1 [16]
js_dataview_setValue
(int8 param_1,int8 param_2,int8 param_3,int param_4,int8 *param_5,
int param_6)
{
char cVar1;
ushort uVar2;
int iVar3;
int1 auVar4 [16];
bool local_a9;
double local_98;
int8 local_90;
int8 local_88;
long local_80;
float local_74;
double local_70;
int1 *local_68;
int local_5c;
uint local_58;
uint local_54;
int *local_50;
long local_48;
int local_3c;
int8 *local_38;
int local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
int4 local_10;
int4 uStack_c;
int8 local_8;
local_3c = param_6;
local_38 = param_5;
local_2c = param_4;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
local_48 = JS_GetOpaque2(param_1,param_2,param_3,0x21);
if (local_48 == 0) {
local_10 = 0;
local_8 = 6;
}
else {
local_5c = 1 << ((&typed_array_size_log2)[local_3c + -0x15] & 0x1f);
iVar3 = JS_ToIndex(local_28,&local_80,*local_38,local_38[1]);
if (iVar3 == 0) {
local_90 = local_38[2];
local_88 = local_38[3];
local_74 = 0.0;
local_70 = 0.0;
if (local_3c < 0x1c) {
iVar3 = JS_ToUint32(local_28,&local_74,local_90,local_88);
if (iVar3 != 0) {
local_10 = 0;
local_8 = 6;
goto LAB_001e3cfb;
}
}
else if (local_3c < 0x1e) {
iVar3 = JS_ToBigInt64(local_28,&local_70,local_90,local_88);
if (iVar3 != 0) {
local_10 = 0;
local_8 = 6;
goto LAB_001e3cfb;
}
}
else {
iVar3 = JS_ToFloat64(local_28,&local_98,local_90,local_88);
if (iVar3 != 0) {
local_10 = 0;
local_8 = 6;
goto LAB_001e3cfb;
}
if (local_3c == 0x1e) {
uVar2 = tofp16(local_98);
local_74 = (float)(uint)uVar2;
}
else if (local_3c == 0x1f) {
local_74 = (float)local_98;
}
else {
local_70 = local_98;
}
}
local_a9 = false;
if (2 < local_2c) {
iVar3 = JS_ToBool(local_28,local_38[4],local_38[5]);
local_a9 = iVar3 != 0;
}
local_54 = (uint)local_a9;
cVar1 = is_be();
local_58 = (uint)(local_a9 ^ (cVar1 != '\0' ^ 0xffU) & 1);
local_50 = *(int **)(*(long *)(local_48 + 0x18) + 0x30);
if ((char)local_50[2] == '\0') {
if ((ulong)*(uint *)(local_48 + 0x24) < (ulong)(local_80 + local_5c)) {
auVar4 = JS_ThrowRangeError(local_28,"out of bound");
local_8 = auVar4._8_8_;
local_10 = auVar4._0_4_;
uStack_c = auVar4._4_4_;
}
else if ((long)*local_50 <
(long)((ulong)*(uint *)(local_48 + 0x20) + (ulong)*(uint *)(local_48 + 0x24))) {
auVar4 = JS_ThrowTypeError(local_28,"out of bound");
local_8 = auVar4._8_8_;
local_10 = auVar4._0_4_;
uStack_c = auVar4._4_4_;
}
else {
local_68 = (int1 *)
(*(long *)(local_50 + 4) + (ulong)*(uint *)(local_48 + 0x20) + local_80);
switch(local_3c) {
case 0x16:
case 0x17:
*local_68 = SUB41(local_74,0);
break;
case 0x18:
case 0x19:
case 0x1e:
if (local_58 != 0) {
uVar2 = bswap16((uint)local_74 & 0xffff);
local_74 = (float)(uint)uVar2;
}
put_u16(local_68,(uint)local_74 & 0xffff);
break;
case 0x1a:
case 0x1b:
case 0x1f:
if (local_58 != 0) {
local_74 = (float)bswap32(local_74);
}
put_u32(local_68,local_74);
break;
case 0x1c:
case 0x1d:
case 0x20:
if (local_58 != 0) {
local_70 = (double)bswap64(local_70);
}
put_u64(local_68,local_70);
break;
default:
/* WARNING: Subroutine does not return */
abort();
}
local_10 = 0;
local_8 = 3;
}
}
else {
auVar4 = JS_ThrowTypeErrorDetachedArrayBuffer(local_28);
local_8 = auVar4._8_8_;
local_10 = auVar4._0_4_;
uStack_c = auVar4._4_4_;
}
}
else {
local_10 = 0;
local_8 = 6;
}
}
LAB_001e3cfb:
auVar4._4_4_ = uStack_c;
auVar4._0_4_ = local_10;
auVar4._8_8_ = local_8;
return auVar4;
}
|
|
8,157 |
js_dataview_setValue
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_dataview_setValue(JSContext *ctx,
JSValue this_obj,
int argc, JSValue *argv, int class_id)
{
JSTypedArray *ta;
JSArrayBuffer *abuf;
BOOL littleEndian, is_swap;
int size;
uint8_t *ptr;
uint64_t v64;
uint32_t v;
uint64_t pos;
JSValue val;
ta = JS_GetOpaque2(ctx, this_obj, JS_CLASS_DATAVIEW);
if (!ta)
return JS_EXCEPTION;
size = 1 << typed_array_size_log2(class_id);
if (JS_ToIndex(ctx, &pos, argv[0]))
return JS_EXCEPTION;
val = argv[1];
v = 0; /* avoid warning */
v64 = 0; /* avoid warning */
if (class_id <= JS_CLASS_UINT32_ARRAY) {
if (JS_ToUint32(ctx, &v, val))
return JS_EXCEPTION;
} else
if (class_id <= JS_CLASS_BIG_UINT64_ARRAY) {
if (JS_ToBigInt64(ctx, (int64_t *)&v64, val))
return JS_EXCEPTION;
} else {
double d;
if (JS_ToFloat64(ctx, &d, val))
return JS_EXCEPTION;
if (class_id == JS_CLASS_FLOAT16_ARRAY) {
v = tofp16(d);
} else if (class_id == JS_CLASS_FLOAT32_ARRAY) {
union {
float f;
uint32_t i;
} u;
u.f = d;
v = u.i;
} else {
JSFloat64Union u;
u.d = d;
v64 = u.u64;
}
}
littleEndian = argc > 2 && JS_ToBool(ctx, argv[2]);
is_swap = littleEndian ^ !is_be();
abuf = ta->buffer->u.array_buffer;
if (abuf->detached)
return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
// order matters: this check should come before the next one
if ((pos + size) > ta->length)
return JS_ThrowRangeError(ctx, "out of bound");
// test262 expects a TypeError for this and V8, in its infinite wisdom,
// throws a "detached array buffer" exception, but IMO that doesn't make
// sense because the buffer is not in fact detached, it's still there
if ((int64_t)ta->offset + ta->length > abuf->byte_length)
return JS_ThrowTypeError(ctx, "out of bound");
ptr = abuf->data + ta->offset + pos;
switch(class_id) {
case JS_CLASS_INT8_ARRAY:
case JS_CLASS_UINT8_ARRAY:
*ptr = v;
break;
case JS_CLASS_INT16_ARRAY:
case JS_CLASS_UINT16_ARRAY:
case JS_CLASS_FLOAT16_ARRAY:
if (is_swap)
v = bswap16(v);
put_u16(ptr, v);
break;
case JS_CLASS_INT32_ARRAY:
case JS_CLASS_UINT32_ARRAY:
case JS_CLASS_FLOAT32_ARRAY:
if (is_swap)
v = bswap32(v);
put_u32(ptr, v);
break;
case JS_CLASS_BIG_INT64_ARRAY:
case JS_CLASS_BIG_UINT64_ARRAY:
case JS_CLASS_FLOAT64_ARRAY:
if (is_swap)
v64 = bswap64(v64);
put_u64(ptr, v64);
break;
default:
abort();
}
return JS_UNDEFINED;
}
|
O1
|
c
|
js_dataview_setValue:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %r15d
movq %r8, %r13
movl %ecx, %ebp
movq %rdi, %r14
movl $0x21, %ecx
callq 0x269a1
movl $0x6, %ebx
testq %rax, %rax
je 0x83384
movq %rax, %r12
movl %ebp, 0x1c(%rsp)
movslq %r15d, %rax
leaq 0x19055(%rip), %rcx # 0x9c1cf
movb -0x15(%rax,%rcx), %cl
movl $0x1, %ebp
shll %cl, %ebp
movq (%r13), %rdx
movq 0x8(%r13), %rcx
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x26e5b
testl %eax, %eax
jne 0x83384
movq 0x10(%r13), %rdx
movq 0x18(%r13), %rcx
movl $0x0, 0x4(%rsp)
movq $0x0, 0x10(%rsp)
cmpl $0x1b, %r15d
jg 0x831e1
movq %rdx, 0x8(%rsp)
cmpl $-0x9, %ecx
jb 0x831d2
movq 0x8(%rsp), %rax
incl (%rax)
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x26daf
jmp 0x83205
cmpl $0x1d, %r15d
jg 0x8323c
movq %rdx, 0x8(%rsp)
cmpl $-0x9, %ecx
jb 0x831f8
movq 0x8(%rsp), %rax
incl (%rax)
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x277c4
testl %eax, %eax
jne 0x83384
cmpl $0x3, 0x1c(%rsp)
jl 0x83279
movq 0x20(%r13), %rsi
movq 0x28(%r13), %rdx
movq %rsi, 0x8(%rsp)
cmpl $-0x9, %edx
jb 0x8322d
movq 0x8(%rsp), %rax
incl (%rax)
movq %r14, %rdi
callq 0x220f9
testl %eax, %eax
setne %dl
jmp 0x8327b
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x26a6d
testl %eax, %eax
jne 0x83384
cmpl $0x1f, %r15d
je 0x83325
cmpl $0x1e, %r15d
jne 0x83336
movsd 0x8(%rsp), %xmm0
callq 0x3d08a
movzwl %ax, %eax
movl %eax, 0x4(%rsp)
jmp 0x8320d
xorl %edx, %edx
movq 0x18(%r12), %rax
movq 0x30(%rax), %rsi
cmpb $0x0, 0x8(%rsi)
je 0x832a0
leaq 0x1da60(%rip), %rsi # 0xa0cf1
movq %r14, %rdi
xorl %eax, %eax
callq 0x21953
jmp 0x83384
movq 0x20(%rsp), %rax
movslq %ebp, %rcx
addq %rax, %rcx
movl 0x24(%r12), %edi
cmpq %rdi, %rcx
jbe 0x832cb
leaq 0x1dd94(%rip), %rsi # 0xa1050
movq %r14, %rdi
xorl %eax, %eax
callq 0x1fec9
jmp 0x83384
movl 0x20(%r12), %ecx
addq %rcx, %rdi
movslq (%rsi), %r8
cmpq %r8, %rdi
jle 0x832e4
leaq 0x1dd6e(%rip), %rsi # 0xa1050
jmp 0x83291
addl $-0x16, %r15d
cmpl $0xa, %r15d
ja 0x83398
addq 0x10(%rsi), %rcx
leaq 0x18e1b(%rip), %rsi # 0x9c118
movslq (%rsi,%r15,4), %rdi
addq %rsi, %rdi
jmpq *%rdi
testb %dl, %dl
jne 0x8331a
movzwl 0x4(%rsp), %edx
rolw $0x8, %dx
movzwl %dx, %edx
movl %edx, 0x4(%rsp)
movzwl 0x4(%rsp), %edx
movw %dx, (%rcx,%rax)
jmp 0x8337f
cvtsd2ss 0x8(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
jmp 0x8320d
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x8320d
testb %dl, %dl
jne 0x83356
movq 0x10(%rsp), %rdx
bswapq %rdx
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rdx
movq %rdx, (%rcx,%rax)
jmp 0x8337f
testb %dl, %dl
jne 0x8336f
movl 0x4(%rsp), %edx
bswapl %edx
movl %edx, 0x4(%rsp)
movl 0x4(%rsp), %edx
movl %edx, (%rcx,%rax)
jmp 0x8337f
movb 0x4(%rsp), %dl
movb %dl, (%rcx,%rax)
movl $0x3, %ebx
xorl %eax, %eax
movq %rbx, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xe090
|
js_dataview_setValue:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r15d, r9d
mov r13, r8
mov ebp, ecx
mov r14, rdi
mov ecx, 21h ; '!'
call JS_GetOpaque2
mov ebx, 6
test rax, rax
jz loc_83384
mov r12, rax
mov [rsp+58h+var_3C], ebp
movsxd rax, r15d
lea rcx, typed_array_size_log2
mov cl, [rax+rcx-15h]
mov ebp, 1
shl ebp, cl
mov rdx, [r13+0]
mov rcx, [r13+8]
lea rsi, [rsp+58h+var_38]
mov rdi, r14
call JS_ToIndex
test eax, eax
jnz loc_83384
mov rdx, [r13+10h]
mov rcx, [r13+18h]
mov [rsp+58h+var_54], 0
mov [rsp+58h+var_48], 0
cmp r15d, 1Bh
jg short loc_831E1
mov [rsp+58h+var_50], rdx
cmp ecx, 0FFFFFFF7h
jb short loc_831D2
mov rax, [rsp+58h+var_50]
inc dword ptr [rax]
loc_831D2:
lea rsi, [rsp+58h+var_54]
mov rdi, r14
call JS_ToInt32Free
jmp short loc_83205
loc_831E1:
cmp r15d, 1Dh
jg short loc_8323C
mov [rsp+58h+var_50], rdx
cmp ecx, 0FFFFFFF7h
jb short loc_831F8
mov rax, [rsp+58h+var_50]
inc dword ptr [rax]
loc_831F8:
lea rsi, [rsp+58h+var_48]
mov rdi, r14
call JS_ToBigInt64Free
loc_83205:
test eax, eax
jnz loc_83384
loc_8320D:
cmp [rsp+58h+var_3C], 3
jl short loc_83279
mov rsi, [r13+20h]
mov rdx, [r13+28h]
mov [rsp+58h+var_50], rsi
cmp edx, 0FFFFFFF7h
jb short loc_8322D
mov rax, [rsp+58h+var_50]
inc dword ptr [rax]
loc_8322D:
mov rdi, r14
call JS_ToBoolFree
test eax, eax
setnz dl
jmp short loc_8327B
loc_8323C:
lea rsi, [rsp+58h+var_50]
mov rdi, r14
call JS_ToFloat64
test eax, eax
jnz loc_83384
cmp r15d, 1Fh
jz loc_83325
cmp r15d, 1Eh
jnz loc_83336
movsd xmm0, [rsp+58h+var_50]
call tofp16
movzx eax, ax
mov [rsp+58h+var_54], eax
jmp short loc_8320D
loc_83279:
xor edx, edx
loc_8327B:
mov rax, [r12+18h]
mov rsi, [rax+30h]
cmp byte ptr [rsi+8], 0
jz short loc_832A0
lea rsi, aArraybufferIsD; "ArrayBuffer is detached"
loc_83291:
mov rdi, r14
xor eax, eax
call JS_ThrowTypeError
jmp loc_83384
loc_832A0:
mov rax, [rsp+58h+var_38]
movsxd rcx, ebp
add rcx, rax
mov edi, [r12+24h]
cmp rcx, rdi
jbe short loc_832CB
lea rsi, aOutOfBound; "out of bound"
mov rdi, r14
xor eax, eax
call JS_ThrowRangeError
jmp loc_83384
loc_832CB:
mov ecx, [r12+20h]
add rdi, rcx
movsxd r8, dword ptr [rsi]
cmp rdi, r8
jle short loc_832E4
lea rsi, aOutOfBound; "out of bound"
jmp short loc_83291
loc_832E4:
add r15d, 0FFFFFFEAh; switch 11 cases
cmp r15d, 0Ah
ja def_83304; jumptable 0000000000083304 default case
add rcx, [rsi+10h]
lea rsi, jpt_83304
movsxd rdi, ds:(jpt_83304 - 9C118h)[rsi+r15*4]
add rdi, rsi
jmp rdi; switch jump
loc_83306:
test dl, dl; jumptable 0000000000083304 cases 24,25,30
jnz short loc_8331A
movzx edx, word ptr [rsp+58h+var_54]
rol dx, 8
movzx edx, dx
mov [rsp+58h+var_54], edx
loc_8331A:
movzx edx, word ptr [rsp+58h+var_54]
mov [rcx+rax], dx
jmp short loc_8337F
loc_83325:
cvtsd2ss xmm0, [rsp+58h+var_50]
movss [rsp+58h+var_54], xmm0
jmp loc_8320D
loc_83336:
mov rax, [rsp+58h+var_50]
mov [rsp+58h+var_48], rax
jmp loc_8320D
loc_83345:
test dl, dl; jumptable 0000000000083304 cases 28,29,32
jnz short loc_83356
mov rdx, [rsp+58h+var_48]
bswap rdx
mov [rsp+58h+var_48], rdx
loc_83356:
mov rdx, [rsp+58h+var_48]
mov [rcx+rax], rdx
jmp short loc_8337F
loc_83361:
test dl, dl; jumptable 0000000000083304 cases 26,27,31
jnz short loc_8336F
mov edx, [rsp+58h+var_54]
bswap edx
mov [rsp+58h+var_54], edx
loc_8336F:
mov edx, [rsp+58h+var_54]
mov [rcx+rax], edx
jmp short loc_8337F
loc_83378:
mov dl, byte ptr [rsp+58h+var_54]; jumptable 0000000000083304 cases 22,23
mov [rcx+rax], dl
loc_8337F:
mov ebx, 3
loc_83384:
xor eax, eax
mov rdx, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
def_83304:
call _abort; jumptable 0000000000083304 default case
|
long long js_dataview_setValue(
long long a1,
long long a2,
int a3,
int a4,
long long *a5,
int a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14)
{
long long Opaque2; // rax
double v19; // xmm4_8
double v20; // xmm5_8
long long v21; // r12
int v22; // ebp
_DWORD *v23; // rdx
long long v24; // rcx
int v25; // eax
long long v26; // rcx
long long v27; // r8
long long v28; // r9
__m128 v29; // xmm4
__m128 v30; // xmm5
long long v31; // rsi
long long v32; // rdx
long long v33; // rdx
int *v34; // rsi
const char *v35; // rsi
unsigned long long v36; // rcx
unsigned long long v37; // rdi
const char *v38; // rdi
long long v39; // rcx
char v41; // [rsp+0h] [rbp-58h]
unsigned int v42; // [rsp+4h] [rbp-54h] BYREF
_DWORD *v43; // [rsp+8h] [rbp-50h] BYREF
_DWORD *v44; // [rsp+10h] [rbp-48h] BYREF
int v45; // [rsp+1Ch] [rbp-3Ch]
unsigned long long v46[7]; // [rsp+20h] [rbp-38h] BYREF
Opaque2 = JS_GetOpaque2(a1, a2, a3, 0x21u);
if ( !Opaque2 )
return 0LL;
v21 = Opaque2;
v45 = a4;
v22 = 1 << typed_array_size_log2[a6 - 21];
if ( (unsigned int)JS_ToIndex(a1, v46, *a5, a5[1], a7, a8, a9, a10, v19, v20, a13, a14) )
return 0LL;
v23 = *((_DWORD **)a5 + 2);
v24 = a5[3];
v42 = 0;
v44 = 0LL;
if ( a6 <= 27 )
{
v43 = v23;
if ( (unsigned int)v24 >= 0xFFFFFFF7 )
++*v43;
v25 = JS_ToInt32Free(a1, (int *)&v42, (unsigned long long)v23, v24);
goto LABEL_11;
}
if ( a6 <= 29 )
{
v43 = v23;
if ( (unsigned int)v24 >= 0xFFFFFFF7 )
++*v43;
v25 = JS_ToBigInt64Free(a1, &v44);
LABEL_11:
if ( v25 )
return 0LL;
goto LABEL_12;
}
if ( (unsigned int)JS_ToFloat64(a1, (double *)&v43, v23, v24) )
return 0LL;
if ( a6 == 31 )
{
a7.m128_f32[0] = *(double *)&v43;
v42 = a7.m128_i32[0];
}
else if ( a6 == 30 )
{
a7 = (__m128)(unsigned long long)v43;
v42 = (unsigned __int16)tofp16(*(double *)&v43);
}
else
{
v44 = v43;
}
LABEL_12:
if ( v45 < 3 )
{
v33 = 0LL;
}
else
{
v31 = a5[4];
v32 = a5[5];
v43 = (_DWORD *)v31;
if ( (unsigned int)v32 >= 0xFFFFFFF7 )
++*v43;
LOBYTE(v33) = (unsigned int)JS_ToBoolFree(a1, v31, v32) != 0;
}
v34 = *(int **)(*(_QWORD *)(v21 + 24) + 48LL);
if ( *((_BYTE *)v34 + 8) )
{
v35 = "ArrayBuffer is detached";
LABEL_23:
JS_ThrowTypeError(a1, (long long)v35, v33, v26, v27, v28, a7, a8, a9, a10, v29, v30, a13, a14, v41);
return 0LL;
}
v36 = v46[0] + v22;
v37 = *(unsigned int *)(v21 + 36);
if ( v36 > v37 )
{
JS_ThrowRangeError(a1, (long long)"out of bound", v33, v36, v27, v28, a7, a8, a9, a10, v29, v30, a13, a14, v41);
return 0LL;
}
v26 = *(unsigned int *)(v21 + 32);
v38 = (const char *)(v26 + v37);
v27 = *v34;
if ( (long long)v38 > v27 )
{
v35 = "out of bound";
goto LABEL_23;
}
v39 = *((_QWORD *)v34 + 2) + v26;
switch ( a6 )
{
case 22:
case 23:
*(_BYTE *)(v39 + v46[0]) = v42;
break;
case 24:
case 25:
case 30:
if ( !(_BYTE)v33 )
v42 = (unsigned __int16)__ROL2__(v42, 8);
*(_WORD *)(v39 + v46[0]) = v42;
break;
case 26:
case 27:
case 31:
if ( !(_BYTE)v33 )
v42 = _byteswap_ulong(v42);
*(_DWORD *)(v39 + v46[0]) = v42;
break;
case 28:
case 29:
case 32:
if ( !(_BYTE)v33 )
v44 = (_DWORD *)_byteswap_uint64((unsigned long long)v44);
*(_QWORD *)(v39 + v46[0]) = v44;
break;
default:
abort(v38, v34, v33, v39);
}
return 0LL;
}
|
js_dataview_setValue:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R15D,R9D
MOV R13,R8
MOV EBP,ECX
MOV R14,RDI
MOV ECX,0x21
CALL 0x001269a1
MOV EBX,0x6
TEST RAX,RAX
JZ 0x00183384
MOV R12,RAX
MOV dword ptr [RSP + 0x1c],EBP
MOVSXD RAX,R15D
LEA RCX,[0x19c1cf]
MOV CL,byte ptr [RAX + RCX*0x1 + -0x15]
MOV EBP,0x1
SHL EBP,CL
MOV RDX,qword ptr [R13]
MOV RCX,qword ptr [R13 + 0x8]
LEA RSI,[RSP + 0x20]
MOV RDI,R14
CALL 0x00126e5b
TEST EAX,EAX
JNZ 0x00183384
MOV RDX,qword ptr [R13 + 0x10]
MOV RCX,qword ptr [R13 + 0x18]
MOV dword ptr [RSP + 0x4],0x0
MOV qword ptr [RSP + 0x10],0x0
CMP R15D,0x1b
JG 0x001831e1
MOV qword ptr [RSP + 0x8],RDX
CMP ECX,-0x9
JC 0x001831d2
MOV RAX,qword ptr [RSP + 0x8]
INC dword ptr [RAX]
LAB_001831d2:
LEA RSI,[RSP + 0x4]
MOV RDI,R14
CALL 0x00126daf
JMP 0x00183205
LAB_001831e1:
CMP R15D,0x1d
JG 0x0018323c
MOV qword ptr [RSP + 0x8],RDX
CMP ECX,-0x9
JC 0x001831f8
MOV RAX,qword ptr [RSP + 0x8]
INC dword ptr [RAX]
LAB_001831f8:
LEA RSI,[RSP + 0x10]
MOV RDI,R14
CALL 0x001277c4
LAB_00183205:
TEST EAX,EAX
JNZ 0x00183384
LAB_0018320d:
CMP dword ptr [RSP + 0x1c],0x3
JL 0x00183279
MOV RSI,qword ptr [R13 + 0x20]
MOV RDX,qword ptr [R13 + 0x28]
MOV qword ptr [RSP + 0x8],RSI
CMP EDX,-0x9
JC 0x0018322d
MOV RAX,qword ptr [RSP + 0x8]
INC dword ptr [RAX]
LAB_0018322d:
MOV RDI,R14
CALL 0x001220f9
TEST EAX,EAX
SETNZ DL
JMP 0x0018327b
LAB_0018323c:
LEA RSI,[RSP + 0x8]
MOV RDI,R14
CALL 0x00126a6d
TEST EAX,EAX
JNZ 0x00183384
CMP R15D,0x1f
JZ 0x00183325
CMP R15D,0x1e
JNZ 0x00183336
MOVSD XMM0,qword ptr [RSP + 0x8]
CALL 0x0013d08a
MOVZX EAX,AX
MOV dword ptr [RSP + 0x4],EAX
JMP 0x0018320d
LAB_00183279:
XOR EDX,EDX
LAB_0018327b:
MOV RAX,qword ptr [R12 + 0x18]
MOV RSI,qword ptr [RAX + 0x30]
CMP byte ptr [RSI + 0x8],0x0
JZ 0x001832a0
LEA RSI,[0x1a0cf1]
LAB_00183291:
MOV RDI,R14
XOR EAX,EAX
CALL 0x00121953
JMP 0x00183384
LAB_001832a0:
MOV RAX,qword ptr [RSP + 0x20]
MOVSXD RCX,EBP
ADD RCX,RAX
MOV EDI,dword ptr [R12 + 0x24]
CMP RCX,RDI
JBE 0x001832cb
LEA RSI,[0x1a1050]
MOV RDI,R14
XOR EAX,EAX
CALL 0x0011fec9
JMP 0x00183384
LAB_001832cb:
MOV ECX,dword ptr [R12 + 0x20]
ADD RDI,RCX
MOVSXD R8,dword ptr [RSI]
CMP RDI,R8
JLE 0x001832e4
LEA RSI,[0x1a1050]
JMP 0x00183291
LAB_001832e4:
ADD R15D,-0x16
CMP R15D,0xa
JA 0x00183398
ADD RCX,qword ptr [RSI + 0x10]
LEA RSI,[0x19c118]
MOVSXD RDI,dword ptr [RSI + R15*0x4]
ADD RDI,RSI
switchD:
JMP RDI
caseD_18:
TEST DL,DL
JNZ 0x0018331a
MOVZX EDX,word ptr [RSP + 0x4]
ROL DX,0x8
MOVZX EDX,DX
MOV dword ptr [RSP + 0x4],EDX
LAB_0018331a:
MOVZX EDX,word ptr [RSP + 0x4]
MOV word ptr [RCX + RAX*0x1],DX
JMP 0x0018337f
LAB_00183325:
CVTSD2SS XMM0,qword ptr [RSP + 0x8]
MOVSS dword ptr [RSP + 0x4],XMM0
JMP 0x0018320d
LAB_00183336:
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x10],RAX
JMP 0x0018320d
caseD_1c:
TEST DL,DL
JNZ 0x00183356
MOV RDX,qword ptr [RSP + 0x10]
BSWAP RDX
MOV qword ptr [RSP + 0x10],RDX
LAB_00183356:
MOV RDX,qword ptr [RSP + 0x10]
MOV qword ptr [RCX + RAX*0x1],RDX
JMP 0x0018337f
caseD_1a:
TEST DL,DL
JNZ 0x0018336f
MOV EDX,dword ptr [RSP + 0x4]
BSWAP EDX
MOV dword ptr [RSP + 0x4],EDX
LAB_0018336f:
MOV EDX,dword ptr [RSP + 0x4]
MOV dword ptr [RCX + RAX*0x1],EDX
JMP 0x0018337f
caseD_16:
MOV DL,byte ptr [RSP + 0x4]
MOV byte ptr [RCX + RAX*0x1],DL
LAB_0018337f:
MOV EBX,0x3
LAB_00183384:
XOR EAX,EAX
MOV RDX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00183398:
CALL 0x0010e090
|
int1 [16]
js_dataview_setValue
(int8 param_1,int8 param_2,int8 param_3,int param_4,int8 *param_5,
int param_6)
{
byte bVar1;
int *piVar2;
int1 auVar3 [16];
ushort uVar4;
int iVar5;
long lVar6;
ulong uVar7;
char *pcVar8;
bool bVar9;
float local_54;
int *local_50;
int *local_48;
int local_3c;
long local_38;
lVar6 = JS_GetOpaque2();
uVar7 = 6;
if (lVar6 == 0) goto LAB_00183384;
bVar1 = "toSorted"[(long)param_6 + 6];
local_3c = param_4;
iVar5 = JS_ToIndex(param_1,&local_38,*param_5,param_5[1]);
if (iVar5 != 0) goto LAB_00183384;
piVar2 = (int *)param_5[2];
local_54 = 0.0;
local_48 = (int *)0x0;
if (param_6 < 0x1c) {
if (0xfffffff6 < (uint)param_5[3]) {
*piVar2 = *piVar2 + 1;
}
local_50 = piVar2;
iVar5 = JS_ToInt32Free(param_1,&local_54);
LAB_00183205:
if (iVar5 != 0) goto LAB_00183384;
}
else {
if (param_6 < 0x1e) {
if (0xfffffff6 < (uint)param_5[3]) {
*piVar2 = *piVar2 + 1;
}
local_50 = piVar2;
iVar5 = JS_ToBigInt64Free(param_1,&local_48);
goto LAB_00183205;
}
iVar5 = JS_ToFloat64(param_1,&local_50);
if (iVar5 != 0) goto LAB_00183384;
if (param_6 == 0x1f) {
local_54 = (float)(double)local_50;
}
else if (param_6 == 0x1e) {
uVar4 = tofp16(local_50);
local_54 = (float)(uint)uVar4;
}
else {
local_48 = local_50;
}
}
if (local_3c < 3) {
bVar9 = false;
}
else {
local_50 = (int *)param_5[4];
if (0xfffffff6 < (uint)param_5[5]) {
*local_50 = *local_50 + 1;
}
iVar5 = JS_ToBoolFree(param_1);
bVar9 = iVar5 != 0;
}
piVar2 = *(int **)(*(long *)(lVar6 + 0x18) + 0x30);
if ((char)piVar2[2] == '\0') {
if ((ulong)*(uint *)(lVar6 + 0x24) < (ulong)((1 << (bVar1 & 0x1f)) + local_38)) {
JS_ThrowRangeError(param_1,"out of bound");
goto LAB_00183384;
}
if ((long)((ulong)*(uint *)(lVar6 + 0x24) + (ulong)*(uint *)(lVar6 + 0x20)) <= (long)*piVar2) {
if (10 < param_6 - 0x16U) {
/* WARNING: Subroutine does not return */
abort();
}
lVar6 = (ulong)*(uint *)(lVar6 + 0x20) + *(long *)(piVar2 + 4);
switch(param_6) {
case 0x16:
case 0x17:
*(int1 *)(lVar6 + local_38) = local_54._0_1_;
break;
default:
if (!bVar9) {
local_54 = (float)(uint)(ushort)(local_54._0_2_ << 8 | local_54._0_2_ >> 8);
}
*(ushort *)(lVar6 + local_38) = local_54._0_2_;
break;
case 0x1a:
case 0x1b:
case 0x1f:
if (!bVar9) {
local_54 = (float)((uint)local_54 >> 0x18 | ((uint)local_54 & 0xff0000) >> 8 |
((uint)local_54 & 0xff00) << 8 | (int)local_54 << 0x18);
}
*(float *)(lVar6 + local_38) = local_54;
break;
case 0x1c:
case 0x1d:
case 0x20:
if (!bVar9) {
local_48 = (int *)((ulong)local_48 >> 0x38 | ((ulong)local_48 & 0xff000000000000) >> 0x28
| ((ulong)local_48 & 0xff0000000000) >> 0x18 |
((ulong)local_48 & 0xff00000000) >> 8 |
((ulong)local_48 & 0xff000000) << 8 |
((ulong)local_48 & 0xff0000) << 0x18 |
((ulong)local_48 & 0xff00) << 0x28 | (long)local_48 << 0x38);
}
*(int **)(lVar6 + local_38) = local_48;
}
uVar7 = 3;
goto LAB_00183384;
}
pcVar8 = "out of bound";
}
else {
pcVar8 = "ArrayBuffer is detached";
}
JS_ThrowTypeError(param_1,pcVar8);
LAB_00183384:
auVar3._8_8_ = 0;
auVar3._0_8_ = uVar7;
return auVar3 << 0x40;
}
|
|
8,158 |
js_regexp_Symbol_match
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_regexp_Symbol_match(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
// [Symbol.match](str)
JSValue rx = this_val;
JSValue A, S, flags, result, matchStr;
int global, n, fullUnicode, isEmpty;
JSString *p;
if (!JS_IsObject(rx))
return JS_ThrowTypeErrorNotAnObject(ctx);
A = JS_UNDEFINED;
flags = JS_UNDEFINED;
result = JS_UNDEFINED;
matchStr = JS_UNDEFINED;
S = JS_ToString(ctx, argv[0]);
if (JS_IsException(S))
goto exception;
flags = JS_GetProperty(ctx, rx, JS_ATOM_flags);
if (JS_IsException(flags))
goto exception;
flags = JS_ToStringFree(ctx, flags);
if (JS_IsException(flags))
goto exception;
p = JS_VALUE_GET_STRING(flags);
// TODO(bnoordhuis) query 'u' flag the same way?
global = (-1 != string_indexof_char(p, 'g', 0));
if (!global) {
A = JS_RegExpExec(ctx, rx, S);
} else {
fullUnicode = JS_ToBoolFree(ctx, JS_GetProperty(ctx, rx, JS_ATOM_unicode));
if (fullUnicode < 0)
goto exception;
if (JS_SetProperty(ctx, rx, JS_ATOM_lastIndex, js_int32(0)) < 0)
goto exception;
A = JS_NewArray(ctx);
if (JS_IsException(A))
goto exception;
n = 0;
for(;;) {
JS_FreeValue(ctx, result);
result = JS_RegExpExec(ctx, rx, S);
if (JS_IsException(result))
goto exception;
if (JS_IsNull(result))
break;
matchStr = JS_ToStringFree(ctx, JS_GetPropertyInt64(ctx, result, 0));
if (JS_IsException(matchStr))
goto exception;
isEmpty = JS_IsEmptyString(matchStr);
if (JS_SetPropertyInt64(ctx, A, n++, matchStr) < 0)
goto exception;
if (isEmpty) {
int64_t thisIndex, nextIndex;
if (JS_ToLengthFree(ctx, &thisIndex,
JS_GetProperty(ctx, rx, JS_ATOM_lastIndex)) < 0)
goto exception;
p = JS_VALUE_GET_STRING(S);
nextIndex = string_advance_index(p, thisIndex, fullUnicode);
if (JS_SetProperty(ctx, rx, JS_ATOM_lastIndex, js_int64(nextIndex)) < 0)
goto exception;
}
}
if (n == 0) {
JS_FreeValue(ctx, A);
A = JS_NULL;
}
}
JS_FreeValue(ctx, result);
JS_FreeValue(ctx, flags);
JS_FreeValue(ctx, S);
return A;
exception:
JS_FreeValue(ctx, A);
JS_FreeValue(ctx, result);
JS_FreeValue(ctx, flags);
JS_FreeValue(ctx, S);
return JS_EXCEPTION;
}
|
O2
|
c
|
js_regexp_Symbol_match:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cmpl $-0x1, %r14d
jne 0x4026e
movq %rsi, %r15
movq (%r8), %rsi
movq 0x8(%r8), %rdx
movq %rbx, %rdi
callq 0x1b03c
movq %rax, 0x28(%rsp)
pushq $0x3
popq %rbp
movq %rdx, 0x30(%rsp)
cmpl $0x6, %edx
jne 0x4027b
xorl %r14d, %r14d
xorl %r13d, %r13d
movq %rbp, %r15
movq %rbp, %r8
xorl %ecx, %ecx
xorl %r12d, %r12d
jmp 0x403d8
movq %rbx, %rdi
callq 0x1d5e1
jmp 0x4041a
pushq $0x6e
popq %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1b043
cmpl $0x6, %edx
jne 0x402a7
xorl %r13d, %r13d
movq %rbp, %r8
xorl %ecx, %ecx
xorl %r12d, %r12d
movq %rax, %r14
movq %rdx, %r15
jmp 0x403d8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2e049
movq %rdx, 0x8(%rsp)
cmpl $0x6, %edx
jne 0x402cf
xorl %r13d, %r13d
movq %rbp, %r8
xorl %ecx, %ecx
xorl %r12d, %r12d
movq %rax, %r14
jmp 0x403d3
pushq $0x67
popq %rsi
movq %rax, 0x10(%rsp)
movq %rax, %rdi
xorl %edx, %edx
callq 0x414fc
cmpl $-0x1, %eax
je 0x40351
pushq $0x70
popq %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1b043
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1cdfa
movl %eax, 0x4c(%rsp)
testl %eax, %eax
js 0x403b9
pushq $0x56
popq %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x1e446
testl %eax, %eax
js 0x403c3
movq %rbx, %rdi
callq 0x1b2bb
movq %rax, %rcx
movq %rdx, %r8
movq %rax, %r12
shrq $0x20, %r12
cmpl $0x6, %r8d
jne 0x40434
xorl %r13d, %r13d
jmp 0x403ce
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq 0x28(%rsp), %r15
movq %r15, %rcx
movq 0x30(%rsp), %r14
movq %r14, %r8
callq 0x4133b
movq %rax, %rbp
movq %rdx, (%rsp)
movq %rax, %r12
shrq $0x20, %r12
pushq $0x3
popq %rdx
xorl %eax, %eax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1801e
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x1801e
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1801e
shlq $0x20, %r12
movl %ebp, %eax
movq (%rsp), %rdx
jmp 0x40422
xorl %r13d, %r13d
movq %rbp, %r8
xorl %ecx, %ecx
jmp 0x403cb
movq %rbp, %r8
xorl %ecx, %ecx
xorl %r13d, %r13d
xorl %r12d, %r12d
movq 0x10(%rsp), %r14
movq 0x8(%rsp), %r15
shlq $0x20, %r12
movl %ecx, %esi
orq %r12, %rsi
movq %rbx, %rdi
movq %r8, %rdx
callq 0x1801e
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x1801e
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1801e
movq %rbx, %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x1801e
pushq $0x6
popq %rdx
xorl %eax, %eax
xorl %r12d, %r12d
orq %r12, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r8, (%rsp)
movq %rcx, 0x18(%rsp)
pushq $0x3
popq %rax
movq %rax, 0x20(%rsp)
movq $0x0, 0x40(%rsp)
xorl %esi, %esi
movq %rbx, %rdi
movq 0x20(%rsp), %rdx
callq 0x1801e
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %r8
callq 0x4133b
movq %rdx, %rbp
cmpl $0x2, %ebp
movq %rdx, 0x20(%rsp)
je 0x40594
cmpl $0x6, %ebp
je 0x405b5
movq %rbx, %rdi
movq %rax, 0x38(%rsp)
movq %rax, %rsi
movq %rbp, %rdx
xorl %ecx, %ecx
callq 0x1e178
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2e049
movq %rdx, %r9
cmpl $-0x7, %r9d
je 0x404d4
movb $0x1, %r13b
cmpl $0x6, %r9d
movq 0x18(%rsp), %rcx
movq 0x40(%rsp), %rbp
movq (%rsp), %r8
jne 0x404ed
jmp 0x405d0
testl $0x7fffffff, 0x4(%rax) # imm = 0x7FFFFFFF
setne %r13b
movq 0x18(%rsp), %rcx
movq 0x40(%rsp), %rbp
movq (%rsp), %r8
movq %rbx, %rdi
movq %rcx, %rsi
movq %r8, %rdx
movq %rbp, %rcx
movq %rax, %r8
callq 0x1f0a6
testl %eax, %eax
js 0x4057e
testb %r13b, %r13b
jne 0x4056c
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
pushq $0x56
popq %r13
movl %r13d, %ecx
callq 0x1b043
movq %rdx, %rcx
movq %rbx, %rdi
leaq 0x50(%rsp), %rsi
movq %rax, %rdx
callq 0x3daf8
testl %eax, %eax
js 0x4057e
movq 0x50(%rsp), %rsi
movq 0x28(%rsp), %rdi
movl 0x4c(%rsp), %edx
callq 0x41551
movq %rax, %rdi
callq 0x20a0b
movq %rdx, %r9
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %r13d, %ecx
movq %rax, %r8
callq 0x1e446
testl %eax, %eax
js 0x4057e
incq %rbp
movq %rbp, 0x40(%rsp)
movq 0x38(%rsp), %rsi
jmp 0x40450
movq 0x10(%rsp), %r14
movq 0x8(%rsp), %r15
movq 0x38(%rsp), %r13
movq 0x20(%rsp), %rbp
jmp 0x405c2
cmpq $0x0, 0x40(%rsp)
je 0x405e9
movq 0x30(%rsp), %r14
movq 0x28(%rsp), %r15
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rbp
jmp 0x40382
movq 0x10(%rsp), %r14
movq 0x8(%rsp), %r15
movq %rax, %r13
movq 0x18(%rsp), %rcx
movq (%rsp), %r8
jmp 0x403d8
movq 0x10(%rsp), %r14
movq 0x8(%rsp), %r15
movq 0x38(%rsp), %r13
movq 0x20(%rsp), %rbp
jmp 0x403d8
movq %rbx, %rdi
movq %rax, %r14
movq 0x18(%rsp), %rsi
movq (%rsp), %rdx
callq 0x1801e
movq %r14, %rax
pushq $0x2
popq %rcx
movq %rcx, (%rsp)
xorl %ebp, %ebp
xorl %r12d, %r12d
movq 0x30(%rsp), %r14
movq 0x28(%rsp), %r15
movq 0x20(%rsp), %rdx
jmp 0x40382
|
js_regexp_Symbol_match:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov r14, rdx
mov rbx, rdi
cmp r14d, 0FFFFFFFFh
jnz short loc_4026E
mov r15, rsi
mov rsi, [r8]
mov rdx, [r8+8]
mov rdi, rbx
call JS_ToString
mov [rsp+88h+var_60], rax
push 3
pop rbp
mov [rsp+88h+var_58], rdx
cmp edx, 6
jnz short loc_4027B
xor r14d, r14d
xor r13d, r13d
mov r15, rbp
mov r8, rbp
xor ecx, ecx
xor r12d, r12d
jmp loc_403D8
loc_4026E:
mov rdi, rbx
call JS_ThrowTypeErrorNotAnObject
jmp loc_4041A
loc_4027B:
push 6Eh ; 'n'
pop rcx
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call JS_GetProperty
cmp edx, 6
jnz short loc_402A7
xor r13d, r13d
mov r8, rbp
xor ecx, ecx
xor r12d, r12d
mov r14, rax
mov r15, rdx
jmp loc_403D8
loc_402A7:
mov rdi, rbx
mov rsi, rax
call JS_ToStringFree
mov [rsp+88h+var_80], rdx
cmp edx, 6
jnz short loc_402CF
xor r13d, r13d
mov r8, rbp
xor ecx, ecx
xor r12d, r12d
mov r14, rax
jmp loc_403D3
loc_402CF:
push 67h ; 'g'
pop rsi
mov [rsp+88h+var_78], rax
mov rdi, rax
xor edx, edx
call string_indexof_char
cmp eax, 0FFFFFFFFh
jz short loc_40351
push 70h ; 'p'
pop rcx
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call JS_GetProperty
mov rdi, rbx
mov rsi, rax
call JS_ToBoolFree
mov [rsp+88h+var_3C], eax
test eax, eax
js loc_403B9
push 56h ; 'V'
pop rcx
mov rdi, rbx
mov rsi, r15
mov rdx, r14
xor r8d, r8d
xor r9d, r9d
call JS_SetProperty
test eax, eax
js loc_403C3
mov rdi, rbx
call JS_NewArray
mov rcx, rax
mov r8, rdx
mov r12, rax
shr r12, 20h
cmp r8d, 6
jnz loc_40434
xor r13d, r13d
jmp short loc_403CE
loc_40351:
mov rdi, rbx
mov rsi, r15
mov rdx, r14
mov r15, [rsp+88h+var_60]
mov rcx, r15
mov r14, [rsp+88h+var_58]
mov r8, r14
call JS_RegExpExec
mov rbp, rax
mov [rsp+88h+var_88], rdx
mov r12, rax
shr r12, 20h
push 3
pop rdx
xor eax, eax
loc_40382:
mov rdi, rbx
mov rsi, rax
call JS_FreeValue
mov rdi, rbx
mov rsi, [rsp+88h+var_78]
mov rdx, [rsp+88h+var_80]
call JS_FreeValue
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call JS_FreeValue
shl r12, 20h
mov eax, ebp
mov rdx, [rsp+88h+var_88]
jmp short loc_40422
loc_403B9:
xor r13d, r13d
mov r8, rbp
xor ecx, ecx
jmp short loc_403CB
loc_403C3:
mov r8, rbp
xor ecx, ecx
xor r13d, r13d
loc_403CB:
xor r12d, r12d
loc_403CE:
mov r14, [rsp+88h+var_78]
loc_403D3:
mov r15, [rsp+88h+var_80]
loc_403D8:
shl r12, 20h
mov esi, ecx
or rsi, r12
mov rdi, rbx
mov rdx, r8
call JS_FreeValue
mov rdi, rbx
mov rsi, r13
mov rdx, rbp
call JS_FreeValue
mov rdi, rbx
mov rsi, r14
mov rdx, r15
call JS_FreeValue
mov rdi, rbx
mov rsi, [rsp+88h+var_60]
mov rdx, [rsp+88h+var_58]
call JS_FreeValue
loc_4041A:
push 6
pop rdx
xor eax, eax
xor r12d, r12d
loc_40422:
or rax, r12
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_40434:
mov [rsp+88h+var_88], r8
mov [rsp+88h+var_70], rcx
push 3
pop rax
mov [rsp+88h+var_68], rax
mov [rsp+88h+var_48], 0
xor esi, esi
loc_40450:
mov rdi, rbx
mov rdx, [rsp+88h+var_68]
call JS_FreeValue
mov rdi, rbx
mov rsi, r15
mov rdx, r14
mov rcx, [rsp+88h+var_60]
mov r8, [rsp+88h+var_58]
call JS_RegExpExec
mov rbp, rdx
cmp ebp, 2
mov [rsp+88h+var_68], rdx
jz loc_40594
cmp ebp, 6
jz loc_405B5
mov rdi, rbx
mov [rsp+88h+var_50], rax
mov rsi, rax
mov rdx, rbp
xor ecx, ecx
call JS_GetPropertyInt64
mov rdi, rbx
mov rsi, rax
call JS_ToStringFree
mov r9, rdx
cmp r9d, 0FFFFFFF9h
jz short loc_404D4
mov r13b, 1
cmp r9d, 6
mov rcx, [rsp+88h+var_70]
mov rbp, [rsp+88h+var_48]
mov r8, [rsp+88h+var_88]
jnz short loc_404ED
jmp loc_405D0
loc_404D4:
test dword ptr [rax+4], 7FFFFFFFh
setnz r13b
mov rcx, [rsp+88h+var_70]
mov rbp, [rsp+88h+var_48]
mov r8, [rsp+88h+var_88]
loc_404ED:
mov rdi, rbx
mov rsi, rcx
mov rdx, r8
mov rcx, rbp
mov r8, rax
call JS_SetPropertyInt64
test eax, eax
js short loc_4057E
test r13b, r13b
jnz short loc_4056C
mov rdi, rbx
mov rsi, r15
mov rdx, r14
push 56h ; 'V'
pop r13
mov ecx, r13d
call JS_GetProperty
mov rcx, rdx
mov rdi, rbx
lea rsi, [rsp+88h+var_38]
mov rdx, rax
call JS_ToLengthFree
test eax, eax
js short loc_4057E
mov rsi, [rsp+88h+var_38]
mov rdi, [rsp+88h+var_60]
mov edx, [rsp+88h+var_3C]
call string_advance_index
mov rdi, rax
call js_int64
mov r9, rdx
mov rdi, rbx
mov rsi, r15
mov rdx, r14
mov ecx, r13d
mov r8, rax
call JS_SetProperty
test eax, eax
js short loc_4057E
loc_4056C:
inc rbp
mov [rsp+88h+var_48], rbp
mov rsi, [rsp+88h+var_50]
jmp loc_40450
loc_4057E:
mov r14, [rsp+88h+var_78]
mov r15, [rsp+88h+var_80]
mov r13, [rsp+88h+var_50]
mov rbp, [rsp+88h+var_68]
jmp short loc_405C2
loc_40594:
cmp [rsp+88h+var_48], 0
jz short loc_405E9
mov r14, [rsp+88h+var_58]
mov r15, [rsp+88h+var_60]
mov rdx, [rsp+88h+var_68]
mov rbp, [rsp+88h+var_70]
jmp loc_40382
loc_405B5:
mov r14, [rsp+88h+var_78]
mov r15, [rsp+88h+var_80]
mov r13, rax
loc_405C2:
mov rcx, [rsp+88h+var_70]
mov r8, [rsp+88h+var_88]
jmp loc_403D8
loc_405D0:
mov r14, [rsp+88h+var_78]
mov r15, [rsp+88h+var_80]
mov r13, [rsp+88h+var_50]
mov rbp, [rsp+88h+var_68]
jmp loc_403D8
loc_405E9:
mov rdi, rbx
mov r14, rax
mov rsi, [rsp+88h+var_70]
mov rdx, [rsp+88h+var_88]
call JS_FreeValue
mov rax, r14
push 2
pop rcx
mov [rsp+88h+var_88], rcx
xor ebp, ebp
xor r12d, r12d
mov r14, [rsp+88h+var_58]
mov r15, [rsp+88h+var_60]
mov rdx, [rsp+88h+var_68]
jmp loc_40382
|
unsigned long long js_regexp_Symbol_match(
long long a1,
long long a2,
long long a3,
long long a4,
long long *a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long v16; // rdx
long long v17; // rbp
long long v18; // r14
long long v19; // r13
long long v20; // r15
long long v21; // r8
long long v22; // rcx
unsigned long long v23; // r12
long long Property; // rax
long long v25; // rdx
long long v26; // rax
long long v27; // rdx
long long v28; // rax
long long v29; // rdx
unsigned long long v30; // rax
long long v31; // rdx
long long v32; // rdx
long long v33; // r15
long long v34; // r14
unsigned long long v35; // rax
unsigned int v36; // ebp
long long v37; // rdx
long long v38; // rax
unsigned long long v39; // r12
long long v40; // rax
long long i; // rsi
unsigned long long PropertyInt64; // rax
long long v44; // rdx
long long v45; // rax
long long v46; // rdx
bool v47; // r13
unsigned long long v48; // rbp
_DWORD *v49; // rax
long long v50; // rdx
long long v51; // rax
int v52; // eax
int v53; // edx
long long v54; // r14
char v55; // [rsp+0h] [rbp-88h]
long long v56; // [rsp+0h] [rbp-88h]
long long v57; // [rsp+8h] [rbp-80h]
long long v58; // [rsp+10h] [rbp-78h]
long long v59; // [rsp+18h] [rbp-70h]
long long v60; // [rsp+20h] [rbp-68h]
long long v61; // [rsp+28h] [rbp-60h]
long long v62; // [rsp+30h] [rbp-58h]
long long v63; // [rsp+38h] [rbp-50h]
unsigned long long v64; // [rsp+40h] [rbp-48h]
int v65; // [rsp+4Ch] [rbp-3Ch]
unsigned long long v66[7]; // [rsp+50h] [rbp-38h] BYREF
if ( (_DWORD)a3 != -1 )
{
JS_ThrowTypeErrorNotAnObject(a1, a7, a8, a9, a10, a11, a12, a13, a14, a2, a3, a4, (long long)a5, a6, v55);
LABEL_22:
v40 = 0LL;
v39 = 0LL;
return v39 | v40;
}
v61 = JS_ToString(a1, *a5, a5[1]);
v17 = 3LL;
v62 = v16;
if ( (_DWORD)v16 == 6 )
{
v18 = 0LL;
v19 = 0LL;
v20 = 3LL;
v21 = 3LL;
LODWORD(v22) = 0;
v23 = 0LL;
LABEL_21:
JS_FreeValue(a1, (v23 << 32) | (unsigned int)v22, v21);
JS_FreeValue(a1, v19, v17);
JS_FreeValue(a1, v18, v20);
JS_FreeValue(a1, v61, v62);
goto LABEL_22;
}
Property = JS_GetProperty(a1, a2, a3, 110);
if ( (_DWORD)v25 == 6 )
{
v19 = 0LL;
v21 = 3LL;
LODWORD(v22) = 0;
v23 = 0LL;
v18 = Property;
v20 = v25;
goto LABEL_21;
}
v26 = JS_ToStringFree(a1, Property, v25);
v57 = v27;
if ( (_DWORD)v27 == 6 )
{
v19 = 0LL;
v21 = 3LL;
LODWORD(v22) = 0;
v23 = 0LL;
v18 = v26;
LABEL_20:
v20 = v57;
goto LABEL_21;
}
v58 = v26;
if ( (unsigned int)string_indexof_char(v26, 103LL, 0LL) == -1 )
{
v32 = a3;
v33 = v61;
v34 = v62;
v35 = JS_RegExpExec(a1, a2, v32, v61, v62);
v36 = v35;
v23 = HIDWORD(v35);
v37 = 3LL;
v38 = 0LL;
goto LABEL_15;
}
v28 = JS_GetProperty(a1, a2, a3, 112);
v65 = JS_ToBoolFree(a1, v28, v29);
if ( v65 < 0 )
{
v19 = 0LL;
v21 = 3LL;
LODWORD(v22) = 0;
LABEL_18:
v23 = 0LL;
goto LABEL_19;
}
if ( (int)JS_SetProperty(a1, a2, a3, 86, 0, 0) < 0 )
{
v21 = 3LL;
LODWORD(v22) = 0;
v19 = 0LL;
goto LABEL_18;
}
v30 = JS_NewArray(a1);
LODWORD(v22) = v30;
v21 = v31;
v23 = HIDWORD(v30);
if ( (_DWORD)v31 == 6 )
{
v19 = 0LL;
LABEL_19:
v18 = v58;
goto LABEL_20;
}
v56 = v31;
v59 = v30;
v60 = 3LL;
v64 = 0LL;
for ( i = 0LL; ; i = v63 )
{
JS_FreeValue(a1, i, v60);
v38 = JS_RegExpExec(a1, a2, a3, v61, v62);
v17 = v37;
v60 = v37;
if ( (_DWORD)v37 == 2 )
break;
if ( (_DWORD)v37 == 6 )
{
v18 = v58;
v20 = v57;
v19 = v38;
goto LABEL_40;
}
v63 = v38;
PropertyInt64 = JS_GetPropertyInt64(a1, v38, v37, 0LL);
v45 = JS_ToStringFree(a1, PropertyInt64, v44);
if ( (_DWORD)v46 == -7 )
{
v47 = (*(_DWORD *)(v45 + 4) & 0x7FFFFFFF) != 0;
v22 = v59;
v48 = v64;
v21 = v56;
}
else
{
v47 = 1;
v22 = v59;
v48 = v64;
v21 = v56;
if ( (_DWORD)v46 == 6 )
{
v18 = v58;
v20 = v57;
v19 = v63;
v17 = v60;
goto LABEL_21;
}
}
if ( (int)JS_SetPropertyInt64(a1, v22, v21, v48, v45, v46) < 0
|| !v47
&& ((v49 = (_DWORD *)JS_GetProperty(a1, a2, a3, 86), (int)JS_ToLengthFree(a1, v66, v49, v50) < 0)
|| (v51 = string_advance_index(v61, v66[0], (unsigned int)v65),
v52 = js_int64(v51),
(int)JS_SetProperty(a1, a2, a3, 86, v52, v53) < 0)) )
{
v18 = v58;
v20 = v57;
v19 = v63;
v17 = v60;
LABEL_40:
LODWORD(v22) = v59;
v21 = v56;
goto LABEL_21;
}
v64 = v48 + 1;
}
if ( v64 )
{
v34 = v62;
v33 = v61;
v36 = v59;
}
else
{
v54 = v38;
JS_FreeValue(a1, v59, v56);
v38 = v54;
v36 = 0;
v23 = 0LL;
v34 = v62;
v33 = v61;
v37 = v60;
}
LABEL_15:
JS_FreeValue(a1, v38, v37);
JS_FreeValue(a1, v58, v57);
JS_FreeValue(a1, v33, v34);
v39 = v23 << 32;
v40 = v36;
return v39 | v40;
}
|
js_regexp_Symbol_match:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R14,RDX
MOV RBX,RDI
CMP R14D,-0x1
JNZ 0x0014026e
MOV R15,RSI
MOV RSI,qword ptr [R8]
MOV RDX,qword ptr [R8 + 0x8]
MOV RDI,RBX
CALL 0x0011b03c
MOV qword ptr [RSP + 0x28],RAX
PUSH 0x3
POP RBP
MOV qword ptr [RSP + 0x30],RDX
CMP EDX,0x6
JNZ 0x0014027b
XOR R14D,R14D
XOR R13D,R13D
MOV R15,RBP
MOV R8,RBP
XOR ECX,ECX
XOR R12D,R12D
JMP 0x001403d8
LAB_0014026e:
MOV RDI,RBX
CALL 0x0011d5e1
JMP 0x0014041a
LAB_0014027b:
PUSH 0x6e
POP RCX
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x0011b043
CMP EDX,0x6
JNZ 0x001402a7
XOR R13D,R13D
MOV R8,RBP
XOR ECX,ECX
XOR R12D,R12D
MOV R14,RAX
MOV R15,RDX
JMP 0x001403d8
LAB_001402a7:
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0012e049
MOV qword ptr [RSP + 0x8],RDX
CMP EDX,0x6
JNZ 0x001402cf
XOR R13D,R13D
MOV R8,RBP
XOR ECX,ECX
XOR R12D,R12D
MOV R14,RAX
JMP 0x001403d3
LAB_001402cf:
PUSH 0x67
POP RSI
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,RAX
XOR EDX,EDX
CALL 0x001414fc
CMP EAX,-0x1
JZ 0x00140351
PUSH 0x70
POP RCX
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x0011b043
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0011cdfa
MOV dword ptr [RSP + 0x4c],EAX
TEST EAX,EAX
JS 0x001403b9
PUSH 0x56
POP RCX
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
XOR R8D,R8D
XOR R9D,R9D
CALL 0x0011e446
TEST EAX,EAX
JS 0x001403c3
MOV RDI,RBX
CALL 0x0011b2bb
MOV RCX,RAX
MOV R8,RDX
MOV R12,RAX
SHR R12,0x20
CMP R8D,0x6
JNZ 0x00140434
XOR R13D,R13D
JMP 0x001403ce
LAB_00140351:
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
MOV R15,qword ptr [RSP + 0x28]
MOV RCX,R15
MOV R14,qword ptr [RSP + 0x30]
MOV R8,R14
CALL 0x0014133b
MOV RBP,RAX
MOV qword ptr [RSP],RDX
MOV R12,RAX
SHR R12,0x20
PUSH 0x3
POP RDX
XOR EAX,EAX
LAB_00140382:
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0011801e
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x8]
CALL 0x0011801e
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x0011801e
SHL R12,0x20
MOV EAX,EBP
MOV RDX,qword ptr [RSP]
JMP 0x00140422
LAB_001403b9:
XOR R13D,R13D
MOV R8,RBP
XOR ECX,ECX
JMP 0x001403cb
LAB_001403c3:
MOV R8,RBP
XOR ECX,ECX
XOR R13D,R13D
LAB_001403cb:
XOR R12D,R12D
LAB_001403ce:
MOV R14,qword ptr [RSP + 0x10]
LAB_001403d3:
MOV R15,qword ptr [RSP + 0x8]
LAB_001403d8:
SHL R12,0x20
MOV ESI,ECX
OR RSI,R12
MOV RDI,RBX
MOV RDX,R8
CALL 0x0011801e
MOV RDI,RBX
MOV RSI,R13
MOV RDX,RBP
CALL 0x0011801e
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
CALL 0x0011801e
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
CALL 0x0011801e
LAB_0014041a:
PUSH 0x6
POP RDX
XOR EAX,EAX
XOR R12D,R12D
LAB_00140422:
OR RAX,R12
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00140434:
MOV qword ptr [RSP],R8
MOV qword ptr [RSP + 0x18],RCX
PUSH 0x3
POP RAX
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x40],0x0
XOR ESI,ESI
LAB_00140450:
MOV RDI,RBX
MOV RDX,qword ptr [RSP + 0x20]
CALL 0x0011801e
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
MOV RCX,qword ptr [RSP + 0x28]
MOV R8,qword ptr [RSP + 0x30]
CALL 0x0014133b
MOV RBP,RDX
CMP EBP,0x2
MOV qword ptr [RSP + 0x20],RDX
JZ 0x00140594
CMP EBP,0x6
JZ 0x001405b5
MOV RDI,RBX
MOV qword ptr [RSP + 0x38],RAX
MOV RSI,RAX
MOV RDX,RBP
XOR ECX,ECX
CALL 0x0011e178
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0012e049
MOV R9,RDX
CMP R9D,-0x7
JZ 0x001404d4
MOV R13B,0x1
CMP R9D,0x6
MOV RCX,qword ptr [RSP + 0x18]
MOV RBP,qword ptr [RSP + 0x40]
MOV R8,qword ptr [RSP]
JNZ 0x001404ed
JMP 0x001405d0
LAB_001404d4:
TEST dword ptr [RAX + 0x4],0x7fffffff
SETNZ R13B
MOV RCX,qword ptr [RSP + 0x18]
MOV RBP,qword ptr [RSP + 0x40]
MOV R8,qword ptr [RSP]
LAB_001404ed:
MOV RDI,RBX
MOV RSI,RCX
MOV RDX,R8
MOV RCX,RBP
MOV R8,RAX
CALL 0x0011f0a6
TEST EAX,EAX
JS 0x0014057e
TEST R13B,R13B
JNZ 0x0014056c
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
PUSH 0x56
POP R13
MOV ECX,R13D
CALL 0x0011b043
MOV RCX,RDX
MOV RDI,RBX
LEA RSI,[RSP + 0x50]
MOV RDX,RAX
CALL 0x0013daf8
TEST EAX,EAX
JS 0x0014057e
MOV RSI,qword ptr [RSP + 0x50]
MOV RDI,qword ptr [RSP + 0x28]
MOV EDX,dword ptr [RSP + 0x4c]
CALL 0x00141551
MOV RDI,RAX
CALL 0x00120a0b
MOV R9,RDX
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
MOV ECX,R13D
MOV R8,RAX
CALL 0x0011e446
TEST EAX,EAX
JS 0x0014057e
LAB_0014056c:
INC RBP
MOV qword ptr [RSP + 0x40],RBP
MOV RSI,qword ptr [RSP + 0x38]
JMP 0x00140450
LAB_0014057e:
MOV R14,qword ptr [RSP + 0x10]
MOV R15,qword ptr [RSP + 0x8]
MOV R13,qword ptr [RSP + 0x38]
MOV RBP,qword ptr [RSP + 0x20]
JMP 0x001405c2
LAB_00140594:
CMP qword ptr [RSP + 0x40],0x0
JZ 0x001405e9
MOV R14,qword ptr [RSP + 0x30]
MOV R15,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x20]
MOV RBP,qword ptr [RSP + 0x18]
JMP 0x00140382
LAB_001405b5:
MOV R14,qword ptr [RSP + 0x10]
MOV R15,qword ptr [RSP + 0x8]
MOV R13,RAX
LAB_001405c2:
MOV RCX,qword ptr [RSP + 0x18]
MOV R8,qword ptr [RSP]
JMP 0x001403d8
LAB_001405d0:
MOV R14,qword ptr [RSP + 0x10]
MOV R15,qword ptr [RSP + 0x8]
MOV R13,qword ptr [RSP + 0x38]
MOV RBP,qword ptr [RSP + 0x20]
JMP 0x001403d8
LAB_001405e9:
MOV RDI,RBX
MOV R14,RAX
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP]
CALL 0x0011801e
MOV RAX,R14
PUSH 0x2
POP RCX
MOV qword ptr [RSP],RCX
XOR EBP,EBP
XOR R12D,R12D
MOV R14,qword ptr [RSP + 0x30]
MOV R15,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x20]
JMP 0x00140382
|
int1 [16]
js_regexp_Symbol_match
(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 *param_5)
{
int iVar1;
int iVar2;
int8 uVar3;
int8 uVar4;
ulong uVar5;
ulong uVar7;
bool bVar8;
int1 auVar9 [16];
int1 auVar10 [16];
int1 auVar11 [16];
int1 auVar12 [16];
int1 auVar13 [12];
int8 local_88;
int8 local_68;
long local_48;
int8 local_38;
int8 uVar6;
if ((int)param_3 == -1) {
auVar9 = JS_ToString(param_1,*param_5,param_5[1]);
uVar6 = auVar9._8_8_;
uVar3 = auVar9._0_8_;
if (auVar9._8_4_ == 6) {
auVar9 = ZEXT816(3) << 0x40;
auVar11 = ZEXT816(3) << 0x40;
auVar10 = ZEXT816(3) << 0x40;
uVar7 = 0;
}
else {
auVar9 = JS_GetProperty(param_1,param_2,param_3,0x6e);
if (auVar9._8_4_ == 6) {
auVar11 = ZEXT816(3) << 0x40;
auVar10 = ZEXT816(3) << 0x40;
uVar7 = 0;
}
else {
auVar9 = JS_ToStringFree(param_1,auVar9._0_8_);
if (auVar9._8_4_ == 6) {
auVar10 = ZEXT816(3) << 0x40;
uVar7 = 0;
}
else {
iVar1 = string_indexof_char(auVar9._0_8_,0x67,0);
if (iVar1 == -1) {
auVar10 = JS_RegExpExec(param_1,param_2,param_3,uVar3,uVar6);
uVar7 = auVar10._0_8_ >> 0x20;
auVar11 = ZEXT816(3) << 0x40;
LAB_00140382:
local_88 = auVar10._8_8_;
JS_FreeValue(param_1,auVar11._0_8_,auVar11._8_8_);
JS_FreeValue(param_1,auVar9._0_8_,auVar9._8_8_);
JS_FreeValue(param_1,uVar3,uVar6);
uVar7 = uVar7 << 0x20;
uVar5 = auVar10._0_8_ & 0xffffffff;
goto LAB_00140422;
}
uVar4 = JS_GetProperty(param_1,param_2,param_3,0x70);
iVar1 = JS_ToBoolFree(param_1,uVar4);
if ((iVar1 < 0) || (iVar2 = JS_SetProperty(param_1,param_2,param_3,0x56,0,0), iVar2 < 0))
{
auVar10 = ZEXT816(3) << 0x40;
uVar7 = 0;
}
else {
auVar10 = JS_NewArray(param_1);
uVar5 = auVar10._0_8_;
uVar7 = uVar5 >> 0x20;
if (auVar10._8_4_ != 6) {
local_48 = 0;
auVar11 = ZEXT816(3) << 0x40;
while( true ) {
local_68 = auVar11._8_8_;
JS_FreeValue(param_1,auVar11._0_8_,local_68);
auVar11 = JS_RegExpExec(param_1,param_2,param_3,uVar3,uVar6);
if (auVar11._8_4_ == 2) break;
if (auVar11._8_4_ == 6) goto LAB_001403d8;
uVar4 = JS_GetPropertyInt64(param_1,auVar11._0_8_,auVar11._8_8_,0);
auVar13 = JS_ToStringFree(param_1,uVar4);
if (auVar13._8_4_ == -7) {
bVar8 = (*(uint *)(auVar13._0_8_ + 4) & 0x7fffffff) != 0;
}
else {
bVar8 = true;
if (auVar13._8_4_ == 6) goto LAB_001403d8;
}
iVar2 = JS_SetPropertyInt64(param_1,uVar5,auVar10._8_8_,local_48,auVar13._0_8_);
if (iVar2 < 0) goto LAB_001403d8;
if (!bVar8) {
auVar12 = JS_GetProperty(param_1,param_2,param_3,0x56);
iVar2 = JS_ToLengthFree(param_1,&local_38,auVar12._0_8_,auVar12._8_8_);
if (iVar2 < 0) goto LAB_001403d8;
uVar4 = string_advance_index(uVar3,local_38,iVar1);
auVar12 = js_int64(uVar4);
iVar2 = JS_SetProperty(param_1,param_2,param_3,0x56,auVar12._0_8_,auVar12._8_8_);
if (iVar2 < 0) goto LAB_001403d8;
}
local_48 = local_48 + 1;
}
if (local_48 == 0) {
JS_FreeValue(param_1,uVar5,auVar10._8_8_);
auVar10 = ZEXT816(2) << 0x40;
uVar7 = 0;
}
goto LAB_00140382;
}
}
}
auVar11 = ZEXT816(3) << 0x40;
}
}
LAB_001403d8:
JS_FreeValue(param_1,auVar10._0_8_ & 0xffffffff | uVar7 << 0x20,auVar10._8_8_);
JS_FreeValue(param_1,auVar11._0_8_,auVar11._8_8_);
JS_FreeValue(param_1,auVar9._0_8_,auVar9._8_8_);
JS_FreeValue(param_1,uVar3,uVar6);
}
else {
JS_ThrowTypeErrorNotAnObject(param_1);
}
local_88 = 6;
uVar5 = 0;
uVar7 = 0;
LAB_00140422:
auVar9._0_8_ = uVar5 | uVar7;
auVar9._8_8_ = local_88;
return auVar9;
}
|
|
8,159 |
my_error
|
eloqsql/mysys/my_error.c
|
void my_error(uint nr, myf MyFlags, ...)
{
const char *format;
va_list args;
char ebuff[ERRMSGSIZE];
DBUG_ENTER("my_error");
DBUG_PRINT("my", ("nr: %d MyFlags: %lu errno: %d", nr, MyFlags, errno));
if (!(format = my_get_err_msg(nr)))
(void) my_snprintf(ebuff, sizeof(ebuff), "Unknown error %d", nr);
else
{
va_start(args,MyFlags);
(void) my_vsnprintf_ex(&my_charset_utf8mb3_general_ci, ebuff,
sizeof(ebuff), format, args);
va_end(args);
}
(*error_handler_hook)(nr, ebuff, MyFlags);
DBUG_VOID_RETURN;
}
|
O0
|
c
|
my_error:
pushq %rbp
movq %rsp, %rbp
subq $0x2f0, %rsp # imm = 0x2F0
testb %al, %al
je 0x3d827
movaps %xmm0, -0x2c0(%rbp)
movaps %xmm1, -0x2b0(%rbp)
movaps %xmm2, -0x2a0(%rbp)
movaps %xmm3, -0x290(%rbp)
movaps %xmm4, -0x280(%rbp)
movaps %xmm5, -0x270(%rbp)
movaps %xmm6, -0x260(%rbp)
movaps %xmm7, -0x250(%rbp)
movq %r9, -0x2c8(%rbp)
movq %r8, -0x2d0(%rbp)
movq %rcx, -0x2d8(%rbp)
movq %rdx, -0x2e0(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movl %edi, -0x214(%rbp)
movq %rsi, -0x220(%rbp)
jmp 0x3d85f
movl -0x214(%rbp), %edi
callq 0x3d730
movq %rax, -0x228(%rbp)
cmpq $0x0, %rax
jne 0x3d899
leaq -0x210(%rbp), %rdi
movl -0x214(%rbp), %ecx
movl $0x200, %esi # imm = 0x200
leaq 0x4b186(%rip), %rdx # 0x88a16
movb $0x0, %al
callq 0x84980
jmp 0x3d8ed
leaq -0x240(%rbp), %rax
leaq -0x2f0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq -0x210(%rbp), %rsi
movq -0x228(%rbp), %rcx
leaq -0x240(%rbp), %r8
leaq 0x353164(%rip), %rdi # 0x390a40
movl $0x200, %edx # imm = 0x200
callq 0x82360
leaq -0x240(%rbp), %rax
leaq 0x19fafc(%rip), %rax # 0x1dd3f0
movq (%rax), %rax
movl -0x214(%rbp), %edi
leaq -0x210(%rbp), %rsi
movq -0x220(%rbp), %rdx
callq *%rax
jmp 0x3d90f
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x3d92a
addq $0x2f0, %rsp # imm = 0x2F0
popq %rbp
retq
callq 0x242c0
nop
|
my_error:
push rbp
mov rbp, rsp
sub rsp, 2F0h
test al, al
jz short loc_3D827
movaps [rbp+var_2C0], xmm0
movaps [rbp+var_2B0], xmm1
movaps [rbp+var_2A0], xmm2
movaps [rbp+var_290], xmm3
movaps [rbp+var_280], xmm4
movaps [rbp+var_270], xmm5
movaps [rbp+var_260], xmm6
movaps [rbp+var_250], xmm7
loc_3D827:
mov [rbp+var_2C8], r9
mov [rbp+var_2D0], r8
mov [rbp+var_2D8], rcx
mov [rbp+var_2E0], rdx
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_214], edi
mov [rbp+var_220], rsi
jmp short $+2
loc_3D85F:
mov edi, [rbp+var_214]
call my_get_err_msg
mov [rbp+var_228], rax
cmp rax, 0
jnz short loc_3D899
lea rdi, [rbp+var_210]
mov ecx, [rbp+var_214]
mov esi, 200h
lea rdx, aUnknownErrorD; "Unknown error %d"
mov al, 0
call my_snprintf
jmp short loc_3D8ED
loc_3D899:
lea rax, [rbp+var_240]
lea rcx, [rbp+var_2F0]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 10h
lea rsi, [rbp+var_210]
mov rcx, [rbp+var_228]
lea r8, [rbp+var_240]
lea rdi, my_charset_utf8mb3_general_ci
mov edx, 200h
call my_vsnprintf_ex
lea rax, [rbp+var_240]
loc_3D8ED:
lea rax, error_handler_hook
mov rax, [rax]
mov edi, [rbp+var_214]
lea rsi, [rbp+var_210]
mov rdx, [rbp+var_220]
call rax
jmp short $+2
loc_3D90F:
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_3D92A
add rsp, 2F0h
pop rbp
retn
loc_3D92A:
call ___stack_chk_fail
|
unsigned long long my_error(unsigned int a1, long long a2, ...)
{
int v2; // r8d
int v3; // r9d
va_list va; // [rsp+B0h] [rbp-240h] BYREF
_BYTE *err_msg; // [rsp+C8h] [rbp-228h]
long long v7; // [rsp+D0h] [rbp-220h]
unsigned int v8; // [rsp+DCh] [rbp-214h]
_BYTE v9[520]; // [rsp+E0h] [rbp-210h] BYREF
unsigned long long v10; // [rsp+2E8h] [rbp-8h]
va_start(va, a2);
va_arg(va, _QWORD);
va_arg(va, _QWORD);
va_arg(va, _QWORD);
va_arg(va, _QWORD);
va_end(va);
v10 = __readfsqword(0x28u);
v8 = a1;
v7 = a2;
err_msg = my_get_err_msg(a1);
if ( err_msg )
{
va_start(va, a2);
my_vsnprintf_ex(&my_charset_utf8mb3_general_ci, v9, 512LL, err_msg, va);
}
else
{
my_snprintf((unsigned int)v9, 512, (unsigned int)"Unknown error %d", v8, v2, v3);
}
((void ( *)(long long, long long, __int16))error_handler_hook[0])(v8, (long long)v9, v7);
return __readfsqword(0x28u);
}
|
my_error:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x2f0
TEST AL,AL
JZ 0x0013d827
MOVAPS xmmword ptr [RBP + -0x2c0],XMM0
MOVAPS xmmword ptr [RBP + -0x2b0],XMM1
MOVAPS xmmword ptr [RBP + -0x2a0],XMM2
MOVAPS xmmword ptr [RBP + -0x290],XMM3
MOVAPS xmmword ptr [RBP + -0x280],XMM4
MOVAPS xmmword ptr [RBP + -0x270],XMM5
MOVAPS xmmword ptr [RBP + -0x260],XMM6
MOVAPS xmmword ptr [RBP + -0x250],XMM7
LAB_0013d827:
MOV qword ptr [RBP + -0x2c8],R9
MOV qword ptr [RBP + -0x2d0],R8
MOV qword ptr [RBP + -0x2d8],RCX
MOV qword ptr [RBP + -0x2e0],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x214],EDI
MOV qword ptr [RBP + -0x220],RSI
JMP 0x0013d85f
LAB_0013d85f:
MOV EDI,dword ptr [RBP + -0x214]
CALL 0x0013d730
MOV qword ptr [RBP + -0x228],RAX
CMP RAX,0x0
JNZ 0x0013d899
LEA RDI,[RBP + -0x210]
MOV ECX,dword ptr [RBP + -0x214]
MOV ESI,0x200
LEA RDX,[0x188a16]
MOV AL,0x0
CALL 0x00184980
JMP 0x0013d8ed
LAB_0013d899:
LEA RAX,[RBP + -0x240]
LEA RCX,[RBP + -0x2f0]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x10
LEA RSI,[RBP + -0x210]
MOV RCX,qword ptr [RBP + -0x228]
LEA R8,[RBP + -0x240]
LEA RDI,[0x490a40]
MOV EDX,0x200
CALL 0x00182360
LEA RAX,[RBP + -0x240]
LAB_0013d8ed:
LEA RAX,[0x2dd3f0]
MOV RAX,qword ptr [RAX]
MOV EDI,dword ptr [RBP + -0x214]
LEA RSI,[RBP + -0x210]
MOV RDX,qword ptr [RBP + -0x220]
CALL RAX
JMP 0x0013d90f
LAB_0013d90f:
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0013d92a
ADD RSP,0x2f0
POP RBP
RET
LAB_0013d92a:
CALL 0x001242c0
|
void my_error(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int4 param_9,int8 param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
char in_AL;
long in_FS_OFFSET;
int1 local_2f8 [16];
int8 local_2e8;
int8 local_2e0;
int8 local_2d8;
int8 local_2d0;
int8 local_2c8;
int8 local_2b8;
int8 local_2a8;
int8 local_298;
int8 local_288;
int8 local_278;
int8 local_268;
int8 local_258;
int4 local_248;
int4 local_244;
int1 *local_240;
int1 *local_238;
long local_230;
int8 local_228;
int4 local_21c;
int1 local_218 [520];
long local_10;
if (in_AL != '\0') {
local_2c8 = param_1;
local_2b8 = param_2;
local_2a8 = param_3;
local_298 = param_4;
local_288 = param_5;
local_278 = param_6;
local_268 = param_7;
local_258 = param_8;
}
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_2e8 = param_11;
local_2e0 = param_12;
local_2d8 = param_13;
local_2d0 = param_14;
local_228 = param_10;
local_21c = param_9;
local_230 = my_get_err_msg(param_9);
if (local_230 == 0) {
my_snprintf(local_218,0x200,"Unknown error %d",local_21c);
}
else {
local_238 = local_2f8;
local_240 = &stack0x00000008;
local_244 = 0x30;
local_248 = 0x10;
my_vsnprintf_ex(my_charset_utf8mb3_general_ci,local_218,0x200,local_230,&local_248);
}
(*(code *)error_handler_hook)(local_21c,local_218,local_228);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
8,160 |
wqueue_release_one_locktype_from_queue
|
eloqsql/mysys/wqueue.c
|
void wqueue_release_one_locktype_from_queue(WQUEUE *wqueue)
{
struct st_my_thread_var *last= wqueue->last_thread;
struct st_my_thread_var *next= last->next;
struct st_my_thread_var *thread;
struct st_my_thread_var *new_list= NULL;
uint first_type= next->lock_type;
if (first_type == MY_PTHREAD_LOCK_WRITE)
{
/* release first waiting for write lock */
mysql_cond_signal(&next->suspend);
if (next == last)
wqueue->last_thread= NULL;
else
last->next= next->next;
next->next= NULL;
return;
}
do
{
thread= next;
next= thread->next;
if (thread->lock_type == MY_PTHREAD_LOCK_WRITE)
{
/* skip waiting for write lock */
if (new_list)
{
thread->next= new_list->next;
new_list= new_list->next= thread;
}
else
new_list= thread->next= thread;
}
else
{
/* release waiting for read lock */
mysql_cond_signal(&thread->suspend);
thread->next= NULL;
}
} while (thread != last);
wqueue->last_thread= new_list;
}
|
O3
|
c
|
wqueue_release_one_locktype_from_queue:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq (%rdi), %r12
movq 0x88(%r12), %rbx
cmpl $0x1, 0xe4(%rbx)
jne 0xad41e
leaq 0x8(%rbx), %r14
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
jne 0xad4bc
movq %r14, %rdi
callq 0x2a630
cmpq %r12, %rbx
je 0xad49b
movq 0x88(%rbx), %rax
movq %rax, 0x88(%r12)
jmp 0xad4a2
movq %r15, %r14
xorl %r13d, %r13d
movq %rbx, %r15
movq 0x88(%rbx), %rbx
cmpl $0x1, 0xe4(%r15)
jne 0xad454
testq %r13, %r13
je 0xad473
movq 0x88(%r13), %rax
movq %rax, 0x88(%r15)
movq %r15, 0x88(%r13)
jmp 0xad47a
movq 0x38(%r15), %rdi
testq %rdi, %rdi
jne 0xad484
leaq 0x8(%r15), %rdi
callq 0x2a630
movq $0x0, 0x88(%r15)
jmp 0xad47d
movq %r15, 0x88(%r15)
movq %r15, %r13
cmpq %r12, %r15
jne 0xad424
jmp 0xad496
leaq 0x2e1dcd(%rip), %rax # 0x38f258
movq (%rax), %rax
callq *0x170(%rax)
jmp 0xad45d
movq %r13, (%r14)
jmp 0xad4ad
movq $0x0, (%r15)
movq $0x0, 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e1d95(%rip), %rax # 0x38f258
movq (%rax), %rax
callq *0x170(%rax)
jmp 0xad3f9
|
wqueue_release_one_locktype_from_queue:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rdi
mov r12, [rdi]
mov rbx, [r12+88h]
cmp dword ptr [rbx+0E4h], 1
jnz short loc_AD41E
lea r14, [rbx+8]
mov rdi, [rbx+38h]
test rdi, rdi
jnz loc_AD4BC
loc_AD3F9:
mov rdi, r14
call _pthread_cond_signal
cmp rbx, r12
jz loc_AD49B
mov rax, [rbx+88h]
mov [r12+88h], rax
jmp loc_AD4A2
loc_AD41E:
mov r14, r15
xor r13d, r13d
loc_AD424:
mov r15, rbx
mov rbx, [rbx+88h]
cmp dword ptr [r15+0E4h], 1
jnz short loc_AD454
test r13, r13
jz short loc_AD473
mov rax, [r13+88h]
mov [r15+88h], rax
mov [r13+88h], r15
jmp short loc_AD47A
loc_AD454:
mov rdi, [r15+38h]
test rdi, rdi
jnz short loc_AD484
loc_AD45D:
lea rdi, [r15+8]
call _pthread_cond_signal
mov qword ptr [r15+88h], 0
jmp short loc_AD47D
loc_AD473:
mov [r15+88h], r15
loc_AD47A:
mov r13, r15
loc_AD47D:
cmp r15, r12
jnz short loc_AD424
jmp short loc_AD496
loc_AD484:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+170h]
jmp short loc_AD45D
loc_AD496:
mov [r14], r13
jmp short loc_AD4AD
loc_AD49B:
mov qword ptr [r15], 0
loc_AD4A2:
mov qword ptr [rbx+88h], 0
loc_AD4AD:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_AD4BC:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+170h]
jmp loc_AD3F9
|
long long wqueue_release_one_locktype_from_queue(long long *a1)
{
long long v2; // r12
long long v3; // rbx
long long v4; // rdi
long long result; // rax
long long v7; // r13
long long v8; // r15
long long v9; // rdi
v2 = *a1;
v3 = *(_QWORD *)(*a1 + 136);
if ( *(_DWORD *)(v3 + 228) == 1 )
{
v4 = *(_QWORD *)(v3 + 56);
if ( v4 )
((void ( *)(long long))PSI_server[46])(v4);
result = pthread_cond_signal(v3 + 8);
if ( v3 == v2 )
{
*a1 = 0LL;
}
else
{
result = *(_QWORD *)(v3 + 136);
*(_QWORD *)(v2 + 136) = result;
}
*(_QWORD *)(v3 + 136) = 0LL;
}
else
{
v7 = 0LL;
do
{
v8 = v3;
v3 = *(_QWORD *)(v3 + 136);
if ( *(_DWORD *)(v8 + 228) == 1 )
{
if ( v7 )
{
result = *(_QWORD *)(v7 + 136);
*(_QWORD *)(v8 + 136) = result;
*(_QWORD *)(v7 + 136) = v8;
}
else
{
*(_QWORD *)(v8 + 136) = v8;
}
v7 = v8;
}
else
{
v9 = *(_QWORD *)(v8 + 56);
if ( v9 )
((void ( *)(long long))PSI_server[46])(v9);
result = pthread_cond_signal(v8 + 8);
*(_QWORD *)(v8 + 136) = 0LL;
}
}
while ( v8 != v2 );
*a1 = v7;
}
return result;
}
|
wqueue_release_one_locktype_from_queue:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDI
MOV R12,qword ptr [RDI]
MOV RBX,qword ptr [R12 + 0x88]
CMP dword ptr [RBX + 0xe4],0x1
JNZ 0x001ad41e
LEA R14,[RBX + 0x8]
MOV RDI,qword ptr [RBX + 0x38]
TEST RDI,RDI
JNZ 0x001ad4bc
LAB_001ad3f9:
MOV RDI,R14
CALL 0x0012a630
CMP RBX,R12
JZ 0x001ad49b
MOV RAX,qword ptr [RBX + 0x88]
MOV qword ptr [R12 + 0x88],RAX
JMP 0x001ad4a2
LAB_001ad41e:
MOV R14,R15
XOR R13D,R13D
LAB_001ad424:
MOV R15,RBX
MOV RBX,qword ptr [RBX + 0x88]
CMP dword ptr [R15 + 0xe4],0x1
JNZ 0x001ad454
TEST R13,R13
JZ 0x001ad473
MOV RAX,qword ptr [R13 + 0x88]
MOV qword ptr [R15 + 0x88],RAX
MOV qword ptr [R13 + 0x88],R15
JMP 0x001ad47a
LAB_001ad454:
MOV RDI,qword ptr [R15 + 0x38]
TEST RDI,RDI
JNZ 0x001ad484
LAB_001ad45d:
LEA RDI,[R15 + 0x8]
CALL 0x0012a630
MOV qword ptr [R15 + 0x88],0x0
JMP 0x001ad47d
LAB_001ad473:
MOV qword ptr [R15 + 0x88],R15
LAB_001ad47a:
MOV R13,R15
LAB_001ad47d:
CMP R15,R12
JNZ 0x001ad424
JMP 0x001ad496
LAB_001ad484:
LEA RAX,[0x48f258]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x170]
JMP 0x001ad45d
LAB_001ad496:
MOV qword ptr [R14],R13
JMP 0x001ad4ad
LAB_001ad49b:
MOV qword ptr [R15],0x0
LAB_001ad4a2:
MOV qword ptr [RBX + 0x88],0x0
LAB_001ad4ad:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001ad4bc:
LEA RAX,[0x48f258]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x170]
JMP 0x001ad3f9
|
void wqueue_release_one_locktype_from_queue(long *param_1)
{
long lVar1;
long lVar2;
long lVar3;
long lVar4;
bool bVar5;
lVar1 = *param_1;
lVar3 = *(long *)(lVar1 + 0x88);
if (*(int *)(lVar3 + 0xe4) == 1) {
if (*(long *)(lVar3 + 0x38) != 0) {
(**(code **)(PSI_server + 0x170))();
}
pthread_cond_signal((pthread_cond_t *)(lVar3 + 8));
if (lVar3 == lVar1) {
*param_1 = 0;
}
else {
*(int8 *)(lVar1 + 0x88) = *(int8 *)(lVar3 + 0x88);
}
*(int8 *)(lVar3 + 0x88) = 0;
}
else {
lVar4 = 0;
do {
lVar2 = *(long *)(lVar3 + 0x88);
if (*(int *)(lVar3 + 0xe4) == 1) {
if (lVar4 == 0) {
*(long *)(lVar3 + 0x88) = lVar3;
lVar4 = lVar3;
}
else {
*(int8 *)(lVar3 + 0x88) = *(int8 *)(lVar4 + 0x88);
*(long *)(lVar4 + 0x88) = lVar3;
lVar4 = lVar3;
}
}
else {
if (*(long *)(lVar3 + 0x38) != 0) {
(**(code **)(PSI_server + 0x170))();
}
pthread_cond_signal((pthread_cond_t *)(lVar3 + 8));
*(int8 *)(lVar3 + 0x88) = 0;
}
bVar5 = lVar3 != lVar1;
lVar3 = lVar2;
} while (bVar5);
*param_1 = lVar4;
}
return;
}
|
|
8,161 |
auto coro::when_all<coro::task<void>, coro::task<void>, coro::task<void>, coro::task<void>, coro::task<void>, coro::task<void>>(coro::task<void>, coro::task<void>, coro::task<void>, coro::task<void>, coro::task<void>, coro::task<void>...)
|
AlayaLite/build_O3/_deps/libcoro-src/include/coro/when_all.hpp
|
[[nodiscard]] auto when_all(awaitables_type... awaitables)
{
return detail::when_all_ready_awaitable<std::tuple<
detail::when_all_task<typename concepts::awaitable_traits<awaitables_type>::awaiter_return_type>...>>(
std::make_tuple(detail::make_when_all_task(std::move(awaitables))...));
}
|
O3
|
cpp
|
auto coro::when_all<coro::task<void>, coro::task<void>, coro::task<void>, coro::task<void>, coro::task<void>, coro::task<void>>(coro::task<void>, coro::task<void>, coro::task<void>, coro::task<void>, coro::task<void>, coro::task<void>...):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, (%rsp)
movq %rcx, %r13
movq %rdx, %r12
movq %rdi, %r15
movq (%rsi), %r14
movq $0x0, (%rsi)
movl $0x38, %edi
callq 0x171f0
movq %rax, %rbx
leaq -0x4649(%rip), %rax # 0xc2f8b
movq %rax, (%rbx)
leaq -0x45bd(%rip), %rax # 0xc3021
movq %rax, 0x8(%rbx)
movq %r14, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movb $0x0, 0x30(%rbx)
movq (%r12), %rbp
movq $0x0, (%r12)
movl $0x38, %edi
callq 0x171f0
movq %rax, %r14
leaq -0x4686(%rip), %r12 # 0xc2f8b
movq %r12, (%rax)
leaq -0x45fa(%rip), %rax # 0xc3021
movq %rax, 0x8(%r14)
movq %rbp, 0x28(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movb $0x0, 0x30(%r14)
movq (%r13), %rbp
movq $0x0, (%r13)
movl $0x38, %edi
callq 0x171f0
movq %rax, %r13
movq %r12, (%rax)
leaq -0x4632(%rip), %rax # 0xc3021
movq %rax, 0x8(%r13)
movq %rbp, 0x28(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r13)
movb $0x0, 0x30(%r13)
movq (%rsp), %rax
movq (%rax), %rbp
movq $0x0, (%rax)
movl $0x38, %edi
callq 0x171f0
movq %r12, (%rax)
leaq -0x4669(%rip), %rcx # 0xc3021
movq %rcx, 0x8(%rax)
movq %rbp, 0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movb $0x0, 0x30(%rax)
movq $0x5, (%r15)
movq $0x0, 0x8(%r15)
movq %rax, 0x10(%r15)
movq %r13, 0x18(%r15)
movq %r14, 0x20(%r15)
movq %rbx, 0x28(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
testq %rbp, %rbp
je 0xc76dc
movq %rbp, %rdi
callq *0x8(%rbp)
movq %r13, %rdi
callq 0xc3021
jmp 0xc76f8
jmp 0xc7739
jmp 0xc7739
movq %rax, %r15
testq %rbp, %rbp
je 0xc76f8
movq %rbp, %rdi
callq *0x8(%rbp)
movq %r14, %rdi
callq 0xc3021
jmp 0xc7714
jmp 0xc7739
jmp 0xc7739
movq %rax, %r15
testq %rbp, %rbp
je 0xc7714
movq %rbp, %rdi
callq *0x8(%rbp)
movq %rbx, %rdi
callq 0xc3021
jmp 0xc7731
jmp 0xc7739
jmp 0xc7739
movq %rax, %r15
testq %r14, %r14
je 0xc7731
movq %r14, %rdi
callq *0x8(%r14)
movq %r15, %rdi
callq 0x17740
movq %rax, %rdi
callq 0x1f2c3
nop
|
_ZN4coro8when_allITpTkNS_8concepts9awaitableEJNS_4taskIvEES3_S3_S3_EEEDaDpT_:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov [rsp+38h+var_38], r8
mov r13, rcx
mov r12, rdx
mov r15, rdi
mov r14, [rsi]
mov qword ptr [rsi], 0
mov edi, 38h ; '8'; unsigned __int64
call __Znwm; operator new(ulong)
mov rbx, rax
lea rax, _ZN4coro6detailL18make_when_all_taskITkNS_8concepts9awaitableENS_4taskIvEEvEENS0_13when_all_taskIT0_EET__resume_11
mov [rbx], rax
lea rax, _ZN4coro6detailL18make_when_all_taskITkNS_8concepts9awaitableENS_4taskIvEEvEENS0_13when_all_taskIT0_EET__destroy_11
mov [rbx+8], rax
mov [rbx+28h], r14
xorps xmm0, xmm0
movups xmmword ptr [rbx+10h], xmm0
mov byte ptr [rbx+30h], 0
mov rbp, [r12]
mov qword ptr [r12], 0
mov edi, 38h ; '8'; unsigned __int64
call __Znwm; operator new(ulong)
mov r14, rax
lea r12, _ZN4coro6detailL18make_when_all_taskITkNS_8concepts9awaitableENS_4taskIvEEvEENS0_13when_all_taskIT0_EET__resume_11
mov [rax], r12
lea rax, _ZN4coro6detailL18make_when_all_taskITkNS_8concepts9awaitableENS_4taskIvEEvEENS0_13when_all_taskIT0_EET__destroy_11
mov [r14+8], rax
mov [r14+28h], rbp
xorps xmm0, xmm0
movups xmmword ptr [r14+10h], xmm0
mov byte ptr [r14+30h], 0
mov rbp, [r13+0]
mov qword ptr [r13+0], 0
mov edi, 38h ; '8'; unsigned __int64
call __Znwm; operator new(ulong)
mov r13, rax
mov [rax], r12
lea rax, _ZN4coro6detailL18make_when_all_taskITkNS_8concepts9awaitableENS_4taskIvEEvEENS0_13when_all_taskIT0_EET__destroy_11
mov [r13+8], rax
mov [r13+28h], rbp
xorps xmm0, xmm0
movups xmmword ptr [r13+10h], xmm0
mov byte ptr [r13+30h], 0
mov rax, [rsp+38h+var_38]
mov rbp, [rax]
mov qword ptr [rax], 0
mov edi, 38h ; '8'; unsigned __int64
call __Znwm; operator new(ulong)
mov [rax], r12
lea rcx, _ZN4coro6detailL18make_when_all_taskITkNS_8concepts9awaitableENS_4taskIvEEvEENS0_13when_all_taskIT0_EET__destroy_11
mov [rax+8], rcx
mov [rax+28h], rbp
xorps xmm0, xmm0
movups xmmword ptr [rax+10h], xmm0
mov byte ptr [rax+30h], 0
mov qword ptr [r15], 5
mov qword ptr [r15+8], 0
mov [r15+10h], rax
mov [r15+18h], r13
mov [r15+20h], r14
mov [r15+28h], rbx
mov rax, r15
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r15, rax
test rbp, rbp
jz short loc_C76DC
mov rdi, rbp
call qword ptr [rbp+8]
loc_C76DC:
mov rdi, r13; void *
call _ZN4coro6detailL18make_when_all_taskITkNS_8concepts9awaitableENS_4taskIvEEvEENS0_13when_all_taskIT0_EET__destroy_11
jmp short loc_C76F8
jmp short loc_C7739
jmp short loc_C7739
mov r15, rax
test rbp, rbp
jz short loc_C76F8
mov rdi, rbp
call qword ptr [rbp+8]
loc_C76F8:
mov rdi, r14; void *
call _ZN4coro6detailL18make_when_all_taskITkNS_8concepts9awaitableENS_4taskIvEEvEENS0_13when_all_taskIT0_EET__destroy_11
jmp short loc_C7714
jmp short loc_C7739
jmp short loc_C7739
mov r15, rax
test rbp, rbp
jz short loc_C7714
mov rdi, rbp
call qword ptr [rbp+8]
loc_C7714:
mov rdi, rbx; void *
call _ZN4coro6detailL18make_when_all_taskITkNS_8concepts9awaitableENS_4taskIvEEvEENS0_13when_all_taskIT0_EET__destroy_11
jmp short loc_C7731
jmp short loc_C7739
jmp short loc_C7739
mov r15, rax
test r14, r14
jz short loc_C7731
mov rdi, r14
call qword ptr [r14+8]
loc_C7731:
mov rdi, r15
call __Unwind_Resume
loc_C7739:
mov rdi, rax
call __clang_call_terminate
|
_QWORD * ZN4coro8when_allITpTkNS_8concepts9awaitableEJNS_4taskIvEES3_S3_S3_EEEDaDpT_(
_QWORD *a1,
long long *a2,
long long *a3,
long long *a4,
long long *a5)
{
long long v7; // r14
long long v8; // rbx
long long v9; // rbp
long long v10; // r14
long long v11; // rbp
long long v12; // r13
long long v13; // rbp
long long v14; // rax
v7 = *a2;
*a2 = 0LL;
v8 = operator new(0x38uLL);
*(_QWORD *)v8 = ZN4coro6detailL18make_when_all_taskITkNS_8concepts9awaitableENS_4taskIvEEvEENS0_13when_all_taskIT0_EET__resume_11;
*(_QWORD *)(v8 + 8) = ZN4coro6detailL18make_when_all_taskITkNS_8concepts9awaitableENS_4taskIvEEvEENS0_13when_all_taskIT0_EET__destroy_11;
*(_QWORD *)(v8 + 40) = v7;
*(_OWORD *)(v8 + 16) = 0LL;
*(_BYTE *)(v8 + 48) = 0;
v9 = *a3;
*a3 = 0LL;
v10 = operator new(0x38uLL);
*(_QWORD *)v10 = ZN4coro6detailL18make_when_all_taskITkNS_8concepts9awaitableENS_4taskIvEEvEENS0_13when_all_taskIT0_EET__resume_11;
*(_QWORD *)(v10 + 8) = ZN4coro6detailL18make_when_all_taskITkNS_8concepts9awaitableENS_4taskIvEEvEENS0_13when_all_taskIT0_EET__destroy_11;
*(_QWORD *)(v10 + 40) = v9;
*(_OWORD *)(v10 + 16) = 0LL;
*(_BYTE *)(v10 + 48) = 0;
v11 = *a4;
*a4 = 0LL;
v12 = operator new(0x38uLL);
*(_QWORD *)v12 = ZN4coro6detailL18make_when_all_taskITkNS_8concepts9awaitableENS_4taskIvEEvEENS0_13when_all_taskIT0_EET__resume_11;
*(_QWORD *)(v12 + 8) = ZN4coro6detailL18make_when_all_taskITkNS_8concepts9awaitableENS_4taskIvEEvEENS0_13when_all_taskIT0_EET__destroy_11;
*(_QWORD *)(v12 + 40) = v11;
*(_OWORD *)(v12 + 16) = 0LL;
*(_BYTE *)(v12 + 48) = 0;
v13 = *a5;
*a5 = 0LL;
v14 = operator new(0x38uLL);
*(_QWORD *)v14 = ZN4coro6detailL18make_when_all_taskITkNS_8concepts9awaitableENS_4taskIvEEvEENS0_13when_all_taskIT0_EET__resume_11;
*(_QWORD *)(v14 + 8) = ZN4coro6detailL18make_when_all_taskITkNS_8concepts9awaitableENS_4taskIvEEvEENS0_13when_all_taskIT0_EET__destroy_11;
*(_QWORD *)(v14 + 40) = v13;
*(_OWORD *)(v14 + 16) = 0LL;
*(_BYTE *)(v14 + 48) = 0;
*a1 = 5LL;
a1[1] = 0LL;
a1[2] = v14;
a1[3] = v12;
a1[4] = v10;
a1[5] = v8;
return a1;
}
|
_ZN4coro8when_allITpTkNS_8concepts9awaitableEJNS_4taskIvEES3_S3_S3_EEEDaDpT_:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV qword ptr [RSP],R8
MOV R13,RCX
MOV R12,RDX
MOV R15,RDI
MOV R14,qword ptr [RSI]
MOV qword ptr [RSI],0x0
LAB_001c75c0:
MOV EDI,0x38
CALL 0x001171f0
MOV RBX,RAX
LEA RAX,[0x1c2f8b]
MOV qword ptr [RBX],RAX
LEA RAX,[0x1c3021]
MOV qword ptr [RBX + 0x8],RAX
MOV qword ptr [RBX + 0x28],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOV byte ptr [RBX + 0x30],0x0
MOV RBP,qword ptr [R12]
MOV qword ptr [R12],0x0
LAB_001c75fd:
MOV EDI,0x38
CALL 0x001171f0
MOV R14,RAX
LEA R12,[0x1c2f8b]
MOV qword ptr [RAX],R12
LEA RAX,[0x1c3021]
MOV qword ptr [R14 + 0x8],RAX
MOV qword ptr [R14 + 0x28],RBP
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x10],XMM0
MOV byte ptr [R14 + 0x30],0x0
MOV RBP,qword ptr [R13]
MOV qword ptr [R13],0x0
LAB_001c763c:
MOV EDI,0x38
CALL 0x001171f0
MOV R13,RAX
MOV qword ptr [RAX],R12
LEA RAX,[0x1c3021]
MOV qword ptr [R13 + 0x8],RAX
MOV qword ptr [R13 + 0x28],RBP
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R13 + 0x10],XMM0
MOV byte ptr [R13 + 0x30],0x0
MOV RAX,qword ptr [RSP]
MOV RBP,qword ptr [RAX]
MOV qword ptr [RAX],0x0
LAB_001c7676:
MOV EDI,0x38
CALL 0x001171f0
MOV qword ptr [RAX],R12
LEA RCX,[0x1c3021]
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [RAX + 0x28],RBP
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX + 0x10],XMM0
MOV byte ptr [RAX + 0x30],0x0
MOV qword ptr [R15],0x5
MOV qword ptr [R15 + 0x8],0x0
MOV qword ptr [R15 + 0x10],RAX
MOV qword ptr [R15 + 0x18],R13
MOV qword ptr [R15 + 0x20],R14
MOV qword ptr [R15 + 0x28],RBX
MOV RAX,R15
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 *
_ZN4coro8when_allITpTkNS_8concepts9awaitableEJNS_4taskIvEES3_S3_S3_EEEDaDpT_
(int8 *param_1,int8 *param_2,int8 *param_3,int8 *param_4,
int8 *param_5)
{
int8 uVar1;
int8 *puVar2;
int8 *puVar3;
int8 *puVar4;
int8 *puVar5;
uVar1 = *param_2;
*param_2 = 0;
/* try { // try from 001c75c0 to 001c75c9 has its CatchHandler @ 001c7722 */
puVar2 = (int8 *)operator_new(0x38);
*puVar2 =
_ZN4coro6detailL18make_when_all_taskITkNS_8concepts9awaitableENS_4taskIvEEvEENS0_13when_all_taskIT0_EET__resume
;
puVar2[1] =
_ZN4coro6detailL18make_when_all_taskITkNS_8concepts9awaitableENS_4taskIvEEvEENS0_13when_all_taskIT0_EET__destroy
;
puVar2[5] = uVar1;
puVar2[2] = 0;
puVar2[3] = 0;
*(int1 *)(puVar2 + 6) = 0;
uVar1 = *param_3;
*param_3 = 0;
/* try { // try from 001c75fd to 001c7606 has its CatchHandler @ 001c7706 */
puVar3 = (int8 *)operator_new(0x38);
*puVar3 =
_ZN4coro6detailL18make_when_all_taskITkNS_8concepts9awaitableENS_4taskIvEEvEENS0_13when_all_taskIT0_EET__resume
;
puVar3[1] =
_ZN4coro6detailL18make_when_all_taskITkNS_8concepts9awaitableENS_4taskIvEEvEENS0_13when_all_taskIT0_EET__destroy
;
puVar3[5] = uVar1;
puVar3[2] = 0;
puVar3[3] = 0;
*(int1 *)(puVar3 + 6) = 0;
uVar1 = *param_4;
*param_4 = 0;
/* try { // try from 001c763c to 001c7645 has its CatchHandler @ 001c76ea */
puVar4 = (int8 *)operator_new(0x38);
*puVar4 =
_ZN4coro6detailL18make_when_all_taskITkNS_8concepts9awaitableENS_4taskIvEEvEENS0_13when_all_taskIT0_EET__resume
;
puVar4[1] =
_ZN4coro6detailL18make_when_all_taskITkNS_8concepts9awaitableENS_4taskIvEEvEENS0_13when_all_taskIT0_EET__destroy
;
puVar4[5] = uVar1;
puVar4[2] = 0;
puVar4[3] = 0;
*(int1 *)(puVar4 + 6) = 0;
uVar1 = *param_5;
*param_5 = 0;
/* try { // try from 001c7676 to 001c767f has its CatchHandler @ 001c76ce */
puVar5 = (int8 *)operator_new(0x38);
*puVar5 =
_ZN4coro6detailL18make_when_all_taskITkNS_8concepts9awaitableENS_4taskIvEEvEENS0_13when_all_taskIT0_EET__resume
;
puVar5[1] =
_ZN4coro6detailL18make_when_all_taskITkNS_8concepts9awaitableENS_4taskIvEEvEENS0_13when_all_taskIT0_EET__destroy
;
puVar5[5] = uVar1;
puVar5[2] = 0;
puVar5[3] = 0;
*(int1 *)(puVar5 + 6) = 0;
*param_1 = 5;
param_1[1] = 0;
param_1[2] = puVar5;
param_1[3] = puVar4;
param_1[4] = puVar3;
param_1[5] = puVar2;
return param_1;
}
|
|
8,162 |
insert_dynamic
|
eloqsql/mysys/array.c
|
my_bool insert_dynamic(DYNAMIC_ARRAY *array, const void * element)
{
void *buffer;
if (array->elements == array->max_element)
{ /* Call only when necessary */
if (!(buffer=alloc_dynamic(array)))
return TRUE;
}
else
{
buffer=array->buffer+(array->elements * array->size_of_element);
array->elements++;
}
memcpy(buffer,element,(size_t) array->size_of_element);
return FALSE;
}
|
O3
|
c
|
insert_dynamic:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %ecx
cmpl 0xc(%rdi), %ecx
jne 0x2c351
movq %r14, %rdi
callq 0x2c378
testq %rax, %rax
je 0x2c374
movq %rax, %rdi
movl 0x14(%r14), %eax
jmp 0x2c363
movl 0x14(%r14), %eax
movl %eax, %edi
imull %ecx, %edi
addq (%r14), %rdi
incl %ecx
movl %ecx, 0x8(%r14)
movl %eax, %edx
movq %rbx, %rsi
callq 0x24300
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movb $0x1, %al
jmp 0x2c36f
|
insert_dynamic:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rsi
mov r14, rdi
mov ecx, [rdi+8]
cmp ecx, [rdi+0Ch]
jnz short loc_2C351
mov rdi, r14
call alloc_dynamic
test rax, rax
jz short loc_2C374
mov rdi, rax
mov eax, [r14+14h]
jmp short loc_2C363
loc_2C351:
mov eax, [r14+14h]
mov edi, eax
imul edi, ecx
add rdi, [r14]
inc ecx
mov [r14+8], ecx
loc_2C363:
mov edx, eax
mov rsi, rbx
call _memcpy
xor eax, eax
loc_2C36F:
pop rbx
pop r14
pop rbp
retn
loc_2C374:
mov al, 1
jmp short loc_2C36F
|
long long insert_dynamic(long long a1, long long a2)
{
int v3; // ecx
long long v4; // rax
long long v5; // rdi
unsigned int v6; // eax
v3 = *(_DWORD *)(a1 + 8);
if ( v3 != *(_DWORD *)(a1 + 12) )
{
v6 = *(_DWORD *)(a1 + 20);
v5 = *(_QWORD *)a1 + v3 * v6;
*(_DWORD *)(a1 + 8) = v3 + 1;
goto LABEL_5;
}
v4 = alloc_dynamic(a1);
if ( v4 )
{
v5 = v4;
v6 = *(_DWORD *)(a1 + 20);
LABEL_5:
memcpy(v5, a2, v6);
return 0LL;
}
return 1LL;
}
|
insert_dynamic:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
MOV ECX,dword ptr [RDI + 0x8]
CMP ECX,dword ptr [RDI + 0xc]
JNZ 0x0012c351
MOV RDI,R14
CALL 0x0012c378
TEST RAX,RAX
JZ 0x0012c374
MOV RDI,RAX
MOV EAX,dword ptr [R14 + 0x14]
JMP 0x0012c363
LAB_0012c351:
MOV EAX,dword ptr [R14 + 0x14]
MOV EDI,EAX
IMUL EDI,ECX
ADD RDI,qword ptr [R14]
INC ECX
MOV dword ptr [R14 + 0x8],ECX
LAB_0012c363:
MOV EDX,EAX
MOV RSI,RBX
CALL 0x00124300
XOR EAX,EAX
LAB_0012c36f:
POP RBX
POP R14
POP RBP
RET
LAB_0012c374:
MOV AL,0x1
JMP 0x0012c36f
|
int8 insert_dynamic(long *param_1,void *param_2)
{
int iVar1;
uint uVar2;
void *__dest;
iVar1 = (int)param_1[1];
if (iVar1 == *(int *)((long)param_1 + 0xc)) {
__dest = (void *)alloc_dynamic(param_1);
if (__dest == (void *)0x0) {
return 1;
}
uVar2 = *(uint *)((long)param_1 + 0x14);
}
else {
uVar2 = *(uint *)((long)param_1 + 0x14);
__dest = (void *)((ulong)(uVar2 * iVar1) + *param_1);
*(int *)(param_1 + 1) = iVar1 + 1;
}
memcpy(__dest,param_2,(ulong)uVar2);
return 0;
}
|
|
8,163 |
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>::basic_json<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, 0>(nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>> const&)
|
llama.cpp/common/./json.hpp
|
basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::basic_json<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, 0>(nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>> const&):
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x634fa
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x4adea
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x4adea
movq %r14, %rdi
xorl %esi, %esi
callq 0x4adea
movq %r14, %rdi
callq 0x4b6f6
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2INS0_6detail8json_refISD_EETnNSt9enable_ifIXsr6detail11conjunctionINSF_11is_json_refIT_EESt7is_sameINSK_10value_typeESD_EEE5valueEiE4typeELi0EEERKSK_:
push r14
push rbx
sub rsp, 18h
mov rbx, rdi
lea r14, [rsp+28h+var_20]
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_36detail8json_refINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15moved_or_copiedEv; nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::moved_or_copied(void)
movups xmm0, xmmword ptr [r14]
movups xmmword ptr [rbx], xmm0
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 byte ptr [r14], 0
mov qword ptr [r14+8], 0
mov rdi, rbx
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
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()
add rsp, 18h
pop rbx
pop r14
retn
|
long long ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2INS0_6detail8json_refISD_EETnNSt9enable_ifIXsr6detail11conjunctionINSF_11is_json_refIT_EESt7is_sameINSK_10value_typeESD_EEE5valueEiE4typeELi0EEERKSK_(
char *a1,
long long a2)
{
_OWORD v3[2]; // [rsp+8h] [rbp-20h] BYREF
nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::moved_or_copied(
(unsigned __int8 *)v3,
a2);
*(_OWORD *)a1 = v3[0];
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v3);
LOBYTE(v3[0]) = 0;
*((_QWORD *)&v3[0] + 1) = 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(a1);
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 *)v3);
return nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v3);
}
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2INS0_6detail8json_refISD_EETnNSt9enable_ifIXsr6detail11conjunctionINSF_11is_json_refIT_EESt7is_sameINSK_10value_typeESD_EEE5valueEiE4typeELi0EEERKSK_:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
LEA R14,[RSP + 0x8]
MOV RDI,R14
CALL 0x001634fa
MOVUPS XMM0,xmmword ptr [R14]
MOVUPS xmmword ptr [RBX],XMM0
MOV RDI,R14
XOR ESI,ESI
CALL 0x0014adea
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,RBX
MOV ESI,0x1
CALL 0x0014adea
MOV RDI,R14
XOR ESI,ESI
CALL 0x0014adea
MOV RDI,R14
CALL 0x0014b6f6
ADD RSP,0x18
POP RBX
POP R14
RET
|
void _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2INS0_6detail8json_refISD_EETnNSt9enable_ifIXsr6detail11conjunctionINSF_11is_json_refIT_EESt7is_sameINSK_10value_typeESD_EEE5valueEiE4typeELi0EEERKSK_
(int8 *param_1)
{
bool bVar1;
data local_20;
int7 uStack_1f;
int8 uStack_18;
nlohmann::json_abi_v3_11_3::detail::
json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::moved_or_copied();
*param_1 = CONCAT71(uStack_1f,local_20);
param_1[1] = uStack_18;
bVar1 = SUB81(&local_20,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>
::assert_invariant(bVar1);
local_20 = (data)0x0;
uStack_18 = 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>
::assert_invariant(SUB81(param_1,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>
::assert_invariant(bVar1);
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(&local_20);
return;
}
|
|
8,164 |
ftxui::Container::Vertical(std::vector<std::shared_ptr<ftxui::ComponentBase>, std::allocator<std::shared_ptr<ftxui::ComponentBase>>>, int*)
|
Andrewchistyakov[P]flashcards_lyc/build_O1/_deps/ftxui-src/src/ftxui/component/container.cpp
|
Component Vertical(Components children, int* selector) {
return std::make_shared<VerticalContainer>(std::move(children), selector);
}
|
O1
|
cpp
|
ftxui::Container::Vertical(std::vector<std::shared_ptr<ftxui::ComponentBase>, std::allocator<std::shared_ptr<ftxui::ComponentBase>>>, int*):
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
leaq 0x18(%rsp), %r8
movq %rdx, (%r8)
xorl %r15d, %r15d
leaq 0x10(%rsp), %rdi
movq %r15, -0x8(%rdi)
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0x27cae
movq (%r14), %rax
movq %rax, (%rbx)
movq %r15, 0x8(%rbx)
movq 0x8(%r14), %rax
movq %r15, 0x8(%r14)
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
_ZN5ftxui9Container8VerticalESt6vectorISt10shared_ptrINS_13ComponentBaseEESaIS4_EEPi:
push r15
push r14
push rbx
sub rsp, 20h
mov rcx, rsi
mov rbx, rdi
lea r8, [rsp+38h+var_20]
mov [r8], rdx
xor r15d, r15d
lea rdi, [rsp+38h+var_28]
mov [rdi-8], r15
lea r14, [rsp+38h+var_30]
lea rdx, [rsp+38h+var_31]
mov rsi, r14
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EEC2IN5ftxui17VerticalContainerESaIS5_EJSt6vectorISt10shared_ptrINS4_13ComponentBaseEESaISA_EERPiEEERPT_St20_Sp_alloc_shared_tagIT0_EDpOT1_; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count<ftxui::VerticalContainer,std::allocator<ftxui::VerticalContainer>,std::vector<std::shared_ptr<ftxui::ComponentBase>>,int *&>(ftxui::VerticalContainer *&,std::_Sp_alloc_shared_tag<std::allocator<ftxui::VerticalContainer>>,std::vector<std::shared_ptr<ftxui::ComponentBase>>,int *&)
mov rax, [r14]
mov [rbx], rax
mov [rbx+8], r15
mov rax, [r14+8]
mov [r14+8], r15
mov [rbx+8], rax
mov rax, rbx
add rsp, 20h
pop rbx
pop r14
pop r15
retn
|
_QWORD * ftxui::Container::Vertical(_QWORD *a1, long long a2, long long a3)
{
char v4; // [rsp+7h] [rbp-31h] BYREF
long long v5; // [rsp+8h] [rbp-30h] BYREF
long long v6; // [rsp+10h] [rbp-28h] BYREF
_QWORD v7[4]; // [rsp+18h] [rbp-20h] BYREF
v7[0] = a3;
v5 = 0LL;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count<ftxui::VerticalContainer,std::allocator<ftxui::VerticalContainer>,std::vector<std::shared_ptr<ftxui::ComponentBase>>,int *&>(
&v6,
&v5,
&v4,
a2,
v7);
*a1 = v5;
a1[1] = 0LL;
a1[1] = v6;
return a1;
}
|
Vertical:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x20
MOV RCX,RSI
MOV RBX,RDI
LEA R8,[RSP + 0x18]
MOV qword ptr [R8],RDX
XOR R15D,R15D
LEA RDI,[RSP + 0x10]
MOV qword ptr [RDI + -0x8],R15
LEA R14,[RSP + 0x8]
LEA RDX,[RSP + 0x7]
MOV RSI,R14
CALL 0x00127cae
MOV RAX,qword ptr [R14]
MOV qword ptr [RBX],RAX
MOV qword ptr [RBX + 0x8],R15
MOV RAX,qword ptr [R14 + 0x8]
MOV qword ptr [R14 + 0x8],R15
MOV qword ptr [RBX + 0x8],RAX
MOV RAX,RBX
ADD RSP,0x20
POP RBX
POP R14
POP R15
RET
|
/* ftxui::Container::Vertical(std::vector<std::shared_ptr<ftxui::ComponentBase>,
std::allocator<std::shared_ptr<ftxui::ComponentBase> > >, int*) */
Container * __thiscall
ftxui::Container::Vertical(Container *this,int8 param_2,int8 param_3)
{
int1 local_31;
int8 local_30;
int8 local_28;
int8 local_20;
local_30 = 0;
local_20 = param_3;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::
__shared_count<ftxui::VerticalContainer,std::allocator<ftxui::VerticalContainer>,std::vector<std::shared_ptr<ftxui::ComponentBase>,std::allocator<std::shared_ptr<ftxui::ComponentBase>>>,int*&>
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&local_28,&local_30,&local_31,param_2);
*(int8 *)this = local_30;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 8) = local_28;
return this;
}
|
|
8,165 |
ac_psr_range
|
alca/libalca/parser.c
|
ac_expr *ac_psr_range(ac_parser *parser)
{
int match_type = AC_RANGE_MATCH_ALL;
uint32_t fixed = 0;
ac_token *ivar = NULL;
ac_expr *range_start = NULL;
ac_expr *range_end = NULL;
ac_expr *condition = NULL;
if (MATCH(parser, TOKEN_ANY))
match_type = AC_RANGE_MATCH_ANY;
if (MATCH(parser, TOKEN_ALL))
match_type = AC_RANGE_MATCH_ALL;
else if (MATCH(parser, TOKEN_NUMBER))
{
match_type = AC_RANGE_MATCH_FIXED;
fixed = *(uint32_t *)ac_psr_previous_token(parser)->value;
} else
{
ac_psr_set_error(parser, ac_psr_current_token(parser), ERROR_INVALID_SYNTAX,
"expected number or quantifiers 'any' or 'all'");
return NULL;
}
if (!ac_psr_consume(parser, TOKEN_IDENTIFIER, ERROR_UNEXPECTED_TOKEN, "expected identifier"))
return NULL;
ivar = ac_psr_previous_token(parser);
if (!ac_psr_consume(parser, TOKEN_IN, ERROR_UNEXPECTED_TOKEN, "unexpected token"))
return NULL;
if (!ac_psr_consume(parser, TOKEN_LPAREN, ERROR_UNEXPECTED_TOKEN, "expected '('"))
return NULL;
range_start = ac_psr_expression(parser);
if (!range_start)
return NULL;
if (!ac_psr_consume(parser,
TOKEN_DOT_DOT,
ERROR_UNEXPECTED_TOKEN,
"unexpected range specifier '..'"))
return NULL;
range_end = ac_psr_expression(parser);
if (!range_end)
return NULL;
if (!ac_psr_consume(parser, TOKEN_RPAREN, ERROR_UNEXPECTED_TOKEN, "expected ')'"))
return NULL;
if (!ac_psr_consume(parser, TOKEN_COLON, ERROR_UNEXPECTED_TOKEN, "expected ':'"))
return NULL;
if (!ac_psr_consume(parser, TOKEN_LPAREN, ERROR_UNEXPECTED_TOKEN, "expected '('"))
return NULL;
condition = ac_psr_expression(parser);
if (!ac_psr_consume(parser, TOKEN_RPAREN, ERROR_UNEXPECTED_TOKEN, "expected ')'"))
return NULL;
return ac_expr_new_range(match_type, fixed, ivar, range_start, range_end, condition);
}
|
O0
|
c
|
ac_psr_range:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl $0x2, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl $0x34, %esi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movb $0x0, %al
callq 0x7700
cmpl $0x0, %eax
je 0x9d1b
movl $0x1, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0x35, %esi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movb $0x0, %al
callq 0x7700
cmpl $0x0, %eax
je 0x9d3e
movl $0x2, -0x14(%rbp)
jmp 0x9dab
movq -0x10(%rbp), %rdi
movl $0x26, %esi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movb $0x0, %al
callq 0x7700
cmpl $0x0, %eax
je 0x9d73
movl $0x3, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7370
movq 0x8(%rax), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
jmp 0x9da9
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7cc0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movl $0x2, %edx
leaq 0x5477b(%rip), %rcx # 0x5e512
callq 0x72e0
movq $0x0, -0x8(%rbp)
jmp 0x9f7f
jmp 0x9dab
movq -0x10(%rbp), %rdi
movl $0x29, %esi
movl $0x3, %edx
leaq 0x54780(%rip), %rcx # 0x5e540
callq 0x7440
cmpq $0x0, %rax
jne 0x9dd8
movq $0x0, -0x8(%rbp)
jmp 0x9f7f
movq -0x10(%rbp), %rdi
callq 0x7370
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x36, %esi
movl $0x3, %edx
leaq 0x5475a(%rip), %rcx # 0x5e554
callq 0x7440
cmpq $0x0, %rax
jne 0x9e12
movq $0x0, -0x8(%rbp)
jmp 0x9f7f
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x3, %edx
leaq 0x54741(%rip), %rcx # 0x5e565
callq 0x7440
cmpq $0x0, %rax
jne 0x9e3c
movq $0x0, -0x8(%rbp)
jmp 0x9f7f
movq -0x10(%rbp), %rdi
callq 0x7590
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x9e5d
movq $0x0, -0x8(%rbp)
jmp 0x9f7f
movq -0x10(%rbp), %rdi
movl $0x4, %esi
movl $0x3, %edx
leaq 0x54700(%rip), %rcx # 0x5e572
callq 0x7440
cmpq $0x0, %rax
jne 0x9e8a
movq $0x0, -0x8(%rbp)
jmp 0x9f7f
movq -0x10(%rbp), %rdi
callq 0x7590
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x9eab
movq $0x0, -0x8(%rbp)
jmp 0x9f7f
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x3, %edx
leaq 0x546d2(%rip), %rcx # 0x5e592
callq 0x7440
cmpq $0x0, %rax
jne 0x9ed8
movq $0x0, -0x8(%rbp)
jmp 0x9f7f
movq -0x10(%rbp), %rdi
movl $0x13, %esi
movl $0x3, %edx
leaq 0x546b2(%rip), %rcx # 0x5e59f
callq 0x7440
cmpq $0x0, %rax
jne 0x9f02
movq $0x0, -0x8(%rbp)
jmp 0x9f7f
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x3, %edx
leaq 0x54651(%rip), %rcx # 0x5e565
callq 0x7440
cmpq $0x0, %rax
jne 0x9f29
movq $0x0, -0x8(%rbp)
jmp 0x9f7f
movq -0x10(%rbp), %rdi
callq 0x7590
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x3, %edx
leaq 0x54647(%rip), %rcx # 0x5e592
callq 0x7440
cmpq $0x0, %rax
jne 0x9f60
movq $0x0, -0x8(%rbp)
jmp 0x9f7f
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
callq 0x73c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
|
ac_psr_range:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_14], 2
mov [rbp+var_18], 0
mov [rbp+var_20], 0
mov [rbp+var_28], 0
mov [rbp+var_30], 0
mov [rbp+var_38], 0
mov rdi, [rbp+var_10]
mov esi, 34h ; '4'
mov edx, 0FFFFFFFFh
mov al, 0
call _ac_psr_match
cmp eax, 0
jz short loc_9D1B
mov [rbp+var_14], 1
loc_9D1B:
mov rdi, [rbp+var_10]
mov esi, 35h ; '5'
mov edx, 0FFFFFFFFh
mov al, 0
call _ac_psr_match
cmp eax, 0
jz short loc_9D3E
mov [rbp+var_14], 2
jmp short loc_9DAB
loc_9D3E:
mov rdi, [rbp+var_10]
mov esi, 26h ; '&'
mov edx, 0FFFFFFFFh
mov al, 0
call _ac_psr_match
cmp eax, 0
jz short loc_9D73
mov [rbp+var_14], 3
mov rdi, [rbp+var_10]
call _ac_psr_previous_token
mov rax, [rax+8]
mov eax, [rax]
mov [rbp+var_18], eax
jmp short loc_9DA9
loc_9D73:
mov rax, [rbp+var_10]
mov [rbp+var_40], rax
mov rdi, [rbp+var_10]
call _ac_psr_current_token
mov rdi, [rbp+var_40]
mov rsi, rax
mov edx, 2
lea rcx, aExpectedNumber; "expected number or quantifiers 'any' or"...
call _ac_psr_set_error
mov [rbp+var_8], 0
jmp loc_9F7F
loc_9DA9:
jmp short $+2
loc_9DAB:
mov rdi, [rbp+var_10]
mov esi, 29h ; ')'
mov edx, 3
lea rcx, aExpectedIdenti; "expected identifier"
call _ac_psr_consume
cmp rax, 0
jnz short loc_9DD8
mov [rbp+var_8], 0
jmp loc_9F7F
loc_9DD8:
mov rdi, [rbp+var_10]
call _ac_psr_previous_token
mov [rbp+var_20], rax
mov rdi, [rbp+var_10]
mov esi, 36h ; '6'
mov edx, 3
lea rcx, aUnexpectedToke; "unexpected token"
call _ac_psr_consume
cmp rax, 0
jnz short loc_9E12
mov [rbp+var_8], 0
jmp loc_9F7F
loc_9E12:
mov rdi, [rbp+var_10]
xor esi, esi
mov edx, 3
lea rcx, aExpected; "expected '('"
call _ac_psr_consume
cmp rax, 0
jnz short loc_9E3C
mov [rbp+var_8], 0
jmp loc_9F7F
loc_9E3C:
mov rdi, [rbp+var_10]
call _ac_psr_expression
mov [rbp+var_28], rax
cmp [rbp+var_28], 0
jnz short loc_9E5D
mov [rbp+var_8], 0
jmp loc_9F7F
loc_9E5D:
mov rdi, [rbp+var_10]
mov esi, 4
mov edx, 3
lea rcx, aUnexpectedRang; "unexpected range specifier '..'"
call _ac_psr_consume
cmp rax, 0
jnz short loc_9E8A
mov [rbp+var_8], 0
jmp loc_9F7F
loc_9E8A:
mov rdi, [rbp+var_10]
call _ac_psr_expression
mov [rbp+var_30], rax
cmp [rbp+var_30], 0
jnz short loc_9EAB
mov [rbp+var_8], 0
jmp loc_9F7F
loc_9EAB:
mov rdi, [rbp+var_10]
mov esi, 1
mov edx, 3
lea rcx, aExpected_0; "expected ')'"
call _ac_psr_consume
cmp rax, 0
jnz short loc_9ED8
mov [rbp+var_8], 0
jmp loc_9F7F
loc_9ED8:
mov rdi, [rbp+var_10]
mov esi, 13h
mov edx, 3
lea rcx, aExpected_1; "expected ':'"
call _ac_psr_consume
cmp rax, 0
jnz short loc_9F02
mov [rbp+var_8], 0
jmp short loc_9F7F
loc_9F02:
mov rdi, [rbp+var_10]
xor esi, esi
mov edx, 3
lea rcx, aExpected; "expected '('"
call _ac_psr_consume
cmp rax, 0
jnz short loc_9F29
mov [rbp+var_8], 0
jmp short loc_9F7F
loc_9F29:
mov rdi, [rbp+var_10]
call _ac_psr_expression
mov [rbp+var_38], rax
mov rdi, [rbp+var_10]
mov esi, 1
mov edx, 3
lea rcx, aExpected_0; "expected ')'"
call _ac_psr_consume
cmp rax, 0
jnz short loc_9F60
mov [rbp+var_8], 0
jmp short loc_9F7F
loc_9F60:
mov edi, [rbp+var_14]
mov esi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
mov r8, [rbp+var_30]
mov r9, [rbp+var_38]
call _ac_expr_new_range
mov [rbp+var_8], rax
loc_9F7F:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
|
long long ac_psr_range(
const char **a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
long long a12,
long long a13,
long long a14)
{
long long v14; // rcx
long long v15; // r8
long long v16; // r9
__m128 v17; // xmm4
__m128 v18; // xmm5
long long v19; // rcx
long long v20; // r8
long long v21; // r9
__m128 v22; // xmm4
__m128 v23; // xmm5
long long v24; // rax
char v26; // [rsp+0h] [rbp-40h]
char v27; // [rsp+0h] [rbp-40h]
char v28; // [rsp+0h] [rbp-40h]
long long v29; // [rsp+8h] [rbp-38h]
long long v30; // [rsp+10h] [rbp-30h]
long long v31; // [rsp+18h] [rbp-28h]
long long v32; // [rsp+20h] [rbp-20h]
unsigned int v33; // [rsp+28h] [rbp-18h]
unsigned int v34; // [rsp+2Ch] [rbp-14h]
v33 = 0;
ac_psr_match((long long)a1, 52LL, 0xFFFFFFFFLL, a12, a13, a14, a2, a3, a4, a5, a6, a7, a8, a9, v26);
if ( (unsigned int)ac_psr_match((long long)a1, 53LL, 0xFFFFFFFFLL, v14, v15, v16, a2, a3, a4, a5, v17, v18, a8, a9, v27) )
{
v34 = 2;
}
else
{
if ( !(unsigned int)ac_psr_match(
(long long)a1,
38LL,
0xFFFFFFFFLL,
v19,
v20,
v21,
a2,
a3,
a4,
a5,
v22,
v23,
a8,
a9,
v28) )
{
v24 = ac_psr_current_token((long long)a1);
ac_psr_set_error(a1, v24, 2, "expected number or quantifiers 'any' or 'all'");
return 0LL;
}
v34 = 3;
v33 = **(_DWORD **)(ac_psr_previous_token((long long)a1) + 8);
}
if ( !ac_psr_consume(a1, 41, 3, "expected identifier") )
return 0LL;
v32 = ac_psr_previous_token((long long)a1);
if ( !ac_psr_consume(a1, 54, 3, "unexpected token") )
return 0LL;
if ( !ac_psr_consume(a1, 0, 3, "expected '('") )
return 0LL;
v31 = ac_psr_expression(a1);
if ( !v31 )
return 0LL;
if ( !ac_psr_consume(a1, 4, 3, "unexpected range specifier '..'") )
return 0LL;
v30 = ac_psr_expression(a1);
if ( !v30 )
return 0LL;
if ( !ac_psr_consume(a1, 1, 3, "expected ')'") )
return 0LL;
if ( !ac_psr_consume(a1, 19, 3, "expected ':'") )
return 0LL;
if ( !ac_psr_consume(a1, 0, 3, "expected '('") )
return 0LL;
v29 = ac_psr_expression(a1);
if ( ac_psr_consume(a1, 1, 3, "expected ')'") )
return ac_expr_new_range(v34, v33, v32, v31, v30, v29);
else
return 0LL;
}
|
ac_psr_range:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],0x2
MOV dword ptr [RBP + -0x18],0x0
MOV qword ptr [RBP + -0x20],0x0
MOV qword ptr [RBP + -0x28],0x0
MOV qword ptr [RBP + -0x30],0x0
MOV qword ptr [RBP + -0x38],0x0
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x34
MOV EDX,0xffffffff
MOV AL,0x0
CALL 0x00107700
CMP EAX,0x0
JZ 0x00109d1b
MOV dword ptr [RBP + -0x14],0x1
LAB_00109d1b:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x35
MOV EDX,0xffffffff
MOV AL,0x0
CALL 0x00107700
CMP EAX,0x0
JZ 0x00109d3e
MOV dword ptr [RBP + -0x14],0x2
JMP 0x00109dab
LAB_00109d3e:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x26
MOV EDX,0xffffffff
MOV AL,0x0
CALL 0x00107700
CMP EAX,0x0
JZ 0x00109d73
MOV dword ptr [RBP + -0x14],0x3
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00107370
MOV RAX,qword ptr [RAX + 0x8]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x18],EAX
JMP 0x00109da9
LAB_00109d73:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00107cc0
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,RAX
MOV EDX,0x2
LEA RCX,[0x15e512]
CALL 0x001072e0
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00109f7f
LAB_00109da9:
JMP 0x00109dab
LAB_00109dab:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x29
MOV EDX,0x3
LEA RCX,[0x15e540]
CALL 0x00107440
CMP RAX,0x0
JNZ 0x00109dd8
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00109f7f
LAB_00109dd8:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00107370
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x36
MOV EDX,0x3
LEA RCX,[0x15e554]
CALL 0x00107440
CMP RAX,0x0
JNZ 0x00109e12
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00109f7f
LAB_00109e12:
MOV RDI,qword ptr [RBP + -0x10]
XOR ESI,ESI
MOV EDX,0x3
LEA RCX,[0x15e565]
CALL 0x00107440
CMP RAX,0x0
JNZ 0x00109e3c
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00109f7f
LAB_00109e3c:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00107590
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],0x0
JNZ 0x00109e5d
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00109f7f
LAB_00109e5d:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x4
MOV EDX,0x3
LEA RCX,[0x15e572]
CALL 0x00107440
CMP RAX,0x0
JNZ 0x00109e8a
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00109f7f
LAB_00109e8a:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00107590
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x00109eab
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00109f7f
LAB_00109eab:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x1
MOV EDX,0x3
LEA RCX,[0x15e592]
CALL 0x00107440
CMP RAX,0x0
JNZ 0x00109ed8
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00109f7f
LAB_00109ed8:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x13
MOV EDX,0x3
LEA RCX,[0x15e59f]
CALL 0x00107440
CMP RAX,0x0
JNZ 0x00109f02
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00109f7f
LAB_00109f02:
MOV RDI,qword ptr [RBP + -0x10]
XOR ESI,ESI
MOV EDX,0x3
LEA RCX,[0x15e565]
CALL 0x00107440
CMP RAX,0x0
JNZ 0x00109f29
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00109f7f
LAB_00109f29:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00107590
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x1
MOV EDX,0x3
LEA RCX,[0x15e592]
CALL 0x00107440
CMP RAX,0x0
JNZ 0x00109f60
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00109f7f
LAB_00109f60:
MOV EDI,dword ptr [RBP + -0x14]
MOV ESI,dword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8,qword ptr [RBP + -0x30]
MOV R9,qword ptr [RBP + -0x38]
CALL 0x001073c0
MOV qword ptr [RBP + -0x8],RAX
LAB_00109f7f:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
int8 ac_psr_range(int8 param_1)
{
int iVar1;
long lVar2;
int8 uVar3;
long lVar4;
long lVar5;
int8 uVar6;
int4 local_20;
int4 local_1c;
int8 local_10;
local_20 = 0;
ac_psr_match(param_1,0x34,0xffffffff);
iVar1 = ac_psr_match(param_1,0x35,0xffffffff);
if (iVar1 == 0) {
iVar1 = ac_psr_match(param_1,0x26,0xffffffff);
if (iVar1 == 0) {
uVar3 = ac_psr_current_token(param_1);
ac_psr_set_error(param_1,uVar3,2,"expected number or quantifiers \'any\' or \'all\'");
return 0;
}
local_1c = 3;
lVar2 = ac_psr_previous_token(param_1);
local_20 = **(int4 **)(lVar2 + 8);
}
else {
local_1c = 2;
}
lVar2 = ac_psr_consume(param_1,0x29,3,"expected identifier");
if (lVar2 == 0) {
local_10 = 0;
}
else {
uVar3 = ac_psr_previous_token(param_1);
lVar2 = ac_psr_consume(param_1,0x36,3,"unexpected token");
if (lVar2 == 0) {
local_10 = 0;
}
else {
lVar2 = ac_psr_consume(param_1,0,3,"expected \'(\'");
if (lVar2 == 0) {
local_10 = 0;
}
else {
lVar2 = ac_psr_expression(param_1);
if (lVar2 == 0) {
local_10 = 0;
}
else {
lVar4 = ac_psr_consume(param_1,4,3,"unexpected range specifier \'..\'");
if (lVar4 == 0) {
local_10 = 0;
}
else {
lVar4 = ac_psr_expression(param_1);
if (lVar4 == 0) {
local_10 = 0;
}
else {
lVar5 = ac_psr_consume(param_1,1,3,"expected \')\'");
if (lVar5 == 0) {
local_10 = 0;
}
else {
lVar5 = ac_psr_consume(param_1,0x13,3,"expected \':\'");
if (lVar5 == 0) {
local_10 = 0;
}
else {
lVar5 = ac_psr_consume(param_1,0,3,"expected \'(\'");
if (lVar5 == 0) {
local_10 = 0;
}
else {
uVar6 = ac_psr_expression(param_1);
lVar5 = ac_psr_consume(param_1,1,3,"expected \')\'");
if (lVar5 == 0) {
local_10 = 0;
}
else {
local_10 = ac_expr_new_range(local_1c,local_20,uVar3,lVar2,lVar4,uVar6);
}
}
}
}
}
}
}
}
}
}
return local_10;
}
|
|
8,166 |
PFS_account::carry_memory_stat_delta(PFS_memory_stat_delta*, unsigned int)
|
eloqsql/storage/perfschema/pfs_account.cc
|
void PFS_account::carry_memory_stat_delta(PFS_memory_stat_delta *delta, uint index)
{
PFS_memory_stat *event_name_array;
PFS_memory_stat *stat;
PFS_memory_stat_delta delta_buffer;
PFS_memory_stat_delta *remaining_delta;
event_name_array= write_instr_class_memory_stats();
stat= & event_name_array[index];
remaining_delta= stat->apply_delta(delta, &delta_buffer);
if (remaining_delta == NULL)
return;
if (m_user != NULL)
{
m_user->carry_memory_stat_delta(remaining_delta, index);
/* do not return, need to process m_host below */
}
if (m_host != NULL)
{
m_host->carry_memory_stat_delta(remaining_delta, index);
return;
}
carry_global_memory_stat_delta(remaining_delta, index);
}
|
O3
|
cpp
|
PFS_account::carry_memory_stat_delta(PFS_memory_stat_delta*, unsigned int):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
cmpb $0x0, 0x4(%rdi)
jne 0x3f46e
movq %r14, %rdi
callq 0x40362
movb $0x1, 0x4(%r14)
movq 0x28(%r14), %rdi
movl %ebx, -0x30(%rbp)
movl %ebx, %eax
leaq (%rax,%rax,8), %r10
movb $0x1, (%rdi,%r10,8)
movq (%r15), %rax
movq 0x28(%rdi,%r10,8), %rdx
cmpq %rdx, %rax
seta -0x29(%rbp)
xorl %r13d, %r13d
movq %rdx, -0x40(%rbp)
subq %rax, %rdx
cmovbq %r13, %rdx
movq 0x30(%rdi,%r10,8), %r9
movq %rdx, 0x28(%rdi,%r10,8)
movq 0x10(%r15), %rdx
movq 0x38(%rdi,%r10,8), %r8
cmpq %r8, %rdx
seta %bl
movq %r8, %rsi
subq %rdx, %rsi
cmovbq %r13, %rsi
movq %rsi, 0x38(%rdi,%r10,8)
movq 0x8(%r15), %rsi
cmpq %r9, %rsi
seta %cl
movq %r9, %r11
subq %rsi, %r11
cmovbq %r13, %r11
movq %r11, 0x30(%rdi,%r10,8)
movq 0x18(%r15), %r11
movq %r14, -0x38(%rbp)
movq 0x40(%rdi,%r10,8), %r14
cmpq %r14, %r11
seta %r12b
movq %r14, %r15
subq %r11, %r15
cmovbq %r13, %r15
movq %r15, 0x40(%rdi,%r10,8)
orb %cl, %r12b
orb -0x29(%rbp), %bl
orb %r12b, %bl
cmpb $0x1, %bl
jne 0x3f580
xorl %ecx, %ecx
subq %r14, %r11
cmovbq %rcx, %r11
subq %r9, %rsi
cmovbq %rcx, %rsi
subq %r8, %rdx
cmovbq %rcx, %rdx
subq -0x40(%rbp), %rax
cmovbq %rcx, %rax
movq %rax, -0x60(%rbp)
movq %rdx, -0x50(%rbp)
movq %rsi, -0x58(%rbp)
movq %r11, -0x48(%rbp)
movq -0x38(%rbp), %r14
movq 0xa90(%r14), %rdi
testq %rdi, %rdi
movl -0x30(%rbp), %ebx
je 0x3f55c
leaq -0x60(%rbp), %rsi
movl %ebx, %edx
callq 0x3acc8
movq 0xa98(%r14), %rdi
testq %rdi, %rdi
je 0x3f575
leaq -0x60(%rbp), %rsi
movl %ebx, %edx
callq 0x442ac
jmp 0x3f580
leaq -0x60(%rbp), %rdi
movl %ebx, %esi
callq 0x2f9b6
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ZN11PFS_account23carry_memory_stat_deltaEP21PFS_memory_stat_deltaj:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov ebx, edx
mov r15, rsi
mov r14, rdi
cmp byte ptr [rdi+4], 0
jnz short loc_3F46E
mov rdi, r14; this
call _ZN20PFS_connection_slice19rebase_memory_statsEv; PFS_connection_slice::rebase_memory_stats(void)
mov byte ptr [r14+4], 1
loc_3F46E:
mov rdi, [r14+28h]
mov [rbp+var_30], ebx
mov eax, ebx
lea r10, [rax+rax*8]
mov byte ptr [rdi+r10*8], 1
mov rax, [r15]
mov rdx, [rdi+r10*8+28h]
cmp rax, rdx
setnbe [rbp+var_29]
xor r13d, r13d
mov [rbp+var_40], rdx
sub rdx, rax
cmovb rdx, r13
mov r9, [rdi+r10*8+30h]
mov [rdi+r10*8+28h], rdx
mov rdx, [r15+10h]
mov r8, [rdi+r10*8+38h]
cmp rdx, r8
setnbe bl
mov rsi, r8
sub rsi, rdx
cmovb rsi, r13
mov [rdi+r10*8+38h], rsi
mov rsi, [r15+8]
cmp rsi, r9
setnbe cl
mov r11, r9
sub r11, rsi
cmovb r11, r13
mov [rdi+r10*8+30h], r11
mov r11, [r15+18h]
mov [rbp+var_38], r14
mov r14, [rdi+r10*8+40h]
cmp r11, r14
setnbe r12b
mov r15, r14
sub r15, r11
cmovb r15, r13
mov [rdi+r10*8+40h], r15
or r12b, cl
or bl, [rbp+var_29]
or bl, r12b
cmp bl, 1
jnz short loc_3F580
xor ecx, ecx
sub r11, r14
cmovb r11, rcx
sub rsi, r9
cmovb rsi, rcx
sub rdx, r8
cmovb rdx, rcx
sub rax, [rbp+var_40]
cmovb rax, rcx
mov [rbp+var_60], rax
mov [rbp+var_50], rdx
mov [rbp+var_58], rsi
mov [rbp+var_48], r11
mov r14, [rbp+var_38]
mov rdi, [r14+0A90h]; this
test rdi, rdi
mov ebx, [rbp+var_30]
jz short loc_3F55C
lea rsi, [rbp+var_60]
mov edx, ebx
call _ZN8PFS_user23carry_memory_stat_deltaEP21PFS_memory_stat_deltaj; PFS_user::carry_memory_stat_delta(PFS_memory_stat_delta *,uint)
loc_3F55C:
mov rdi, [r14+0A98h]; this
test rdi, rdi
jz short loc_3F575
lea rsi, [rbp+var_60]
mov edx, ebx
call _ZN8PFS_host23carry_memory_stat_deltaEP21PFS_memory_stat_deltaj; PFS_host::carry_memory_stat_delta(PFS_memory_stat_delta *,uint)
jmp short loc_3F580
loc_3F575:
lea rdi, [rbp+var_60]
mov esi, ebx
call _Z30carry_global_memory_stat_deltaP21PFS_memory_stat_deltaj; carry_global_memory_stat_delta(PFS_memory_stat_delta *,uint)
loc_3F580:
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
PFS_memory_stat * PFS_account::carry_memory_stat_delta(
PFS_connection_slice *this,
long long *a2,
unsigned int a3)
{
long long v6; // rdi
PFS_memory_stat *result; // rax
unsigned long long v8; // rdx
bool v9; // cf
unsigned long long v10; // rdx
unsigned long long v11; // r9
unsigned long long v12; // rdx
unsigned long long v13; // r8
unsigned long long v14; // rsi
unsigned long long v15; // rsi
unsigned long long v16; // r11
unsigned long long v17; // r11
unsigned long long v18; // r14
unsigned long long v19; // r15
unsigned long long v20; // r11
unsigned long long v21; // rsi
unsigned long long v22; // rdx
unsigned long long v23; // rax
PFS_connection_slice *v24; // r14
PFS_connection_slice *v25; // rdi
unsigned int v26; // ebx
PFS_connection_slice *v27; // rdi
unsigned long long v28[4]; // [rsp+0h] [rbp-60h] BYREF
unsigned long long v29; // [rsp+20h] [rbp-40h]
PFS_connection_slice *v30; // [rsp+28h] [rbp-38h]
unsigned int v31; // [rsp+30h] [rbp-30h]
bool v32; // [rsp+37h] [rbp-29h]
if ( !*((_BYTE *)this + 4) )
{
PFS_connection_slice::rebase_memory_stats(this);
*((_BYTE *)this + 4) = 1;
}
v6 = *((_QWORD *)this + 5);
v31 = a3;
*(_BYTE *)(v6 + 72LL * a3) = 1;
result = (PFS_memory_stat *)*a2;
v8 = *(_QWORD *)(v6 + 72LL * a3 + 40);
v32 = *a2 > v8;
v29 = v8;
v9 = v8 < (unsigned long long)result;
v10 = v8 - (_QWORD)result;
if ( v9 )
v10 = 0LL;
v11 = *(_QWORD *)(v6 + 72LL * a3 + 48);
*(_QWORD *)(v6 + 72LL * a3 + 40) = v10;
v12 = a2[2];
v13 = *(_QWORD *)(v6 + 72LL * a3 + 56);
v14 = v13 - v12;
if ( v13 < v12 )
v14 = 0LL;
*(_QWORD *)(v6 + 72LL * a3 + 56) = v14;
v15 = a2[1];
v16 = v11 - v15;
if ( v11 < v15 )
v16 = 0LL;
*(_QWORD *)(v6 + 72LL * a3 + 48) = v16;
v17 = a2[3];
v30 = this;
v18 = *(_QWORD *)(v6 + 72LL * a3 + 64);
v19 = v18 - v17;
if ( v18 < v17 )
v19 = 0LL;
*(_QWORD *)(v6 + 72LL * a3 + 64) = v19;
if ( v15 > v11 || v17 > v18 || v32 || v12 > v13 )
{
v9 = v17 < v18;
v20 = v17 - v18;
if ( v9 )
v20 = 0LL;
v9 = v15 < v11;
v21 = v15 - v11;
if ( v9 )
v21 = 0LL;
v9 = v12 < v13;
v22 = v12 - v13;
if ( v9 )
v22 = 0LL;
v9 = (unsigned long long)result < v29;
v23 = (unsigned long long)result - v29;
if ( v9 )
v23 = 0LL;
v28[0] = v23;
v28[2] = v22;
v28[1] = v21;
v28[3] = v20;
v24 = v30;
v25 = (PFS_connection_slice *)*((_QWORD *)v30 + 338);
v26 = v31;
if ( v25 )
PFS_user::carry_memory_stat_delta(v25, v28, v31);
v27 = (PFS_connection_slice *)*((_QWORD *)v24 + 339);
if ( v27 )
return (PFS_memory_stat *)PFS_host::carry_memory_stat_delta(v27);
else
return carry_global_memory_stat_delta(v28, v26);
}
return result;
}
|
carry_memory_stat_delta:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV EBX,EDX
MOV R15,RSI
MOV R14,RDI
CMP byte ptr [RDI + 0x4],0x0
JNZ 0x0013f46e
MOV RDI,R14
CALL 0x00140362
MOV byte ptr [R14 + 0x4],0x1
LAB_0013f46e:
MOV RDI,qword ptr [R14 + 0x28]
MOV dword ptr [RBP + -0x30],EBX
MOV EAX,EBX
LEA R10,[RAX + RAX*0x8]
MOV byte ptr [RDI + R10*0x8],0x1
MOV RAX,qword ptr [R15]
MOV RDX,qword ptr [RDI + R10*0x8 + 0x28]
CMP RAX,RDX
SETA byte ptr [RBP + -0x29]
XOR R13D,R13D
MOV qword ptr [RBP + -0x40],RDX
SUB RDX,RAX
CMOVC RDX,R13
MOV R9,qword ptr [RDI + R10*0x8 + 0x30]
MOV qword ptr [RDI + R10*0x8 + 0x28],RDX
MOV RDX,qword ptr [R15 + 0x10]
MOV R8,qword ptr [RDI + R10*0x8 + 0x38]
CMP RDX,R8
SETA BL
MOV RSI,R8
SUB RSI,RDX
CMOVC RSI,R13
MOV qword ptr [RDI + R10*0x8 + 0x38],RSI
MOV RSI,qword ptr [R15 + 0x8]
CMP RSI,R9
SETA CL
MOV R11,R9
SUB R11,RSI
CMOVC R11,R13
MOV qword ptr [RDI + R10*0x8 + 0x30],R11
MOV R11,qword ptr [R15 + 0x18]
MOV qword ptr [RBP + -0x38],R14
MOV R14,qword ptr [RDI + R10*0x8 + 0x40]
CMP R11,R14
SETA R12B
MOV R15,R14
SUB R15,R11
CMOVC R15,R13
MOV qword ptr [RDI + R10*0x8 + 0x40],R15
OR R12B,CL
OR BL,byte ptr [RBP + -0x29]
OR BL,R12B
CMP BL,0x1
JNZ 0x0013f580
XOR ECX,ECX
SUB R11,R14
CMOVC R11,RCX
SUB RSI,R9
CMOVC RSI,RCX
SUB RDX,R8
CMOVC RDX,RCX
SUB RAX,qword ptr [RBP + -0x40]
CMOVC RAX,RCX
MOV qword ptr [RBP + -0x60],RAX
MOV qword ptr [RBP + -0x50],RDX
MOV qword ptr [RBP + -0x58],RSI
MOV qword ptr [RBP + -0x48],R11
MOV R14,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [R14 + 0xa90]
TEST RDI,RDI
MOV EBX,dword ptr [RBP + -0x30]
JZ 0x0013f55c
LEA RSI,[RBP + -0x60]
MOV EDX,EBX
CALL 0x0013acc8
LAB_0013f55c:
MOV RDI,qword ptr [R14 + 0xa98]
TEST RDI,RDI
JZ 0x0013f575
LEA RSI,[RBP + -0x60]
MOV EDX,EBX
CALL 0x001442ac
JMP 0x0013f580
LAB_0013f575:
LEA RDI,[RBP + -0x60]
MOV ESI,EBX
CALL 0x0012f9b6
LAB_0013f580:
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* PFS_account::carry_memory_stat_delta(PFS_memory_stat_delta*, unsigned int) */
void __thiscall
PFS_account::carry_memory_stat_delta(PFS_account *this,PFS_memory_stat_delta *param_1,uint param_2)
{
ulong uVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
ulong uVar5;
ulong uVar6;
ulong uVar7;
ulong uVar8;
long lVar9;
long lVar10;
long lVar11;
long local_68;
long local_60;
long local_58;
long local_50;
ulong local_48;
PFS_account *local_40;
uint local_38;
int1 local_31;
if (this[4] == (PFS_account)0x0) {
PFS_connection_slice::rebase_memory_stats((PFS_connection_slice *)this);
this[4] = (PFS_account)0x1;
}
lVar9 = *(long *)(this + 0x28);
uVar8 = (ulong)param_2;
*(int1 *)(lVar9 + uVar8 * 0x48) = 1;
uVar1 = *(ulong *)param_1;
local_48 = *(ulong *)(lVar9 + 0x28 + uVar8 * 0x48);
local_31 = local_48 < uVar1;
lVar11 = 0;
lVar10 = local_48 - uVar1;
if (local_48 < uVar1) {
lVar10 = lVar11;
}
uVar2 = *(ulong *)(lVar9 + 0x30 + uVar8 * 0x48);
*(long *)(lVar9 + 0x28 + uVar8 * 0x48) = lVar10;
uVar3 = *(ulong *)(param_1 + 0x10);
uVar4 = *(ulong *)(lVar9 + 0x38 + uVar8 * 0x48);
lVar10 = uVar4 - uVar3;
if (uVar4 < uVar3) {
lVar10 = lVar11;
}
*(long *)(lVar9 + 0x38 + uVar8 * 0x48) = lVar10;
uVar5 = *(ulong *)(param_1 + 8);
lVar10 = uVar2 - uVar5;
if (uVar2 < uVar5) {
lVar10 = lVar11;
}
*(long *)(lVar9 + 0x30 + uVar8 * 0x48) = lVar10;
uVar6 = *(ulong *)(param_1 + 0x18);
uVar7 = *(ulong *)(lVar9 + 0x40 + uVar8 * 0x48);
lVar10 = uVar7 - uVar6;
if (uVar7 < uVar6) {
lVar10 = lVar11;
}
*(long *)(lVar9 + 0x40 + uVar8 * 0x48) = lVar10;
if ((uVar4 < uVar3 || (bool)local_31) || (uVar7 < uVar6 || uVar2 < uVar5)) {
lVar9 = 0;
local_50 = uVar6 - uVar7;
if (uVar6 < uVar7) {
local_50 = lVar9;
}
local_60 = uVar5 - uVar2;
if (uVar5 < uVar2) {
local_60 = lVar9;
}
local_58 = uVar3 - uVar4;
if (uVar3 < uVar4) {
local_58 = lVar9;
}
local_68 = uVar1 - local_48;
if (uVar1 < local_48) {
local_68 = lVar9;
}
local_40 = this;
local_38 = param_2;
if (*(PFS_user **)(this + 0xa90) != (PFS_user *)0x0) {
PFS_user::carry_memory_stat_delta
(*(PFS_user **)(this + 0xa90),(PFS_memory_stat_delta *)&local_68,param_2);
}
if (*(PFS_host **)(this + 0xa98) == (PFS_host *)0x0) {
carry_global_memory_stat_delta((PFS_memory_stat_delta *)&local_68,param_2);
}
else {
PFS_host::carry_memory_stat_delta
(*(PFS_host **)(this + 0xa98),(PFS_memory_stat_delta *)&local_68,param_2);
}
}
return;
}
|
|
8,167 |
u64toa_shift
|
bluesky950520[P]quickjs/tests/test_conv.c
|
size_t u64toa_shift(char buf[minimum_length(21)], uint64_t n)
{
if (likely(n < 0x100000000))
return u32toa_shift(buf, n);
size_t len;
if (n >= TEN_POW_7) {
uint64_t n1 = n / TEN_POW_7;
n %= TEN_POW_7;
if (n1 >= TEN_POW_7) {
uint32_t quo = n1 / TEN_POW_7;
n1 %= TEN_POW_7;
len = u7toa_shift(buf, quo);
len = u07toa_shift(buf, n1, len);
} else {
len = u7toa_shift(buf, n1);
}
return u07toa_shift(buf, n, len);
}
return u7toa_shift(buf, n);
}
|
O0
|
c
|
u64toa_shift:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
cmpq %rax, 0x20(%rsp)
setb %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x24dc
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movl %eax, %esi
callq 0x23e0
movq %rax, 0x30(%rsp)
jmp 0x25be
cmpq $0x989680, 0x20(%rsp) # imm = 0x989680
jb 0x25a8
movq 0x20(%rsp), %rax
movl $0x989680, %ecx # imm = 0x989680
xorl %edx, %edx
divq %rcx
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movl $0x989680, %ecx # imm = 0x989680
xorl %edx, %edx
divq %rcx
movq %rdx, 0x20(%rsp)
cmpq $0x989680, 0x10(%rsp) # imm = 0x989680
jb 0x2575
movq 0x10(%rsp), %rax
movl $0x989680, %ecx # imm = 0x989680
xorl %edx, %edx
divq %rcx
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl $0x989680, %ecx # imm = 0x989680
xorl %edx, %edx
divq %rcx
movq %rdx, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x2220
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rax
movl %eax, %esi
movq 0x18(%rsp), %rdx
callq 0x2340
movq %rax, 0x18(%rsp)
jmp 0x258b
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rax
movl %eax, %esi
callq 0x2220
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movl %eax, %esi
movq 0x18(%rsp), %rdx
callq 0x2340
movq %rax, 0x30(%rsp)
jmp 0x25be
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movl %eax, %esi
callq 0x2220
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
|
u64toa_shift:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_18], rsi
mov rax, 100000000h
cmp [rsp+38h+var_18], rax
setb al
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_24DC
mov rdi, [rsp+38h+var_10]
mov rax, [rsp+38h+var_18]
mov esi, eax
call u32toa_shift
mov [rsp+38h+var_8], rax
jmp loc_25BE
loc_24DC:
cmp [rsp+38h+var_18], 989680h
jb loc_25A8
mov rax, [rsp+38h+var_18]
mov ecx, 989680h
xor edx, edx
div rcx
mov [rsp+38h+var_28], rax
mov rax, [rsp+38h+var_18]
mov ecx, 989680h
xor edx, edx
div rcx
mov [rsp+38h+var_18], rdx
cmp [rsp+38h+var_28], 989680h
jb short loc_2575
mov rax, [rsp+38h+var_28]
mov ecx, 989680h
xor edx, edx
div rcx
mov [rsp+38h+var_2C], eax
mov rax, [rsp+38h+var_28]
mov ecx, 989680h
xor edx, edx
div rcx
mov [rsp+38h+var_28], rdx
mov rdi, [rsp+38h+var_10]
mov esi, [rsp+38h+var_2C]
call u7toa_shift
mov [rsp+38h+var_20], rax
mov rdi, [rsp+38h+var_10]
mov rax, [rsp+38h+var_28]
mov esi, eax
mov rdx, [rsp+38h+var_20]
call u07toa_shift
mov [rsp+38h+var_20], rax
jmp short loc_258B
loc_2575:
mov rdi, [rsp+38h+var_10]
mov rax, [rsp+38h+var_28]
mov esi, eax
call u7toa_shift
mov [rsp+38h+var_20], rax
loc_258B:
mov rdi, [rsp+38h+var_10]
mov rax, [rsp+38h+var_18]
mov esi, eax
mov rdx, [rsp+38h+var_20]
call u07toa_shift
mov [rsp+38h+var_8], rax
jmp short loc_25BE
loc_25A8:
mov rdi, [rsp+38h+var_10]
mov rax, [rsp+38h+var_18]
mov esi, eax
call u7toa_shift
mov [rsp+38h+var_8], rax
loc_25BE:
mov rax, [rsp+38h+var_8]
add rsp, 38h
retn
|
long long u64toa_shift(unsigned long long *a1, unsigned long long a2)
{
long long v2; // rax
unsigned long long v4; // [rsp+10h] [rbp-28h]
long long v5; // [rsp+18h] [rbp-20h]
if ( a2 < 0x100000000LL )
return u32toa_shift((long long)a1, a2);
v4 = a2 / 0x989680;
if ( a2 / 0x989680 < 0x989680 )
{
v5 = u7toa_shift(a1, (unsigned int)v4);
}
else
{
v2 = u7toa_shift(a1, (unsigned int)(v4 / 0x989680));
v5 = u07toa_shift((long long)a1, v4 % 0x989680, v2);
}
return u07toa_shift((long long)a1, a2 % 0x989680, v5);
}
|
u64toa_shift:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RDI
MOV qword ptr [RSP + 0x20],RSI
MOV RAX,0x100000000
CMP qword ptr [RSP + 0x20],RAX
SETC AL
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001024dc
MOV RDI,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x20]
MOV ESI,EAX
CALL 0x001023e0
MOV qword ptr [RSP + 0x30],RAX
JMP 0x001025be
LAB_001024dc:
CMP qword ptr [RSP + 0x20],0x989680
JC 0x001025a8
MOV RAX,qword ptr [RSP + 0x20]
MOV ECX,0x989680
XOR EDX,EDX
DIV RCX
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV ECX,0x989680
XOR EDX,EDX
DIV RCX
MOV qword ptr [RSP + 0x20],RDX
CMP qword ptr [RSP + 0x10],0x989680
JC 0x00102575
MOV RAX,qword ptr [RSP + 0x10]
MOV ECX,0x989680
XOR EDX,EDX
DIV RCX
MOV dword ptr [RSP + 0xc],EAX
MOV RAX,qword ptr [RSP + 0x10]
MOV ECX,0x989680
XOR EDX,EDX
DIV RCX
MOV qword ptr [RSP + 0x10],RDX
MOV RDI,qword ptr [RSP + 0x28]
MOV ESI,dword ptr [RSP + 0xc]
CALL 0x00102220
MOV qword ptr [RSP + 0x18],RAX
MOV RDI,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x10]
MOV ESI,EAX
MOV RDX,qword ptr [RSP + 0x18]
CALL 0x00102340
MOV qword ptr [RSP + 0x18],RAX
JMP 0x0010258b
LAB_00102575:
MOV RDI,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x10]
MOV ESI,EAX
CALL 0x00102220
MOV qword ptr [RSP + 0x18],RAX
LAB_0010258b:
MOV RDI,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x20]
MOV ESI,EAX
MOV RDX,qword ptr [RSP + 0x18]
CALL 0x00102340
MOV qword ptr [RSP + 0x30],RAX
JMP 0x001025be
LAB_001025a8:
MOV RDI,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x20]
MOV ESI,EAX
CALL 0x00102220
MOV qword ptr [RSP + 0x30],RAX
LAB_001025be:
MOV RAX,qword ptr [RSP + 0x30]
ADD RSP,0x38
RET
|
int8 u64toa_shift(int8 param_1,ulong param_2)
{
int1 auVar1 [16];
ulong uVar2;
int8 uVar3;
int8 local_20;
int8 local_8;
if (param_2 < 0x100000000) {
local_8 = u32toa_shift(param_1,param_2 & 0xffffffff);
}
else if (param_2 < 10000000) {
local_8 = u7toa_shift(param_1,param_2 & 0xffffffff);
}
else {
uVar2 = param_2 / 10000000;
if (uVar2 < 10000000) {
local_20 = u7toa_shift(param_1,uVar2 & 0xffffffff);
}
else {
auVar1._8_8_ = 0;
auVar1._0_8_ = uVar2;
uVar3 = u7toa_shift(param_1,SUB164(auVar1 / ZEXT816(10000000),0));
local_20 = u07toa_shift(param_1,uVar2 % 10000000,uVar3);
}
local_8 = u07toa_shift(param_1,param_2 % 10000000,local_20);
}
return local_8;
}
|
|
8,168 |
u64toa_shift
|
bluesky950520[P]quickjs/tests/test_conv.c
|
size_t u64toa_shift(char buf[minimum_length(21)], uint64_t n)
{
if (likely(n < 0x100000000))
return u32toa_shift(buf, n);
size_t len;
if (n >= TEN_POW_7) {
uint64_t n1 = n / TEN_POW_7;
n %= TEN_POW_7;
if (n1 >= TEN_POW_7) {
uint32_t quo = n1 / TEN_POW_7;
n1 %= TEN_POW_7;
len = u7toa_shift(buf, quo);
len = u07toa_shift(buf, n1, len);
} else {
len = u7toa_shift(buf, n1);
}
return u07toa_shift(buf, n, len);
}
return u7toa_shift(buf, n);
}
|
O1
|
c
|
u64toa_shift:
movq %rdi, %rax
movq %rsi, %rcx
shrq $0x20, %rcx
jne 0x28c8
movq %rax, %rdi
jmp 0x2788
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
movq %rsi, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x2140
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
|
u64toa_shift:
mov rax, rdi
mov rcx, rsi
shr rcx, 20h
jnz short loc_28C8
mov rdi, rax
jmp u32toa_shift
loc_28C8:
push rbx
sub rsp, 10h
lea rbx, [rsp+18h+var_10]
mov rdi, rsi
mov rsi, rax
mov rdx, rbx
call u64toa_shift_cold_1
mov rax, [rbx]
add rsp, 10h
pop rbx
retn
|
long long u64toa_shift(_QWORD *a1, unsigned long long a2)
{
long long v3; // [rsp+0h] [rbp-10h] BYREF
if ( !HIDWORD(a2) )
return u32toa_shift((long long)a1, a2);
u64toa_shift_cold_1(a2, a1, &v3);
return v3;
}
|
u64toa_shift:
MOV RAX,RDI
MOV RCX,RSI
SHR RCX,0x20
JNZ 0x001028c8
MOV RDI,RAX
JMP 0x00102788
LAB_001028c8:
PUSH RBX
SUB RSP,0x10
LEA RBX,[RSP + 0x8]
MOV RDI,RSI
MOV RSI,RAX
MOV RDX,RBX
CALL 0x00102140
MOV RAX,qword ptr [RBX]
ADD RSP,0x10
POP RBX
RET
|
int8 u64toa_shift(int8 param_1,ulong param_2)
{
int8 uVar1;
int8 local_10;
if (param_2 >> 0x20 == 0) {
uVar1 = u32toa_shift(param_1);
return uVar1;
}
u64toa_shift_cold_1(param_2,param_1,&local_10);
return local_10;
}
|
|
8,169 |
u64toa_shift
|
bluesky950520[P]quickjs/tests/test_conv.c
|
size_t u64toa_shift(char buf[minimum_length(21)], uint64_t n)
{
if (likely(n < 0x100000000))
return u32toa_shift(buf, n);
size_t len;
if (n >= TEN_POW_7) {
uint64_t n1 = n / TEN_POW_7;
n %= TEN_POW_7;
if (n1 >= TEN_POW_7) {
uint32_t quo = n1 / TEN_POW_7;
n1 %= TEN_POW_7;
len = u7toa_shift(buf, quo);
len = u07toa_shift(buf, n1, len);
} else {
len = u7toa_shift(buf, n1);
}
return u07toa_shift(buf, n, len);
}
return u7toa_shift(buf, n);
}
|
O2
|
c
|
u64toa_shift:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rax
shrq $0x20, %rax
jne 0x2306
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2288
movl $0x989680, %edi # imm = 0x989680
movq %rsi, %rax
xorl %edx, %edx
divq %rdi
movq %rax, %rcx
movq %rdx, %r14
movabsq $0x5af3107a4000, %r8 # imm = 0x5AF3107A4000
cmpq %r8, %rsi
jb 0x2356
movq %rsi, %rax
xorl %edx, %edx
divq %r8
movq %rax, %rsi
movq %rcx, %rax
xorl %edx, %edx
divq %rdi
movq %rdx, %r15
movq %rbx, %rdi
callq 0x221c
movq %rbx, %rdi
movl %r15d, %esi
movq %rax, %rdx
callq 0x2255
jmp 0x2360
movq %rbx, %rdi
movl %ecx, %esi
callq 0x221c
movq %rbx, %rdi
movl %r14d, %esi
movq %rax, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2255
|
u64toa_shift:
push r15
push r14
push rbx
mov rbx, rdi
mov rax, rsi
shr rax, 20h
jnz short loc_2306
mov rdi, rbx
pop rbx
pop r14
pop r15
jmp u32toa_shift
loc_2306:
mov edi, 989680h
mov rax, rsi
xor edx, edx
div rdi
mov rcx, rax
mov r14, rdx
mov r8, 5AF3107A4000h
cmp rsi, r8
jb short loc_2356
mov rax, rsi
xor edx, edx
div r8
mov rsi, rax
mov rax, rcx
xor edx, edx
div rdi
mov r15, rdx
mov rdi, rbx
call u7toa_shift
mov rdi, rbx
mov esi, r15d
mov rdx, rax
call u07toa_shift
jmp short loc_2360
loc_2356:
mov rdi, rbx
mov esi, ecx
call u7toa_shift
loc_2360:
mov rdi, rbx
mov esi, r14d
mov rdx, rax
pop rbx
pop r14
pop r15
jmp u07toa_shift
|
long long u64toa_shift(_QWORD *a1, unsigned long long a2)
{
unsigned long long v3; // rcx
unsigned long long v4; // r15
long long v5; // rax
long long v6; // rax
if ( !HIDWORD(a2) )
return u32toa_shift((long long)a1, a2);
v3 = a2 / 0x989680;
if ( a2 < 0x5AF3107A4000LL )
{
v6 = u7toa_shift(a1, v3);
}
else
{
v4 = v3 % 0x989680;
v5 = u7toa_shift(a1, a2 / 0x5AF3107A4000LL);
v6 = u07toa_shift((long long)a1, v4, v5);
}
return u07toa_shift((long long)a1, a2 % 0x989680, v6);
}
|
u64toa_shift:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV RAX,RSI
SHR RAX,0x20
JNZ 0x00102306
MOV RDI,RBX
POP RBX
POP R14
POP R15
JMP 0x00102288
LAB_00102306:
MOV EDI,0x989680
MOV RAX,RSI
XOR EDX,EDX
DIV RDI
MOV RCX,RAX
MOV R14,RDX
MOV R8,0x5af3107a4000
CMP RSI,R8
JC 0x00102356
MOV RAX,RSI
XOR EDX,EDX
DIV R8
MOV RSI,RAX
MOV RAX,RCX
XOR EDX,EDX
DIV RDI
MOV R15,RDX
MOV RDI,RBX
CALL 0x0010221c
MOV RDI,RBX
MOV ESI,R15D
MOV RDX,RAX
CALL 0x00102255
JMP 0x00102360
LAB_00102356:
MOV RDI,RBX
MOV ESI,ECX
CALL 0x0010221c
LAB_00102360:
MOV RDI,RBX
MOV ESI,R14D
MOV RDX,RAX
POP RBX
POP R14
POP R15
JMP 0x00102255
|
void u64toa_shift(int8 param_1,ulong param_2)
{
int8 uVar1;
if (param_2 >> 0x20 == 0) {
u32toa_shift(param_1);
return;
}
if (param_2 < 100000000000000) {
uVar1 = u7toa_shift(param_1,param_2 / 10000000 & 0xffffffff);
}
else {
uVar1 = u7toa_shift(param_1,param_2 / 100000000000000);
uVar1 = u07toa_shift(param_1,(param_2 / 10000000) % 10000000,uVar1);
}
u07toa_shift(param_1,param_2 % 10000000,uVar1);
return;
}
|
|
8,170 |
my_multi_malloc
|
eloqsql/mysys/mulalloc.c
|
void* my_multi_malloc(PSI_memory_key key, myf myFlags, ...)
{
va_list args;
char **ptr,*start,*res;
size_t tot_length,length;
DBUG_ENTER("my_multi_malloc");
va_start(args,myFlags);
tot_length=0;
while ((ptr=va_arg(args, char **)))
{
length=va_arg(args,uint);
tot_length+=ALIGN_SIZE(length);
}
va_end(args);
if (!(start=(char *) my_malloc(key, tot_length,myFlags)))
DBUG_RETURN(0); /* purecov: inspected */
va_start(args,myFlags);
res=start;
while ((ptr=va_arg(args, char **)))
{
*ptr=res;
length=va_arg(args,uint);
res+=ALIGN_SIZE(length);
}
va_end(args);
DBUG_RETURN((void*) start);
}
|
O0
|
c
|
my_multi_malloc:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
testb %al, %al
je 0xed811
movaps %xmm0, -0xe0(%rbp)
movaps %xmm1, -0xd0(%rbp)
movaps %xmm2, -0xc0(%rbp)
movaps %xmm3, -0xb0(%rbp)
movaps %xmm4, -0xa0(%rbp)
movaps %xmm5, -0x90(%rbp)
movaps %xmm6, -0x80(%rbp)
movaps %xmm7, -0x70(%rbp)
movq %r9, -0xe8(%rbp)
movq %r8, -0xf0(%rbp)
movq %rcx, -0xf8(%rbp)
movq %rdx, -0x100(%rbp)
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x30(%rbp), %rax
leaq -0x110(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq $0x0, -0x50(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x120(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x114(%rbp)
cmpl $0x28, %eax
ja 0xed89b
movq -0x120(%rbp), %rcx
movl -0x114(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x128(%rbp)
jmp 0xed8b8
movq -0x120(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x128(%rbp)
movq -0x128(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xed952
leaq -0x30(%rbp), %rax
movq %rax, -0x138(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x12c(%rbp)
cmpl $0x28, %eax
ja 0xed90b
movq -0x138(%rbp), %rcx
movl -0x12c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x140(%rbp)
jmp 0xed928
movq -0x138(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x140(%rbp)
movq -0x140(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0x8, %rax
subq $0x1, %rax
andq $-0x8, %rax
addq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0xed860
leaq -0x30(%rbp), %rax
movl -0xc(%rbp), %edi
movq -0x50(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xf4710
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0xed97f
jmp 0xed972
movq $0x0, -0x8(%rbp)
jmp 0xedab4
leaq -0x30(%rbp), %rax
leaq -0x110(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x150(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x144(%rbp)
cmpl $0x28, %eax
ja 0xed9e6
movq -0x150(%rbp), %rcx
movl -0x144(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x158(%rbp)
jmp 0xeda03
movq -0x150(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x158(%rbp)
movq -0x158(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xedaa8
movq -0x48(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
leaq -0x30(%rbp), %rax
movq %rax, -0x168(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x15c(%rbp)
cmpl $0x28, %eax
ja 0xeda61
movq -0x168(%rbp), %rcx
movl -0x15c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x170(%rbp)
jmp 0xeda7e
movq -0x168(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x170(%rbp)
movq -0x170(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0x8, %rax
subq $0x1, %rax
andq $-0x8, %rax
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0xed9ab
leaq -0x30(%rbp), %rax
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x170, %rsp # imm = 0x170
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_multi_malloc:
push rbp
mov rbp, rsp
sub rsp, 170h
test al, al
jz short loc_ED811
movaps [rbp+var_E0], xmm0
movaps [rbp+var_D0], xmm1
movaps [rbp+var_C0], xmm2
movaps [rbp+var_B0], xmm3
movaps [rbp+var_A0], xmm4
movaps [rbp+var_90], xmm5
movaps [rbp+var_80], xmm6
movaps [rbp+var_70], xmm7
loc_ED811:
mov [rbp+var_E8], r9
mov [rbp+var_F0], r8
mov [rbp+var_F8], rcx
mov [rbp+var_100], rdx
mov [rbp+var_C], edi
mov [rbp+var_18], rsi
lea rax, [rbp+var_30]
lea rcx, [rbp+var_110]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 10h
mov [rbp+var_50], 0
loc_ED860:
lea rax, [rbp+var_30]
mov [rbp+var_120], rax
mov eax, [rbp+var_30]
mov [rbp+var_114], eax
cmp eax, 28h ; '('
ja short loc_ED89B
mov rcx, [rbp+var_120]
mov edx, [rbp+var_114]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_128], rax
jmp short loc_ED8B8
loc_ED89B:
mov rcx, [rbp+var_120]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_128], rax
loc_ED8B8:
mov rax, [rbp+var_128]
mov rax, [rax]
mov [rbp+var_38], rax
cmp rax, 0
jz loc_ED952
lea rax, [rbp+var_30]
mov [rbp+var_138], rax
mov eax, [rbp+var_30]
mov [rbp+var_12C], eax
cmp eax, 28h ; '('
ja short loc_ED90B
mov rcx, [rbp+var_138]
mov edx, [rbp+var_12C]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_140], rax
jmp short loc_ED928
loc_ED90B:
mov rcx, [rbp+var_138]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_140], rax
loc_ED928:
mov rax, [rbp+var_140]
mov eax, [rax]
mov [rbp+var_58], rax
mov rax, [rbp+var_58]
add rax, 8
sub rax, 1
and rax, 0FFFFFFFFFFFFFFF8h
add rax, [rbp+var_50]
mov [rbp+var_50], rax
jmp loc_ED860
loc_ED952:
lea rax, [rbp+var_30]
mov edi, [rbp+var_C]
mov rsi, [rbp+var_50]
mov rdx, [rbp+var_18]
call my_malloc
mov [rbp+var_40], rax
cmp rax, 0
jnz short loc_ED97F
jmp short $+2
loc_ED972:
mov [rbp+var_8], 0
jmp loc_EDAB4
loc_ED97F:
lea rax, [rbp+var_30]
lea rcx, [rbp+var_110]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 10h
mov rax, [rbp+var_40]
mov [rbp+var_48], rax
loc_ED9AB:
lea rax, [rbp+var_30]
mov [rbp+var_150], rax
mov eax, [rbp+var_30]
mov [rbp+var_144], eax
cmp eax, 28h ; '('
ja short loc_ED9E6
mov rcx, [rbp+var_150]
mov edx, [rbp+var_144]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_158], rax
jmp short loc_EDA03
loc_ED9E6:
mov rcx, [rbp+var_150]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_158], rax
loc_EDA03:
mov rax, [rbp+var_158]
mov rax, [rax]
mov [rbp+var_38], rax
cmp rax, 0
jz loc_EDAA8
mov rcx, [rbp+var_48]
mov rax, [rbp+var_38]
mov [rax], rcx
lea rax, [rbp+var_30]
mov [rbp+var_168], rax
mov eax, [rbp+var_30]
mov [rbp+var_15C], eax
cmp eax, 28h ; '('
ja short loc_EDA61
mov rcx, [rbp+var_168]
mov edx, [rbp+var_15C]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_170], rax
jmp short loc_EDA7E
loc_EDA61:
mov rcx, [rbp+var_168]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_170], rax
loc_EDA7E:
mov rax, [rbp+var_170]
mov eax, [rax]
mov [rbp+var_58], rax
mov rax, [rbp+var_58]
add rax, 8
sub rax, 1
and rax, 0FFFFFFFFFFFFFFF8h
add rax, [rbp+var_48]
mov [rbp+var_48], rax
jmp loc_ED9AB
loc_EDAA8:
lea rax, [rbp+var_30]
mov rax, [rbp+var_40]
mov [rbp+var_8], rax
loc_EDAB4:
mov rax, [rbp+var_8]
add rsp, 170h
pop rbp
retn
|
long long my_multi_malloc(unsigned int a1, long long a2, ...)
{
_QWORD *overflow_arg_area; // rax
unsigned int *v3; // rax
_QWORD *v4; // rax
unsigned int *v5; // rax
long long i; // [rsp+120h] [rbp-50h]
long long j; // [rsp+128h] [rbp-48h]
long long v9; // [rsp+130h] [rbp-40h]
va_list va; // [rsp+140h] [rbp-30h] BYREF
long long v11; // [rsp+158h] [rbp-18h]
unsigned int v12; // [rsp+164h] [rbp-Ch]
va_start(va, a2);
v12 = a1;
v11 = a2;
for ( i = 0LL; ; i += (*v3 + 7LL) & 0xFFFFFFFFFFFFFFF8LL )
{
if ( va[0].gp_offset > 0x28 )
{
overflow_arg_area = va[0].overflow_arg_area;
va[0].overflow_arg_area = (char *)va[0].overflow_arg_area + 8;
}
else
{
overflow_arg_area = (char *)va[0].reg_save_area + (int)va[0].gp_offset;
va[0].gp_offset += 8;
}
if ( !*overflow_arg_area )
break;
if ( va[0].gp_offset > 0x28 )
{
v3 = (unsigned int *)va[0].overflow_arg_area;
va[0].overflow_arg_area = (char *)va[0].overflow_arg_area + 8;
}
else
{
v3 = (unsigned int *)((char *)va[0].reg_save_area + (int)va[0].gp_offset);
va[0].gp_offset += 8;
}
}
v9 = my_malloc(v12, i, v11);
if ( !v9 )
return 0LL;
va_end(va);
va_start(va, a2);
for ( j = v9; ; j += (*v5 + 7LL) & 0xFFFFFFFFFFFFFFF8LL )
{
if ( va[0].gp_offset > 0x28 )
{
v4 = va[0].overflow_arg_area;
va[0].overflow_arg_area = (char *)va[0].overflow_arg_area + 8;
}
else
{
v4 = (char *)va[0].reg_save_area + (int)va[0].gp_offset;
va[0].gp_offset += 8;
}
if ( !*v4 )
break;
*(_QWORD *)*v4 = j;
if ( va[0].gp_offset > 0x28 )
{
v5 = (unsigned int *)va[0].overflow_arg_area;
va[0].overflow_arg_area = (char *)va[0].overflow_arg_area + 8;
}
else
{
v5 = (unsigned int *)((char *)va[0].reg_save_area + (int)va[0].gp_offset);
va[0].gp_offset += 8;
}
}
return v9;
}
|
my_multi_malloc:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x170
TEST AL,AL
JZ 0x001ed811
MOVAPS xmmword ptr [RBP + -0xe0],XMM0
MOVAPS xmmword ptr [RBP + -0xd0],XMM1
MOVAPS xmmword ptr [RBP + -0xc0],XMM2
MOVAPS xmmword ptr [RBP + -0xb0],XMM3
MOVAPS xmmword ptr [RBP + -0xa0],XMM4
MOVAPS xmmword ptr [RBP + -0x90],XMM5
MOVAPS xmmword ptr [RBP + -0x80],XMM6
MOVAPS xmmword ptr [RBP + -0x70],XMM7
LAB_001ed811:
MOV qword ptr [RBP + -0xe8],R9
MOV qword ptr [RBP + -0xf0],R8
MOV qword ptr [RBP + -0xf8],RCX
MOV qword ptr [RBP + -0x100],RDX
MOV dword ptr [RBP + -0xc],EDI
MOV qword ptr [RBP + -0x18],RSI
LEA RAX,[RBP + -0x30]
LEA RCX,[RBP + -0x110]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x10
MOV qword ptr [RBP + -0x50],0x0
LAB_001ed860:
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x120],RAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x114],EAX
CMP EAX,0x28
JA 0x001ed89b
MOV RCX,qword ptr [RBP + -0x120]
MOV EDX,dword ptr [RBP + -0x114]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x128],RAX
JMP 0x001ed8b8
LAB_001ed89b:
MOV RCX,qword ptr [RBP + -0x120]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x128],RAX
LAB_001ed8b8:
MOV RAX,qword ptr [RBP + -0x128]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JZ 0x001ed952
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x138],RAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x12c],EAX
CMP EAX,0x28
JA 0x001ed90b
MOV RCX,qword ptr [RBP + -0x138]
MOV EDX,dword ptr [RBP + -0x12c]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x140],RAX
JMP 0x001ed928
LAB_001ed90b:
MOV RCX,qword ptr [RBP + -0x138]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x140],RAX
LAB_001ed928:
MOV RAX,qword ptr [RBP + -0x140]
MOV EAX,dword ptr [RAX]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x8
SUB RAX,0x1
AND RAX,-0x8
ADD RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x001ed860
LAB_001ed952:
LEA RAX,[RBP + -0x30]
MOV EDI,dword ptr [RBP + -0xc]
MOV RSI,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x001f4710
MOV qword ptr [RBP + -0x40],RAX
CMP RAX,0x0
JNZ 0x001ed97f
JMP 0x001ed972
LAB_001ed972:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001edab4
LAB_001ed97f:
LEA RAX,[RBP + -0x30]
LEA RCX,[RBP + -0x110]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x10
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x48],RAX
LAB_001ed9ab:
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x150],RAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x144],EAX
CMP EAX,0x28
JA 0x001ed9e6
MOV RCX,qword ptr [RBP + -0x150]
MOV EDX,dword ptr [RBP + -0x144]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x158],RAX
JMP 0x001eda03
LAB_001ed9e6:
MOV RCX,qword ptr [RBP + -0x150]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x158],RAX
LAB_001eda03:
MOV RAX,qword ptr [RBP + -0x158]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JZ 0x001edaa8
MOV RCX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RCX
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x168],RAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x15c],EAX
CMP EAX,0x28
JA 0x001eda61
MOV RCX,qword ptr [RBP + -0x168]
MOV EDX,dword ptr [RBP + -0x15c]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x170],RAX
JMP 0x001eda7e
LAB_001eda61:
MOV RCX,qword ptr [RBP + -0x168]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x170],RAX
LAB_001eda7e:
MOV RAX,qword ptr [RBP + -0x170]
MOV EAX,dword ptr [RAX]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x8
SUB RAX,0x1
AND RAX,-0x8
ADD RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x001ed9ab
LAB_001edaa8:
LEA RAX,[RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x8],RAX
LAB_001edab4:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x170
POP RBP
RET
|
/* WARNING: Restarted to delay deadcode elimination for space: stack */
long my_multi_malloc(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int4 param_9,int8 param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
char in_AL;
uint *local_178;
uint *local_160;
uint *local_148;
uint *local_130;
uint local_118 [4];
int8 local_108;
int8 local_100;
int8 local_f8;
int8 local_f0;
int8 local_e8;
int8 local_d8;
int8 local_c8;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
ulong local_60;
long local_58;
long local_50;
long local_40;
uint local_38;
int4 local_34;
uint *local_30;
uint *local_28;
int8 local_20;
int4 local_14;
long local_10;
if (in_AL != '\0') {
local_e8 = param_1;
local_d8 = param_2;
local_c8 = param_3;
local_b8 = param_4;
local_a8 = param_5;
local_98 = param_6;
local_88 = param_7;
local_78 = param_8;
}
local_28 = local_118;
local_30 = (uint *)&stack0x00000008;
local_34 = 0x30;
local_38 = 0x10;
local_58 = 0;
while( true ) {
if (local_38 < 0x29) {
local_130 = (uint *)((long)local_28 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_130 = local_30;
local_30 = local_30 + 2;
}
local_40 = *(long *)local_130;
if (local_40 == 0) break;
if (local_38 < 0x29) {
local_148 = (uint *)((long)local_28 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_148 = local_30;
local_30 = local_30 + 2;
}
local_60 = (ulong)*local_148;
local_58 = (local_60 + 7 & 0xfffffffffffffff8) + local_58;
}
local_108 = param_11;
local_100 = param_12;
local_f8 = param_13;
local_f0 = param_14;
local_20 = param_10;
local_14 = param_9;
local_10 = my_malloc(param_9,local_58,param_10);
if (local_10 == 0) {
local_10 = 0;
}
else {
local_30 = (uint *)&stack0x00000008;
local_38 = 0x10;
local_50 = local_10;
while( true ) {
if (local_38 < 0x29) {
local_160 = (uint *)((long)local_118 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_160 = local_30;
local_30 = local_30 + 2;
}
if (*(long **)local_160 == (long *)0x0) break;
**(long **)local_160 = local_50;
if (local_38 < 0x29) {
local_178 = (uint *)((long)local_118 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_178 = local_30;
local_30 = local_30 + 2;
}
local_50 = ((ulong)*local_178 + 7 & 0xfffffffffffffff8) + local_50;
}
}
return local_10;
}
|
|
8,171 |
js_async_module_execution_rejected
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_async_module_execution_rejected(JSContext *ctx, JSValueConst this_val,
int argc, JSValueConst *argv, int magic, JSValue *func_data)
{
JSModuleDef *module = JS_VALUE_GET_PTR(func_data[0]);
JSValueConst error = argv[0];
int i;
if (js_check_stack_overflow(ctx->rt, 0))
return JS_ThrowStackOverflow(ctx);
if (module->status == JS_MODULE_STATUS_EVALUATED) {
assert(module->eval_has_exception);
return JS_UNDEFINED;
}
assert(module->status == JS_MODULE_STATUS_EVALUATING_ASYNC);
assert(!module->eval_has_exception);
assert(module->async_evaluation);
module->eval_has_exception = TRUE;
module->eval_exception = JS_DupValue(ctx, error);
module->status = JS_MODULE_STATUS_EVALUATED;
for(i = 0; i < module->async_parent_modules_count; i++) {
JSModuleDef *m = module->async_parent_modules[i];
JSValue m_obj = JS_NewModuleValue(ctx, m);
js_async_module_execution_rejected(ctx, JS_UNDEFINED, 1, &error, 0,
&m_obj);
JS_FreeValue(ctx, m_obj);
}
if (!JS_IsUndefined(module->promise)) {
JSValue ret_val;
assert(module->cycle_root == module);
ret_val = JS_Call(ctx, module->resolving_funcs[1], JS_UNDEFINED,
1, &error);
JS_FreeValue(ctx, ret_val);
}
return JS_UNDEFINED;
}
|
O0
|
c
|
js_async_module_execution_rejected:
subq $0xe8, %rsp
movq 0xf0(%rsp), %rax
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xd0(%rsp)
movq %rdi, 0xc0(%rsp)
movl %ecx, 0xbc(%rsp)
movq %r8, 0xb0(%rsp)
movl %r9d, 0xac(%rsp)
movq 0xf0(%rsp), %rax
movq (%rax), %rax
movq %rax, 0xa0(%rsp)
movq 0xb0(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x90(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x98(%rsp)
movq 0xc0(%rsp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x53fd0
cmpl $0x0, %eax
je 0x7d7bc
movq 0xc0(%rsp), %rdi
callq 0x664d0
movq %rax, 0xd8(%rsp)
movq %rdx, 0xe0(%rsp)
jmp 0x7da11
movq 0xa0(%rsp), %rax
movl 0x80(%rax), %eax
shrl $0x18, %eax
cmpl $0x5, %eax
jne 0x7d7ee
movl $0x0, 0xd8(%rsp)
movq $0x3, 0xe0(%rsp)
jmp 0x7da11
movq 0xa0(%rsp), %rax
movb $0x1, 0xf0(%rax)
movq 0xa0(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xc0(%rsp), %rdi
movq 0x90(%rsp), %rsi
movq 0x98(%rsp), %rdx
callq 0x27980
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x78(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x78(%rsp), %rcx
movq %rcx, 0xf8(%rax)
movq 0x80(%rsp), %rcx
movq %rcx, 0x100(%rax)
movq 0xa0(%rsp), %rax
movl 0x80(%rax), %ecx
andl $0xffffff, %ecx # imm = 0xFFFFFF
orl $0x5000000, %ecx # imm = 0x5000000
movl %ecx, 0x80(%rax)
movl $0x0, 0x8c(%rsp)
movl 0x8c(%rsp), %eax
movq 0xa0(%rsp), %rcx
cmpl 0xa0(%rcx), %eax
jge 0x7d951
movq 0xa0(%rsp), %rax
movq 0x98(%rax), %rax
movslq 0x8c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x70(%rsp)
movq 0xc0(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x7a2e0
movq %rax, 0x60(%rsp)
movq %rdx, 0x68(%rsp)
movq 0xc0(%rsp), %rdi
movl $0x0, 0x50(%rsp)
movq $0x3, 0x58(%rsp)
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
movl $0x1, %ecx
leaq 0x90(%rsp), %r8
xorl %r9d, %r9d
leaq 0x60(%rsp), %rax
movq %rax, (%rsp)
callq 0x7d710
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq 0xc0(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
callq 0x29f80
movl 0x8c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8c(%rsp)
jmp 0x7d882
movq 0xa0(%rsp), %rax
movq 0xc0(%rax), %rdi
movq 0xc8(%rax), %rsi
callq 0x34550
cmpl $0x0, %eax
jne 0x7d9fa
movq 0xc0(%rsp), %rdi
movq 0xa0(%rsp), %rax
movl $0x0, 0x10(%rsp)
movq $0x3, 0x18(%rsp)
movq 0xe0(%rax), %rsi
movq 0xe8(%rax), %rdx
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %r8
movl $0x1, %r9d
leaq 0x90(%rsp), %rax
movq %rax, (%rsp)
callq 0x40340
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0xc0(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x29f80
movl $0x0, 0xd8(%rsp)
movq $0x3, 0xe0(%rsp)
movq 0xd8(%rsp), %rax
movq 0xe0(%rsp), %rdx
addq $0xe8, %rsp
retq
nopl (%rax)
|
js_async_module_execution_rejected:
sub rsp, 0E8h
mov rax, [rsp+0E8h+arg_0]
mov [rsp+0E8h+var_20], rsi
mov [rsp+0E8h+var_18], rdx
mov [rsp+0E8h+var_28], rdi
mov [rsp+0E8h+var_2C], ecx
mov [rsp+0E8h+var_38], r8
mov [rsp+0E8h+var_3C], r9d
mov rax, [rsp+0E8h+arg_0]
mov rax, [rax]
mov [rsp+0E8h+var_48], rax
mov rax, [rsp+0E8h+var_38]
mov rcx, [rax]
mov [rsp+0E8h+var_58], rcx
mov rax, [rax+8]
mov [rsp+0E8h+var_50], rax
mov rax, [rsp+0E8h+var_28]
mov rdi, [rax+18h]
xor eax, eax
mov esi, eax
call js_check_stack_overflow
cmp eax, 0
jz short loc_7D7BC
mov rdi, [rsp+0E8h+var_28]
call JS_ThrowStackOverflow
mov [rsp+0E8h+var_10], rax
mov [rsp+0E8h+var_8], rdx
jmp loc_7DA11
loc_7D7BC:
mov rax, [rsp+0E8h+var_48]
mov eax, [rax+80h]
shr eax, 18h
cmp eax, 5
jnz short loc_7D7EE
mov dword ptr [rsp+0E8h+var_10], 0
mov [rsp+0E8h+var_8], 3
jmp loc_7DA11
loc_7D7EE:
mov rax, [rsp+0E8h+var_48]
mov byte ptr [rax+0F0h], 1
mov rax, [rsp+0E8h+var_48]
mov [rsp+0E8h+var_E0], rax
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_58]
mov rdx, [rsp+0E8h+var_50]
call JS_DupValue
mov rcx, rax
mov rax, [rsp+0E8h+var_E0]
mov [rsp+0E8h+var_70], rcx
mov [rsp+0E8h+var_68], rdx
mov rcx, [rsp+0E8h+var_70]
mov [rax+0F8h], rcx
mov rcx, [rsp+0E8h+var_68]
mov [rax+100h], rcx
mov rax, [rsp+0E8h+var_48]
mov ecx, [rax+80h]
and ecx, 0FFFFFFh
or ecx, 5000000h
mov [rax+80h], ecx
mov [rsp+0E8h+var_5C], 0
loc_7D882:
mov eax, [rsp+0E8h+var_5C]
mov rcx, [rsp+0E8h+var_48]
cmp eax, [rcx+0A0h]
jge loc_7D951
mov rax, [rsp+0E8h+var_48]
mov rax, [rax+98h]
movsxd rcx, [rsp+0E8h+var_5C]
mov rax, [rax+rcx*8]
mov [rsp+0E8h+var_78], rax
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_78]
call JS_NewModuleValue
mov [rsp+0E8h+var_88], rax
mov [rsp+0E8h+var_80], rdx
mov rdi, [rsp+0E8h+var_28]
mov dword ptr [rsp+0E8h+var_98], 0
mov [rsp+0E8h+var_90], 3
mov rsi, [rsp+0E8h+var_98]
mov rdx, [rsp+0E8h+var_90]
mov ecx, 1
lea r8, [rsp+0E8h+var_58]
xor r9d, r9d
lea rax, [rsp+0E8h+var_88]
mov [rsp+0E8h+var_E8], rax
call js_async_module_execution_rejected
mov [rsp+0E8h+var_A8], rax
mov [rsp+0E8h+var_A0], rdx
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_88]
mov rdx, [rsp+0E8h+var_80]
call JS_FreeValue
mov eax, [rsp+0E8h+var_5C]
add eax, 1
mov [rsp+0E8h+var_5C], eax
jmp loc_7D882
loc_7D951:
mov rax, [rsp+0E8h+var_48]
mov rdi, [rax+0C0h]
mov rsi, [rax+0C8h]
call JS_IsUndefined_1
cmp eax, 0
jnz loc_7D9FA
mov rdi, [rsp+0E8h+var_28]
mov rax, [rsp+0E8h+var_48]
mov dword ptr [rsp+0E8h+var_D8], 0
mov [rsp+0E8h+var_D0], 3
mov rsi, [rax+0E0h]
mov rdx, [rax+0E8h]
mov rcx, [rsp+0E8h+var_D8]
mov r8, [rsp+0E8h+var_D0]
mov r9d, 1
lea rax, [rsp+0E8h+var_58]
mov [rsp+0E8h+var_E8], rax
call JS_Call
mov [rsp+0E8h+var_C8], rax
mov [rsp+0E8h+var_C0], rdx
mov rax, [rsp+0E8h+var_C8]
mov [rsp+0E8h+var_B8], rax
mov rax, [rsp+0E8h+var_C0]
mov [rsp+0E8h+var_B0], rax
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_B8]
mov rdx, [rsp+0E8h+var_B0]
call JS_FreeValue
loc_7D9FA:
mov dword ptr [rsp+0E8h+var_10], 0
mov [rsp+0E8h+var_8], 3
loc_7DA11:
mov rax, [rsp+0E8h+var_10]
mov rdx, [rsp+0E8h+var_8]
add rsp, 0E8h
retn
|
long long js_async_module_execution_rejected(
long long a1,
long long a2,
long long a3,
int a4,
long long *a5,
int a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14,
long long *a15)
{
long long v15; // rdx
long long v16; // rcx
long long v17; // r8
long long v18; // r9
__m128 v19; // xmm4
__m128 v20; // xmm5
long long v21; // rdx
long long v22; // rdx
long long v23; // r8
long long v24; // r9
long long v25; // rdx
long long v26; // rdx
long long v28; // [rsp+8h] [rbp-E0h]
long long v29; // [rsp+20h] [rbp-C8h]
long long v30; // [rsp+60h] [rbp-88h] BYREF
long long v31; // [rsp+68h] [rbp-80h]
long long v32; // [rsp+70h] [rbp-78h]
long long v33; // [rsp+78h] [rbp-70h]
long long v34; // [rsp+80h] [rbp-68h]
int i; // [rsp+8Ch] [rbp-5Ch]
long long v36; // [rsp+90h] [rbp-58h] BYREF
long long v37; // [rsp+98h] [rbp-50h]
long long v38; // [rsp+A0h] [rbp-48h]
int v39; // [rsp+ACh] [rbp-3Ch]
long long *v40; // [rsp+B0h] [rbp-38h]
int v41; // [rsp+BCh] [rbp-2Ch]
long long v42; // [rsp+C0h] [rbp-28h]
long long v43; // [rsp+C8h] [rbp-20h]
long long v44; // [rsp+D0h] [rbp-18h]
long long v45; // [rsp+D8h] [rbp-10h]
long long v46; // [rsp+E0h] [rbp-8h]
v43 = a2;
v44 = a3;
v42 = a1;
v41 = a4;
v40 = a5;
v39 = a6;
v38 = *a15;
v36 = *a5;
v37 = a5[1];
if ( js_check_stack_overflow(*(_QWORD *)(a1 + 24), 0LL) )
{
v45 = JS_ThrowStackOverflow(v42, a7, a8, a9, a10, v19, v20, a13, a14, 0LL, v15, v16, v17, v18);
v46 = v21;
}
else if ( HIBYTE(*(_DWORD *)(v38 + 128)) == 5 )
{
LODWORD(v45) = 0;
v46 = 3LL;
}
else
{
*(_BYTE *)(v38 + 240) = 1;
v28 = v38;
v33 = JS_DupValue(v42, v36, v37, v16, v17, v18);
v34 = v22;
*(_QWORD *)(v38 + 248) = v33;
*(_QWORD *)(v28 + 256) = v34;
*(_DWORD *)(v38 + 128) = *(_DWORD *)(v38 + 128) & 0xFFFFFF | 0x5000000;
for ( i = 0; i < *(_DWORD *)(v38 + 160); ++i )
{
v32 = *(_QWORD *)(*(_QWORD *)(v38 + 152) + 8LL * i);
v30 = JS_NewModuleValue(v42, v32, v22, i, v23, v24);
v31 = v25;
js_async_module_execution_rejected(v42, 0, 3, 1, (int)&v36, 0, (long long)&v30);
JS_FreeValue(v42, v30, v31);
}
if ( !JS_IsUndefined_1(*(_QWORD *)(v38 + 192), *(_QWORD *)(v38 + 200)) )
{
v29 = JS_Call(v42, *(_QWORD *)(v38 + 224), *(_QWORD *)(v38 + 232), 0, 3, 1, (long long)&v36);
JS_FreeValue(v42, v29, v26);
}
LODWORD(v45) = 0;
v46 = 3LL;
}
return v45;
}
|
js_async_module_execution_rejected:
SUB RSP,0xe8
MOV RAX,qword ptr [RSP + 0xf0]
MOV qword ptr [RSP + 0xc8],RSI
MOV qword ptr [RSP + 0xd0],RDX
MOV qword ptr [RSP + 0xc0],RDI
MOV dword ptr [RSP + 0xbc],ECX
MOV qword ptr [RSP + 0xb0],R8
MOV dword ptr [RSP + 0xac],R9D
MOV RAX,qword ptr [RSP + 0xf0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0xa0],RAX
MOV RAX,qword ptr [RSP + 0xb0]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP + 0x90],RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x98],RAX
MOV RAX,qword ptr [RSP + 0xc0]
MOV RDI,qword ptr [RAX + 0x18]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x00153fd0
CMP EAX,0x0
JZ 0x0017d7bc
MOV RDI,qword ptr [RSP + 0xc0]
CALL 0x001664d0
MOV qword ptr [RSP + 0xd8],RAX
MOV qword ptr [RSP + 0xe0],RDX
JMP 0x0017da11
LAB_0017d7bc:
MOV RAX,qword ptr [RSP + 0xa0]
MOV EAX,dword ptr [RAX + 0x80]
SHR EAX,0x18
CMP EAX,0x5
JNZ 0x0017d7ee
MOV dword ptr [RSP + 0xd8],0x0
MOV qword ptr [RSP + 0xe0],0x3
JMP 0x0017da11
LAB_0017d7ee:
MOV RAX,qword ptr [RSP + 0xa0]
MOV byte ptr [RAX + 0xf0],0x1
MOV RAX,qword ptr [RSP + 0xa0]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0x90]
MOV RDX,qword ptr [RSP + 0x98]
CALL 0x00127980
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x78],RCX
MOV qword ptr [RSP + 0x80],RDX
MOV RCX,qword ptr [RSP + 0x78]
MOV qword ptr [RAX + 0xf8],RCX
MOV RCX,qword ptr [RSP + 0x80]
MOV qword ptr [RAX + 0x100],RCX
MOV RAX,qword ptr [RSP + 0xa0]
MOV ECX,dword ptr [RAX + 0x80]
AND ECX,0xffffff
OR ECX,0x5000000
MOV dword ptr [RAX + 0x80],ECX
MOV dword ptr [RSP + 0x8c],0x0
LAB_0017d882:
MOV EAX,dword ptr [RSP + 0x8c]
MOV RCX,qword ptr [RSP + 0xa0]
CMP EAX,dword ptr [RCX + 0xa0]
JGE 0x0017d951
MOV RAX,qword ptr [RSP + 0xa0]
MOV RAX,qword ptr [RAX + 0x98]
MOVSXD RCX,dword ptr [RSP + 0x8c]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RSP + 0x70],RAX
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0x70]
CALL 0x0017a2e0
MOV qword ptr [RSP + 0x60],RAX
MOV qword ptr [RSP + 0x68],RDX
MOV RDI,qword ptr [RSP + 0xc0]
MOV dword ptr [RSP + 0x50],0x0
MOV qword ptr [RSP + 0x58],0x3
MOV RSI,qword ptr [RSP + 0x50]
MOV RDX,qword ptr [RSP + 0x58]
MOV ECX,0x1
LEA R8,[RSP + 0x90]
XOR R9D,R9D
LEA RAX,[RSP + 0x60]
MOV qword ptr [RSP],RAX
CALL 0x0017d710
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],RDX
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x68]
CALL 0x00129f80
MOV EAX,dword ptr [RSP + 0x8c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x8c],EAX
JMP 0x0017d882
LAB_0017d951:
MOV RAX,qword ptr [RSP + 0xa0]
MOV RDI,qword ptr [RAX + 0xc0]
MOV RSI,qword ptr [RAX + 0xc8]
CALL 0x00134550
CMP EAX,0x0
JNZ 0x0017d9fa
MOV RDI,qword ptr [RSP + 0xc0]
MOV RAX,qword ptr [RSP + 0xa0]
MOV dword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x3
MOV RSI,qword ptr [RAX + 0xe0]
MOV RDX,qword ptr [RAX + 0xe8]
MOV RCX,qword ptr [RSP + 0x10]
MOV R8,qword ptr [RSP + 0x18]
MOV R9D,0x1
LEA RAX,[RSP + 0x90]
MOV qword ptr [RSP],RAX
CALL 0x00140340
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x28],RDX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x38],RAX
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x38]
CALL 0x00129f80
LAB_0017d9fa:
MOV dword ptr [RSP + 0xd8],0x0
MOV qword ptr [RSP + 0xe0],0x3
LAB_0017da11:
MOV RAX,qword ptr [RSP + 0xd8]
MOV RDX,qword ptr [RSP + 0xe0]
ADD RSP,0xe8
RET
|
int1 [16]
js_async_module_execution_rejected
(long param_1,int8 param_2,int8 param_3,int4 param_4,int8 *param_5
,int4 param_6,long *param_7)
{
long lVar1;
int iVar2;
int1 auVar3 [16];
uint uStack_d4;
uint uStack_94;
int1 local_88 [16];
int8 local_78;
int1 local_70 [16];
int local_5c;
int8 local_58;
int8 local_50;
long local_48;
int4 local_3c;
int8 *local_38;
int4 local_2c;
long local_28;
int8 local_20;
int8 local_18;
int4 local_10;
int4 uStack_c;
int8 local_8;
local_48 = *param_7;
local_58 = *param_5;
local_50 = param_5[1];
local_3c = param_6;
local_38 = param_5;
local_2c = param_4;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
iVar2 = js_check_stack_overflow(*(int8 *)(param_1 + 0x18),0);
lVar1 = local_48;
if (iVar2 == 0) {
if (*(uint *)(local_48 + 0x80) >> 0x18 == 5) {
local_10 = 0;
local_8 = 3;
}
else {
*(int1 *)(local_48 + 0xf0) = 1;
local_70 = JS_DupValue(local_28,local_58,local_50);
*(int1 (*) [16])(lVar1 + 0xf8) = local_70;
*(uint *)(local_48 + 0x80) = *(uint *)(local_48 + 0x80) & 0xffffff | 0x5000000;
for (local_5c = 0; local_5c < *(int *)(local_48 + 0xa0); local_5c = local_5c + 1) {
local_78 = *(int8 *)(*(long *)(local_48 + 0x98) + (long)local_5c * 8);
auVar3 = JS_NewModuleValue(local_28,local_78);
local_88 = auVar3;
js_async_module_execution_rejected
(local_28,(ulong)uStack_94 << 0x20,3,1,&local_58,0,local_88);
JS_FreeValue(local_28,local_88._0_8_,local_88._8_8_);
}
iVar2 = JS_IsUndefined(*(int8 *)(local_48 + 0xc0),*(int8 *)(local_48 + 200));
if (iVar2 == 0) {
auVar3 = JS_Call(local_28,*(int8 *)(local_48 + 0xe0),*(int8 *)(local_48 + 0xe8),
(ulong)uStack_d4 << 0x20,3,1,&local_58);
JS_FreeValue(local_28,auVar3._0_8_,auVar3._8_8_);
}
local_10 = 0;
local_8 = 3;
}
}
else {
auVar3 = JS_ThrowStackOverflow(local_28);
local_8 = auVar3._8_8_;
local_10 = auVar3._0_4_;
uStack_c = auVar3._4_4_;
}
auVar3._4_4_ = uStack_c;
auVar3._0_4_ = local_10;
auVar3._8_8_ = local_8;
return auVar3;
}
|
|
8,172 |
dequantize_row_iq3_s
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c
|
void dequantize_row_iq3_s(const block_iq3_s * restrict x, float * restrict y, int64_t k) {
assert(k % QK_K == 0);
const int64_t nb = k / QK_K;
for (int i = 0; i < nb; i++) {
const float d = GGML_FP16_TO_FP32(x[i].d);
const uint8_t * qs = x[i].qs;
const uint8_t * qh = x[i].qh;
const uint8_t * signs = x[i].signs;
for (int ib32 = 0; ib32 < QK_K/32; ib32 += 2) {
const float db1 = d * (1 + 2*(x[i].scales[ib32/2] & 0xf));
const float db2 = d * (1 + 2*(x[i].scales[ib32/2] >> 4));
for (int l = 0; l < 4; ++l) {
const uint8_t * grid1 = (const uint8_t *)(iq3s_grid + (qs[2*l+0] | ((qh[0] << (8-2*l)) & 256)));
const uint8_t * grid2 = (const uint8_t *)(iq3s_grid + (qs[2*l+1] | ((qh[0] << (7-2*l)) & 256)));
for (int j = 0; j < 4; ++j) {
y[j+0] = db1 * grid1[j] * (signs[l] & kmask_iq2xs[j+0] ? -1.f : 1.f);
y[j+4] = db1 * grid2[j] * (signs[l] & kmask_iq2xs[j+4] ? -1.f : 1.f);
}
y += 8;
}
qs += 8;
signs += 4;
for (int l = 0; l < 4; ++l) {
const uint8_t * grid1 = (const uint8_t *)(iq3s_grid + (qs[2*l+0] | ((qh[1] << (8-2*l)) & 256)));
const uint8_t * grid2 = (const uint8_t *)(iq3s_grid + (qs[2*l+1] | ((qh[1] << (7-2*l)) & 256)));
for (int j = 0; j < 4; ++j) {
y[j+0] = db2 * grid1[j] * (signs[l] & kmask_iq2xs[j+0] ? -1.f : 1.f);
y[j+4] = db2 * grid2[j] * (signs[l] & kmask_iq2xs[j+4] ? -1.f : 1.f);
}
y += 8;
}
qh += 2;
qs += 8;
signs += 4;
}
}
}
|
O1
|
c
|
dequantize_row_iq3_s:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, 0x8(%rsp)
testb %dl, %dl
jne 0x34832
sarq $0x8, %rdx
testq %rdx, %rdx
jle 0x34823
xorl %eax, %eax
movl $0x100, %r9d # imm = 0x100
leaq 0x205c8(%rip), %r10 # 0x54be0
leaq 0x1c845(%rip), %r11 # 0x50e64
movaps 0x1c74a(%rip), %xmm0 # 0x50d70
movq %rdx, (%rsp)
movq %rax, 0x10(%rsp)
imulq $0x6e, %rax, %rax
movq 0x8(%rsp), %rdx
leaq (%rdx,%rax), %rcx
movq %rcx, 0x18(%rsp)
leaq (%rdx,%rax), %r14
addq $0x2, %r14
movzwl -0x2(%r14), %ecx
movq 0x39953(%rip), %rdi # 0x6dfa8
movss (%rdi,%rcx,4), %xmm1
leaq (%rdx,%rax), %r15
addq $0x42, %r15
leaq (%rdx,%rax), %r12
addq $0x4a, %r12
xorl %eax, %eax
movq %rax, 0x20(%rsp)
shrq %rax
movq 0x18(%rsp), %rcx
movzbl 0x6a(%rcx,%rax), %eax
movl %eax, %ecx
andl $0xf, %ecx
leal 0x1(,%rcx,2), %ecx
xorps %xmm3, %xmm3
cvtsi2ss %ecx, %xmm3
shrl $0x3, %eax
orl $0x1, %eax
xorps %xmm2, %xmm2
cvtsi2ss %eax, %xmm2
mulss %xmm1, %xmm3
movzbl (%r15), %r8d
leaq 0x30(%rsi), %rcx
xorl %eax, %eax
movq %rcx, %rbp
leaq (%rax,%rax), %rdi
movzbl (%r14,%rax,2), %edx
movb $0x8, %cl
subb %dil, %cl
movl %r8d, %ebx
shll %cl, %ebx
andl %r9d, %ebx
orl %edx, %ebx
leaq (%r10,%rbx,4), %rdx
movzbl 0x1(%r14,%rax,2), %ebx
movb $0x7, %cl
subb %dil, %cl
movl %r8d, %edi
shll %cl, %edi
andl %r9d, %edi
orl %ebx, %edi
leaq (%r10,%rdi,4), %rcx
movb (%r12,%rax), %dil
xorl %ebx, %ebx
movzbl (%rdx,%rbx), %r13d
xorps %xmm4, %xmm4
cvtsi2ss %r13d, %xmm4
mulss %xmm3, %xmm4
testb %dil, (%rbx,%r11)
je 0x34704
xorps %xmm0, %xmm4
movzbl (%rcx,%rbx), %r13d
xorps %xmm5, %xmm5
cvtsi2ss %r13d, %xmm5
movss %xmm4, (%rsi,%rbx,4)
mulss %xmm3, %xmm5
testb %dil, 0x4(%rbx,%r11)
je 0x34724
xorps %xmm0, %xmm5
movss %xmm5, 0x10(%rsi,%rbx,4)
incq %rbx
cmpq $0x4, %rbx
jne 0x346ea
addq $0x20, %rsi
incq %rax
leaq 0x20(%rbp), %rcx
cmpq $0x4, %rax
jne 0x346ac
mulss %xmm1, %xmm2
movzbl 0x1(%r15), %r8d
xorl %eax, %eax
leaq (%rax,%rax), %rdi
movzbl 0x8(%r14,%rax,2), %edx
movb $0x8, %cl
subb %dil, %cl
movl %r8d, %ebx
shll %cl, %ebx
andl %r9d, %ebx
orl %edx, %ebx
leaq (%r10,%rbx,4), %rdx
movzbl 0x9(%r14,%rax,2), %ebx
movb $0x7, %cl
subb %dil, %cl
movl %r8d, %edi
shll %cl, %edi
andl %r9d, %edi
orl %ebx, %edi
leaq (%r10,%rdi,4), %rcx
movb 0x4(%r12,%rax), %dil
xorl %ebx, %ebx
movzbl (%rdx,%rbx), %r13d
xorps %xmm3, %xmm3
cvtsi2ss %r13d, %xmm3
mulss %xmm2, %xmm3
testb %dil, (%rbx,%r11)
je 0x347aa
xorps %xmm0, %xmm3
movzbl (%rcx,%rbx), %r13d
xorps %xmm4, %xmm4
cvtsi2ss %r13d, %xmm4
movss %xmm3, -0x10(%rbp,%rbx,4)
mulss %xmm2, %xmm4
testb %dil, 0x4(%rbx,%r11)
je 0x347cb
xorps %xmm0, %xmm4
movss %xmm4, (%rbp,%rbx,4)
incq %rbx
cmpq $0x4, %rbx
jne 0x34790
addq $0x20, %rsi
incq %rax
addq $0x20, %rbp
cmpq $0x4, %rax
jne 0x34753
addq $0x2, %r15
addq $0x10, %r14
addq $0x8, %r12
movq 0x20(%rsp), %rcx
leaq 0x2(%rcx), %rax
cmpq $0x6, %rcx
jb 0x3466c
movq 0x10(%rsp), %rax
incq %rax
movq (%rsp), %rdx
cmpq %rdx, %rax
jne 0x3462a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x273b3(%rip), %rdi # 0x5bbec
leaq 0x26fc4(%rip), %rsi # 0x5b804
leaq 0x27969(%rip), %rcx # 0x5c1b0
movl $0x90d, %edx # imm = 0x90D
callq 0x17b00
|
dequantize_row_iq3_s:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov [rsp+58h+var_50], rdi
test dl, dl
jnz loc_34832
sar rdx, 8
test rdx, rdx
jle loc_34823
xor eax, eax
mov r9d, 100h
lea r10, iq3s_grid
lea r11, kmask_iq2xs
movaps xmm0, cs:xmmword_50D70
mov [rsp+58h+var_58], rdx
loc_3462A:
mov [rsp+58h+var_48], rax
imul rax, 6Eh ; 'n'
mov rdx, [rsp+58h+var_50]
lea rcx, [rdx+rax]
mov [rsp+58h+var_40], rcx
lea r14, [rdx+rax]
add r14, 2
movzx ecx, word ptr [r14-2]
mov rdi, cs:ggml_table_f32_f16_ptr
movss xmm1, dword ptr [rdi+rcx*4]
lea r15, [rdx+rax]
add r15, 42h ; 'B'
lea r12, [rdx+rax]
add r12, 4Ah ; 'J'
xor eax, eax
loc_3466C:
mov [rsp+58h+var_38], rax
shr rax, 1
mov rcx, [rsp+58h+var_40]
movzx eax, byte ptr [rcx+rax+6Ah]
mov ecx, eax
and ecx, 0Fh
lea ecx, ds:1[rcx*2]
xorps xmm3, xmm3
cvtsi2ss xmm3, ecx
shr eax, 3
or eax, 1
xorps xmm2, xmm2
cvtsi2ss xmm2, eax
mulss xmm3, xmm1
movzx r8d, byte ptr [r15]
lea rcx, [rsi+30h]
xor eax, eax
loc_346AC:
mov rbp, rcx
lea rdi, [rax+rax]
movzx edx, byte ptr [r14+rax*2]
mov cl, 8
sub cl, dil
mov ebx, r8d
shl ebx, cl
and ebx, r9d
or ebx, edx
lea rdx, [r10+rbx*4]
movzx ebx, byte ptr [r14+rax*2+1]
mov cl, 7
sub cl, dil
mov edi, r8d
shl edi, cl
and edi, r9d
or edi, ebx
lea rcx, [r10+rdi*4]
mov dil, [r12+rax]
xor ebx, ebx
loc_346EA:
movzx r13d, byte ptr [rdx+rbx]
xorps xmm4, xmm4
cvtsi2ss xmm4, r13d
mulss xmm4, xmm3
test [rbx+r11], dil
jz short loc_34704
xorps xmm4, xmm0
loc_34704:
movzx r13d, byte ptr [rcx+rbx]
xorps xmm5, xmm5
cvtsi2ss xmm5, r13d
movss dword ptr [rsi+rbx*4], xmm4
mulss xmm5, xmm3
test [rbx+r11+4], dil
jz short loc_34724
xorps xmm5, xmm0
loc_34724:
movss dword ptr [rsi+rbx*4+10h], xmm5
inc rbx
cmp rbx, 4
jnz short loc_346EA
add rsi, 20h ; ' '
inc rax
lea rcx, [rbp+20h]
cmp rax, 4
jnz loc_346AC
mulss xmm2, xmm1
movzx r8d, byte ptr [r15+1]
xor eax, eax
loc_34753:
lea rdi, [rax+rax]
movzx edx, byte ptr [r14+rax*2+8]
mov cl, 8
sub cl, dil
mov ebx, r8d
shl ebx, cl
and ebx, r9d
or ebx, edx
lea rdx, [r10+rbx*4]
movzx ebx, byte ptr [r14+rax*2+9]
mov cl, 7
sub cl, dil
mov edi, r8d
shl edi, cl
and edi, r9d
or edi, ebx
lea rcx, [r10+rdi*4]
mov dil, [r12+rax+4]
xor ebx, ebx
loc_34790:
movzx r13d, byte ptr [rdx+rbx]
xorps xmm3, xmm3
cvtsi2ss xmm3, r13d
mulss xmm3, xmm2
test [rbx+r11], dil
jz short loc_347AA
xorps xmm3, xmm0
loc_347AA:
movzx r13d, byte ptr [rcx+rbx]
xorps xmm4, xmm4
cvtsi2ss xmm4, r13d
movss dword ptr [rbp+rbx*4-10h], xmm3
mulss xmm4, xmm2
test [rbx+r11+4], dil
jz short loc_347CB
xorps xmm4, xmm0
loc_347CB:
movss dword ptr [rbp+rbx*4+0], xmm4
inc rbx
cmp rbx, 4
jnz short loc_34790
add rsi, 20h ; ' '
inc rax
add rbp, 20h ; ' '
cmp rax, 4
jnz loc_34753
add r15, 2
add r14, 10h
add r12, 8
mov rcx, [rsp+58h+var_38]
lea rax, [rcx+2]
cmp rcx, 6
jb loc_3466C
mov rax, [rsp+58h+var_48]
inc rax
mov rdx, [rsp+58h+var_58]
cmp rax, rdx
jnz loc_3462A
loc_34823:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_34832:
lea rdi, aKQkK0; "k % QK_K == 0"
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidDequantize_15; "void dequantize_row_iq3_s(const block_i"...
mov edx, 90Dh
call ___assert_fail
|
void dequantize_row_iq3_s(long long a1, long long a2, long long a3)
{
long long v3; // rdx
long long v4; // rax
unsigned __int16 *v5; // r14
float v6; // xmm1_4
unsigned __int8 *v7; // r15
unsigned __int16 *v8; // r12
unsigned long long v9; // rax
unsigned int v10; // eax
float v11; // xmm2_4
float v12; // xmm3_4
int v13; // r8d
long long v14; // rcx
long long i; // rax
long long v16; // rbp
char *v17; // rdx
char *v18; // rcx
unsigned __int8 v19; // di
long long j; // rbx
float v21; // xmm4_4
int v22; // r13d
float v23; // xmm5_4
float v24; // xmm2_4
int v25; // r8d
long long k; // rax
char *v27; // rdx
char *v28; // rcx
unsigned __int8 v29; // di
long long m; // rbx
float v31; // xmm3_4
int v32; // r13d
float v33; // xmm4_4
long long v34; // [rsp+0h] [rbp-58h]
long long v36; // [rsp+10h] [rbp-48h]
unsigned __int16 *v37; // [rsp+18h] [rbp-40h]
unsigned long long v38; // [rsp+20h] [rbp-38h]
if ( (_BYTE)a3 )
__assert_fail(
"k % QK_K == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c",
2317LL,
"void dequantize_row_iq3_s(const block_iq3_s *restrict, float *restrict, int64_t)");
v3 = a3 >> 8;
if ( v3 > 0 )
{
v4 = 0LL;
v34 = v3;
do
{
v36 = v4;
v37 = (unsigned __int16 *)(a1 + 110 * v4);
v5 = v37 + 1;
v6 = ggml_table_f32_f16[*v37];
v7 = (unsigned __int8 *)(v37 + 33);
v8 = v37 + 37;
v9 = 0LL;
do
{
v38 = v9;
v10 = *((unsigned __int8 *)v37 + (v9 >> 1) + 106);
v11 = (float)((v10 >> 3) | 1);
v12 = (float)(int)(2 * (v10 & 0xF) + 1) * v6;
v13 = *v7;
v14 = a2 + 48;
for ( i = 0LL; i != 4; ++i )
{
v16 = v14;
v17 = (char *)&iq3s_grid + 4 * (LOBYTE(v5[i]) | (v13 << (8 - 2 * i)) & 0x100u);
v18 = (char *)&iq3s_grid + 4 * (HIBYTE(v5[i]) | (v13 << (7 - 2 * i)) & 0x100u);
v19 = *((_BYTE *)v8 + i);
for ( j = 0LL; j != 4; ++j )
{
v21 = (float)(unsigned __int8)v17[j] * v12;
if ( (v19 & kmask_iq2xs[j]) != 0 )
v21 = -v21;
v22 = (unsigned __int8)v18[j];
*(float *)(a2 + 4 * j) = v21;
v23 = (float)v22 * v12;
if ( (v19 & kmask_iq2xs[j + 4]) != 0 )
v23 = -v23;
*(float *)(a2 + 4 * j + 16) = v23;
}
a2 += 32LL;
v14 = v16 + 32;
}
v24 = v11 * v6;
v25 = v7[1];
for ( k = 0LL; k != 4; ++k )
{
v27 = (char *)&iq3s_grid + 4 * (LOBYTE(v5[k + 4]) | (v25 << (8 - 2 * k)) & 0x100u);
v28 = (char *)&iq3s_grid + 4 * (HIBYTE(v5[k + 4]) | (v25 << (7 - 2 * k)) & 0x100u);
v29 = *((_BYTE *)v8 + k + 4);
for ( m = 0LL; m != 4; ++m )
{
v31 = (float)(unsigned __int8)v27[m] * v24;
if ( (v29 & kmask_iq2xs[m]) != 0 )
v31 = -v31;
v32 = (unsigned __int8)v28[m];
*(float *)(v16 + 4 * m - 16) = v31;
v33 = (float)v32 * v24;
if ( (v29 & kmask_iq2xs[m + 4]) != 0 )
v33 = -v33;
*(float *)(v16 + 4 * m) = v33;
}
a2 += 32LL;
v16 += 32LL;
}
v7 += 2;
v5 += 8;
v8 += 4;
v9 = v38 + 2;
}
while ( v38 < 6 );
v4 = v36 + 1;
}
while ( v36 + 1 != v34 );
}
}
|
dequantize_row_iq3_s:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP + 0x8],RDI
TEST DL,DL
JNZ 0x00134832
SAR RDX,0x8
TEST RDX,RDX
JLE 0x00134823
XOR EAX,EAX
MOV R9D,0x100
LEA R10,[0x154be0]
LEA R11,[0x150e64]
MOVAPS XMM0,xmmword ptr [0x00150d70]
MOV qword ptr [RSP],RDX
LAB_0013462a:
MOV qword ptr [RSP + 0x10],RAX
IMUL RAX,RAX,0x6e
MOV RDX,qword ptr [RSP + 0x8]
LEA RCX,[RDX + RAX*0x1]
MOV qword ptr [RSP + 0x18],RCX
LEA R14,[RDX + RAX*0x1]
ADD R14,0x2
MOVZX ECX,word ptr [R14 + -0x2]
MOV RDI,qword ptr [0x0016dfa8]
MOVSS XMM1,dword ptr [RDI + RCX*0x4]
LEA R15,[RDX + RAX*0x1]
ADD R15,0x42
LEA R12,[RDX + RAX*0x1]
ADD R12,0x4a
XOR EAX,EAX
LAB_0013466c:
MOV qword ptr [RSP + 0x20],RAX
SHR RAX,0x1
MOV RCX,qword ptr [RSP + 0x18]
MOVZX EAX,byte ptr [RCX + RAX*0x1 + 0x6a]
MOV ECX,EAX
AND ECX,0xf
LEA ECX,[0x1 + RCX*0x2]
XORPS XMM3,XMM3
CVTSI2SS XMM3,ECX
SHR EAX,0x3
OR EAX,0x1
XORPS XMM2,XMM2
CVTSI2SS XMM2,EAX
MULSS XMM3,XMM1
MOVZX R8D,byte ptr [R15]
LEA RCX,[RSI + 0x30]
XOR EAX,EAX
LAB_001346ac:
MOV RBP,RCX
LEA RDI,[RAX + RAX*0x1]
MOVZX EDX,byte ptr [R14 + RAX*0x2]
MOV CL,0x8
SUB CL,DIL
MOV EBX,R8D
SHL EBX,CL
AND EBX,R9D
OR EBX,EDX
LEA RDX,[R10 + RBX*0x4]
MOVZX EBX,byte ptr [R14 + RAX*0x2 + 0x1]
MOV CL,0x7
SUB CL,DIL
MOV EDI,R8D
SHL EDI,CL
AND EDI,R9D
OR EDI,EBX
LEA RCX,[R10 + RDI*0x4]
MOV DIL,byte ptr [R12 + RAX*0x1]
XOR EBX,EBX
LAB_001346ea:
MOVZX R13D,byte ptr [RDX + RBX*0x1]
XORPS XMM4,XMM4
CVTSI2SS XMM4,R13D
MULSS XMM4,XMM3
TEST byte ptr [RBX + R11*0x1],DIL
JZ 0x00134704
XORPS XMM4,XMM0
LAB_00134704:
MOVZX R13D,byte ptr [RCX + RBX*0x1]
XORPS XMM5,XMM5
CVTSI2SS XMM5,R13D
MOVSS dword ptr [RSI + RBX*0x4],XMM4
MULSS XMM5,XMM3
TEST byte ptr [RBX + R11*0x1 + 0x4],DIL
JZ 0x00134724
XORPS XMM5,XMM0
LAB_00134724:
MOVSS dword ptr [RSI + RBX*0x4 + 0x10],XMM5
INC RBX
CMP RBX,0x4
JNZ 0x001346ea
ADD RSI,0x20
INC RAX
LEA RCX,[RBP + 0x20]
CMP RAX,0x4
JNZ 0x001346ac
MULSS XMM2,XMM1
MOVZX R8D,byte ptr [R15 + 0x1]
XOR EAX,EAX
LAB_00134753:
LEA RDI,[RAX + RAX*0x1]
MOVZX EDX,byte ptr [R14 + RAX*0x2 + 0x8]
MOV CL,0x8
SUB CL,DIL
MOV EBX,R8D
SHL EBX,CL
AND EBX,R9D
OR EBX,EDX
LEA RDX,[R10 + RBX*0x4]
MOVZX EBX,byte ptr [R14 + RAX*0x2 + 0x9]
MOV CL,0x7
SUB CL,DIL
MOV EDI,R8D
SHL EDI,CL
AND EDI,R9D
OR EDI,EBX
LEA RCX,[R10 + RDI*0x4]
MOV DIL,byte ptr [R12 + RAX*0x1 + 0x4]
XOR EBX,EBX
LAB_00134790:
MOVZX R13D,byte ptr [RDX + RBX*0x1]
XORPS XMM3,XMM3
CVTSI2SS XMM3,R13D
MULSS XMM3,XMM2
TEST byte ptr [RBX + R11*0x1],DIL
JZ 0x001347aa
XORPS XMM3,XMM0
LAB_001347aa:
MOVZX R13D,byte ptr [RCX + RBX*0x1]
XORPS XMM4,XMM4
CVTSI2SS XMM4,R13D
MOVSS dword ptr [RBP + RBX*0x4 + -0x10],XMM3
MULSS XMM4,XMM2
TEST byte ptr [RBX + R11*0x1 + 0x4],DIL
JZ 0x001347cb
XORPS XMM4,XMM0
LAB_001347cb:
MOVSS dword ptr [RBP + RBX*0x4],XMM4
INC RBX
CMP RBX,0x4
JNZ 0x00134790
ADD RSI,0x20
INC RAX
ADD RBP,0x20
CMP RAX,0x4
JNZ 0x00134753
ADD R15,0x2
ADD R14,0x10
ADD R12,0x8
MOV RCX,qword ptr [RSP + 0x20]
LEA RAX,[RCX + 0x2]
CMP RCX,0x6
JC 0x0013466c
MOV RAX,qword ptr [RSP + 0x10]
INC RAX
MOV RDX,qword ptr [RSP]
CMP RAX,RDX
JNZ 0x0013462a
LAB_00134823:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00134832:
LEA RDI,[0x15bbec]
LEA RSI,[0x15b804]
LEA RCX,[0x15c1b0]
MOV EDX,0x90d
CALL 0x00117b00
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void dequantize_row_iq3_s(long param_1,long param_2,long param_3)
{
float fVar1;
byte bVar2;
byte bVar3;
byte bVar4;
byte bVar5;
byte bVar6;
ushort uVar7;
uint uVar8;
long lVar9;
ulong uVar10;
long lVar11;
long lVar12;
long lVar13;
long lVar14;
long lVar15;
ushort *puVar16;
byte *pbVar17;
bool bVar18;
float fVar19;
float fVar20;
uVar8 = _DAT_00150d70;
if ((char)param_3 == '\0') {
if (0 < param_3 >> 8) {
lVar12 = 0;
do {
lVar9 = lVar12 * 0x6e;
puVar16 = (ushort *)(param_1 + lVar9) + 1;
fVar1 = *(float *)(PTR_ggml_table_f32_f16_0016dfa8 + (ulong)*(ushort *)(param_1 + lVar9) * 4
);
pbVar17 = (byte *)(param_1 + lVar9 + 0x42);
lVar15 = param_1 + lVar9 + 0x4a;
uVar10 = 0;
do {
bVar3 = *(byte *)(param_1 + lVar9 + 0x6a + (uVar10 >> 1));
fVar19 = (float)(byte)((bVar3 & 0xf) * '\x02' + 1) * fVar1;
bVar4 = *pbVar17;
lVar11 = 0;
lVar13 = param_2 + 0x30;
do {
lVar14 = lVar13;
uVar7 = puVar16[lVar11];
bVar5 = *(byte *)((long)puVar16 + lVar11 * 2 + 1);
bVar2 = *(byte *)(lVar15 + lVar11);
lVar13 = 0;
do {
fVar20 = (float)(byte)iq3s_grid[lVar13 + (ulong)((uint)bVar4 <<
((char)lVar11 * -2 + 8U & 0x1f) &
0x100 | (uint)(byte)uVar7) * 4] *
fVar19;
if (((&kmask_iq2xs)[lVar13] & bVar2) != 0) {
fVar20 = (float)((uint)fVar20 ^ uVar8);
}
bVar6 = iq3s_grid[lVar13 + (ulong)((uint)bVar4 << ((char)lVar11 * -2 + 7U & 0x1f) &
0x100 | (uint)bVar5) * 4];
*(float *)(param_2 + lVar13 * 4) = fVar20;
fVar20 = (float)bVar6 * fVar19;
if (((&DAT_00150e68)[lVar13] & bVar2) != 0) {
fVar20 = (float)((uint)fVar20 ^ uVar8);
}
*(float *)(param_2 + 0x10 + lVar13 * 4) = fVar20;
lVar13 = lVar13 + 1;
} while (lVar13 != 4);
param_2 = param_2 + 0x20;
lVar11 = lVar11 + 1;
lVar13 = lVar14 + 0x20;
} while (lVar11 != 4);
fVar19 = (float)(byte)(bVar3 >> 3 | 1) * fVar1;
bVar3 = pbVar17[1];
lVar13 = 0;
do {
uVar7 = puVar16[lVar13 + 4];
bVar2 = *(byte *)((long)puVar16 + lVar13 * 2 + 9);
bVar4 = *(byte *)(lVar15 + 4 + lVar13);
lVar11 = 0;
do {
fVar20 = (float)(byte)iq3s_grid[lVar11 + (ulong)((uint)bVar3 <<
((char)lVar13 * -2 + 8U & 0x1f) &
0x100 | (uint)(byte)uVar7) * 4] *
fVar19;
if (((&kmask_iq2xs)[lVar11] & bVar4) != 0) {
fVar20 = (float)((uint)fVar20 ^ uVar8);
}
bVar5 = iq3s_grid[lVar11 + (ulong)((uint)bVar3 << ((char)lVar13 * -2 + 7U & 0x1f) &
0x100 | (uint)bVar2) * 4];
*(float *)(lVar14 + -0x10 + lVar11 * 4) = fVar20;
fVar20 = (float)bVar5 * fVar19;
if (((&DAT_00150e68)[lVar11] & bVar4) != 0) {
fVar20 = (float)((uint)fVar20 ^ uVar8);
}
*(float *)(lVar14 + lVar11 * 4) = fVar20;
lVar11 = lVar11 + 1;
} while (lVar11 != 4);
param_2 = param_2 + 0x20;
lVar13 = lVar13 + 1;
lVar14 = lVar14 + 0x20;
} while (lVar13 != 4);
pbVar17 = pbVar17 + 2;
puVar16 = puVar16 + 8;
lVar15 = lVar15 + 8;
bVar18 = uVar10 < 6;
uVar10 = uVar10 + 2;
} while (bVar18);
lVar12 = lVar12 + 1;
} while (lVar12 != param_3 >> 8);
}
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("k % QK_K == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c"
,0x90d,
"void dequantize_row_iq3_s(const block_iq3_s *restrict, float *restrict, int64_t)");
}
|
|
8,173 |
Catch::Matchers::StringEqualsMatcher::match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
|
AlayaLite/build_O3/_deps/libcoro-src/test/catch_amalgamated.cpp
|
bool StringEqualsMatcher::match( std::string const& source ) const {
return m_comparator.adjustString( source ) == m_comparator.m_str;
}
|
O3
|
cpp
|
Catch::Matchers::StringEqualsMatcher::match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rdx
movq %rdi, %r14
leaq 0x28(%rdi), %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x658ea
movq 0x8(%rbx), %rdx
cmpq 0x38(%r14), %rdx
jne 0x65b12
movq (%rsp), %rbx
testq %rdx, %rdx
je 0x65b1a
movq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0x177b0
testl %eax, %eax
sete %bpl
jmp 0x65b1d
movq (%rsp), %rbx
xorl %ebp, %ebp
jmp 0x65b1d
movb $0x1, %bpl
leaq 0x10(%rsp), %rax
cmpq %rax, %rbx
je 0x65b37
movq 0x10(%rsp), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x17150
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
|
_ZNK5Catch8Matchers19StringEqualsMatcher5matchERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r14
push rbx
sub rsp, 20h
mov rdx, rsi
mov r14, rdi
lea rsi, [rdi+28h]
mov rbx, rsp
mov rdi, rbx
call _ZNK5Catch8Matchers11CasedString12adjustStringERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; Catch::Matchers::CasedString::adjustString(std::string const&)
mov rdx, [rbx+8]
cmp rdx, [r14+38h]
jnz short loc_65B12
mov rbx, [rsp+38h+var_38]
test rdx, rdx
jz short loc_65B1A
mov rsi, [r14+30h]
mov rdi, rbx
call _bcmp
test eax, eax
setz bpl
jmp short loc_65B1D
loc_65B12:
mov rbx, [rsp+38h+var_38]
xor ebp, ebp
jmp short loc_65B1D
loc_65B1A:
mov bpl, 1
loc_65B1D:
lea rax, [rsp+38h+var_28]
cmp rbx, rax
jz short loc_65B37
mov rsi, [rsp+38h+var_28]
inc rsi; unsigned __int64
mov rdi, rbx; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_65B37:
mov eax, ebp
add rsp, 20h
pop rbx
pop r14
pop rbp
retn
|
long long Catch::Matchers::StringEqualsMatcher::match(long long a1, long long a2)
{
unsigned int v2; // ebp
long long *v3; // rbx
void *v5; // [rsp+0h] [rbp-38h] BYREF
long long v6; // [rsp+8h] [rbp-30h]
long long v7; // [rsp+10h] [rbp-28h] BYREF
Catch::Matchers::CasedString::adjustString((long long *)&v5, (_DWORD *)(a1 + 40), a2);
if ( v6 == *(_QWORD *)(a1 + 56) )
{
v3 = (long long *)v5;
if ( v6 )
LOBYTE(v2) = (unsigned int)bcmp(v5, *(_QWORD *)(a1 + 48)) == 0;
else
LOBYTE(v2) = 1;
}
else
{
v3 = (long long *)v5;
v2 = 0;
}
if ( v3 != &v7 )
operator delete(v3, v7 + 1);
return v2;
}
|
match:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x20
MOV RDX,RSI
MOV R14,RDI
LEA RSI,[RDI + 0x28]
MOV RBX,RSP
MOV RDI,RBX
CALL 0x001658ea
MOV RDX,qword ptr [RBX + 0x8]
CMP RDX,qword ptr [R14 + 0x38]
JNZ 0x00165b12
MOV RBX,qword ptr [RSP]
TEST RDX,RDX
JZ 0x00165b1a
MOV RSI,qword ptr [R14 + 0x30]
MOV RDI,RBX
CALL 0x001177b0
TEST EAX,EAX
SETZ BPL
JMP 0x00165b1d
LAB_00165b12:
MOV RBX,qword ptr [RSP]
XOR EBP,EBP
JMP 0x00165b1d
LAB_00165b1a:
MOV BPL,0x1
LAB_00165b1d:
LEA RAX,[RSP + 0x10]
CMP RBX,RAX
JZ 0x00165b37
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
MOV RDI,RBX
CALL 0x00117150
LAB_00165b37:
MOV EAX,EBP
ADD RSP,0x20
POP RBX
POP R14
POP RBP
RET
|
/* Catch::Matchers::StringEqualsMatcher::match(std::__cxx11::string const&) const */
ulong Catch::Matchers::StringEqualsMatcher::match(string *param_1)
{
int iVar1;
int8 unaff_RBP;
int7 uVar3;
ulong uVar2;
long *local_38;
size_t local_30;
long local_28 [2];
CasedString::adjustString((string *)&local_38);
if (local_30 == *(size_t *)(param_1 + 0x38)) {
uVar3 = (int7)((ulong)unaff_RBP >> 8);
if (local_30 == 0) {
uVar2 = CONCAT71(uVar3,1);
}
else {
iVar1 = bcmp(local_38,*(void **)(param_1 + 0x30),local_30);
uVar2 = CONCAT71(uVar3,iVar1 == 0);
}
}
else {
uVar2 = 0;
}
if (local_38 != local_28) {
operator_delete(local_38,local_28[0] + 1);
}
return uVar2 & 0xffffffff;
}
|
|
8,174 |
js_cond_destroy
|
bluesky950520[P]quickjs/cutils.c
|
void js_cond_destroy(js_cond_t *cond) {
#if defined(__APPLE__) && defined(__MACH__)
/* It has been reported that destroying condition variables that have been
* signalled but not waited on can sometimes result in application crashes.
* See https://codereview.chromium.org/1323293005.
*/
pthread_mutex_t mutex;
struct timespec ts;
int err;
if (pthread_mutex_init(&mutex, NULL))
abort();
if (pthread_mutex_lock(&mutex))
abort();
ts.tv_sec = 0;
ts.tv_nsec = 1;
err = pthread_cond_timedwait_relative_np(cond, &mutex, &ts);
if (err != 0 && err != ETIMEDOUT)
abort();
if (pthread_mutex_unlock(&mutex))
abort();
if (pthread_mutex_destroy(&mutex))
abort();
#endif /* defined(__APPLE__) && defined(__MACH__) */
if (pthread_cond_destroy(cond))
abort();
}
|
O0
|
c
|
js_cond_destroy:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0xe7e0
cmpl $0x0, %eax
je 0x272e8
callq 0xe090
popq %rax
retq
nopw (%rax,%rax)
|
js_cond_destroy:
push rax
mov [rsp+8+var_8], rdi
mov rdi, [rsp+8+var_8]
call _pthread_cond_destroy
cmp eax, 0
jz short loc_272E8
call _abort
loc_272E8:
pop rax
retn
|
long long js_cond_destroy(long long a1)
{
if ( (unsigned int)pthread_cond_destroy(a1) )
abort();
return a1;
}
|
js_cond_destroy:
PUSH RAX
MOV qword ptr [RSP],RDI
MOV RDI,qword ptr [RSP]
CALL 0x0010e7e0
CMP EAX,0x0
JZ 0x001272e8
CALL 0x0010e090
LAB_001272e8:
POP RAX
RET
|
pthread_cond_t * js_cond_destroy(pthread_cond_t *param_1)
{
int iVar1;
iVar1 = pthread_cond_destroy(param_1);
if (iVar1 != 0) {
/* WARNING: Subroutine does not return */
abort();
}
return param_1;
}
|
|
8,175 |
js_cond_destroy
|
bluesky950520[P]quickjs/cutils.c
|
void js_cond_destroy(js_cond_t *cond) {
#if defined(__APPLE__) && defined(__MACH__)
/* It has been reported that destroying condition variables that have been
* signalled but not waited on can sometimes result in application crashes.
* See https://codereview.chromium.org/1323293005.
*/
pthread_mutex_t mutex;
struct timespec ts;
int err;
if (pthread_mutex_init(&mutex, NULL))
abort();
if (pthread_mutex_lock(&mutex))
abort();
ts.tv_sec = 0;
ts.tv_nsec = 1;
err = pthread_cond_timedwait_relative_np(cond, &mutex, &ts);
if (err != 0 && err != ETIMEDOUT)
abort();
if (pthread_mutex_unlock(&mutex))
abort();
if (pthread_mutex_destroy(&mutex))
abort();
#endif /* defined(__APPLE__) && defined(__MACH__) */
if (pthread_cond_destroy(cond))
abort();
}
|
O2
|
c
|
js_cond_destroy:
pushq %rax
callq 0xe820
testl %eax, %eax
jne 0x1a9c8
popq %rax
retq
callq 0xe090
|
js_cond_destroy:
push rax
call _pthread_cond_destroy
test eax, eax
jnz short loc_1A9C8
pop rax
retn
loc_1A9C8:
call _abort
|
void __spoils<rdx,rcx,r8,r9,r10,r11,xmm4,xmm5> js_cond_destroy()
{
if ( (unsigned int)pthread_cond_destroy() )
abort();
}
|
js_cond_destroy:
PUSH RAX
CALL 0x0010e820
TEST EAX,EAX
JNZ 0x0011a9c8
POP RAX
RET
LAB_0011a9c8:
CALL 0x0010e090
|
int8 js_cond_destroy(pthread_cond_t *param_1)
{
int iVar1;
int8 in_RAX;
iVar1 = pthread_cond_destroy(param_1);
if (iVar1 == 0) {
return in_RAX;
}
/* WARNING: Subroutine does not return */
abort();
}
|
|
8,176 |
ma_keyseg_read
|
eloqsql/storage/maria/ma_open.c
|
uchar *_ma_keyseg_read(uchar *ptr, HA_KEYSEG *keyseg)
{
keyseg->type = *ptr++;
keyseg->language = *ptr++;
keyseg->null_bit = *ptr++;
keyseg->bit_start = *ptr++;
keyseg->language += ((uint16) (*ptr++)) << 8;
keyseg->bit_length = *ptr++;
keyseg->flag = mi_uint2korr(ptr); ptr+= 2;
keyseg->length = mi_uint2korr(ptr); ptr+= 2;
keyseg->start = mi_uint4korr(ptr); ptr+= 4;
keyseg->null_pos = mi_uint4korr(ptr); ptr+= 4;
keyseg->charset=0; /* Will be filled in later */
if (keyseg->null_bit)
keyseg->bit_pos= (uint16)(keyseg->null_pos + (keyseg->null_bit == 7));
else
{
keyseg->bit_pos= (uint16)keyseg->null_pos;
keyseg->null_pos= 0;
}
return ptr;
}
|
O3
|
c
|
ma_keyseg_read:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movb (%rdi), %cl
movb %cl, 0x18(%rsi)
movzbl 0x1(%rdi), %edx
movw %dx, 0x16(%rsi)
movb 0x2(%rdi), %cl
movb %cl, 0x19(%rsi)
movb 0x3(%rdi), %dil
movb %dil, 0x1a(%rsi)
movzbl 0x4(%rax), %edi
shll $0x8, %edi
orl %edx, %edi
movw %di, 0x16(%rsi)
movb 0x5(%rax), %dl
movb %dl, 0x1b(%rsi)
movzwl 0x6(%rax), %edx
rolw $0x8, %dx
movw %dx, 0x12(%rsi)
movzwl 0x8(%rax), %edx
rolw $0x8, %dx
movw %dx, 0x14(%rsi)
movl 0xa(%rax), %edx
bswapl %edx
movl %edx, 0x8(%rsi)
movzwl 0x10(%rax), %edx
rolw $0x8, %dx
movzwl %dx, %edx
movzbl 0xf(%rax), %edi
shll $0x10, %edi
movzbl 0xe(%rax), %r8d
shll $0x18, %r8d
orl %edi, %r8d
orl %edx, %r8d
movl %r8d, 0xc(%rsi)
movq $0x0, (%rsi)
testb %cl, %cl
je 0x5462c
xorl %edi, %edi
cmpb $0x7, %cl
sete %dil
addl %edi, %edx
jmp 0x54633
movl $0x0, 0xc(%rsi)
movw %dx, 0x10(%rsi)
addq $0x12, %rax
popq %rbp
retq
|
_ma_keyseg_read:
push rbp
mov rbp, rsp
mov rax, rdi
mov cl, [rdi]
mov [rsi+18h], cl
movzx edx, byte ptr [rdi+1]
mov [rsi+16h], dx
mov cl, [rdi+2]
mov [rsi+19h], cl
mov dil, [rdi+3]
mov [rsi+1Ah], dil
movzx edi, byte ptr [rax+4]
shl edi, 8
or edi, edx
mov [rsi+16h], di
mov dl, [rax+5]
mov [rsi+1Bh], dl
movzx edx, word ptr [rax+6]
rol dx, 8
mov [rsi+12h], dx
movzx edx, word ptr [rax+8]
rol dx, 8
mov [rsi+14h], dx
mov edx, [rax+0Ah]
bswap edx
mov [rsi+8], edx
movzx edx, word ptr [rax+10h]
rol dx, 8
movzx edx, dx
movzx edi, byte ptr [rax+0Fh]
shl edi, 10h
movzx r8d, byte ptr [rax+0Eh]
shl r8d, 18h
or r8d, edi
or r8d, edx
mov [rsi+0Ch], r8d
mov qword ptr [rsi], 0
test cl, cl
jz short loc_5462C
xor edi, edi
cmp cl, 7
setz dil
add edx, edi
jmp short loc_54633
loc_5462C:
mov dword ptr [rsi+0Ch], 0
loc_54633:
mov [rsi+10h], dx
add rax, 12h
pop rbp
retn
|
long long ma_keyseg_read(long long a1, long long a2)
{
__int16 v2; // dx
char v3; // cl
unsigned __int16 v4; // dx
*(_BYTE *)(a2 + 24) = *(_BYTE *)a1;
v2 = *(unsigned __int8 *)(a1 + 1);
*(_WORD *)(a2 + 22) = v2;
v3 = *(_BYTE *)(a1 + 2);
*(_BYTE *)(a2 + 25) = v3;
*(_BYTE *)(a2 + 26) = *(_BYTE *)(a1 + 3);
*(_WORD *)(a2 + 22) = v2 | (*(unsigned __int8 *)(a1 + 4) << 8);
*(_BYTE *)(a2 + 27) = *(_BYTE *)(a1 + 5);
*(_WORD *)(a2 + 18) = __ROL2__(*(_WORD *)(a1 + 6), 8);
*(_WORD *)(a2 + 20) = __ROL2__(*(_WORD *)(a1 + 8), 8);
*(_DWORD *)(a2 + 8) = _byteswap_ulong(*(_DWORD *)(a1 + 10));
v4 = __ROL2__(*(_WORD *)(a1 + 16), 8);
*(_DWORD *)(a2 + 12) = v4 | (*(unsigned __int8 *)(a1 + 15) << 16) | (*(unsigned __int8 *)(a1 + 14) << 24);
*(_QWORD *)a2 = 0LL;
if ( v3 )
v4 += v3 == 7;
else
*(_DWORD *)(a2 + 12) = 0;
*(_WORD *)(a2 + 16) = v4;
return a1 + 18;
}
|
_ma_keyseg_read:
PUSH RBP
MOV RBP,RSP
MOV RAX,RDI
MOV CL,byte ptr [RDI]
MOV byte ptr [RSI + 0x18],CL
MOVZX EDX,byte ptr [RDI + 0x1]
MOV word ptr [RSI + 0x16],DX
MOV CL,byte ptr [RDI + 0x2]
MOV byte ptr [RSI + 0x19],CL
MOV DIL,byte ptr [RDI + 0x3]
MOV byte ptr [RSI + 0x1a],DIL
MOVZX EDI,byte ptr [RAX + 0x4]
SHL EDI,0x8
OR EDI,EDX
MOV word ptr [RSI + 0x16],DI
MOV DL,byte ptr [RAX + 0x5]
MOV byte ptr [RSI + 0x1b],DL
MOVZX EDX,word ptr [RAX + 0x6]
ROL DX,0x8
MOV word ptr [RSI + 0x12],DX
MOVZX EDX,word ptr [RAX + 0x8]
ROL DX,0x8
MOV word ptr [RSI + 0x14],DX
MOV EDX,dword ptr [RAX + 0xa]
BSWAP EDX
MOV dword ptr [RSI + 0x8],EDX
MOVZX EDX,word ptr [RAX + 0x10]
ROL DX,0x8
MOVZX EDX,DX
MOVZX EDI,byte ptr [RAX + 0xf]
SHL EDI,0x10
MOVZX R8D,byte ptr [RAX + 0xe]
SHL R8D,0x18
OR R8D,EDI
OR R8D,EDX
MOV dword ptr [RSI + 0xc],R8D
MOV qword ptr [RSI],0x0
TEST CL,CL
JZ 0x0015462c
XOR EDI,EDI
CMP CL,0x7
SETZ DIL
ADD EDX,EDI
JMP 0x00154633
LAB_0015462c:
MOV dword ptr [RSI + 0xc],0x0
LAB_00154633:
MOV word ptr [RSI + 0x10],DX
ADD RAX,0x12
POP RBP
RET
|
int1 * _ma_keyseg_read(int1 *param_1,int8 *param_2)
{
char cVar1;
byte bVar2;
uint uVar3;
ushort uVar4;
*(int1 *)(param_2 + 3) = *param_1;
bVar2 = param_1[1];
*(ushort *)((long)param_2 + 0x16) = (ushort)bVar2;
cVar1 = param_1[2];
*(char *)((long)param_2 + 0x19) = cVar1;
*(int1 *)((long)param_2 + 0x1a) = param_1[3];
*(ushort *)((long)param_2 + 0x16) = CONCAT11(param_1[4],bVar2);
*(int1 *)((long)param_2 + 0x1b) = param_1[5];
*(ushort *)((long)param_2 + 0x12) = *(ushort *)(param_1 + 6) << 8 | *(ushort *)(param_1 + 6) >> 8;
*(ushort *)((long)param_2 + 0x14) = *(ushort *)(param_1 + 8) << 8 | *(ushort *)(param_1 + 8) >> 8;
uVar3 = *(uint *)(param_1 + 10);
*(uint *)(param_2 + 1) =
uVar3 >> 0x18 | (uVar3 & 0xff0000) >> 8 | (uVar3 & 0xff00) << 8 | uVar3 << 0x18;
uVar4 = *(ushort *)(param_1 + 0x10) << 8 | *(ushort *)(param_1 + 0x10) >> 8;
*(uint *)((long)param_2 + 0xc) =
(uint)(byte)param_1[0xe] << 0x18 | (uint)(byte)param_1[0xf] << 0x10 | (uint)uVar4;
*param_2 = 0;
if (cVar1 == '\0') {
*(int4 *)((long)param_2 + 0xc) = 0;
}
else {
uVar4 = uVar4 + (cVar1 == '\a');
}
*(ushort *)(param_2 + 2) = uVar4;
return param_1 + 0x12;
}
|
|
8,177 |
set_dynamic
|
eloqsql/mysys/array.c
|
my_bool set_dynamic(DYNAMIC_ARRAY *array, const void *element, uint idx)
{
if (idx >= array->elements)
{
if (idx >= array->max_element && allocate_dynamic(array, idx))
return TRUE;
bzero((uchar*) (array->buffer+array->elements*array->size_of_element),
(idx - array->elements)*array->size_of_element);
array->elements=idx+1;
}
memcpy(array->buffer+(idx * array->size_of_element),element,
(size_t) array->size_of_element);
return FALSE;
}
|
O3
|
c
|
set_dynamic:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movl 0x8(%rdi), %eax
cmpl %edx, %eax
ja 0x32dd2
cmpl %r14d, 0xc(%r15)
ja 0x32daf
movq %r15, %rdi
movl %r14d, %esi
callq 0x32df5
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x32dea
movl 0x8(%r15), %eax
movl 0x14(%r15), %ecx
movl %r14d, %edx
subl %eax, %edx
imull %ecx, %edx
movl %ecx, %edi
imull %eax, %edi
addq (%r15), %rdi
xorl %esi, %esi
callq 0x241e0
leal 0x1(%r14), %eax
movl %eax, 0x8(%r15)
movl 0x14(%r15), %edx
imull %edx, %r14d
addq (%r15), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x24290
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
set_dynamic:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14d, edx
mov rbx, rsi
mov r15, rdi
mov eax, [rdi+8]
cmp eax, edx
ja short loc_32DD2
cmp [r15+0Ch], r14d
ja short loc_32DAF
mov rdi, r15
mov esi, r14d
call allocate_dynamic
mov ecx, eax
mov al, 1
test cl, cl
jnz short loc_32DEA
mov eax, [r15+8]
loc_32DAF:
mov ecx, [r15+14h]
mov edx, r14d
sub edx, eax
imul edx, ecx
mov edi, ecx
imul edi, eax
add rdi, [r15]
xor esi, esi
call _memset
lea eax, [r14+1]
mov [r15+8], eax
loc_32DD2:
mov edx, [r15+14h]
imul r14d, edx
add r14, [r15]
mov rdi, r14
mov rsi, rbx
call _memcpy
xor eax, eax
loc_32DEA:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
char set_dynamic(long long a1, long long a2, unsigned int a3)
{
unsigned int v4; // eax
char dynamic; // cl
char result; // al
v4 = *(_DWORD *)(a1 + 8);
if ( v4 <= a3 )
{
if ( *(_DWORD *)(a1 + 12) <= a3 )
{
dynamic = allocate_dynamic(a1, a3);
result = 1;
if ( dynamic )
return result;
v4 = *(_DWORD *)(a1 + 8);
}
memset(*(_QWORD *)a1 + v4 * *(_DWORD *)(a1 + 20), 0LL, *(_DWORD *)(a1 + 20) * (a3 - v4));
*(_DWORD *)(a1 + 8) = a3 + 1;
}
memcpy(*(_QWORD *)a1 + *(_DWORD *)(a1 + 20) * a3, a2);
return 0;
}
|
set_dynamic:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14D,EDX
MOV RBX,RSI
MOV R15,RDI
MOV EAX,dword ptr [RDI + 0x8]
CMP EAX,EDX
JA 0x00132dd2
CMP dword ptr [R15 + 0xc],R14D
JA 0x00132daf
MOV RDI,R15
MOV ESI,R14D
CALL 0x00132df5
MOV ECX,EAX
MOV AL,0x1
TEST CL,CL
JNZ 0x00132dea
MOV EAX,dword ptr [R15 + 0x8]
LAB_00132daf:
MOV ECX,dword ptr [R15 + 0x14]
MOV EDX,R14D
SUB EDX,EAX
IMUL EDX,ECX
MOV EDI,ECX
IMUL EDI,EAX
ADD RDI,qword ptr [R15]
XOR ESI,ESI
CALL 0x001241e0
LEA EAX,[R14 + 0x1]
MOV dword ptr [R15 + 0x8],EAX
LAB_00132dd2:
MOV EDX,dword ptr [R15 + 0x14]
IMUL R14D,EDX
ADD R14,qword ptr [R15]
MOV RDI,R14
MOV RSI,RBX
CALL 0x00124290
XOR EAX,EAX
LAB_00132dea:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int8 set_dynamic(long *param_1,void *param_2,uint param_3)
{
char cVar1;
uint uVar2;
uVar2 = *(uint *)(param_1 + 1);
if (uVar2 <= param_3) {
if (*(uint *)((long)param_1 + 0xc) <= param_3) {
cVar1 = allocate_dynamic(param_1);
if (cVar1 != '\0') {
return 1;
}
uVar2 = *(uint *)(param_1 + 1);
}
memset((void *)((ulong)(*(int *)((long)param_1 + 0x14) * uVar2) + *param_1),0,
(ulong)((param_3 - uVar2) * *(int *)((long)param_1 + 0x14)));
*(uint *)(param_1 + 1) = param_3 + 1;
}
memcpy((void *)((ulong)(param_3 * *(uint *)((long)param_1 + 0x14)) + *param_1),param_2,
(ulong)*(uint *)((long)param_1 + 0x14));
return 0;
}
|
|
8,178 |
my_string_repertoire
|
eloqsql/strings/ctype.c
|
my_repertoire_t
my_string_repertoire(CHARSET_INFO *cs, const char *str, size_t length)
{
if (cs->mbminlen == 1 && !(cs->state & MY_CS_NONASCII))
{
return my_string_repertoire_8bit(cs, str, length);
}
else
{
const char *strend= str + length;
my_wc_t wc;
int chlen;
for (;
(chlen= my_ci_mb_wc(cs, &wc, (uchar*) str, (uchar*) strend)) > 0;
str+= chlen)
{
if (wc > 0x7F)
return MY_REPERTOIRE_UNICODE30;
}
}
return MY_REPERTOIRE_ASCII;
}
|
O0
|
c
|
my_string_repertoire:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x98(%rax)
jne 0xbbee8
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x2000, %eax # imm = 0x2000
cmpl $0x0, %eax
jne 0xbbee8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xbbc90
movl %eax, -0x4(%rbp)
jmp 0xbbf4b
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq *%rax
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jle 0xbbf42
cmpq $0x7f, -0x30(%rbp)
jbe 0xbbf2d
movl $0x3, -0x4(%rbp)
jmp 0xbbf4b
jmp 0xbbf2f
movl -0x34(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0xbbef4
jmp 0xbbf44
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_string_repertoire:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
cmp dword ptr [rax+98h], 1
jnz short loc_BBEE8
mov rax, [rbp+var_10]
mov eax, [rax+0Ch]
and eax, 2000h
cmp eax, 0
jnz short loc_BBEE8
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call my_string_repertoire_8bit
mov [rbp+var_4], eax
jmp short loc_BBF4B
loc_BBEE8:
mov rax, [rbp+var_18]
add rax, [rbp+var_20]
mov [rbp+var_28], rax
loc_BBEF4:
mov rax, [rbp+var_10]
mov rax, [rax+0B8h]
mov rax, [rax+28h]
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_28]
lea rsi, [rbp+var_30]
call rax
mov [rbp+var_34], eax
cmp eax, 0
jle short loc_BBF42
cmp [rbp+var_30], 7Fh
jbe short loc_BBF2D
mov [rbp+var_4], 3
jmp short loc_BBF4B
loc_BBF2D:
jmp short $+2
loc_BBF2F:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_18]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_18], rax
jmp short loc_BBEF4
loc_BBF42:
jmp short $+2
loc_BBF44:
mov [rbp+var_4], 1
loc_BBF4B:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
|
long long my_string_repertoire(long long a1, unsigned __int8 *a2, long long a3)
{
int v4; // [rsp+Ch] [rbp-34h]
unsigned long long v5; // [rsp+10h] [rbp-30h] BYREF
unsigned __int8 *v6; // [rsp+18h] [rbp-28h]
long long v7; // [rsp+20h] [rbp-20h]
unsigned __int8 *v8; // [rsp+28h] [rbp-18h]
long long v9; // [rsp+30h] [rbp-10h]
v9 = a1;
v8 = a2;
v7 = a3;
if ( *(_DWORD *)(a1 + 152) != 1 || (*(_DWORD *)(v9 + 12) & 0x2000) != 0 )
{
v6 = &v8[v7];
while ( 1 )
{
v4 = (*(long long ( **)(long long, unsigned long long *, unsigned __int8 *, unsigned __int8 *))(*(_QWORD *)(v9 + 184) + 40LL))(
v9,
&v5,
v8,
v6);
if ( v4 <= 0 )
break;
if ( v5 > 0x7F )
return 3;
v8 += v4;
}
return 1;
}
else
{
return (unsigned int)my_string_repertoire_8bit(v9, v8, v7);
}
}
|
my_string_repertoire:
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 RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x98],0x1
JNZ 0x001bbee8
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0xc]
AND EAX,0x2000
CMP EAX,0x0
JNZ 0x001bbee8
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x001bbc90
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001bbf4b
LAB_001bbee8:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x28],RAX
LAB_001bbef4:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x28]
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x28]
LEA RSI,[RBP + -0x30]
CALL RAX
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
JLE 0x001bbf42
CMP qword ptr [RBP + -0x30],0x7f
JBE 0x001bbf2d
MOV dword ptr [RBP + -0x4],0x3
JMP 0x001bbf4b
LAB_001bbf2d:
JMP 0x001bbf2f
LAB_001bbf2f:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x18]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001bbef4
LAB_001bbf42:
JMP 0x001bbf44
LAB_001bbf44:
MOV dword ptr [RBP + -0x4],0x1
LAB_001bbf4b:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
int4 my_string_repertoire(long param_1,long param_2,long param_3)
{
int iVar1;
ulong local_38;
long local_30;
long local_28;
long local_20;
long local_18;
int4 local_c;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
if ((*(int *)(param_1 + 0x98) == 1) && ((*(uint *)(param_1 + 0xc) & 0x2000) == 0)) {
local_c = my_string_repertoire_8bit(param_1,param_2,param_3);
}
else {
local_30 = param_2 + param_3;
while (iVar1 = (**(code **)(*(long *)(local_18 + 0xb8) + 0x28))
(local_18,&local_38,local_20,local_30), 0 < iVar1) {
if (0x7f < local_38) {
return 3;
}
local_20 = local_20 + iVar1;
}
local_c = 1;
}
return local_c;
}
|
|
8,179 |
ELFIO::section_impl<ELFIO::Elf64_Shdr>::~section_impl()
|
EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/include/elfio/elfio_section.hpp
|
~section_impl()
{
delete [] data;
}
|
O1
|
cpp
|
ELFIO::section_impl<ELFIO::Elf64_Shdr>::~section_impl():
pushq %rbx
movq %rdi, %rbx
leaq 0xe6dd(%rip), %rax # 0x1ba68
movq %rax, (%rdi)
movq 0x60(%rdi), %rdi
testq %rdi, %rdi
je 0xd39c
callq 0xb280
movq 0x40(%rbx), %rdi
addq $0x50, %rbx
cmpq %rbx, %rdi
je 0xd3af
popq %rbx
jmp 0xb1a0
popq %rbx
retq
nop
|
_ZN5ELFIO12section_implINS_10Elf32_ShdrEED2Ev:
push rbx
mov rbx, rdi
lea rax, off_1BA68
mov [rdi], rax
mov rdi, [rdi+60h]; void *
test rdi, rdi
jz short loc_D39C
call __ZdaPv; operator delete[](void *)
loc_D39C:
mov rdi, [rbx+40h]; void *
add rbx, 50h ; 'P'
cmp rdi, rbx
jz short loc_D3AF
pop rbx
jmp __ZdlPv; operator delete(void *)
loc_D3AF:
pop rbx
retn
|
void ELFIO::section_impl<ELFIO::Elf32_Shdr>::~section_impl(_QWORD *a1)
{
void *v2; // rdi
_QWORD *v3; // rdi
*a1 = &off_1BA68;
v2 = (void *)a1[12];
if ( v2 )
operator delete[](v2);
v3 = (_QWORD *)a1[8];
if ( v3 != a1 + 10 )
operator delete(v3);
}
|
~section_impl:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x11ba68]
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x60]
TEST RDI,RDI
JZ 0x0010d39c
CALL 0x0010b280
LAB_0010d39c:
MOV RDI,qword ptr [RBX + 0x40]
ADD RBX,0x50
CMP RDI,RBX
JZ 0x0010d3af
POP RBX
JMP 0x0010b1a0
LAB_0010d3af:
POP RBX
RET
|
/* ELFIO::section_impl<ELFIO::Elf32_Shdr>::~section_impl() */
void __thiscall
ELFIO::section_impl<ELFIO::Elf32_Shdr>::~section_impl(section_impl<ELFIO::Elf32_Shdr> *this)
{
*(int ***)this = &PTR__section_impl_0011ba68;
if (*(void **)(this + 0x60) != (void *)0x0) {
operator_delete__(*(void **)(this + 0x60));
}
if (*(section_impl<ELFIO::Elf32_Shdr> **)(this + 0x40) != this + 0x50) {
operator_delete(*(section_impl<ELFIO::Elf32_Shdr> **)(this + 0x40));
return;
}
return;
}
|
|
8,180 |
ELFIO::section_impl<ELFIO::Elf64_Shdr>::~section_impl()
|
EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/include/elfio/elfio_section.hpp
|
~section_impl()
{
delete [] data;
}
|
O3
|
cpp
|
ELFIO::section_impl<ELFIO::Elf64_Shdr>::~section_impl():
pushq %rbx
movq %rdi, %rbx
leaq 0xe721(%rip), %rax # 0x1ba68
movq %rax, (%rdi)
movq 0x60(%rdi), %rdi
testq %rdi, %rdi
je 0xd358
callq 0xb280
movq 0x40(%rbx), %rdi
addq $0x50, %rbx
cmpq %rbx, %rdi
je 0xd36b
popq %rbx
jmp 0xb1a0
popq %rbx
retq
nop
|
_ZN5ELFIO12section_implINS_10Elf32_ShdrEED2Ev:
push rbx
mov rbx, rdi
lea rax, off_1BA68
mov [rdi], rax
mov rdi, [rdi+60h]; void *
test rdi, rdi
jz short loc_D358
call __ZdaPv; operator delete[](void *)
loc_D358:
mov rdi, [rbx+40h]; void *
add rbx, 50h ; 'P'
cmp rdi, rbx
jz short loc_D36B
pop rbx
jmp __ZdlPv; operator delete(void *)
loc_D36B:
pop rbx
retn
|
void ELFIO::section_impl<ELFIO::Elf32_Shdr>::~section_impl(_QWORD *a1)
{
void *v2; // rdi
_QWORD *v3; // rdi
*a1 = &off_1BA68;
v2 = (void *)a1[12];
if ( v2 )
operator delete[](v2);
v3 = (_QWORD *)a1[8];
if ( v3 != a1 + 10 )
operator delete(v3);
}
|
~section_impl:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x11ba68]
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x60]
TEST RDI,RDI
JZ 0x0010d358
CALL 0x0010b280
LAB_0010d358:
MOV RDI,qword ptr [RBX + 0x40]
ADD RBX,0x50
CMP RDI,RBX
JZ 0x0010d36b
POP RBX
JMP 0x0010b1a0
LAB_0010d36b:
POP RBX
RET
|
/* ELFIO::section_impl<ELFIO::Elf32_Shdr>::~section_impl() */
void __thiscall
ELFIO::section_impl<ELFIO::Elf32_Shdr>::~section_impl(section_impl<ELFIO::Elf32_Shdr> *this)
{
*(int ***)this = &PTR__section_impl_0011ba68;
if (*(void **)(this + 0x60) != (void *)0x0) {
operator_delete__(*(void **)(this + 0x60));
}
if (*(section_impl<ELFIO::Elf32_Shdr> **)(this + 0x40) != this + 0x50) {
operator_delete(*(section_impl<ELFIO::Elf32_Shdr> **)(this + 0x40));
return;
}
return;
}
|
|
8,181 |
void nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::dump_integer<unsigned long, 0>(unsigned long)
|
llama.cpp/common/json.hpp
|
void dump_integer(NumberType x)
{
static constexpr std::array<std::array<char, 2>, 100> digits_to_99
{
{
{{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
{{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}},
{{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}},
{{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}},
{{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}},
{{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}},
{{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}},
{{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}},
{{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}},
{{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}},
}
};
// special case for "0"
if (x == 0)
{
o->write_character('0');
return;
}
// use a pointer to fill the buffer
auto buffer_ptr = number_buffer.begin(); // NOLINT(llvm-qualified-auto,readability-qualified-auto,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
number_unsigned_t abs_value;
unsigned int n_chars{};
if (is_negative_number(x))
{
*buffer_ptr = '-';
abs_value = remove_sign(static_cast<number_integer_t>(x));
// account one more byte for the minus sign
n_chars = 1 + count_digits(abs_value);
}
else
{
abs_value = static_cast<number_unsigned_t>(x);
n_chars = count_digits(abs_value);
}
// spare 1 byte for '\0'
JSON_ASSERT(n_chars < number_buffer.size() - 1);
// jump to the end to generate the string from backward,
// so we later avoid reversing the result
buffer_ptr += n_chars;
// Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu
// See: https://www.youtube.com/watch?v=o4-CwDo2zpg
while (abs_value >= 100)
{
const auto digits_index = static_cast<unsigned>((abs_value % 100));
abs_value /= 100;
*(--buffer_ptr) = digits_to_99[digits_index][1];
*(--buffer_ptr) = digits_to_99[digits_index][0];
}
if (abs_value >= 10)
{
const auto digits_index = static_cast<unsigned>(abs_value);
*(--buffer_ptr) = digits_to_99[digits_index][1];
*(--buffer_ptr) = digits_to_99[digits_index][0];
}
else
{
*(--buffer_ptr) = static_cast<char>('0' + abs_value);
}
o->write_characters(number_buffer.data(), n_chars);
}
|
O3
|
cpp
|
void nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::dump_integer<unsigned long, 0>(unsigned long):
pushq %rbx
testq %rsi, %rsi
je 0xefdfa
movq %rsi, %rcx
leaq 0x10(%rdi), %rsi
cmpq $0xa, %rcx
jae 0xefe0b
leaq 0x11(%rdi), %r9
movl $0x1, %r8d
jmp 0xefed6
movq (%rdi), %rdi
movq (%rdi), %rax
movq (%rax), %rax
movl $0x30, %esi
popq %rbx
jmpq *%rax
movl $0x4, %r9d
movabsq $0x346dc5d63886594b, %r10 # imm = 0x346DC5D63886594B
movq %rcx, %r8
cmpq $0x63, %r8
jbe 0xefe56
cmpq $0x3e7, %r8 # imm = 0x3E7
jbe 0xefe5c
cmpq $0x2710, %r8 # imm = 0x2710
jb 0xefe5f
movq %r8, %rax
mulq %r10
shrq $0xb, %rdx
addl $0x4, %r9d
cmpq $0x1869f, %r8 # imm = 0x1869F
movq %rdx, %r8
ja 0xefe1e
addl $-0x3, %r9d
jmp 0xefe5f
addl $-0x2, %r9d
jmp 0xefe5f
decl %r9d
cmpl $0x3f, %r9d
jae 0xefeed
movl %r9d, %r8d
leaq (%rsi,%r8), %r9
cmpq $0x64, %rcx
jb 0xefeb8
movabsq $0x28f5c28f5c28f5c3, %r10 # imm = 0x28F5C28F5C28F5C3
leaq 0x93b29(%rip), %r11 # 0x1839b0
movq %rcx, %rax
shrq $0x2, %rax
mulq %r10
shrq $0x2, %rdx
imull $0x64, %edx, %eax
movl %ecx, %ebx
subl %eax, %ebx
movzwl (%r11,%rbx,2), %eax
movw %ax, -0x2(%r9)
addq $-0x2, %r9
cmpq $0x270f, %rcx # imm = 0x270F
movq %rdx, %rcx
ja 0xefe87
jmp 0xefebb
movq %rcx, %rdx
cmpq $0xa, %rdx
jb 0xefed3
leaq 0x93ae8(%rip), %rax # 0x1839b0
movzwl (%rax,%rdx,2), %eax
movw %ax, -0x2(%r9)
jmp 0xefedd
movq %rdx, %rcx
orb $0x30, %cl
movb %cl, -0x1(%r9)
movq (%rdi), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
movq %r8, %rdx
popq %rbx
jmpq *%rax
leaq 0x92350(%rip), %rdi # 0x182244
leaq 0x82f17(%rip), %rdx # 0x172e12
leaq 0x84a0f(%rip), %rcx # 0x174911
movl $0x4952, %esi # imm = 0x4952
xorl %eax, %eax
callq 0x26090
|
_ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerImTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_:
push rbx
test rsi, rsi
jz short loc_EFDFA
mov rcx, rsi
lea rsi, [rdi+10h]
cmp rcx, 0Ah
jnb short loc_EFE0B
lea r9, [rdi+11h]
mov r8d, 1
jmp loc_EFED6
loc_EFDFA:
mov rdi, [rdi]
mov rax, [rdi]
mov rax, [rax]
mov esi, 30h ; '0'
pop rbx
jmp rax
loc_EFE0B:
mov r9d, 4
mov r10, 346DC5D63886594Bh
mov r8, rcx
loc_EFE1E:
cmp r8, 63h ; 'c'
jbe short loc_EFE56
cmp r8, 3E7h
jbe short loc_EFE5C
cmp r8, 2710h
jb short loc_EFE5F
mov rax, r8
mul r10
shr rdx, 0Bh
add r9d, 4
cmp r8, 1869Fh
mov r8, rdx
ja short loc_EFE1E
add r9d, 0FFFFFFFDh
jmp short loc_EFE5F
loc_EFE56:
add r9d, 0FFFFFFFEh
jmp short loc_EFE5F
loc_EFE5C:
dec r9d
loc_EFE5F:
cmp r9d, 3Fh ; '?'
jnb loc_EFEED
mov r8d, r9d
lea r9, [rsi+r8]
cmp rcx, 64h ; 'd'
jb short loc_EFEB8
mov r10, 28F5C28F5C28F5C3h
lea r11, _ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerImTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99
loc_EFE87:
mov rax, rcx
shr rax, 2
mul r10
shr rdx, 2
imul eax, edx, 64h ; 'd'
mov ebx, ecx
sub ebx, eax
movzx eax, word ptr [r11+rbx*2]
mov [r9-2], ax
add r9, 0FFFFFFFFFFFFFFFEh
cmp rcx, 270Fh
mov rcx, rdx
ja short loc_EFE87
jmp short loc_EFEBB
loc_EFEB8:
mov rdx, rcx
loc_EFEBB:
cmp rdx, 0Ah
jb short loc_EFED3
lea rax, _ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerImTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99
movzx eax, word ptr [rax+rdx*2]
mov [r9-2], ax
jmp short loc_EFEDD
loc_EFED3:
mov rcx, rdx
loc_EFED6:
or cl, 30h
mov [r9-1], cl
loc_EFEDD:
mov rdi, [rdi]
mov rax, [rdi]
mov rax, [rax+8]
mov rdx, r8
pop rbx
jmp rax
loc_EFEED:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aNCharsNumberBu; "n_chars < number_buffer.size() - 1"
mov esi, 4952h
xor eax, eax
call _ggml_abort
|
long long ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerImTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_(
_QWORD *a1,
unsigned long long a2)
{
unsigned long long v2; // rcx
_QWORD *v3; // rsi
char *v4; // r9
long long v5; // r8
unsigned int v7; // r9d
unsigned long long v8; // r8
bool v9; // cc
unsigned long long v10; // rdx
if ( !a2 )
return (**(long long ( ***)(_QWORD, long long))*a1)(*a1, 48LL);
v2 = a2;
v3 = a1 + 2;
if ( v2 < 0xA )
{
v4 = (char *)a1 + 17;
v5 = 1LL;
goto LABEL_21;
}
v7 = 4;
v8 = v2;
while ( 1 )
{
if ( v8 <= 0x63 )
{
v7 -= 2;
goto LABEL_13;
}
if ( v8 <= 0x3E7 )
break;
if ( v8 < 0x2710 )
goto LABEL_13;
v7 += 4;
v9 = v8 <= 0x1869F;
v8 /= 0x2710uLL;
if ( v9 )
{
v7 -= 3;
goto LABEL_13;
}
}
--v7;
LABEL_13:
if ( v7 < 0x3F )
{
v5 = v7;
v4 = (char *)v3 + v7;
if ( v2 < 0x64 )
{
v10 = v2;
}
else
{
do
{
v10 = v2 / 0x64;
*((_WORD *)v4 - 1) = ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerImTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99[v2 % 0x64];
v4 -= 2;
v9 = v2 <= 0x270F;
v2 /= 0x64uLL;
}
while ( !v9 );
}
if ( v10 >= 0xA )
{
*((_WORD *)v4 - 1) = ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerImTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99[v10];
return (*(long long ( **)(_QWORD, _QWORD *, long long, unsigned long long))(*(_QWORD *)*a1 + 8LL))(
*a1,
v3,
v5,
v2);
}
v2 = v10;
LABEL_21:
LOBYTE(v2) = v2 | 0x30;
*(v4 - 1) = v2;
return (*(long long ( **)(_QWORD, _QWORD *, long long, unsigned long long))(*(_QWORD *)*a1 + 8LL))(
*a1,
v3,
v5,
v2);
}
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
18770LL,
"GGML_ASSERT(%s) failed",
"n_chars < number_buffer.size() - 1");
return ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
18770LL);
}
|
_ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerImTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_:
PUSH RBX
TEST RSI,RSI
JZ 0x001efdfa
MOV RCX,RSI
LEA RSI,[RDI + 0x10]
CMP RCX,0xa
JNC 0x001efe0b
LEA R9,[RDI + 0x11]
MOV R8D,0x1
JMP 0x001efed6
LAB_001efdfa:
MOV RDI,qword ptr [RDI]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX]
MOV ESI,0x30
POP RBX
JMP RAX
LAB_001efe0b:
MOV R9D,0x4
MOV R10,0x346dc5d63886594b
MOV R8,RCX
LAB_001efe1e:
CMP R8,0x63
JBE 0x001efe56
CMP R8,0x3e7
JBE 0x001efe5c
CMP R8,0x2710
JC 0x001efe5f
MOV RAX,R8
MUL R10
SHR RDX,0xb
ADD R9D,0x4
CMP R8,0x1869f
MOV R8,RDX
JA 0x001efe1e
ADD R9D,-0x3
JMP 0x001efe5f
LAB_001efe56:
ADD R9D,-0x2
JMP 0x001efe5f
LAB_001efe5c:
DEC R9D
LAB_001efe5f:
CMP R9D,0x3f
JNC 0x001efeed
MOV R8D,R9D
LEA R9,[RSI + R8*0x1]
CMP RCX,0x64
JC 0x001efeb8
MOV R10,0x28f5c28f5c28f5c3
LEA R11,[0x2839b0]
LAB_001efe87:
MOV RAX,RCX
SHR RAX,0x2
MUL R10
SHR RDX,0x2
IMUL EAX,EDX,0x64
MOV EBX,ECX
SUB EBX,EAX
MOVZX EAX,word ptr [R11 + RBX*0x2]
MOV word ptr [R9 + -0x2],AX
ADD R9,-0x2
CMP RCX,0x270f
MOV RCX,RDX
JA 0x001efe87
JMP 0x001efebb
LAB_001efeb8:
MOV RDX,RCX
LAB_001efebb:
CMP RDX,0xa
JC 0x001efed3
LEA RAX,[0x2839b0]
MOVZX EAX,word ptr [RAX + RDX*0x2]
MOV word ptr [R9 + -0x2],AX
JMP 0x001efedd
LAB_001efed3:
MOV RCX,RDX
LAB_001efed6:
OR CL,0x30
MOV byte ptr [R9 + -0x1],CL
LAB_001efedd:
MOV RDI,qword ptr [RDI]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDX,R8
POP RBX
JMP RAX
LAB_001efeed:
LEA RDI,[0x282244]
LEA RDX,[0x272e12]
LEA RCX,[0x274911]
MOV ESI,0x4952
XOR EAX,EAX
CALL 0x00126090
|
void _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerImTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_
(int8 *param_1,ulong param_2)
{
bool bVar1;
ulong uVar2;
ulong uVar3;
int iVar4;
long lVar5;
if (param_2 == 0) {
/* WARNING: Could not recover jumptable at 0x001efe09. Too many branches */
/* WARNING: Treating indirect jump as call */
(*(code *)**(int8 **)*param_1)((int8 *)*param_1,0x30);
return;
}
if (param_2 < 10) {
lVar5 = (long)param_1 + 0x11;
uVar3 = 1;
}
else {
uVar3 = 4;
uVar2 = param_2;
do {
iVar4 = (int)uVar3;
if (uVar2 < 100) {
uVar3 = (ulong)(iVar4 - 2);
goto LAB_001efe5f;
}
if (uVar2 < 1000) {
uVar3 = (ulong)(iVar4 - 1);
goto LAB_001efe5f;
}
if (uVar2 < 10000) goto LAB_001efe5f;
uVar3 = (ulong)(iVar4 + 4);
bVar1 = 99999 < uVar2;
uVar2 = uVar2 / 10000;
} while (bVar1);
uVar3 = (ulong)(iVar4 + 1);
LAB_001efe5f:
if (0x3e < (uint)uVar3) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",0x4952,
"GGML_ASSERT(%s) failed","n_chars < number_buffer.size() - 1");
}
lVar5 = (long)(param_1 + 2) + uVar3;
if (99 < param_2) {
do {
uVar2 = param_2 / 100;
*(int2 *)(lVar5 + -2) =
*(int2 *)
(
_ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerImTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99
+ (ulong)(uint)((int)param_2 + (int)uVar2 * -100) * 2);
lVar5 = lVar5 + -2;
bVar1 = 9999 < param_2;
param_2 = uVar2;
} while (bVar1);
}
if (9 < param_2) {
*(int2 *)(lVar5 + -2) =
*(int2 *)
(
_ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerImTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99
+ param_2 * 2);
goto LAB_001efedd;
}
}
*(byte *)(lVar5 + -1) = (byte)param_2 | 0x30;
LAB_001efedd:
/* WARNING: Could not recover jumptable at 0x001efeeb. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(*(long *)*param_1 + 8))((long *)*param_1,param_1 + 2,uVar3);
return;
}
|
|
8,182 |
Catch::BinaryExpr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [12]>::streamReconstructedExpression(std::ostream&) const
|
11AgReS1SoR11[P]Graph/build_O3/_deps/catch2-src/src/catch2/../catch2/internal/catch_decomposer.hpp
|
void streamReconstructedExpression( std::ostream &os ) const override {
formatReconstructedExpression
( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
}
|
O3
|
cpp
|
Catch::BinaryExpr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [12]>::streamReconstructedExpression(std::ostream&) const:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r12
movq 0x10(%rdi), %rsi
leaq 0x20(%rsp), %rdi
callq 0x430b6
movq 0x18(%r12), %r14
movq 0x20(%r12), %r15
movq 0x28(%r12), %r12
movl $0x15, %r13d
movl $0x15, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x11580
movq %rax, %rdx
subq %r12, %rdx
testq %rax, %rax
cmoveq %r13, %rdx
movq %rsp, %rdi
movq %r12, %rsi
callq 0x42f69
leaq 0x20(%rsp), %rsi
movq %rsp, %r8
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x50464
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c6ee
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x114e0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c709
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x114e0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c73a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x114e0
jmp 0x3c73a
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c755
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x114e0
movq %rbx, %rdi
callq 0x11910
nop
|
_ZNK5Catch10BinaryExprIRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA21_KcE29streamReconstructedExpressionERSo:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 40h
mov rbx, rsi
mov r12, rdi
mov rsi, [rdi+10h]
lea rdi, [rsp+68h+var_48]
call _ZN5Catch11StringMakerINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEvE7convertERKS6_; Catch::StringMaker<std::string,void>::convert(std::string const&)
mov r14, [r12+18h]
mov r15, [r12+20h]
mov r12, [r12+28h]
mov r13d, 15h
mov edx, 15h
mov rdi, r12
xor esi, esi
call _memchr
mov rdx, rax
sub rdx, r12
test rax, rax
cmovz rdx, r13
mov rdi, rsp
mov rsi, r12
call _ZN5Catch6Detail17convertIntoStringB5cxx11ENS_9StringRefE; Catch::Detail::convertIntoString(Catch::StringRef)
lea rsi, [rsp+68h+var_48]
mov r8, rsp
mov rdi, rbx
mov rdx, r14
mov rcx, r15
call _ZN5Catch29formatReconstructedExpressionERSoRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_9StringRefES8_; Catch::formatReconstructedExpression(std::ostream &,std::string const&,Catch::StringRef,std::string const&)
lea rax, [rsp+68h+var_58]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_3C6EE
mov rsi, [rsp+68h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3C6EE:
lea rax, [rsp+68h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_3C709
mov rsi, [rsp+68h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3C709:
add rsp, 40h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov rbx, rax
lea rax, [rsp+arg_8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_3C73A
mov rsi, [rsp+arg_8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_3C73A
mov rbx, rax
loc_3C73A:
lea rax, [rsp+arg_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_3C755
mov rsi, [rsp+arg_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3C755:
mov rdi, rbx
call __Unwind_Resume
|
void Catch::BinaryExpr<std::string const&,char const(&)[21]>::streamReconstructedExpression(
_QWORD *a1,
long long a2)
{
long long v2; // r14
long long v3; // r15
long long v4; // r12
long long v5; // rax
long long v6; // rdx
void *v7[2]; // [rsp+0h] [rbp-68h] BYREF
long long v8; // [rsp+10h] [rbp-58h] BYREF
void *v9[2]; // [rsp+20h] [rbp-48h] BYREF
long long v10; // [rsp+30h] [rbp-38h] BYREF
Catch::StringMaker<std::string,void>::convert(v9, a1[2]);
v2 = a1[3];
v3 = a1[4];
v4 = a1[5];
v5 = memchr(v4, 0LL, 21LL);
v6 = v5 - v4;
if ( !v5 )
v6 = 21LL;
Catch::Detail::convertIntoString[abi:cxx11](v7, v4, v6);
Catch::formatReconstructedExpression(a2, v9, v2, v3, v7);
if ( v7[0] != &v8 )
operator delete(v7[0], v8 + 1);
if ( v9[0] != &v10 )
operator delete(v9[0], v10 + 1);
}
|
streamReconstructedExpression:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV RBX,RSI
MOV R12,RDI
MOV RSI,qword ptr [RDI + 0x10]
LEA RDI,[RSP + 0x20]
CALL 0x001430b6
MOV R14,qword ptr [R12 + 0x18]
MOV R15,qword ptr [R12 + 0x20]
MOV R12,qword ptr [R12 + 0x28]
MOV R13D,0x15
MOV EDX,0x15
MOV RDI,R12
XOR ESI,ESI
CALL 0x00111580
MOV RDX,RAX
SUB RDX,R12
TEST RAX,RAX
CMOVZ RDX,R13
LAB_0013c6b2:
MOV RDI,RSP
MOV RSI,R12
CALL 0x00142f69
LAB_0013c6bd:
LEA RSI,[RSP + 0x20]
MOV R8,RSP
MOV RDI,RBX
MOV RDX,R14
MOV RCX,R15
CALL 0x00150464
LAB_0013c6d3:
LEA RAX,[RSP + 0x10]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0013c6ee
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x001114e0
LAB_0013c6ee:
LEA RAX,[RSP + 0x30]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0013c709
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x001114e0
LAB_0013c709:
ADD RSP,0x40
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* Catch::BinaryExpr<std::__cxx11::string const&, char const (&)
[21]>::streamReconstructedExpression(std::ostream&) const */
void __thiscall
Catch::BinaryExpr<std::__cxx11::string_const&,char_const(&)[21]>::streamReconstructedExpression
(BinaryExpr<std::__cxx11::string_const&,char_const(&)[21]> *this,ostream *param_1)
{
int8 uVar1;
int8 uVar2;
void *__s;
void *pvVar3;
long lVar4;
long *local_68 [2];
long local_58 [2];
long *local_48 [2];
long local_38 [2];
StringMaker<std::__cxx11::string,void>::convert
((StringMaker<std::__cxx11::string,void> *)local_48,*(string **)(this + 0x10));
uVar1 = *(int8 *)(this + 0x18);
uVar2 = *(int8 *)(this + 0x20);
__s = *(void **)(this + 0x28);
pvVar3 = memchr(__s,0,0x15);
lVar4 = (long)pvVar3 - (long)__s;
if (pvVar3 == (void *)0x0) {
lVar4 = 0x15;
}
/* try { // try from 0013c6b2 to 0013c6bc has its CatchHandler @ 0013c737 */
Detail::convertIntoString_abi_cxx11_(local_68,__s,lVar4);
/* try { // try from 0013c6bd to 0013c6d2 has its CatchHandler @ 0013c717 */
formatReconstructedExpression((Catch *)param_1,local_48,uVar1,uVar2,local_68);
if (local_68[0] != local_58) {
operator_delete(local_68[0],local_58[0] + 1);
}
if (local_48[0] != local_38) {
operator_delete(local_48[0],local_38[0] + 1);
}
return;
}
|
|
8,183 |
prepare_resize_simple_key_cache
|
eloqsql/mysys/mf_keycache.c
|
static
int prepare_resize_simple_key_cache(SIMPLE_KEY_CACHE_CB *keycache,
my_bool release_lock)
{
int res= 0;
DBUG_ENTER("prepare_resize_simple_key_cache");
keycache_pthread_mutex_lock(&keycache->cache_lock);
/*
We may need to wait for another thread which is doing a resize
already. This cannot happen in the MySQL server though. It allows
one resizer only. In set_var.cc keycache->in_init is used to block
multiple attempts.
*/
while (keycache->in_resize)
{
/* purecov: begin inspected */
wait_on_queue(&keycache->resize_queue, &keycache->cache_lock);
/* purecov: end */
}
/*
Mark the operation in progress. This blocks other threads from doing
a resize in parallel. It prohibits new blocks to enter the cache.
Read/write requests can bypass the cache during the flush phase.
*/
keycache->in_resize= 1;
/* Need to flush only if keycache is enabled. */
if (keycache->can_be_used && keycache->disk_blocks != -1)
{
/* Start the flush phase. */
keycache->resize_in_flush= 1;
if (flush_all_key_blocks(keycache))
{
/* TODO: if this happens, we should write a warning in the log file ! */
keycache->resize_in_flush= 0;
keycache->can_be_used= 0;
res= 1;
goto finish;
}
DBUG_SLOW_ASSERT(cache_empty(keycache));
/* End the flush phase. */
keycache->resize_in_flush= 0;
}
/*
Some direct read/write operations (bypassing the cache) may still be
unfinished. Wait until they are done. If the key cache can be used,
direct I/O is done in increments of key_cache_block_size. That is,
every block is checked if it is in the cache. We need to wait for
pending I/O before re-initializing the cache, because we may change
the block size. Otherwise they could check for blocks at file
positions where the new block division has none. We do also want to
wait for I/O done when (if) the cache was disabled. It must not
run in parallel with normal cache operation.
*/
while (keycache->cnt_for_resize_op)
wait_on_queue(&keycache->waiting_for_resize_cnt, &keycache->cache_lock);
end_simple_key_cache(keycache, 0);
finish:
if (release_lock)
keycache_pthread_mutex_unlock(&keycache->cache_lock);
DBUG_RETURN(res);
}
|
O3
|
c
|
prepare_resize_simple_key_cache:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r15d
movq %rdi, %r14
leaq 0xc0(%rdi), %rbx
cmpq $0x0, 0x100(%rdi)
jne 0x99c33
movq %rbx, %rdi
callq 0x29200
cmpb $0x0, 0x1(%r14)
je 0x99ace
leaq 0x108(%r14), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x97500
cmpb $0x0, 0x1(%r14)
jne 0x99abc
movb $0x1, 0x1(%r14)
cmpb $0x0, 0x3(%r14)
je 0x99bc8
cmpl $-0x1, 0x48(%r14)
je 0x99bc8
movl %r15d, -0x2c(%rbp)
movb $0x1, 0x2(%r14)
movl 0x3c(%r14), %ecx
movq %rcx, -0x38(%rbp)
testq %rcx, %rcx
je 0x99b4f
xorl %r13d, %r13d
xorl %r15d, %r15d
movq 0x128(%r14), %rax
movq (%rax,%r13,8), %rax
testq %rax, %rax
je 0x99b35
incl %r15d
movq 0x20(%rax), %rax
movl 0x18(%rax), %esi
movq %r14, %rdi
movl $0x3, %edx
callq 0x99caa
testl %eax, %eax
je 0x99b05
jmp 0x99bf7
incq %r13
movq -0x38(%rbp), %rcx
cmpq %rcx, %r13
jne 0x99b05
xorl %r13d, %r13d
testl %r15d, %r15d
movl $0x0, %r15d
jne 0x99b05
xorl %eax, %eax
testq %rcx, %rcx
je 0x99bbf
xorl %r13d, %r13d
xorl %ecx, %ecx
movl %eax, -0x3c(%rbp)
movl %ecx, %r12d
xorl %r15d, %r15d
movq 0x130(%r14), %rax
movq (%rax,%r13,8), %rax
testq %rax, %rax
je 0x99b91
movq 0x20(%rax), %rax
movl 0x18(%rax), %esi
movq %r14, %rdi
movl $0x1, %edx
callq 0x99caa
decl %r15d
testl %eax, %eax
je 0x99b64
jmp 0x99bf7
incq %r13
movl -0x3c(%rbp), %edx
movl %edx, %eax
subl %r15d, %eax
movl %r12d, %ecx
subl %r15d, %ecx
cmpq -0x38(%rbp), %r13
jne 0x99b5b
movl %edx, %eax
subl %r15d, %eax
cmpl %r15d, %r12d
movq -0x38(%rbp), %rcx
jne 0x99b51
cmpl %r15d, %edx
jne 0x99afa
movb $0x0, 0x2(%r14)
movl -0x2c(%rbp), %r15d
cmpq $0x0, 0x70(%r14)
je 0x99be8
leaq 0x110(%r14), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x97500
cmpq $0x0, 0x70(%r14)
jne 0x99bd6
xorl %r12d, %r12d
movq %r14, %rdi
xorl %esi, %esi
callq 0x99966
jmp 0x99c08
movw $0x0, 0x2(%r14)
movl $0x1, %r12d
movl -0x2c(%rbp), %r15d
testb %r15b, %r15b
je 0x99c21
movq 0x100(%r14), %rdi
testq %rdi, %rdi
jne 0x99c4c
movq %rbx, %rdi
callq 0x291c0
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4255e(%rip), %rsi # 0xdc198
movq %rbx, %rdi
movl $0x2a9, %edx # imm = 0x2A9
callq 0x2eb6f
jmp 0x99aae
leaq 0x2ec3bd(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x99c19
|
prepare_resize_simple_key_cache:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r15d, esi
mov r14, rdi
lea rbx, [rdi+0C0h]
cmp qword ptr [rdi+100h], 0
jnz loc_99C33
mov rdi, rbx
call _pthread_mutex_lock
loc_99AAE:
cmp byte ptr [r14+1], 0
jz short loc_99ACE
lea r12, [r14+108h]
loc_99ABC:
mov rdi, r12
mov rsi, rbx
call wait_on_queue
cmp byte ptr [r14+1], 0
jnz short loc_99ABC
loc_99ACE:
mov byte ptr [r14+1], 1
cmp byte ptr [r14+3], 0
jz loc_99BC8
cmp dword ptr [r14+48h], 0FFFFFFFFh
jz loc_99BC8
mov [rbp+var_2C], r15d
mov byte ptr [r14+2], 1
mov ecx, [r14+3Ch]
mov [rbp+var_38], rcx
loc_99AFA:
test rcx, rcx
jz short loc_99B4F
xor r13d, r13d
xor r15d, r15d
loc_99B05:
mov rax, [r14+128h]
mov rax, [rax+r13*8]
test rax, rax
jz short loc_99B35
inc r15d
mov rax, [rax+20h]
mov esi, [rax+18h]
mov rdi, r14
mov edx, 3
call flush_key_blocks_int
test eax, eax
jz short loc_99B05
jmp loc_99BF7
loc_99B35:
inc r13
mov rcx, [rbp+var_38]
cmp r13, rcx
jnz short loc_99B05
xor r13d, r13d
test r15d, r15d
mov r15d, 0
jnz short loc_99B05
loc_99B4F:
xor eax, eax
loc_99B51:
test rcx, rcx
jz short loc_99BBF
xor r13d, r13d
xor ecx, ecx
loc_99B5B:
mov [rbp+var_3C], eax
mov r12d, ecx
xor r15d, r15d
loc_99B64:
mov rax, [r14+130h]
mov rax, [rax+r13*8]
test rax, rax
jz short loc_99B91
mov rax, [rax+20h]
mov esi, [rax+18h]
mov rdi, r14
mov edx, 1
call flush_key_blocks_int
dec r15d
test eax, eax
jz short loc_99B64
jmp short loc_99BF7
loc_99B91:
inc r13
mov edx, [rbp+var_3C]
mov eax, edx
sub eax, r15d
mov ecx, r12d
sub ecx, r15d
cmp r13, [rbp+var_38]
jnz short loc_99B5B
mov eax, edx
sub eax, r15d
cmp r12d, r15d
mov rcx, [rbp+var_38]
jnz short loc_99B51
cmp edx, r15d
jnz loc_99AFA
loc_99BBF:
mov byte ptr [r14+2], 0
mov r15d, [rbp+var_2C]
loc_99BC8:
cmp qword ptr [r14+70h], 0
jz short loc_99BE8
lea r12, [r14+110h]
loc_99BD6:
mov rdi, r12
mov rsi, rbx
call wait_on_queue
cmp qword ptr [r14+70h], 0
jnz short loc_99BD6
loc_99BE8:
xor r12d, r12d
mov rdi, r14
xor esi, esi
call end_simple_key_cache
jmp short loc_99C08
loc_99BF7:
mov word ptr [r14+2], 0
mov r12d, 1
mov r15d, [rbp+var_2C]
loc_99C08:
test r15b, r15b
jz short loc_99C21
mov rdi, [r14+100h]
test rdi, rdi
jnz short loc_99C4C
loc_99C19:
mov rdi, rbx
call _pthread_mutex_unlock
loc_99C21:
mov eax, r12d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_99C33:
lea rsi, aWorkspaceLlm4b_39; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, rbx
mov edx, 2A9h
call psi_mutex_lock
jmp loc_99AAE
loc_99C4C:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_99C19
|
long long prepare_resize_simple_key_cache(long long a1, char a2)
{
char v2; // r15
long long v3; // rbx
long long v4; // rcx
long long v5; // r13
int v6; // r15d
long long v7; // rax
bool v8; // zf
int v9; // eax
long long v10; // r13
int v11; // ecx
int v12; // r12d
int v13; // r15d
long long v14; // rax
unsigned int v15; // r12d
int v17; // [rsp+4h] [rbp-3Ch]
long long v18; // [rsp+8h] [rbp-38h]
v2 = a2;
v3 = a1 + 192;
if ( *(_QWORD *)(a1 + 256) )
psi_mutex_lock(a1 + 192, (long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c", 0x2A9u);
else
pthread_mutex_lock(a1 + 192);
while ( *(_BYTE *)(a1 + 1) )
wait_on_queue((long long *)(a1 + 264), v3);
*(_BYTE *)(a1 + 1) = 1;
if ( !*(_BYTE *)(a1 + 3) || *(_DWORD *)(a1 + 72) == -1 )
{
LABEL_26:
while ( *(_QWORD *)(a1 + 112) )
wait_on_queue((long long *)(a1 + 272), v3);
v15 = 0;
end_simple_key_cache(a1, 0);
goto LABEL_30;
}
*(_BYTE *)(a1 + 2) = 1;
v4 = *(unsigned int *)(a1 + 60);
v18 = v4;
LABEL_8:
if ( !v4 )
{
LABEL_15:
v9 = 0;
while ( v4 )
{
v10 = 0LL;
v11 = 0;
do
{
v17 = v9;
v12 = v11;
v13 = 0;
while ( 1 )
{
v14 = *(_QWORD *)(*(_QWORD *)(a1 + 304) + 8 * v10);
if ( !v14 )
break;
--v13;
if ( (unsigned int)flush_key_blocks_int(a1, *(unsigned int *)(*(_QWORD *)(v14 + 32) + 24LL), 1LL) )
goto LABEL_29;
}
++v10;
v9 = v17 - v13;
v11 = v12 - v13;
}
while ( v10 != v18 );
v9 = v17 - v13;
v4 = v18;
if ( v12 == v13 )
{
if ( v17 != v13 )
goto LABEL_8;
break;
}
}
*(_BYTE *)(a1 + 2) = 0;
v2 = a2;
goto LABEL_26;
}
v5 = 0LL;
v6 = 0;
do
{
while ( 1 )
{
v7 = *(_QWORD *)(*(_QWORD *)(a1 + 296) + 8 * v5);
if ( v7 )
break;
++v5;
v4 = v18;
if ( v5 == v18 )
{
v5 = 0LL;
v8 = v6 == 0;
v6 = 0;
if ( v8 )
goto LABEL_15;
}
}
++v6;
}
while ( !(unsigned int)flush_key_blocks_int(a1, *(unsigned int *)(*(_QWORD *)(v7 + 32) + 24LL), 3LL) );
LABEL_29:
*(_WORD *)(a1 + 2) = 0;
v15 = 1;
v2 = a2;
LABEL_30:
if ( v2 )
{
if ( *(_QWORD *)(a1 + 256) )
PSI_server[44]();
pthread_mutex_unlock(v3);
}
return v15;
}
|
prepare_resize_simple_key_cache:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R15D,ESI
MOV R14,RDI
LEA RBX,[RDI + 0xc0]
CMP qword ptr [RDI + 0x100],0x0
JNZ 0x00199c33
MOV RDI,RBX
CALL 0x00129200
LAB_00199aae:
CMP byte ptr [R14 + 0x1],0x0
JZ 0x00199ace
LEA R12,[R14 + 0x108]
LAB_00199abc:
MOV RDI,R12
MOV RSI,RBX
CALL 0x00197500
CMP byte ptr [R14 + 0x1],0x0
JNZ 0x00199abc
LAB_00199ace:
MOV byte ptr [R14 + 0x1],0x1
CMP byte ptr [R14 + 0x3],0x0
JZ 0x00199bc8
CMP dword ptr [R14 + 0x48],-0x1
JZ 0x00199bc8
MOV dword ptr [RBP + -0x2c],R15D
MOV byte ptr [R14 + 0x2],0x1
MOV ECX,dword ptr [R14 + 0x3c]
MOV qword ptr [RBP + -0x38],RCX
LAB_00199afa:
TEST RCX,RCX
JZ 0x00199b4f
XOR R13D,R13D
XOR R15D,R15D
LAB_00199b05:
MOV RAX,qword ptr [R14 + 0x128]
MOV RAX,qword ptr [RAX + R13*0x8]
TEST RAX,RAX
JZ 0x00199b35
INC R15D
MOV RAX,qword ptr [RAX + 0x20]
MOV ESI,dword ptr [RAX + 0x18]
MOV RDI,R14
MOV EDX,0x3
CALL 0x00199caa
TEST EAX,EAX
JZ 0x00199b05
JMP 0x00199bf7
LAB_00199b35:
INC R13
MOV RCX,qword ptr [RBP + -0x38]
CMP R13,RCX
JNZ 0x00199b05
XOR R13D,R13D
TEST R15D,R15D
MOV R15D,0x0
JNZ 0x00199b05
LAB_00199b4f:
XOR EAX,EAX
LAB_00199b51:
TEST RCX,RCX
JZ 0x00199bbf
XOR R13D,R13D
XOR ECX,ECX
LAB_00199b5b:
MOV dword ptr [RBP + -0x3c],EAX
MOV R12D,ECX
XOR R15D,R15D
LAB_00199b64:
MOV RAX,qword ptr [R14 + 0x130]
MOV RAX,qword ptr [RAX + R13*0x8]
TEST RAX,RAX
JZ 0x00199b91
MOV RAX,qword ptr [RAX + 0x20]
MOV ESI,dword ptr [RAX + 0x18]
MOV RDI,R14
MOV EDX,0x1
CALL 0x00199caa
DEC R15D
TEST EAX,EAX
JZ 0x00199b64
JMP 0x00199bf7
LAB_00199b91:
INC R13
MOV EDX,dword ptr [RBP + -0x3c]
MOV EAX,EDX
SUB EAX,R15D
MOV ECX,R12D
SUB ECX,R15D
CMP R13,qword ptr [RBP + -0x38]
JNZ 0x00199b5b
MOV EAX,EDX
SUB EAX,R15D
CMP R12D,R15D
MOV RCX,qword ptr [RBP + -0x38]
JNZ 0x00199b51
CMP EDX,R15D
JNZ 0x00199afa
LAB_00199bbf:
MOV byte ptr [R14 + 0x2],0x0
MOV R15D,dword ptr [RBP + -0x2c]
LAB_00199bc8:
CMP qword ptr [R14 + 0x70],0x0
JZ 0x00199be8
LEA R12,[R14 + 0x110]
LAB_00199bd6:
MOV RDI,R12
MOV RSI,RBX
CALL 0x00197500
CMP qword ptr [R14 + 0x70],0x0
JNZ 0x00199bd6
LAB_00199be8:
XOR R12D,R12D
MOV RDI,R14
XOR ESI,ESI
CALL 0x00199966
JMP 0x00199c08
LAB_00199bf7:
MOV word ptr [R14 + 0x2],0x0
MOV R12D,0x1
MOV R15D,dword ptr [RBP + -0x2c]
LAB_00199c08:
TEST R15B,R15B
JZ 0x00199c21
MOV RDI,qword ptr [R14 + 0x100]
TEST RDI,RDI
JNZ 0x00199c4c
LAB_00199c19:
MOV RDI,RBX
CALL 0x001291c0
LAB_00199c21:
MOV EAX,R12D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00199c33:
LEA RSI,[0x1dc198]
MOV RDI,RBX
MOV EDX,0x2a9
CALL 0x0012eb6f
JMP 0x00199aae
LAB_00199c4c:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00199c19
|
int8 prepare_resize_simple_key_cache(long param_1,char param_2)
{
pthread_mutex_t *__mutex;
long lVar1;
int iVar2;
int iVar3;
int iVar4;
ulong uVar5;
int8 uVar6;
ulong uVar7;
int iVar8;
int iVar9;
bool bVar10;
__mutex = (pthread_mutex_t *)(param_1 + 0xc0);
if (*(long *)(param_1 + 0x100) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c",0x2a9);
}
if (*(char *)(param_1 + 1) != '\0') {
do {
wait_on_queue(param_1 + 0x108,__mutex);
} while (*(char *)(param_1 + 1) != '\0');
}
*(int1 *)(param_1 + 1) = 1;
if ((*(char *)(param_1 + 3) != '\0') && (*(int *)(param_1 + 0x48) != -1)) {
*(int1 *)(param_1 + 2) = 1;
uVar5 = (ulong)*(uint *)(param_1 + 0x3c);
do {
if (uVar5 != 0) {
uVar7 = 0;
iVar8 = 0;
do {
do {
while (lVar1 = *(long *)(*(long *)(param_1 + 0x128) + uVar7 * 8), lVar1 != 0) {
iVar8 = iVar8 + 1;
iVar2 = flush_key_blocks_int
(param_1,*(int4 *)(*(long *)(lVar1 + 0x20) + 0x18),3);
if (iVar2 != 0) goto LAB_00199bf7;
}
uVar7 = uVar7 + 1;
} while (uVar7 != uVar5);
uVar7 = 0;
bVar10 = iVar8 != 0;
iVar8 = 0;
} while (bVar10);
}
iVar8 = 0;
do {
if (uVar5 == 0) goto LAB_00199bbf;
uVar7 = 0;
iVar2 = 0;
do {
iVar3 = iVar8;
iVar4 = iVar2;
iVar9 = 0;
while (lVar1 = *(long *)(*(long *)(param_1 + 0x130) + uVar7 * 8), lVar1 != 0) {
iVar8 = flush_key_blocks_int(param_1,*(int4 *)(*(long *)(lVar1 + 0x20) + 0x18),1);
iVar9 = iVar9 + -1;
if (iVar8 != 0) goto LAB_00199bf7;
}
uVar7 = uVar7 + 1;
iVar2 = iVar4 - iVar9;
iVar8 = iVar3 - iVar9;
} while (uVar7 != uVar5);
iVar8 = iVar3 - iVar9;
} while (iVar4 != iVar9);
} while (iVar3 != iVar9);
LAB_00199bbf:
*(int1 *)(param_1 + 2) = 0;
}
if (*(long *)(param_1 + 0x70) != 0) {
do {
wait_on_queue(param_1 + 0x110,__mutex);
} while (*(long *)(param_1 + 0x70) != 0);
}
uVar6 = 0;
end_simple_key_cache(param_1,0);
LAB_00199c08:
if (param_2 != '\0') {
if (*(long *)(param_1 + 0x100) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
}
return uVar6;
LAB_00199bf7:
*(int2 *)(param_1 + 2) = 0;
uVar6 = 1;
goto LAB_00199c08;
}
|
|
8,184 |
Load_log_processor::prepare_new_file_for_old_format(Load_log_event*, char*)
|
eloqsql/client/mysqlbinlog.cc
|
File Load_log_processor::prepare_new_file_for_old_format(Load_log_event *le,
char *filename)
{
size_t len;
char *tail;
File file;
fn_format(filename, le->fname, target_dir_name, "", MY_REPLACE_DIR);
len= strlen(filename);
tail= filename + len;
if ((file= create_unique_file(filename,tail)) < 0)
{
error("Could not construct local filename %s.",filename);
return -1;
}
le->set_fname_outside_temp_buf(filename,len+strlen(tail));
return file;
}
|
O3
|
cpp
|
Load_log_processor::prepare_new_file_for_old_format(Load_log_event*, char*):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0xd8(%rsi), %rsi
leaq 0x84b2d(%rip), %rcx # 0xc2f9e
movq %rdx, %rdi
movq %r15, %rdx
movl $0x1, %r8d
callq 0x7ae4c
movq %rbx, %rdi
callq 0x3a4c0
movq %rax, %r12
leaq (%rbx,%rax), %r13
movq %r15, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x567d6
testl %eax, %eax
js 0x3e4c9
movl %eax, %r15d
movq %r13, %rdi
callq 0x3a4c0
addl %r12d, %eax
movq %rbx, 0xd8(%r14)
movl %eax, 0xa8(%r14)
movb $0x1, 0x120(%r14)
jmp 0x3e4e0
leaq 0x7aae4(%rip), %rdi # 0xb8fb4
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3d713
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ZN18Load_log_processor31prepare_new_file_for_old_formatEP14Load_log_eventPc:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov rsi, [rsi+0D8h]
lea rcx, asc_C2F9A+4; ""
mov rdi, rdx
mov rdx, r15
mov r8d, 1
call fn_format
mov rdi, rbx
call _strlen
mov r12, rax
lea r13, [rbx+rax]
mov rdi, r15; this
mov rsi, rbx; char *
mov rdx, r13; char *
call _ZN18Load_log_processor18create_unique_fileEPcS0_; Load_log_processor::create_unique_file(char *,char *)
test eax, eax
js short loc_3E4C9
mov r15d, eax
mov rdi, r13
call _strlen
add eax, r12d
mov [r14+0D8h], rbx
mov [r14+0A8h], eax
mov byte ptr [r14+120h], 1
jmp short loc_3E4E0
loc_3E4C9:
lea rdi, aCouldNotConstr; "Could not construct local filename %s."
mov rsi, rbx
xor eax, eax
call _ZL5errorPKcz; error(char const*,...)
mov r15d, 0FFFFFFFFh
loc_3E4E0:
mov eax, r15d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long Load_log_processor::prepare_new_file_for_old_format(
Load_log_processor *this,
Load_log_event *a2,
char *a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
char v11; // al
long long v13; // rax
int v14; // r12d
char *v15; // r13
int unique_file; // eax
long long v17; // rdx
long long v18; // rcx
long long v19; // r8
long long v20; // r9
__m128 v21; // xmm4
__m128 v22; // xmm5
unsigned int v23; // r15d
int v24; // eax
char v26; // [rsp-8h] [rbp-30h]
v26 = v11;
fn_format(a3, *((_QWORD *)a2 + 27), this, "", 1LL);
v13 = strlen(a3);
v14 = v13;
v15 = &a3[v13];
unique_file = Load_log_processor::create_unique_file(this, a3, &a3[v13]);
if ( unique_file < 0 )
{
error(
"Could not construct local filename %s.",
(long long)a3,
v17,
v18,
v19,
v20,
a4,
a5,
a6,
a7,
v21,
v22,
a10,
a11,
v26);
return (unsigned int)-1;
}
else
{
v23 = unique_file;
v24 = strlen(v15);
*((_QWORD *)a2 + 27) = a3;
*((_DWORD *)a2 + 42) = v14 + v24;
*((_BYTE *)a2 + 288) = 1;
}
return v23;
}
|
prepare_new_file_for_old_format:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV RSI,qword ptr [RSI + 0xd8]
LEA RCX,[0x1c2f9e]
MOV RDI,RDX
MOV RDX,R15
MOV R8D,0x1
CALL 0x0017ae4c
MOV RDI,RBX
CALL 0x0013a4c0
MOV R12,RAX
LEA R13,[RBX + RAX*0x1]
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R13
CALL 0x001567d6
TEST EAX,EAX
JS 0x0013e4c9
MOV R15D,EAX
MOV RDI,R13
CALL 0x0013a4c0
ADD EAX,R12D
MOV qword ptr [R14 + 0xd8],RBX
MOV dword ptr [R14 + 0xa8],EAX
MOV byte ptr [R14 + 0x120],0x1
JMP 0x0013e4e0
LAB_0013e4c9:
LEA RDI,[0x1b8fb4]
MOV RSI,RBX
XOR EAX,EAX
CALL 0x0013d713
MOV R15D,0xffffffff
LAB_0013e4e0:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* Load_log_processor::prepare_new_file_for_old_format(Load_log_event*, char*) */
int __thiscall
Load_log_processor::prepare_new_file_for_old_format
(Load_log_processor *this,Load_log_event *param_1,char *param_2)
{
int iVar1;
size_t sVar2;
size_t sVar3;
fn_format(param_2,*(int8 *)(param_1 + 0xd8),this,&DAT_001c2f9e,1);
sVar2 = strlen(param_2);
iVar1 = create_unique_file(this,param_2,param_2 + sVar2);
if (iVar1 < 0) {
error("Could not construct local filename %s.",param_2);
iVar1 = -1;
}
else {
sVar3 = strlen(param_2 + sVar2);
*(char **)(param_1 + 0xd8) = param_2;
*(int *)(param_1 + 0xa8) = (int)sVar3 + (int)sVar2;
param_1[0x120] = (Load_log_event)0x1;
}
return iVar1;
}
|
|
8,185 |
findopt
|
eloqsql/mysys/my_getopt.c
|
static int findopt(char *optpat, uint length,
const struct my_option **opt_res,
const char **ffname)
{
uint count;
const struct my_option *opt= *opt_res;
DBUG_ENTER("findopt");
for (count= 0; opt->name; opt++)
{
if (!getopt_compare_strings(opt->name, optpat, length)) /* match found */
{
(*opt_res)= opt;
if (!opt->name[length]) /* Exact match */
DBUG_RETURN(1);
if (!my_getopt_prefix_matching)
continue;
if (!count)
{
/* We only need to know one prev */
count= 1;
*ffname= opt->name;
}
else if (strcmp(*ffname, opt->name))
{
/*
The above test is to not count same option twice
(see mysql.cc, option "help")
*/
count++;
}
}
}
if (count == 1)
my_getopt_error_reporter(INFORMATION_LEVEL,
"Using unique option prefix '%.*s' is error-prone "
"and can break in the future. "
"Please use the full name '%s' instead.",
length, optpat, *ffname);
DBUG_RETURN(count);
}
|
O3
|
c
|
findopt:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, -0x38(%rbp)
movq (%rdx), %r15
movq (%r15), %rax
testq %rax, %rax
je 0xbc793
movq %rdx, %r12
movl %esi, %r10d
movq %rdi, %rbx
movl %esi, %r13d
leaq 0x2f1abe(%rip), %rcx # 0x3ae189
movb (%rcx), %r9b
xorl %edi, %edi
movl $0x5f, %r14d
movl %esi, -0x3c(%rbp)
movb %r9b, -0x29(%rbp)
testl %r10d, %r10d
je 0xbc70a
xorl %ecx, %ecx
movzbl (%rax,%rcx), %r8d
cmpb $0x2d, %r8b
cmovel %r14d, %r8d
movzbl (%rbx,%rcx), %esi
cmpb $0x2d, %sil
cmovel %r14d, %esi
cmpb %sil, %r8b
jne 0xbc751
incq %rcx
cmpq %rcx, %r13
jne 0xbc6e4
movq %r15, (%r12)
movq (%r15), %rsi
cmpb $0x0, (%rsi,%r13)
je 0xbc78c
testb %r9b, %r9b
je 0xbc751
testl %edi, %edi
je 0xbc745
movq -0x38(%rbp), %rax
movq %rdi, -0x48(%rbp)
movq (%rax), %rdi
callq 0x2a750
movb -0x29(%rbp), %r9b
movq -0x48(%rbp), %rdi
movl -0x3c(%rbp), %r10d
cmpl $0x1, %eax
sbbl $-0x1, %edi
jmp 0xbc751
movq -0x38(%rbp), %rax
movq %rsi, (%rax)
movl $0x1, %edi
movq 0x70(%r15), %rax
addq $0x70, %r15
testq %rax, %rax
jne 0xbc6dd
cmpl $0x1, %edi
jne 0xbc795
leaq 0x2f19fa(%rip), %r9 # 0x3ae168
movq -0x38(%rbp), %rax
movq (%rax), %r8
leaq 0x43c6a(%rip), %rsi # 0x1003e6
movl $0x2, %edi
movl %r10d, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq *(%r9)
movl $0x1, %edi
jmp 0xbc795
xorl %edi, %edi
movl %edi, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
findopt:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov [rbp+var_38], rcx
mov r15, [rdx]
mov rax, [r15]
test rax, rax
jz loc_BC793
mov r12, rdx
mov r10d, esi
mov rbx, rdi
mov r13d, esi
lea rcx, my_getopt_prefix_matching
mov r9b, [rcx]
xor edi, edi
mov r14d, 5Fh ; '_'
mov [rbp+var_3C], esi
mov [rbp+var_29], r9b
loc_BC6DD:
test r10d, r10d
jz short loc_BC70A
xor ecx, ecx
loc_BC6E4:
movzx r8d, byte ptr [rax+rcx]
cmp r8b, 2Dh ; '-'
cmovz r8d, r14d
movzx esi, byte ptr [rbx+rcx]
cmp sil, 2Dh ; '-'
cmovz esi, r14d
cmp r8b, sil
jnz short loc_BC751
inc rcx
cmp r13, rcx
jnz short loc_BC6E4
loc_BC70A:
mov [r12], r15
mov rsi, [r15]
cmp byte ptr [rsi+r13], 0
jz short loc_BC78C
test r9b, r9b
jz short loc_BC751
test edi, edi
jz short loc_BC745
mov rax, [rbp+var_38]
mov [rbp+var_48], rdi
mov rdi, [rax]
call _strcmp
mov r9b, [rbp+var_29]
mov rdi, [rbp+var_48]
mov r10d, [rbp+var_3C]
cmp eax, 1
sbb edi, 0FFFFFFFFh
jmp short loc_BC751
loc_BC745:
mov rax, [rbp+var_38]
mov [rax], rsi
mov edi, 1
loc_BC751:
mov rax, [r15+70h]
add r15, 70h ; 'p'
test rax, rax
jnz loc_BC6DD
cmp edi, 1
jnz short loc_BC795
lea r9, my_getopt_error_reporter
mov rax, [rbp+var_38]
mov r8, [rax]
lea rsi, aUsingUniqueOpt; "Using unique option prefix '%.*s' is er"...
mov edi, 2
mov edx, r10d
mov rcx, rbx
xor eax, eax
call qword ptr [r9]
loc_BC78C:
mov edi, 1
jmp short loc_BC795
loc_BC793:
xor edi, edi
loc_BC795:
mov eax, edi
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long findopt(const char *a1, unsigned int a2, long long **a3, const char **a4)
{
long long *v4; // r15
long long v5; // rax
int v7; // r10d
long long v9; // r13
char v10; // r9
unsigned int v11; // edi
long long v12; // rcx
char v13; // r8
char v14; // si
const char *v15; // rsi
int v16; // eax
char v20; // [rsp+27h] [rbp-29h]
v4 = *a3;
v5 = **a3;
if ( v5 )
{
v7 = a2;
v9 = a2;
v10 = my_getopt_prefix_matching;
v11 = 0;
v20 = my_getopt_prefix_matching;
do
{
if ( v7 )
{
v12 = 0LL;
while ( 1 )
{
v13 = *(_BYTE *)(v5 + v12);
if ( v13 == 45 )
v13 = 95;
v14 = a1[v12];
if ( v14 == 45 )
v14 = 95;
if ( v13 != v14 )
break;
if ( v9 == ++v12 )
goto LABEL_11;
}
}
else
{
LABEL_11:
*a3 = v4;
v15 = (const char *)*v4;
if ( !*(_BYTE *)(*v4 + v9) )
return 1;
if ( v10 )
{
if ( v11 )
{
v16 = strcmp(*a4, v15);
v10 = v20;
v7 = a2;
v11 -= (v16 == 0) - 1;
}
else
{
*a4 = v15;
v11 = 1;
}
}
}
v5 = v4[14];
v4 += 14;
}
while ( v5 );
if ( v11 != 1 )
return v11;
my_getopt_error_reporter(
2,
"Using unique option prefix '%.*s' is error-prone and can break in the future. Please use the full name '%s' instead.",
v7,
a1,
*a4);
return 1;
}
else
{
return 0;
}
}
|
findopt:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x38],RCX
MOV R15,qword ptr [RDX]
MOV RAX,qword ptr [R15]
TEST RAX,RAX
JZ 0x001bc793
MOV R12,RDX
MOV R10D,ESI
MOV RBX,RDI
MOV R13D,ESI
LEA RCX,[0x4ae189]
MOV R9B,byte ptr [RCX]
XOR EDI,EDI
MOV R14D,0x5f
MOV dword ptr [RBP + -0x3c],ESI
MOV byte ptr [RBP + -0x29],R9B
LAB_001bc6dd:
TEST R10D,R10D
JZ 0x001bc70a
XOR ECX,ECX
LAB_001bc6e4:
MOVZX R8D,byte ptr [RAX + RCX*0x1]
CMP R8B,0x2d
CMOVZ R8D,R14D
MOVZX ESI,byte ptr [RBX + RCX*0x1]
CMP SIL,0x2d
CMOVZ ESI,R14D
CMP R8B,SIL
JNZ 0x001bc751
INC RCX
CMP R13,RCX
JNZ 0x001bc6e4
LAB_001bc70a:
MOV qword ptr [R12],R15
MOV RSI,qword ptr [R15]
CMP byte ptr [RSI + R13*0x1],0x0
JZ 0x001bc78c
TEST R9B,R9B
JZ 0x001bc751
TEST EDI,EDI
JZ 0x001bc745
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x48],RDI
MOV RDI,qword ptr [RAX]
CALL 0x0012a750
MOV R9B,byte ptr [RBP + -0x29]
MOV RDI,qword ptr [RBP + -0x48]
MOV R10D,dword ptr [RBP + -0x3c]
CMP EAX,0x1
SBB EDI,-0x1
JMP 0x001bc751
LAB_001bc745:
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RSI
MOV EDI,0x1
LAB_001bc751:
MOV RAX,qword ptr [R15 + 0x70]
ADD R15,0x70
TEST RAX,RAX
JNZ 0x001bc6dd
CMP EDI,0x1
JNZ 0x001bc795
LEA R9,[0x4ae168]
MOV RAX,qword ptr [RBP + -0x38]
MOV R8,qword ptr [RAX]
LEA RSI,[0x2003e6]
MOV EDI,0x2
MOV EDX,R10D
MOV RCX,RBX
XOR EAX,EAX
CALL qword ptr [R9]
LAB_001bc78c:
MOV EDI,0x1
JMP 0x001bc795
LAB_001bc793:
XOR EDI,EDI
LAB_001bc795:
MOV EAX,EDI
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int findopt(long param_1,uint param_2,int8 *param_3,int8 *param_4)
{
char *__s2;
char cVar1;
int iVar2;
long lVar3;
ulong uVar4;
char cVar5;
int iVar6;
char cVar7;
long *plVar8;
cVar1 = my_getopt_prefix_matching;
plVar8 = (long *)*param_3;
lVar3 = *plVar8;
if (lVar3 == 0) {
iVar6 = 0;
}
else {
iVar6 = 0;
do {
if (param_2 != 0) {
uVar4 = 0;
do {
cVar7 = *(char *)(lVar3 + uVar4);
if (*(char *)(lVar3 + uVar4) == '-') {
cVar7 = '_';
}
cVar5 = *(char *)(param_1 + uVar4);
if (cVar5 == '-') {
cVar5 = '_';
}
if (cVar7 != cVar5) goto LAB_001bc751;
uVar4 = uVar4 + 1;
} while (param_2 != uVar4);
}
*param_3 = plVar8;
__s2 = (char *)*plVar8;
if (__s2[param_2] == '\0') goto LAB_001bc78c;
if (cVar1 != '\0') {
if (iVar6 == 0) {
*param_4 = __s2;
iVar6 = 1;
}
else {
iVar2 = strcmp((char *)*param_4,__s2);
iVar6 = (iVar6 + 1) - (uint)(iVar2 == 0);
}
}
LAB_001bc751:
lVar3 = plVar8[0xe];
plVar8 = plVar8 + 0xe;
} while (lVar3 != 0);
if (iVar6 == 1) {
(*(code *)my_getopt_error_reporter)
(2,
"Using unique option prefix \'%.*s\' is error-prone and can break in the future. Please use the full name \'%s\' instead."
,param_2,param_1,*param_4);
LAB_001bc78c:
iVar6 = 1;
}
}
return iVar6;
}
|
|
8,186 |
my_caseup_utf32
|
eloqsql/strings/ctype-ucs2.c
|
static size_t
my_caseup_utf32(CHARSET_INFO *cs, const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
int res;
const char *srcend= src + srclen;
char *dstend= dst + dstlen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(srclen <= dstlen);
while ((src < srcend) &&
(res= my_utf32_uni(cs, &wc, (uchar *)src, (uchar*) srcend)) > 0)
{
my_toupper_utf32(uni_plane, &wc);
if (res != my_uni_utf32(cs, wc, (uchar*) dst, (uchar*) dstend))
break;
src+= res;
dst+= res;
}
return srclen;
}
|
O0
|
c
|
my_caseup_utf32:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0x695f2
jmp 0x695f4
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x51(%rbp)
jae 0x69624
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq 0x694d0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x6962d
jmp 0x69687
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6d7c0
movl -0x34(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0x69500
movl %eax, %ecx
movl -0x58(%rbp), %eax
cmpl %ecx, %eax
je 0x69660
jmp 0x69687
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x34(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x695f4
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_caseup_utf32:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_20]
add rax, [rbp+var_28]
mov [rbp+var_48], rax
mov rax, [rbp+var_8]
mov rax, [rax+78h]
mov [rbp+var_50], rax
jmp short $+2
loc_695F2:
jmp short $+2
loc_695F4:
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_51], al
jnb short loc_69624
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_40]
lea rsi, [rbp+var_30]
call my_utf32_uni
mov [rbp+var_34], eax
cmp eax, 0
setnle al
mov [rbp+var_51], al
loc_69624:
mov al, [rbp+var_51]
test al, 1
jnz short loc_6962D
jmp short loc_69687
loc_6962D:
mov rdi, [rbp+var_50]
lea rsi, [rbp+var_30]
call my_toupper_utf32
mov eax, [rbp+var_34]
mov [rbp+var_58], eax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_48]
call my_uni_utf32
mov ecx, eax
mov eax, [rbp+var_58]
cmp eax, ecx
jz short loc_69660
jmp short loc_69687
loc_69660:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
mov ecx, [rbp+var_34]
mov rax, [rbp+var_20]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_20], rax
jmp loc_695F4
loc_69687:
mov rax, [rbp+var_18]
add rsp, 60h
pop rbp
retn
|
long long my_caseup_utf32(long long a1, unsigned long long a2, long long a3, _BYTE *a4, long long a5, long long a6)
{
bool v7; // [rsp+Fh] [rbp-51h]
long long v8; // [rsp+10h] [rbp-50h]
unsigned long long v9; // [rsp+18h] [rbp-48h]
unsigned long long v10; // [rsp+20h] [rbp-40h]
int v11; // [rsp+2Ch] [rbp-34h]
unsigned long long v12[2]; // [rsp+30h] [rbp-30h] BYREF
_BYTE *v13; // [rsp+40h] [rbp-20h]
long long v14; // [rsp+48h] [rbp-18h]
unsigned long long v15; // [rsp+50h] [rbp-10h]
long long v16; // [rsp+58h] [rbp-8h]
v16 = a1;
v15 = a2;
v14 = a3;
v13 = a4;
v12[1] = a5;
v10 = a3 + a2;
v9 = (unsigned long long)&a4[a5];
v8 = *(_QWORD *)(a1 + 120);
while ( 1 )
{
v7 = 0;
if ( v15 < v10 )
{
v11 = my_utf32_uni(v16, (long long)v12, v15, v10, a5, a6);
v7 = v11 > 0;
}
if ( !v7 )
break;
my_toupper_utf32(v8, v12);
if ( v11 != (unsigned int)my_uni_utf32(v16, v12[0], v13, v9) )
break;
v15 += v11;
v13 += v11;
}
return v14;
}
|
my_caseup_utf32:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x001695f2
LAB_001695f2:
JMP 0x001695f4
LAB_001695f4:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x51],AL
JNC 0x00169624
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x40]
LEA RSI,[RBP + -0x30]
CALL 0x001694d0
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
SETG AL
MOV byte ptr [RBP + -0x51],AL
LAB_00169624:
MOV AL,byte ptr [RBP + -0x51]
TEST AL,0x1
JNZ 0x0016962d
JMP 0x00169687
LAB_0016962d:
MOV RDI,qword ptr [RBP + -0x50]
LEA RSI,[RBP + -0x30]
CALL 0x0016d7c0
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x58],EAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x48]
CALL 0x00169500
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x58]
CMP EAX,ECX
JZ 0x00169660
JMP 0x00169687
LAB_00169660:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001695f4
LAB_00169687:
MOV RAX,qword ptr [RBP + -0x18]
ADD RSP,0x60
POP RBP
RET
|
long my_caseup_utf32(long param_1,ulong param_2,long param_3,long param_4,long param_5)
{
int8 uVar1;
bool bVar2;
int iVar3;
int local_3c;
int8 local_38;
long local_30;
long local_28;
long local_20;
ulong local_18;
long local_10;
uVar1 = *(int8 *)(param_1 + 0x78);
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
bVar2 = false;
if (local_18 < param_2 + param_3) {
local_3c = my_utf32_uni(local_10,&local_38,local_18,param_2 + param_3);
bVar2 = 0 < local_3c;
}
if (!bVar2) break;
my_toupper_utf32(uVar1,&local_38);
iVar3 = my_uni_utf32(local_10,local_38,local_28,param_4 + param_5);
if (local_3c != iVar3) {
return local_20;
}
local_18 = local_18 + (long)local_3c;
local_28 = local_28 + local_3c;
}
return local_20;
}
|
|
8,187 |
facebook::yoga::StyleValuePool::getNumber(facebook::yoga::StyleValueHandle) const
|
yoga-mod/yoga/../yoga/style/StyleValuePool.h
|
FloatOptional getNumber(StyleValueHandle handle) const {
if (handle.isUndefined()) {
return FloatOptional{};
} else {
assert(handle.type() == StyleValueHandle::Type::Number);
float value = (handle.isValueIndexed())
? std::bit_cast<float>(buffer_.get32(handle.value()))
: unpackInlineInteger(handle.value());
return FloatOptional{value};
}
}
|
O0
|
c
|
facebook::yoga::StyleValuePool::getNumber(facebook::yoga::StyleValueHandle) const:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %si, %ax
movw %ax, -0x6(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x6(%rbp), %rdi
callq 0xb8450
testb $0x1, %al
jne 0xbba7a
jmp 0xbba98
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x352b0
leaq -0x4(%rbp), %rdi
callq 0xb7890
jmp 0xbbb2b
leaq -0x6(%rbp), %rdi
callq 0xb8480
cmpb $0x3, %al
jne 0xbbaa7
jmp 0xbbac6
leaq 0x68b910(%rip), %rdi # 0x7473be
leaq 0x68b4fb(%rip), %rsi # 0x746fb0
movl $0x74, %edx
leaq 0x68b92d(%rip), %rcx # 0x7473ee
callq 0x35320
leaq -0x6(%rbp), %rdi
callq 0xb7640
testb $0x1, %al
jne 0xbbad5
jmp 0xbbafd
leaq -0x6(%rbp), %rdi
callq 0xb7660
movq -0x20(%rbp), %rdi
movzwl %ax, %esi
callq 0xaf730
movl %eax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb8510
movss %xmm0, -0x24(%rbp)
jmp 0xbbb13
leaq -0x6(%rbp), %rdi
callq 0xb7660
movzwl %ax, %edi
callq 0xb8530
movss %xmm0, -0x24(%rbp)
movss -0x24(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
movss -0x14(%rbp), %xmm0
leaq -0x4(%rbp), %rdi
callq 0xa8cd0
movss -0x4(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_ZNK8facebook4yoga14StyleValuePool9getNumberENS0_16StyleValueHandleE:
push rbp
mov rbp, rsp
sub rsp, 30h
mov ax, si
mov [rbp+var_6], ax
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov [rbp+var_20], rax
lea rdi, [rbp+var_6]; this
call _ZNK8facebook4yoga16StyleValueHandle11isUndefinedEv; facebook::yoga::StyleValueHandle::isUndefined(void)
test al, 1
jnz short loc_BBA7A
jmp short loc_BBA98
loc_BBA7A:
lea rdi, [rbp+var_4]
xor esi, esi
mov edx, 4
call _memset
lea rdi, [rbp+var_4]; this
call _ZN8facebook4yoga13FloatOptionalC2Ev; facebook::yoga::FloatOptional::FloatOptional(void)
jmp loc_BBB2B
loc_BBA98:
lea rdi, [rbp+var_6]; this
call _ZNK8facebook4yoga16StyleValueHandle4typeEv; facebook::yoga::StyleValueHandle::type(void)
cmp al, 3
jnz short loc_BBAA7
jmp short loc_BBAC6
loc_BBAA7:
lea rdi, aHandleTypeStyl_0; "handle.type() == StyleValueHandle::Type"...
lea rsi, aWorkspaceLlm4b_60; "/workspace/llm4binary/github2025/yoga-m"...
mov edx, 74h ; 't'
lea rcx, aFloatoptionalF; "FloatOptional facebook::yoga::StyleValu"...
call ___assert_fail
loc_BBAC6:
lea rdi, [rbp+var_6]; this
call _ZNK8facebook4yoga16StyleValueHandle14isValueIndexedEv; facebook::yoga::StyleValueHandle::isValueIndexed(void)
test al, 1
jnz short loc_BBAD5
jmp short loc_BBAFD
loc_BBAD5:
lea rdi, [rbp+var_6]; this
call _ZNK8facebook4yoga16StyleValueHandle5valueEv; facebook::yoga::StyleValueHandle::value(void)
mov rdi, [rbp+var_20]
movzx esi, ax; unsigned __int16
call _ZNK8facebook4yoga16SmallValueBufferILm4EE5get32Et; facebook::yoga::SmallValueBuffer<4ul>::get32(ushort)
mov [rbp+var_18], eax
lea rdi, [rbp+var_18]
call _ZSt8bit_castIfjET_RKT0_QaaaaeqstS0_stS1_u23__is_trivially_copyableS0_Eu23__is_trivially_copyableS1_E
movss [rbp+var_24], xmm0
jmp short loc_BBB13
loc_BBAFD:
lea rdi, [rbp+var_6]; this
call _ZNK8facebook4yoga16StyleValueHandle5valueEv; facebook::yoga::StyleValueHandle::value(void)
movzx edi, ax; this
call _ZN8facebook4yoga14StyleValuePool19unpackInlineIntegerEt; facebook::yoga::StyleValuePool::unpackInlineInteger(ushort)
movss [rbp+var_24], xmm0
loc_BBB13:
movss xmm0, [rbp+var_24]
movss [rbp+var_14], xmm0
movss xmm0, [rbp+var_14]; float
lea rdi, [rbp+var_4]; this
call _ZN8facebook4yoga13FloatOptionalC2Ef; facebook::yoga::FloatOptional::FloatOptional(float)
loc_BBB2B:
movss xmm0, [rbp+var_4]
add rsp, 30h
pop rbp
retn
|
float facebook::yoga::StyleValuePool::getNumber(long long a1, __int16 a2)
{
unsigned __int16 v2; // ax
unsigned __int16 v3; // ax
float v5; // [rsp+Ch] [rbp-24h]
_DWORD v6[2]; // [rsp+18h] [rbp-18h] BYREF
long long v7; // [rsp+20h] [rbp-10h]
__int16 v8; // [rsp+2Ah] [rbp-6h] BYREF
float v9; // [rsp+2Ch] [rbp-4h] BYREF
v8 = a2;
v7 = a1;
if ( facebook::yoga::StyleValueHandle::isUndefined((facebook::yoga::StyleValueHandle *)&v8) )
{
memset(&v9, 0LL, sizeof(v9));
facebook::yoga::FloatOptional::FloatOptional((facebook::yoga::FloatOptional *)&v9);
}
else
{
if ( (unsigned __int8)facebook::yoga::StyleValueHandle::type((facebook::yoga::StyleValueHandle *)&v8) != 3 )
__assert_fail(
"handle.type() == StyleValueHandle::Type::Number",
"/workspace/llm4binary/github2025/yoga-mod/yoga/../yoga/style/StyleValuePool.h",
116LL,
"FloatOptional facebook::yoga::StyleValuePool::getNumber(StyleValueHandle) const");
if ( facebook::yoga::StyleValueHandle::isValueIndexed((facebook::yoga::StyleValueHandle *)&v8) )
{
v2 = facebook::yoga::StyleValueHandle::value((facebook::yoga::StyleValueHandle *)&v8);
v6[0] = facebook::yoga::SmallValueBuffer<4ul>::get32(a1, v2);
v5 = std::bit_cast<float,unsigned int>((long long)v6);
}
else
{
v3 = facebook::yoga::StyleValueHandle::value((facebook::yoga::StyleValueHandle *)&v8);
v5 = facebook::yoga::StyleValuePool::unpackInlineInteger((facebook::yoga::StyleValuePool *)v3);
}
*(float *)&v6[1] = v5;
facebook::yoga::FloatOptional::FloatOptional((facebook::yoga::FloatOptional *)&v9, v5);
}
return v9;
}
|
getNumber:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV AX,SI
MOV word ptr [RBP + -0x6],AX
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x20],RAX
LEA RDI,[RBP + -0x6]
CALL 0x001b8450
TEST AL,0x1
JNZ 0x001bba7a
JMP 0x001bba98
LAB_001bba7a:
LEA RDI,[RBP + -0x4]
XOR ESI,ESI
MOV EDX,0x4
CALL 0x001352b0
LEA RDI,[RBP + -0x4]
CALL 0x001b7890
JMP 0x001bbb2b
LAB_001bba98:
LEA RDI,[RBP + -0x6]
CALL 0x001b8480
CMP AL,0x3
JNZ 0x001bbaa7
JMP 0x001bbac6
LAB_001bbaa7:
LEA RDI,[0x8473be]
LEA RSI,[0x846fb0]
MOV EDX,0x74
LEA RCX,[0x8473ee]
CALL 0x00135320
LAB_001bbac6:
LEA RDI,[RBP + -0x6]
CALL 0x001b7640
TEST AL,0x1
JNZ 0x001bbad5
JMP 0x001bbafd
LAB_001bbad5:
LEA RDI,[RBP + -0x6]
CALL 0x001b7660
MOV RDI,qword ptr [RBP + -0x20]
MOVZX ESI,AX
CALL 0x001af730
MOV dword ptr [RBP + -0x18],EAX
LEA RDI,[RBP + -0x18]
CALL 0x001b8510
MOVSS dword ptr [RBP + -0x24],XMM0
JMP 0x001bbb13
LAB_001bbafd:
LEA RDI,[RBP + -0x6]
CALL 0x001b7660
MOVZX EDI,AX
CALL 0x001b8530
MOVSS dword ptr [RBP + -0x24],XMM0
LAB_001bbb13:
MOVSS XMM0,dword ptr [RBP + -0x24]
MOVSS dword ptr [RBP + -0x14],XMM0
MOVSS XMM0,dword ptr [RBP + -0x14]
LEA RDI,[RBP + -0x4]
CALL 0x001a8cd0
LAB_001bbb2b:
MOVSS XMM0,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
/* facebook::yoga::StyleValuePool::getNumber(facebook::yoga::StyleValueHandle) const */
int4 __thiscall
facebook::yoga::StyleValuePool::getNumber(StyleValuePool *this,int2 param_2)
{
char cVar1;
ushort uVar2;
ulong uVar3;
float local_2c;
int4 local_20;
float local_1c;
StyleValuePool *local_18;
int2 local_e;
int4 local_c;
local_18 = this;
local_e = param_2;
uVar3 = StyleValueHandle::isUndefined((StyleValueHandle *)&local_e);
if ((uVar3 & 1) == 0) {
cVar1 = StyleValueHandle::type((StyleValueHandle *)&local_e);
if (cVar1 != '\x03') {
/* WARNING: Subroutine does not return */
__assert_fail("handle.type() == StyleValueHandle::Type::Number",
"/workspace/llm4binary/github2025/yoga-mod/yoga/../yoga/style/StyleValuePool.h",
0x74,
"FloatOptional facebook::yoga::StyleValuePool::getNumber(StyleValueHandle) const"
);
}
uVar3 = StyleValueHandle::isValueIndexed((StyleValueHandle *)&local_e);
if ((uVar3 & 1) == 0) {
uVar2 = StyleValueHandle::value((StyleValueHandle *)&local_e);
local_2c = (float)unpackInlineInteger(uVar2);
}
else {
uVar2 = StyleValueHandle::value((StyleValueHandle *)&local_e);
local_20 = SmallValueBuffer<4ul>::get32((SmallValueBuffer<4ul> *)this,uVar2);
local_2c = (float)_ZSt8bit_castIfjET_RKT0_QaaaaeqstS0_stS1_u23__is_trivially_copyableS0_Eu23__is_trivially_copyableS1_E
(&local_20);
}
local_1c = local_2c;
FloatOptional::FloatOptional((FloatOptional *)&local_c,local_2c);
}
else {
memset(&local_c,0,4);
FloatOptional::FloatOptional((FloatOptional *)&local_c);
}
return local_c;
}
|
|
8,188 |
test_dict_inflate
|
3fs/build_O3/src/apache-arrow-cpp/cpp/zlib_ep-prefix/src/zlib_ep/test/example.c
|
void test_dict_inflate(compr, comprLen, uncompr, uncomprLen)
Byte *compr, *uncompr;
uLong comprLen, uncomprLen;
{
int err;
z_stream d_stream; /* decompression stream */
strcpy((char*)uncompr, "garbage");
d_stream.zalloc = zalloc;
d_stream.zfree = zfree;
d_stream.opaque = (voidpf)0;
d_stream.next_in = compr;
d_stream.avail_in = (uInt)comprLen;
err = inflateInit(&d_stream);
CHECK_ERR(err, "inflateInit");
d_stream.next_out = uncompr;
d_stream.avail_out = (uInt)uncomprLen;
for (;;) {
err = inflate(&d_stream, Z_NO_FLUSH);
if (err == Z_STREAM_END) break;
if (err == Z_NEED_DICT) {
if (d_stream.adler != dictId) {
fprintf(stderr, "unexpected dictionary");
exit(1);
}
err = inflateSetDictionary(&d_stream, (const Bytef*)dictionary,
(int)sizeof(dictionary));
}
CHECK_ERR(err, "inflate with dict");
}
err = inflateEnd(&d_stream);
CHECK_ERR(err, "inflateEnd");
if (strcmp((char*)uncompr, hello)) {
fprintf(stderr, "bad inflate with dict\n");
exit(1);
} else {
printf("inflate with dictionary: %s\n", (char *)uncompr);
}
}
|
O3
|
c
|
test_dict_inflate:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movabsq $0x65676162726167, %rax # imm = 0x65676162726167
movq %rax, (%rdx)
xorps %xmm0, %xmm0
movq %rsp, %rax
movups %xmm0, 0x40(%rax)
movq $0x0, 0x50(%rax)
movq %rdi, (%rax)
movl %esi, 0x8(%rax)
leaq 0xc2f(%rip), %rsi # 0x4140
movq %rax, %rdi
movl $0x70, %edx
callq 0x21d0
testl %eax, %eax
jne 0x35b6
movq %rsp, %r14
movq %rbx, 0x18(%r14)
movl %r15d, 0x20(%r14)
leaq 0xe1d(%rip), %r15 # 0x4355
movq %r14, %rdi
xorl %esi, %esi
callq 0x2060
cmpl $0x2, %eax
je 0x354e
cmpl $0x1, %eax
jne 0x356c
jmp 0x3577
movq 0x60(%rsp), %rax
cmpq 0x3bfe(%rip), %rax # 0x7158
jne 0x35b1
movq %r14, %rdi
movq %r15, %rsi
movl $0x6, %edx
callq 0x2190
testl %eax, %eax
je 0x3538
movl %eax, %edi
callq 0x2a6a
movq %rsp, %rdi
callq 0x2170
testl %eax, %eax
jne 0x35bd
leaq 0x3bb6(%rip), %rsi # 0x7140
movq %rbx, %rdi
callq 0x2130
testl %eax, %eax
jne 0x35c4
leaq 0xcfa(%rip), %rdi # 0x4297
movq %rbx, %rsi
xorl %eax, %eax
callq 0x20f0
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x29f6
movl %eax, %edi
callq 0x29cc
movl %eax, %edi
callq 0x2a1b
callq 0x2a45
|
test_dict_inflate:
push r15
push r14
push rbx
sub rsp, 70h
mov r15, rcx
mov rbx, rdx
mov rax, 65676162726167h
mov [rdx], rax
xorps xmm0, xmm0
mov rax, rsp
movups xmmword ptr [rax+40h], xmm0
mov qword ptr [rax+50h], 0
mov [rax], rdi
mov [rax+8], esi
lea rsi, a1213; "1.2.13"
mov rdi, rax
mov edx, 70h ; 'p'
call _inflateInit_
test eax, eax
jnz loc_35B6
mov r14, rsp
mov [r14+18h], rbx
mov [r14+20h], r15d
lea r15, aHello; "hello"
loc_3538:
mov rdi, r14
xor esi, esi
call _inflate
cmp eax, 2
jz short loc_354E
cmp eax, 1
jnz short loc_356C
jmp short loc_3577
loc_354E:
mov rax, [rsp+88h+var_28]
cmp rax, cs:dictId
jnz short loc_35B1
mov rdi, r14
mov rsi, r15
mov edx, 6
call _inflateSetDictionary
loc_356C:
test eax, eax
jz short loc_3538
mov edi, eax
call test_dict_inflate_cold_5
loc_3577:
mov rdi, rsp
call _inflateEnd
test eax, eax
jnz short loc_35BD
lea rsi, hello; "hello, hello!"
mov rdi, rbx
call _strcmp
test eax, eax
jnz short loc_35C4
lea rdi, aInflateWithDic_0; "inflate with dictionary: %s\n"
mov rsi, rbx
xor eax, eax
call _printf
add rsp, 70h
pop rbx
pop r14
pop r15
retn
loc_35B1:
call test_dict_inflate_cold_2
loc_35B6:
mov edi, eax
call test_dict_inflate_cold_1
loc_35BD:
mov edi, eax
call test_dict_inflate_cold_3
loc_35C4:
call test_dict_inflate_cold_4
|
long long test_dict_inflate(long long a1, int a2, char *a3, int a4)
{
int v6; // eax
int v7; // eax
int v8; // eax
long long v10; // [rsp+0h] [rbp-88h] BYREF
int v11; // [rsp+8h] [rbp-80h]
char *v12; // [rsp+18h] [rbp-70h]
int v13; // [rsp+20h] [rbp-68h]
__int128 v14; // [rsp+40h] [rbp-48h]
long long v15; // [rsp+50h] [rbp-38h]
long long v16; // [rsp+60h] [rbp-28h]
*(_QWORD *)a3 = 0x65676162726167LL;
v14 = 0LL;
v15 = 0LL;
v10 = a1;
v11 = a2;
v6 = inflateInit_(&v10, "1.2.13", 112LL);
if ( v6 )
test_dict_inflate_cold_1(v6);
v12 = a3;
v13 = a4;
while ( 1 )
{
v7 = inflate(&v10, 0LL);
if ( v7 != 2 )
break;
if ( v16 != dictId )
test_dict_inflate_cold_2();
v7 = inflateSetDictionary(&v10, "hello", 6LL);
LABEL_8:
if ( v7 )
test_dict_inflate_cold_5(v7);
}
if ( v7 != 1 )
goto LABEL_8;
v8 = inflateEnd(&v10);
if ( v8 )
test_dict_inflate_cold_3(v8);
if ( (unsigned int)strcmp(a3, hello) )
test_dict_inflate_cold_4();
return printf("inflate with dictionary: %s\n", a3);
}
|
test_dict_inflate:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x70
MOV R15,RCX
MOV RBX,RDX
MOV RAX,0x65676162726167
MOV qword ptr [RDX],RAX
XORPS XMM0,XMM0
MOV RAX,RSP
MOVUPS xmmword ptr [RAX + 0x40],XMM0
MOV qword ptr [RAX + 0x50],0x0
MOV qword ptr [RAX],RDI
MOV dword ptr [RAX + 0x8],ESI
LEA RSI,[0x104140]
MOV RDI,RAX
MOV EDX,0x70
CALL 0x001021d0
TEST EAX,EAX
JNZ 0x001035b6
MOV R14,RSP
MOV qword ptr [R14 + 0x18],RBX
MOV dword ptr [R14 + 0x20],R15D
LEA R15,[0x104355]
LAB_00103538:
MOV RDI,R14
XOR ESI,ESI
CALL 0x00102060
CMP EAX,0x2
JZ 0x0010354e
CMP EAX,0x1
JNZ 0x0010356c
JMP 0x00103577
LAB_0010354e:
MOV RAX,qword ptr [RSP + 0x60]
CMP RAX,qword ptr [0x00107158]
JNZ 0x001035b1
MOV RDI,R14
MOV RSI,R15
MOV EDX,0x6
CALL 0x00102190
LAB_0010356c:
TEST EAX,EAX
JZ 0x00103538
MOV EDI,EAX
CALL 0x00102a6a
LAB_00103577:
MOV RDI,RSP
CALL 0x00102170
TEST EAX,EAX
JNZ 0x001035bd
LEA RSI,[0x107140]
MOV RDI,RBX
CALL 0x00102130
TEST EAX,EAX
JNZ 0x001035c4
LEA RDI,[0x104297]
MOV RSI,RBX
XOR EAX,EAX
CALL 0x001020f0
ADD RSP,0x70
POP RBX
POP R14
POP R15
RET
LAB_001035b1:
CALL 0x001029f6
LAB_001035b6:
MOV EDI,EAX
CALL 0x001029cc
LAB_001035bd:
MOV EDI,EAX
CALL 0x00102a1b
LAB_001035c4:
CALL 0x00102a45
|
int test_dict_inflate(int8 param_1,int4 param_2,char *param_3,char *param_4)
{
int iVar1;
int iVar2;
char *pcVar3;
int8 uVar4;
void *__ptr;
void *__ptr_00;
char *pcVar5;
int8 *unaff_R14;
int8 uStack_b0;
char *pcStack_a8;
int1 *puStack_a0;
char *pcStack_98;
int8 local_88;
int4 local_80;
char *local_70;
int4 local_68;
int8 local_48;
int8 uStack_40;
int8 local_38;
long local_28;
builtin_strncpy(param_3,"garbage",8);
local_48 = 0;
uStack_40 = 0;
local_38 = 0;
pcVar5 = "1.2.13";
local_88 = param_1;
local_80 = param_2;
iVar1 = inflateInit_(&local_88,"1.2.13",0x70);
if (iVar1 == 0) {
local_68 = SUB84(param_4,0);
param_4 = "hello";
local_70 = param_3;
do {
pcVar5 = (char *)0x0;
iVar1 = inflate(&local_88);
if (iVar1 == 2) {
if (local_28 != dictId) {
iVar1 = test_dict_inflate_cold_2();
unaff_R14 = &local_88;
goto LAB_001035b6;
}
pcVar5 = "hello";
iVar1 = inflateSetDictionary(&local_88,"hello",6);
}
else if (iVar1 == 1) goto LAB_00103577;
} while (iVar1 == 0);
test_dict_inflate_cold_5(iVar1);
LAB_00103577:
iVar1 = inflateEnd(&local_88);
unaff_R14 = &local_88;
if (iVar1 == 0) {
pcVar5 = hello;
pcVar3 = param_3;
iVar2 = strcmp(param_3,hello);
iVar1 = (int)pcVar3;
unaff_R14 = &local_88;
if (iVar2 == 0) {
iVar1 = printf("inflate with dictionary: %s\n",param_3);
return iVar1;
}
goto LAB_001035c4;
}
}
else {
LAB_001035b6:
iVar1 = test_dict_inflate_cold_1(iVar1);
}
test_dict_inflate_cold_3();
LAB_001035c4:
test_dict_inflate_cold_4();
uStack_b0 = 40000;
pcStack_a8 = param_3;
puStack_a0 = (int1 *)unaff_R14;
pcStack_98 = param_4;
pcVar3 = (char *)zlibVersion();
if (*pcVar3 == '1') {
pcVar3 = (char *)zlibVersion();
iVar2 = strcmp(pcVar3,"1.2.13");
if (iVar2 != 0) {
main_cold_2();
}
uVar4 = zlibCompileFlags();
printf("zlib version %s = 0x%04x, compile flags = 0x%lx\n","1.2.13",0x12d0,uVar4);
__ptr = calloc(40000,1);
__ptr_00 = calloc(40000,1);
if ((__ptr != (void *)0x0) && (__ptr_00 != (void *)0x0)) {
test_compress(__ptr,40000,__ptr_00,40000);
if (iVar1 < 2) {
pcVar5 = "foo.gz";
}
else {
pcVar5 = *(char **)(pcVar5 + 8);
}
test_gzio(pcVar5,__ptr_00,40000);
test_deflate(__ptr,40000);
test_inflate(__ptr,40000,__ptr_00,40000);
test_large_deflate(__ptr,40000,__ptr_00,40000);
test_large_inflate(__ptr,40000,__ptr_00,40000);
test_flush(__ptr,&uStack_b0);
test_sync(__ptr,uStack_b0,__ptr_00,40000);
test_dict_deflate(__ptr,40000);
test_dict_inflate(__ptr,40000,__ptr_00,40000);
free(__ptr);
free(__ptr_00);
return 0;
}
}
else {
main_cold_1();
}
puts("out of memory");
/* WARNING: Subroutine does not return */
exit(1);
}
|
|
8,189 |
resolve_collation
|
eloqsql/mysys/charset.c
|
my_bool resolve_collation(const char *cl_name,
CHARSET_INFO *default_cl,
CHARSET_INFO **cl,
myf my_flags)
{
*cl= get_charset_by_name(cl_name, my_flags);
if (*cl == NULL)
{
*cl= default_cl;
return TRUE;
}
return FALSE;
}
|
O3
|
c
|
resolve_collation:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
movq %fs:0x28, %rax
movq %rax, -0x18(%rbp)
leaq -0xc8(%rbp), %rdi
movb $0x0, (%rdi)
leaq -0x13af(%rip), %rax # 0x4dbd6
movq %rax, 0x80(%rdi)
leaq -0x13ae(%rip), %rax # 0x4dbe5
movq %rax, 0x88(%rdi)
leaq -0x13a1(%rip), %rax # 0x4dc00
movq %rax, 0x90(%rdi)
leaq 0xe31b(%rip), %rax # 0x5d2ca
movq %rax, 0x98(%rdi)
leaq 0x2e6f83(%rip), %rax # 0x335f40
movq (%rax), %rax
movq %rax, 0xa0(%rdi)
leaq -0x13b0(%rip), %rax # 0x4dc1e
movq %rax, 0xa8(%rdi)
movq %rcx, %rdx
callq 0x4eb50
movq %rax, %rcx
testq %rax, %rax
sete %al
cmovneq %rcx, %r14
movq %r14, (%rbx)
movq %fs:0x28, %rcx
cmpq -0x18(%rbp), %rcx
jne 0x4f008
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x28430
|
resolve_collation:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 0C0h
mov rbx, rdx
mov r14, rsi
mov rsi, rdi
mov rax, fs:28h
mov [rbp+var_18], rax
lea rdi, [rbp+var_C8]
mov byte ptr [rdi], 0
lea rax, my_once_alloc_c
mov [rdi+80h], rax
lea rax, my_malloc_c
mov [rdi+88h], rax
lea rax, my_realloc_c
mov [rdi+90h], rax
lea rax, my_free
mov [rdi+98h], rax
lea rax, my_charset_error_reporter
mov rax, [rax]
mov [rdi+0A0h], rax
lea rax, add_collation
mov [rdi+0A8h], rax
mov rdx, rcx
call my_collation_get_by_name
mov rcx, rax
test rax, rax
setz al
cmovnz r14, rcx
mov [rbx], r14
mov rcx, fs:28h
cmp rcx, [rbp+var_18]
jnz short loc_4F008
add rsp, 0C0h
pop rbx
pop r14
pop rbp
retn
loc_4F008:
call ___stack_chk_fail
|
bool resolve_collation(long long a1, long long a2, long long *a3, long long a4)
{
long long v6; // rcx
bool result; // al
char v8[128]; // [rsp+8h] [rbp-C8h] BYREF
long long ( *v9)(long long); // [rsp+88h] [rbp-48h]
long long ( *v10)(long long); // [rsp+90h] [rbp-40h]
long long ( *v11)(long long, long long); // [rsp+98h] [rbp-38h]
long long ( *v12)(_QWORD); // [rsp+A0h] [rbp-30h]
long long ( *v13)(); // [rsp+A8h] [rbp-28h]
long long ( *v14)(unsigned int *); // [rsp+B0h] [rbp-20h]
unsigned long long v15; // [rsp+B8h] [rbp-18h]
v15 = __readfsqword(0x28u);
v8[0] = 0;
v9 = my_once_alloc_c;
v10 = my_malloc_c;
v11 = my_realloc_c;
v12 = my_free;
v13 = my_charset_error_reporter;
v14 = add_collation;
v6 = my_collation_get_by_name((long long)v8, a1, a4);
result = v6 == 0;
if ( v6 )
a2 = v6;
*a3 = a2;
return result;
}
|
resolve_collation:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0xc0
MOV RBX,RDX
MOV R14,RSI
MOV RSI,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
LEA RDI,[RBP + -0xc8]
MOV byte ptr [RDI],0x0
LEA RAX,[0x14dbd6]
MOV qword ptr [RDI + 0x80],RAX
LEA RAX,[0x14dbe5]
MOV qword ptr [RDI + 0x88],RAX
LEA RAX,[0x14dc00]
MOV qword ptr [RDI + 0x90],RAX
LEA RAX,[0x15d2ca]
MOV qword ptr [RDI + 0x98],RAX
LEA RAX,[0x435f40]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RDI + 0xa0],RAX
LEA RAX,[0x14dc1e]
MOV qword ptr [RDI + 0xa8],RAX
MOV RDX,RCX
CALL 0x0014eb50
MOV RCX,RAX
TEST RAX,RAX
SETZ AL
CMOVNZ R14,RCX
MOV qword ptr [RBX],R14
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x18]
JNZ 0x0014f008
ADD RSP,0xc0
POP RBX
POP R14
POP RBP
RET
LAB_0014f008:
CALL 0x00128430
|
bool resolve_collation(int8 param_1,long param_2,long *param_3,int8 param_4)
{
long lVar1;
long in_FS_OFFSET;
int1 local_d0 [128];
code *local_50;
code *local_48;
code *local_40;
code *local_38;
int *local_30;
code *local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_d0[0] = 0;
local_50 = my_once_alloc_c;
local_48 = my_malloc_c;
local_40 = my_realloc_c;
local_38 = my_free;
local_30 = my_charset_error_reporter;
local_28 = add_collation;
lVar1 = my_collation_get_by_name(local_d0,param_1,param_4);
if (lVar1 != 0) {
param_2 = lVar1;
}
*param_3 = param_2;
if (*(long *)(in_FS_OFFSET + 0x28) == local_20) {
return lVar1 == 0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
8,190 |
LefDefParser::defiNet::addPts(char const*, int, LefDefParser::defiGeometries*, int*, int, char const*, char const*, char const*)
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiNet.cpp
|
void defiNet::addPts(const char* viaName, int o, defiGeometries* geom,
int *needCbk, int colorMask,
const char* routeStatus,
const char* shapeType,
const char* routeStatusShieldName) {
struct defiPoints* p;
int x, y;
int i;
*needCbk = 0;
if (numPts_ == ptsAllocated_) {
struct defiPoints** pts;
char** newn;
char** newRS;
char** newST;
char** newRSN;
int* orientn;
int* maskn;
ptsAllocated_ = (ptsAllocated_ == 0) ?
1000 : ptsAllocated_ * 2;
newn = (char**)malloc(sizeof(char*) *ptsAllocated_);
newRS = (char**)malloc(sizeof(char*) *ptsAllocated_);
newST = (char**)malloc(sizeof(char*) *ptsAllocated_);
newRSN = (char**)malloc(sizeof(char*) *ptsAllocated_);
orientn = (int*)malloc(sizeof(int) *ptsAllocated_);
pts= (struct defiPoints**)malloc(sizeof(struct defiPoints*) *
ptsAllocated_);
maskn = (int*)malloc(sizeof(int) *ptsAllocated_);
for (i = 0; i < numPts_; i++) {
pts[i] = viaPts_[i];
newn[i] = viaNames_[i];
newRS[i] = viaRouteStatus_[i];
newST[i] = viaShapeTypes_[i];
newRSN[i] = viaRouteStatusShieldNames_[i];
orientn[i] = viaOrients_[i];
maskn[i] = viaMasks_[i];
}
if (viaPts_)
free((char*)(viaPts_));
if (viaNames_)
free((char*)(viaNames_));
if (viaOrients_)
free((char*)(viaOrients_));
if (viaMasks_)
free((char*)(viaMasks_));
if (viaRouteStatus_)
free((char*)(viaRouteStatus_));
if (viaShapeTypes_)
free((char*)(viaShapeTypes_));
if (viaRouteStatusShieldNames_)
free((char*)(viaRouteStatusShieldNames_));
viaPts_ = pts;
viaNames_ = newn;
viaOrients_ = orientn;
viaMasks_ = maskn;
viaShapeTypes_= newST;
viaRouteStatus_ = newRS;
viaRouteStatusShieldNames_ = newRSN;
}
viaNames_[numPts_] = strdup(viaName);
viaShapeTypes_[numPts_] = strdup(shapeType);
viaRouteStatus_[numPts_] = strdup(routeStatus);
viaRouteStatusShieldNames_[numPts_] = strdup(routeStatusShieldName);
viaOrients_[numPts_] = o;
viaMasks_[numPts_] = colorMask;
p = (struct defiPoints*)malloc(sizeof(struct defiPoints));
p->numPoints = geom->numPoints();
p->x = (int*)malloc(sizeof(int)*p->numPoints);
p->y = (int*)malloc(sizeof(int)*p->numPoints);
for (i = 0; i < p->numPoints; i++) {
geom->points(i, &x, &y);
p->x[i] = x;
p->y[i] = y;
}
viaPts_[numPts_] = p;
numPts_ += 1;
if (numPts_ == 1000) // Want to invoke the partial callback if set
*needCbk = 1;
}
|
O3
|
cpp
|
LefDefParser::defiNet::addPts(char const*, int, LefDefParser::defiGeometries*, int*, int, char const*, char const*, char const*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %r12
movl %edx, %r13d
movq %rdi, %r14
movl $0x0, (%r8)
movl 0x210(%rdi), %r15d
cmpl 0x214(%rdi), %r15d
movq %r8, 0x60(%rsp)
movq %rdi, 0x48(%rsp)
movl %r9d, 0xc(%rsp)
jne 0x2460d
movq %rsi, 0x50(%rsp)
movl %r13d, 0x8(%rsp)
movq %r12, 0x58(%rsp)
leal (%r15,%r15), %eax
testl %r15d, %r15d
movl $0x3e8, %ecx # imm = 0x3E8
cmovnel %eax, %ecx
movl %ecx, 0x214(%r14)
movslq %ecx, %r12
leaq (,%r12,8), %rbx
movq %rbx, %rdi
callq 0x6270
movq %rax, 0x40(%rsp)
movq %rbx, %rdi
callq 0x6270
movq %rax, 0x38(%rsp)
movq %rbx, %rdi
callq 0x6270
movq %rax, 0x30(%rsp)
movq %rbx, %rdi
callq 0x6270
movq %rax, 0x28(%rsp)
shlq $0x2, %r12
movq %r12, %rdi
callq 0x6270
movq %rax, 0x20(%rsp)
movq %rbx, %rdi
callq 0x6270
movq %rax, 0x18(%rsp)
movq %r12, %rdi
callq 0x6270
movq 0x200(%r14), %rdi
testl %r15d, %r15d
movq %rax, (%rsp)
jle 0x24619
movq 0x208(%r14), %rax
movq %rax, 0x70(%rsp)
movq 0x218(%r14), %rax
movq %rax, 0x68(%rsp)
movq 0x228(%r14), %rdx
movq 0x238(%r14), %rsi
movq 0x230(%r14), %r8
movq 0x220(%r14), %r9
shlq $0x2, %r15
xorl %r10d, %r10d
movq 0x40(%rsp), %r13
movq 0x38(%rsp), %rbp
movq 0x30(%rsp), %rbx
movq 0x28(%rsp), %r12
movq 0x20(%rsp), %r14
movq 0x18(%rsp), %rcx
movq (%rdi,%r10,2), %r11
movq %r11, (%rcx,%r10,2)
movq 0x70(%rsp), %rax
movq (%rax,%r10,2), %r11
movq %r11, (%r13,%r10,2)
movq (%rdx,%r10,2), %r11
movq %r11, (%rbp,%r10,2)
movq (%rsi,%r10,2), %r11
movq %r11, (%rbx,%r10,2)
movq (%r8,%r10,2), %r11
movq %r11, (%r12,%r10,2)
movq 0x68(%rsp), %rax
movl (%rax,%r10), %r11d
movl %r11d, (%r14,%r10)
movl (%r9,%r10), %r11d
movq (%rsp), %rax
movl %r11d, (%rax,%r10)
addq $0x4, %r10
cmpq %r10, %r15
jne 0x245ba
jmp 0x24621
movq 0x208(%r14), %rbp
jmp 0x24715
movq %rax, %rcx
testq %rdi, %rdi
je 0x2462a
callq 0x6220
movq (%rsp), %rcx
movq 0x48(%rsp), %r14
movq 0x208(%r14), %rdi
testq %rdi, %rdi
je 0x24644
callq 0x6220
movq (%rsp), %rcx
movq 0x218(%r14), %rdi
testq %rdi, %rdi
movq 0x40(%rsp), %r15
movq 0x38(%rsp), %r13
movq 0x30(%rsp), %rbp
movq 0x28(%rsp), %rbx
movq 0x20(%rsp), %r12
je 0x24672
callq 0x6220
movq (%rsp), %rcx
movq 0x220(%r14), %rdi
testq %rdi, %rdi
je 0x24687
callq 0x6220
movq (%rsp), %rcx
movq 0x228(%r14), %rdi
testq %rdi, %rdi
je 0x2469c
callq 0x6220
movq (%rsp), %rcx
movq 0x238(%r14), %rdi
testq %rdi, %rdi
je 0x246b1
callq 0x6220
movq (%rsp), %rcx
movq 0x230(%r14), %rdi
testq %rdi, %rdi
je 0x246c6
callq 0x6220
movq (%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rax, 0x200(%r14)
movq %r15, 0x208(%r14)
movq %r12, 0x218(%r14)
movq %rcx, 0x220(%r14)
movq %rbp, 0x238(%r14)
movq %r13, 0x228(%r14)
movq %rbx, 0x230(%r14)
movq %r15, %rbp
movl 0x210(%r14), %r15d
movq 0x58(%rsp), %r12
movl 0x8(%rsp), %r13d
movq 0x50(%rsp), %rsi
movq %rsi, %rdi
callq 0x6320
movslq %r15d, %rbx
movq %rax, (%rbp,%rbx,8)
movq 0xb8(%rsp), %rdi
callq 0x6320
movq 0x238(%r14), %rcx
movq %rax, (%rcx,%rbx,8)
movq 0xb0(%rsp), %rdi
callq 0x6320
movq 0x228(%r14), %rcx
movq %rax, (%rcx,%rbx,8)
movq 0xc0(%rsp), %rdi
callq 0x6320
movq 0x230(%r14), %rcx
movq %rax, (%rcx,%rbx,8)
movq 0x218(%r14), %rax
movl %r13d, (%rax,%rbx,4)
movq 0x220(%r14), %rax
movslq 0x210(%r14), %rcx
movl 0xc(%rsp), %edx
movl %edx, (%rax,%rcx,4)
movl $0x18, %edi
callq 0x6270
movq %rax, %rbp
movq %r12, %rdi
callq 0x1911e
movl %eax, (%rbp)
movslq %eax, %r14
leaq (,%r14,4), %r15
movq %r15, %rdi
callq 0x6270
movq %r12, %rbx
movq %rax, %r12
movq %rax, 0x8(%rbp)
movq %r15, %rdi
callq 0x6270
movq %rbp, (%rsp)
movq %rax, 0x10(%rbp)
testl %r14d, %r14d
jle 0x2480c
movq %rax, %r13
xorl %ebp, %ebp
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movl %ebp, %esi
leaq 0x14(%rsp), %rdx
movq %r15, %rcx
callq 0x19122
movl 0x14(%rsp), %eax
movl %eax, (%r12,%rbp,4)
movl 0x10(%rsp), %eax
movl %eax, (%r13,%rbp,4)
incq %rbp
cmpq %r14, %rbp
jl 0x247e1
movq 0x48(%rsp), %rdx
movq 0x200(%rdx), %rax
movslq 0x210(%rdx), %rcx
movq (%rsp), %rsi
movq %rsi, (%rax,%rcx,8)
leal 0x1(%rcx), %eax
movl %eax, 0x210(%rdx)
cmpl $0x3e8, %eax # imm = 0x3E8
jne 0x24842
movq 0x60(%rsp), %rax
movl $0x1, (%rax)
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
_ZN12LefDefParser7defiNet6addPtsEPKciPNS_14defiGeometriesEPiiS2_S2_S2_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov r12, rcx
mov r13d, edx
mov r14, rdi
mov dword ptr [r8], 0
mov r15d, [rdi+210h]
cmp r15d, [rdi+214h]
mov [rsp+0A8h+var_48], r8
mov [rsp+0A8h+var_60], rdi
mov [rsp+0A8h+var_9C], r9d
jnz loc_2460D
mov [rsp+0A8h+var_58], rsi
mov [rsp+0A8h+var_A0], r13d
mov [rsp+0A8h+var_50], r12
lea eax, [r15+r15]
test r15d, r15d
mov ecx, 3E8h
cmovnz ecx, eax
mov [r14+214h], ecx
movsxd r12, ecx
lea rbx, ds:0[r12*8]
mov rdi, rbx
call _malloc
mov [rsp+0A8h+var_68], rax
mov rdi, rbx
call _malloc
mov [rsp+0A8h+var_70], rax
mov rdi, rbx
call _malloc
mov [rsp+0A8h+var_78], rax
mov rdi, rbx
call _malloc
mov [rsp+0A8h+var_80], rax
shl r12, 2
mov rdi, r12
call _malloc
mov [rsp+0A8h+var_88], rax
mov rdi, rbx
call _malloc
mov [rsp+0A8h+var_90], rax
mov rdi, r12
call _malloc
mov rdi, [r14+200h]
test r15d, r15d
mov [rsp+0A8h+var_A8], rax
jle loc_24619
mov rax, [r14+208h]
mov [rsp+0A8h+var_38], rax
mov rax, [r14+218h]
mov [rsp+0A8h+var_40], rax
mov rdx, [r14+228h]
mov rsi, [r14+238h]
mov r8, [r14+230h]
mov r9, [r14+220h]
shl r15, 2
xor r10d, r10d
mov r13, [rsp+0A8h+var_68]
mov rbp, [rsp+0A8h+var_70]
mov rbx, [rsp+0A8h+var_78]
mov r12, [rsp+0A8h+var_80]
mov r14, [rsp+0A8h+var_88]
mov rcx, [rsp+0A8h+var_90]
loc_245BA:
mov r11, [rdi+r10*2]
mov [rcx+r10*2], r11
mov rax, [rsp+0A8h+var_38]
mov r11, [rax+r10*2]
mov [r13+r10*2+0], r11
mov r11, [rdx+r10*2]
mov [rbp+r10*2+0], r11
mov r11, [rsi+r10*2]
mov [rbx+r10*2], r11
mov r11, [r8+r10*2]
mov [r12+r10*2], r11
mov rax, [rsp+0A8h+var_40]
mov r11d, [rax+r10]
mov [r14+r10], r11d
mov r11d, [r9+r10]
mov rax, [rsp+0A8h+var_A8]
mov [rax+r10], r11d
add r10, 4
cmp r15, r10
jnz short loc_245BA
jmp short loc_24621
loc_2460D:
mov rbp, [r14+208h]
jmp loc_24715
loc_24619:
mov rcx, rax
test rdi, rdi
jz short loc_2462A
loc_24621:
call _free
mov rcx, [rsp+0A8h+var_A8]
loc_2462A:
mov r14, [rsp+0A8h+var_60]
mov rdi, [r14+208h]
test rdi, rdi
jz short loc_24644
call _free
mov rcx, [rsp+0A8h+var_A8]
loc_24644:
mov rdi, [r14+218h]
test rdi, rdi
mov r15, [rsp+0A8h+var_68]
mov r13, [rsp+0A8h+var_70]
mov rbp, [rsp+0A8h+var_78]
mov rbx, [rsp+0A8h+var_80]
mov r12, [rsp+0A8h+var_88]
jz short loc_24672
call _free
mov rcx, [rsp+0A8h+var_A8]
loc_24672:
mov rdi, [r14+220h]
test rdi, rdi
jz short loc_24687
call _free
mov rcx, [rsp+0A8h+var_A8]
loc_24687:
mov rdi, [r14+228h]
test rdi, rdi
jz short loc_2469C
call _free
mov rcx, [rsp+0A8h+var_A8]
loc_2469C:
mov rdi, [r14+238h]
test rdi, rdi
jz short loc_246B1
call _free
mov rcx, [rsp+0A8h+var_A8]
loc_246B1:
mov rdi, [r14+230h]
test rdi, rdi
jz short loc_246C6
call _free
mov rcx, [rsp+0A8h+var_A8]
loc_246C6:
mov rax, [rsp+0A8h+var_90]
mov [r14+200h], rax
mov [r14+208h], r15
mov [r14+218h], r12
mov [r14+220h], rcx
mov [r14+238h], rbp
mov [r14+228h], r13
mov [r14+230h], rbx
mov rbp, r15
mov r15d, [r14+210h]
mov r12, [rsp+0A8h+var_50]
mov r13d, [rsp+0A8h+var_A0]
mov rsi, [rsp+0A8h+var_58]
loc_24715:
mov rdi, rsi
call _strdup
movsxd rbx, r15d
mov [rbp+rbx*8+0], rax
mov rdi, [rsp+0A8h+arg_8]
call _strdup
mov rcx, [r14+238h]
mov [rcx+rbx*8], rax
mov rdi, [rsp+0A8h+arg_0]
call _strdup
mov rcx, [r14+228h]
mov [rcx+rbx*8], rax
mov rdi, [rsp+0A8h+arg_10]
call _strdup
mov rcx, [r14+230h]
mov [rcx+rbx*8], rax
mov rax, [r14+218h]
mov [rax+rbx*4], r13d
mov rax, [r14+220h]
movsxd rcx, dword ptr [r14+210h]
mov edx, [rsp+0A8h+var_9C]
mov [rax+rcx*4], edx
mov edi, 18h
call _malloc
mov rbp, rax
mov rdi, r12; this
call _ZNK12LefDefParser14defiGeometries9numPointsEv; LefDefParser::defiGeometries::numPoints(void)
mov [rbp+0], eax
movsxd r14, eax
lea r15, ds:0[r14*4]
mov rdi, r15
call _malloc
mov rbx, r12
mov r12, rax
mov [rbp+8], rax
mov rdi, r15
call _malloc
mov [rsp+0A8h+var_A8], rbp
mov [rbp+10h], rax
test r14d, r14d
jle short loc_2480C
mov r13, rax
xor ebp, ebp
lea r15, [rsp+0A8h+var_98]
loc_247E1:
mov rdi, rbx; this
mov esi, ebp; int
lea rdx, [rsp+0A8h+var_94]; int *
mov rcx, r15; int *
call _ZNK12LefDefParser14defiGeometries6pointsEiPiS1_; LefDefParser::defiGeometries::points(int,int *,int *)
mov eax, [rsp+0A8h+var_94]
mov [r12+rbp*4], eax
mov eax, [rsp+0A8h+var_98]
mov [r13+rbp*4+0], eax
inc rbp
cmp rbp, r14
jl short loc_247E1
loc_2480C:
mov rdx, [rsp+0A8h+var_60]
mov rax, [rdx+200h]
movsxd rcx, dword ptr [rdx+210h]
mov rsi, [rsp+0A8h+var_A8]
mov [rax+rcx*8], rsi
lea eax, [rcx+1]
mov [rdx+210h], eax
cmp eax, 3E8h
jnz short loc_24842
mov rax, [rsp+0A8h+var_48]
mov dword ptr [rax], 1
loc_24842:
add rsp, 78h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
int * LefDefParser::defiNet::addPts(
LefDefParser::defiNet *this,
const char *a2,
int a3,
LefDefParser::defiGeometries *a4,
int *a5,
int a6,
const char *a7,
const char *a8,
const char *a9)
{
LefDefParser::defiGeometries *v9; // r12
int v10; // r13d
LefDefParser::defiNet *v11; // r14
long long v12; // r15
bool v13; // zf
int v14; // ecx
long long v15; // r12
long long v16; // rbx
long long v17; // rax
long long v18; // rdi
long long v19; // rdx
long long v20; // rsi
long long v21; // r8
long long v22; // r9
long long v23; // r15
long long v24; // r10
long long v25; // r13
long long v26; // rbp
long long v27; // rbx
long long v28; // r12
long long v29; // r14
long long v30; // rcx
long long v31; // rbp
long long v32; // rcx
long long v33; // rdi
long long v34; // rdi
long long v35; // r13
long long v36; // rbp
long long v37; // rbx
long long v38; // r12
long long v39; // rdi
long long v40; // rdi
long long v41; // rdi
long long v42; // rdi
long long v43; // rbp
int v44; // eax
long long v45; // r14
long long v46; // r15
LefDefParser::defiGeometries *v47; // rbx
long long v48; // r12
long long v49; // rax
long long v50; // r13
long long i; // rbp
LefDefParser::defiNet *v52; // rdx
long long v53; // rcx
int *result; // rax
long long v55; // [rsp+0h] [rbp-A8h]
long long v56; // [rsp+0h] [rbp-A8h]
int v59; // [rsp+10h] [rbp-98h] BYREF
int v60; // [rsp+14h] [rbp-94h] BYREF
long long v61; // [rsp+18h] [rbp-90h]
long long v62; // [rsp+20h] [rbp-88h]
long long v63; // [rsp+28h] [rbp-80h]
long long v64; // [rsp+30h] [rbp-78h]
long long v65; // [rsp+38h] [rbp-70h]
long long v66; // [rsp+40h] [rbp-68h]
LefDefParser::defiNet *v67; // [rsp+48h] [rbp-60h]
const char *v68; // [rsp+50h] [rbp-58h]
LefDefParser::defiGeometries *v69; // [rsp+58h] [rbp-50h]
int *v70; // [rsp+60h] [rbp-48h]
long long v71; // [rsp+68h] [rbp-40h]
long long v72; // [rsp+70h] [rbp-38h]
v9 = a4;
v10 = a3;
v11 = this;
*a5 = 0;
v12 = *((unsigned int *)this + 132);
v13 = (_DWORD)v12 == *((_DWORD *)this + 133);
v70 = a5;
v67 = this;
if ( !v13 )
{
v31 = *((_QWORD *)this + 65);
goto LABEL_24;
}
v68 = a2;
v69 = a4;
v14 = 1000;
if ( (_DWORD)v12 )
v14 = 2 * v12;
*((_DWORD *)this + 133) = v14;
v15 = v14;
v16 = 8LL * v14;
v66 = malloc(v16);
v65 = malloc(v16);
v64 = malloc(v16);
v63 = malloc(v16);
v15 *= 4LL;
v62 = malloc(v15);
v61 = malloc(v16);
v17 = malloc(v15);
v18 = *((_QWORD *)this + 64);
v55 = v17;
if ( (int)v12 > 0 )
{
v72 = *((_QWORD *)v11 + 65);
v71 = *((_QWORD *)v11 + 67);
v19 = *((_QWORD *)v11 + 69);
v20 = *((_QWORD *)v11 + 71);
v21 = *((_QWORD *)v11 + 70);
v22 = *((_QWORD *)v11 + 68);
v23 = 4 * v12;
v24 = 0LL;
v25 = v66;
v26 = v65;
v27 = v64;
v28 = v63;
v29 = v62;
v30 = v61;
do
{
*(_QWORD *)(v30 + 2 * v24) = *(_QWORD *)(v18 + 2 * v24);
*(_QWORD *)(v25 + 2 * v24) = *(_QWORD *)(v72 + 2 * v24);
*(_QWORD *)(v26 + 2 * v24) = *(_QWORD *)(v19 + 2 * v24);
*(_QWORD *)(v27 + 2 * v24) = *(_QWORD *)(v20 + 2 * v24);
*(_QWORD *)(v28 + 2 * v24) = *(_QWORD *)(v21 + 2 * v24);
*(_DWORD *)(v29 + v24) = *(_DWORD *)(v71 + v24);
*(_DWORD *)(v17 + v24) = *(_DWORD *)(v22 + v24);
v24 += 4LL;
}
while ( v23 != v24 );
goto LABEL_10;
}
v32 = v17;
if ( v18 )
{
LABEL_10:
free(v18);
v32 = v55;
}
v11 = v67;
v33 = *((_QWORD *)v67 + 65);
if ( v33 )
{
free(v33);
v32 = v55;
}
v34 = *((_QWORD *)v67 + 67);
v12 = v66;
v35 = v65;
v36 = v64;
v37 = v63;
v38 = v62;
if ( v34 )
{
free(v34);
v32 = v55;
}
v39 = *((_QWORD *)v67 + 68);
if ( v39 )
{
free(v39);
v32 = v55;
}
v40 = *((_QWORD *)v67 + 69);
if ( v40 )
{
free(v40);
v32 = v55;
}
v41 = *((_QWORD *)v67 + 71);
if ( v41 )
{
free(v41);
v32 = v55;
}
v42 = *((_QWORD *)v67 + 70);
if ( v42 )
{
free(v42);
v32 = v55;
}
*((_QWORD *)v67 + 64) = v61;
*((_QWORD *)v11 + 65) = v12;
*((_QWORD *)v11 + 67) = v38;
*((_QWORD *)v11 + 68) = v32;
*((_QWORD *)v11 + 71) = v36;
*((_QWORD *)v11 + 69) = v35;
*((_QWORD *)v11 + 70) = v37;
v31 = v12;
LODWORD(v12) = *((_DWORD *)v11 + 132);
v9 = v69;
v10 = a3;
a2 = v68;
LABEL_24:
*(_QWORD *)(v31 + 8LL * (int)v12) = strdup(a2);
*(_QWORD *)(*((_QWORD *)v11 + 71) + 8LL * (int)v12) = strdup(a8);
*(_QWORD *)(*((_QWORD *)v11 + 69) + 8LL * (int)v12) = strdup(a7);
*(_QWORD *)(*((_QWORD *)v11 + 70) + 8LL * (int)v12) = strdup(a9);
*(_DWORD *)(*((_QWORD *)v11 + 67) + 4LL * (int)v12) = v10;
*(_DWORD *)(*((_QWORD *)v11 + 68) + 4LL * *((int *)v11 + 132)) = a6;
v43 = malloc(24LL);
v44 = LefDefParser::defiGeometries::numPoints(v9);
*(_DWORD *)v43 = v44;
v45 = v44;
v46 = 4LL * v44;
v47 = v9;
v48 = malloc(v46);
*(_QWORD *)(v43 + 8) = v48;
v49 = malloc(v46);
v56 = v43;
*(_QWORD *)(v43 + 16) = v49;
if ( (int)v45 > 0 )
{
v50 = v49;
for ( i = 0LL; i < v45; ++i )
{
LefDefParser::defiGeometries::points(v47, i, &v60, &v59);
*(_DWORD *)(v48 + 4 * i) = v60;
*(_DWORD *)(v50 + 4 * i) = v59;
}
}
v52 = v67;
v53 = *((int *)v67 + 132);
*(_QWORD *)(*((_QWORD *)v67 + 64) + 8 * v53) = v56;
result = (int *)(unsigned int)(v53 + 1);
*((_DWORD *)v52 + 132) = (_DWORD)result;
if ( (_DWORD)v53 == 999 )
{
result = v70;
*v70 = 1;
}
return result;
}
|
addPts:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV R12,RCX
MOV R13D,EDX
MOV R14,RDI
MOV dword ptr [R8],0x0
MOV R15D,dword ptr [RDI + 0x210]
CMP R15D,dword ptr [RDI + 0x214]
MOV qword ptr [RSP + 0x60],R8
MOV qword ptr [RSP + 0x48],RDI
MOV dword ptr [RSP + 0xc],R9D
JNZ 0x0012460d
MOV qword ptr [RSP + 0x50],RSI
MOV dword ptr [RSP + 0x8],R13D
MOV qword ptr [RSP + 0x58],R12
LEA EAX,[R15 + R15*0x1]
TEST R15D,R15D
MOV ECX,0x3e8
CMOVNZ ECX,EAX
MOV dword ptr [R14 + 0x214],ECX
MOVSXD R12,ECX
LEA RBX,[R12*0x8]
MOV RDI,RBX
CALL 0x00106270
MOV qword ptr [RSP + 0x40],RAX
MOV RDI,RBX
CALL 0x00106270
MOV qword ptr [RSP + 0x38],RAX
MOV RDI,RBX
CALL 0x00106270
MOV qword ptr [RSP + 0x30],RAX
MOV RDI,RBX
CALL 0x00106270
MOV qword ptr [RSP + 0x28],RAX
SHL R12,0x2
MOV RDI,R12
CALL 0x00106270
MOV qword ptr [RSP + 0x20],RAX
MOV RDI,RBX
CALL 0x00106270
MOV qword ptr [RSP + 0x18],RAX
MOV RDI,R12
CALL 0x00106270
MOV RDI,qword ptr [R14 + 0x200]
TEST R15D,R15D
MOV qword ptr [RSP],RAX
JLE 0x00124619
MOV RAX,qword ptr [R14 + 0x208]
MOV qword ptr [RSP + 0x70],RAX
MOV RAX,qword ptr [R14 + 0x218]
MOV qword ptr [RSP + 0x68],RAX
MOV RDX,qword ptr [R14 + 0x228]
MOV RSI,qword ptr [R14 + 0x238]
MOV R8,qword ptr [R14 + 0x230]
MOV R9,qword ptr [R14 + 0x220]
SHL R15,0x2
XOR R10D,R10D
MOV R13,qword ptr [RSP + 0x40]
MOV RBP,qword ptr [RSP + 0x38]
MOV RBX,qword ptr [RSP + 0x30]
MOV R12,qword ptr [RSP + 0x28]
MOV R14,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x18]
LAB_001245ba:
MOV R11,qword ptr [RDI + R10*0x2]
MOV qword ptr [RCX + R10*0x2],R11
MOV RAX,qword ptr [RSP + 0x70]
MOV R11,qword ptr [RAX + R10*0x2]
MOV qword ptr [R13 + R10*0x2],R11
MOV R11,qword ptr [RDX + R10*0x2]
MOV qword ptr [RBP + R10*0x2],R11
MOV R11,qword ptr [RSI + R10*0x2]
MOV qword ptr [RBX + R10*0x2],R11
MOV R11,qword ptr [R8 + R10*0x2]
MOV qword ptr [R12 + R10*0x2],R11
MOV RAX,qword ptr [RSP + 0x68]
MOV R11D,dword ptr [RAX + R10*0x1]
MOV dword ptr [R14 + R10*0x1],R11D
MOV R11D,dword ptr [R9 + R10*0x1]
MOV RAX,qword ptr [RSP]
MOV dword ptr [RAX + R10*0x1],R11D
ADD R10,0x4
CMP R15,R10
JNZ 0x001245ba
JMP 0x00124621
LAB_0012460d:
MOV RBP,qword ptr [R14 + 0x208]
JMP 0x00124715
LAB_00124619:
MOV RCX,RAX
TEST RDI,RDI
JZ 0x0012462a
LAB_00124621:
CALL 0x00106220
MOV RCX,qword ptr [RSP]
LAB_0012462a:
MOV R14,qword ptr [RSP + 0x48]
MOV RDI,qword ptr [R14 + 0x208]
TEST RDI,RDI
JZ 0x00124644
CALL 0x00106220
MOV RCX,qword ptr [RSP]
LAB_00124644:
MOV RDI,qword ptr [R14 + 0x218]
TEST RDI,RDI
MOV R15,qword ptr [RSP + 0x40]
MOV R13,qword ptr [RSP + 0x38]
MOV RBP,qword ptr [RSP + 0x30]
MOV RBX,qword ptr [RSP + 0x28]
MOV R12,qword ptr [RSP + 0x20]
JZ 0x00124672
CALL 0x00106220
MOV RCX,qword ptr [RSP]
LAB_00124672:
MOV RDI,qword ptr [R14 + 0x220]
TEST RDI,RDI
JZ 0x00124687
CALL 0x00106220
MOV RCX,qword ptr [RSP]
LAB_00124687:
MOV RDI,qword ptr [R14 + 0x228]
TEST RDI,RDI
JZ 0x0012469c
CALL 0x00106220
MOV RCX,qword ptr [RSP]
LAB_0012469c:
MOV RDI,qword ptr [R14 + 0x238]
TEST RDI,RDI
JZ 0x001246b1
CALL 0x00106220
MOV RCX,qword ptr [RSP]
LAB_001246b1:
MOV RDI,qword ptr [R14 + 0x230]
TEST RDI,RDI
JZ 0x001246c6
CALL 0x00106220
MOV RCX,qword ptr [RSP]
LAB_001246c6:
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [R14 + 0x200],RAX
MOV qword ptr [R14 + 0x208],R15
MOV qword ptr [R14 + 0x218],R12
MOV qword ptr [R14 + 0x220],RCX
MOV qword ptr [R14 + 0x238],RBP
MOV qword ptr [R14 + 0x228],R13
MOV qword ptr [R14 + 0x230],RBX
MOV RBP,R15
MOV R15D,dword ptr [R14 + 0x210]
MOV R12,qword ptr [RSP + 0x58]
MOV R13D,dword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x50]
LAB_00124715:
MOV RDI,RSI
CALL 0x00106320
MOVSXD RBX,R15D
MOV qword ptr [RBP + RBX*0x8],RAX
MOV RDI,qword ptr [RSP + 0xb8]
CALL 0x00106320
MOV RCX,qword ptr [R14 + 0x238]
MOV qword ptr [RCX + RBX*0x8],RAX
MOV RDI,qword ptr [RSP + 0xb0]
CALL 0x00106320
MOV RCX,qword ptr [R14 + 0x228]
MOV qword ptr [RCX + RBX*0x8],RAX
MOV RDI,qword ptr [RSP + 0xc0]
CALL 0x00106320
MOV RCX,qword ptr [R14 + 0x230]
MOV qword ptr [RCX + RBX*0x8],RAX
MOV RAX,qword ptr [R14 + 0x218]
MOV dword ptr [RAX + RBX*0x4],R13D
MOV RAX,qword ptr [R14 + 0x220]
MOVSXD RCX,dword ptr [R14 + 0x210]
MOV EDX,dword ptr [RSP + 0xc]
MOV dword ptr [RAX + RCX*0x4],EDX
MOV EDI,0x18
CALL 0x00106270
MOV RBP,RAX
MOV RDI,R12
CALL 0x0011911e
MOV dword ptr [RBP],EAX
MOVSXD R14,EAX
LEA R15,[R14*0x4]
MOV RDI,R15
CALL 0x00106270
MOV RBX,R12
MOV R12,RAX
MOV qword ptr [RBP + 0x8],RAX
MOV RDI,R15
CALL 0x00106270
MOV qword ptr [RSP],RBP
MOV qword ptr [RBP + 0x10],RAX
TEST R14D,R14D
JLE 0x0012480c
MOV R13,RAX
XOR EBP,EBP
LEA R15,[RSP + 0x10]
LAB_001247e1:
MOV RDI,RBX
MOV ESI,EBP
LEA RDX,[RSP + 0x14]
MOV RCX,R15
CALL 0x00119122
MOV EAX,dword ptr [RSP + 0x14]
MOV dword ptr [R12 + RBP*0x4],EAX
MOV EAX,dword ptr [RSP + 0x10]
MOV dword ptr [R13 + RBP*0x4],EAX
INC RBP
CMP RBP,R14
JL 0x001247e1
LAB_0012480c:
MOV RDX,qword ptr [RSP + 0x48]
MOV RAX,qword ptr [RDX + 0x200]
MOVSXD RCX,dword ptr [RDX + 0x210]
MOV RSI,qword ptr [RSP]
MOV qword ptr [RAX + RCX*0x8],RSI
LEA EAX,[RCX + 0x1]
MOV dword ptr [RDX + 0x210],EAX
CMP EAX,0x3e8
JNZ 0x00124842
MOV RAX,qword ptr [RSP + 0x60]
MOV dword ptr [RAX],0x1
LAB_00124842:
ADD RSP,0x78
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* LefDefParser::defiNet::addPts(char const*, int, LefDefParser::defiGeometries*, int*, int, char
const*, char const*, char const*) */
void __thiscall
LefDefParser::defiNet::addPts
(defiNet *this,char *param_1,int param_2,defiGeometries *param_3,int *param_4,int param_5,
char *param_6,char *param_7,char *param_8)
{
size_t sVar1;
long lVar2;
long lVar3;
long lVar4;
void *pvVar5;
void *pvVar6;
void *pvVar7;
void *pvVar8;
int iVar9;
void *pvVar10;
char *pcVar11;
int *piVar12;
void *pvVar13;
long lVar14;
long lVar15;
size_t __size;
uint uVar16;
int local_98;
int local_94;
void *local_90;
void *local_88;
void *local_80;
void *local_78;
void *local_70;
void *local_68;
defiNet *local_60;
char *local_58;
defiGeometries *local_50;
int *local_48;
long local_40;
long local_38;
*param_4 = 0;
uVar16 = *(uint *)(this + 0x210);
local_60 = this;
local_48 = param_4;
if (uVar16 != *(uint *)(this + 0x214)) {
pvVar13 = *(void **)(this + 0x208);
goto LAB_00124715;
}
iVar9 = 1000;
if (uVar16 != 0) {
iVar9 = uVar16 * 2;
}
*(int *)(this + 0x214) = iVar9;
sVar1 = (long)iVar9 * 8;
local_58 = param_1;
local_50 = param_3;
local_68 = malloc(sVar1);
local_70 = malloc(sVar1);
local_78 = malloc(sVar1);
local_80 = malloc(sVar1);
__size = (long)iVar9 << 2;
local_88 = malloc(__size);
local_90 = malloc(sVar1);
pvVar10 = malloc(__size);
pvVar13 = *(void **)(this + 0x200);
if ((int)uVar16 < 1) {
if (pvVar13 != (void *)0x0) goto LAB_00124621;
}
else {
local_38 = *(long *)(this + 0x208);
local_40 = *(long *)(this + 0x218);
lVar14 = *(long *)(this + 0x228);
lVar2 = *(long *)(this + 0x238);
lVar3 = *(long *)(this + 0x230);
lVar4 = *(long *)(this + 0x220);
lVar15 = 0;
do {
*(int8 *)((long)local_90 + lVar15 * 2) = *(int8 *)((long)pvVar13 + lVar15 * 2);
*(int8 *)((long)local_68 + lVar15 * 2) = *(int8 *)(local_38 + lVar15 * 2);
*(int8 *)((long)local_70 + lVar15 * 2) = *(int8 *)(lVar14 + lVar15 * 2);
*(int8 *)((long)local_78 + lVar15 * 2) = *(int8 *)(lVar2 + lVar15 * 2);
*(int8 *)((long)local_80 + lVar15 * 2) = *(int8 *)(lVar3 + lVar15 * 2);
*(int4 *)((long)local_88 + lVar15) = *(int4 *)(local_40 + lVar15);
*(int4 *)((long)pvVar10 + lVar15) = *(int4 *)(lVar4 + lVar15);
lVar15 = lVar15 + 4;
} while ((ulong)uVar16 << 2 != lVar15);
LAB_00124621:
free(pvVar13);
}
this = local_60;
if (*(void **)(local_60 + 0x208) != (void *)0x0) {
free(*(void **)(local_60 + 0x208));
}
pvVar13 = local_68;
pvVar8 = local_70;
pvVar7 = local_78;
pvVar6 = local_80;
pvVar5 = local_88;
if (*(void **)(this + 0x218) != (void *)0x0) {
free(*(void **)(this + 0x218));
}
if (*(void **)(this + 0x220) != (void *)0x0) {
free(*(void **)(this + 0x220));
}
if (*(void **)(this + 0x228) != (void *)0x0) {
free(*(void **)(this + 0x228));
}
if (*(void **)(this + 0x238) != (void *)0x0) {
free(*(void **)(this + 0x238));
}
if (*(void **)(this + 0x230) != (void *)0x0) {
free(*(void **)(this + 0x230));
}
*(void **)(this + 0x200) = local_90;
*(void **)(this + 0x208) = pvVar13;
*(void **)(this + 0x218) = pvVar5;
*(void **)(this + 0x220) = pvVar10;
*(void **)(this + 0x238) = pvVar7;
*(void **)(this + 0x228) = pvVar8;
*(void **)(this + 0x230) = pvVar6;
uVar16 = *(uint *)(this + 0x210);
param_1 = local_58;
param_3 = local_50;
LAB_00124715:
pcVar11 = strdup(param_1);
lVar14 = (long)(int)uVar16;
*(char **)((long)pvVar13 + lVar14 * 8) = pcVar11;
pcVar11 = strdup(param_7);
*(char **)(*(long *)(this + 0x238) + lVar14 * 8) = pcVar11;
pcVar11 = strdup(param_6);
*(char **)(*(long *)(this + 0x228) + lVar14 * 8) = pcVar11;
pcVar11 = strdup(param_8);
*(char **)(*(long *)(this + 0x230) + lVar14 * 8) = pcVar11;
*(int *)(*(long *)(this + 0x218) + lVar14 * 4) = param_2;
*(int *)(*(long *)(this + 0x220) + (long)*(int *)(this + 0x210) * 4) = param_5;
piVar12 = (int *)malloc(0x18);
iVar9 = defiGeometries::numPoints(param_3);
*piVar12 = iVar9;
sVar1 = (long)iVar9 * 4;
pvVar13 = malloc(sVar1);
*(void **)(piVar12 + 2) = pvVar13;
pvVar10 = malloc(sVar1);
*(void **)(piVar12 + 4) = pvVar10;
if (0 < iVar9) {
lVar14 = 0;
do {
defiGeometries::points(param_3,(int)lVar14,&local_94,&local_98);
*(int *)((long)pvVar13 + lVar14 * 4) = local_94;
*(int *)((long)pvVar10 + lVar14 * 4) = local_98;
lVar14 = lVar14 + 1;
} while (lVar14 < iVar9);
}
iVar9 = *(int *)(local_60 + 0x210);
*(int **)(*(long *)(local_60 + 0x200) + (long)iVar9 * 8) = piVar12;
iVar9 = iVar9 + 1;
*(int *)(local_60 + 0x210) = iVar9;
if (iVar9 == 1000) {
*local_48 = 1;
}
return;
}
|
|
8,191 |
mi_ft_cmp
|
eloqsql/storage/myisam/ft_update.c
|
int _mi_ft_cmp(MI_INFO *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("_mi_ft_cmp");
_mi_ft_segiterator_init(info, keynr, rec1, &ftsi1);
_mi_ft_segiterator_init(info, keynr, rec2, &ftsi2);
while (_mi_ft_segiterator(&ftsi1) && _mi_ft_segiterator(&ftsi2))
{
if ((ftsi1.pos != ftsi2.pos) &&
(!ftsi1.pos || !ftsi2.pos ||
ha_compare_text(cs, (uchar*) ftsi1.pos,ftsi1.len,
(uchar*) ftsi2.pos,ftsi2.len,0)))
DBUG_RETURN(THOSE_TWO_DAMN_KEYS_ARE_REALLY_DIFFERENT);
}
DBUG_RETURN(GEE_THEY_ARE_ABSOLUTELY_IDENTICAL);
}
|
O3
|
c
|
mi_ft_cmp:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq (%rdi), %rax
movq 0x218(%rax), %rax
movl %esi, %esi
imulq $0x70, %rsi, %rsi
movq 0x28(%rax,%rsi), %r8
movq (%r8), %rbx
movzwl 0x8(%rax,%rsi), %eax
leaq -0x60(%rbp), %rdi
movl %eax, (%rdi)
movq %r8, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
xorl %r14d, %r14d
movq %r14, 0x18(%rdi)
movl %r14d, 0x4(%rdi)
movl %eax, -0x40(%rbp)
movq %r8, -0x38(%rbp)
movq %rcx, -0x30(%rbp)
movq %r14, -0x28(%rbp)
movl %r14d, -0x3c(%rbp)
callq 0x756de
testl %eax, %eax
je 0x759b4
leaq -0x40(%rbp), %r15
leaq -0x60(%rbp), %r12
movq %r15, %rdi
callq 0x756de
testl %eax, %eax
je 0x759b1
movq -0x48(%rbp), %rsi
movq -0x28(%rbp), %rcx
cmpq %rcx, %rsi
je 0x759a5
movl $0x1, %r14d
testq %rsi, %rsi
je 0x759b4
testq %rcx, %rcx
je 0x759b4
movl -0x5c(%rbp), %edx
movl -0x3c(%rbp), %r8d
movq %rbx, %rdi
xorl %r9d, %r9d
callq 0xa3148
testl %eax, %eax
jne 0x759b4
movq %r12, %rdi
callq 0x756de
testl %eax, %eax
jne 0x75966
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
_mi_ft_cmp:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 40h
mov rax, [rdi]
mov rax, [rax+218h]
mov esi, esi
imul rsi, 70h ; 'p'
mov r8, [rax+rsi+28h]
mov rbx, [r8]
movzx eax, word ptr [rax+rsi+8]
lea rdi, [rbp+var_60]
mov [rdi], eax
mov [rdi+8], r8
mov [rdi+10h], rdx
xor r14d, r14d
mov [rdi+18h], r14
mov [rdi+4], r14d
mov [rbp+var_40], eax
mov [rbp+var_38], r8
mov [rbp+var_30], rcx
mov [rbp+var_28], r14
mov [rbp+var_3C], r14d
call _mi_ft_segiterator
test eax, eax
jz short loc_759B4
lea r15, [rbp+var_40]
lea r12, [rbp+var_60]
loc_75966:
mov rdi, r15
call _mi_ft_segiterator
test eax, eax
jz short loc_759B1
mov rsi, [rbp+var_48]
mov rcx, [rbp+var_28]
cmp rsi, rcx
jz short loc_759A5
mov r14d, 1
test rsi, rsi
jz short loc_759B4
test rcx, rcx
jz short loc_759B4
mov edx, [rbp+var_5C]
mov r8d, [rbp+var_3C]
mov rdi, rbx
xor r9d, r9d
call ha_compare_text
test eax, eax
jnz short loc_759B4
loc_759A5:
mov rdi, r12
call _mi_ft_segiterator
test eax, eax
jnz short loc_75966
loc_759B1:
xor r14d, r14d
loc_759B4:
mov eax, r14d
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long mi_ft_cmp(long long a1, unsigned int a2, long long a3, long long a4)
{
long long v4; // rax
long long v5; // rsi
_QWORD *v6; // r8
long long v7; // rbx
unsigned int v8; // r14d
int v10; // [rsp+0h] [rbp-60h] BYREF
unsigned int v11; // [rsp+4h] [rbp-5Ch]
_QWORD *v12; // [rsp+8h] [rbp-58h]
long long v13; // [rsp+10h] [rbp-50h]
long long v14; // [rsp+18h] [rbp-48h]
int v15; // [rsp+20h] [rbp-40h] BYREF
unsigned int v16; // [rsp+24h] [rbp-3Ch]
_QWORD *v17; // [rsp+28h] [rbp-38h]
long long v18; // [rsp+30h] [rbp-30h]
long long v19; // [rsp+38h] [rbp-28h]
v4 = *(_QWORD *)(*(_QWORD *)a1 + 536LL);
v5 = 112LL * a2;
v6 = *(_QWORD **)(v4 + v5 + 40);
v7 = *v6;
v10 = *(unsigned __int16 *)(v4 + v5 + 8);
v12 = v6;
v13 = a3;
v8 = 0;
v14 = 0LL;
v11 = 0;
v15 = v10;
v17 = v6;
v18 = a4;
v19 = 0LL;
v16 = 0;
if ( (unsigned int)mi_ft_segiterator((long long)&v10) )
{
do
{
if ( !(unsigned int)mi_ft_segiterator((long long)&v15) )
break;
if ( v14 != v19 )
{
v8 = 1;
if ( !v14 || !v19 || (unsigned int)ha_compare_text(v7, v14, v11, v19, v16, 0LL) )
return v8;
}
}
while ( (unsigned int)mi_ft_segiterator((long long)&v10) );
return 0;
}
return v8;
}
|
_mi_ft_cmp:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x218]
MOV ESI,ESI
IMUL RSI,RSI,0x70
MOV R8,qword ptr [RAX + RSI*0x1 + 0x28]
MOV RBX,qword ptr [R8]
MOVZX EAX,word ptr [RAX + RSI*0x1 + 0x8]
LEA RDI,[RBP + -0x60]
MOV dword ptr [RDI],EAX
MOV qword ptr [RDI + 0x8],R8
MOV qword ptr [RDI + 0x10],RDX
XOR R14D,R14D
MOV qword ptr [RDI + 0x18],R14
MOV dword ptr [RDI + 0x4],R14D
MOV dword ptr [RBP + -0x40],EAX
MOV qword ptr [RBP + -0x38],R8
MOV qword ptr [RBP + -0x30],RCX
MOV qword ptr [RBP + -0x28],R14
MOV dword ptr [RBP + -0x3c],R14D
CALL 0x001756de
TEST EAX,EAX
JZ 0x001759b4
LEA R15,[RBP + -0x40]
LEA R12,[RBP + -0x60]
LAB_00175966:
MOV RDI,R15
CALL 0x001756de
TEST EAX,EAX
JZ 0x001759b1
MOV RSI,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x28]
CMP RSI,RCX
JZ 0x001759a5
MOV R14D,0x1
TEST RSI,RSI
JZ 0x001759b4
TEST RCX,RCX
JZ 0x001759b4
MOV EDX,dword ptr [RBP + -0x5c]
MOV R8D,dword ptr [RBP + -0x3c]
MOV RDI,RBX
XOR R9D,R9D
CALL 0x001a3148
TEST EAX,EAX
JNZ 0x001759b4
LAB_001759a5:
MOV RDI,R12
CALL 0x001756de
TEST EAX,EAX
JNZ 0x00175966
LAB_001759b1:
XOR R14D,R14D
LAB_001759b4:
MOV EAX,R14D
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int8 _mi_ft_cmp(long *param_1,uint param_2,int8 param_3,int8 param_4)
{
int8 uVar1;
int iVar2;
uint local_68;
int4 local_64;
int8 *local_60;
int8 local_58;
long local_50;
uint local_48;
int4 local_44;
int8 *local_40;
int8 local_38;
long local_30;
local_60 = *(int8 **)(*(long *)(*param_1 + 0x218) + 0x28 + (ulong)param_2 * 0x70);
uVar1 = *local_60;
local_68 = (uint)*(ushort *)(*(long *)(*param_1 + 0x218) + 8 + (ulong)param_2 * 0x70);
local_50 = 0;
local_64 = 0;
local_30 = 0;
local_44 = 0;
local_58 = param_3;
local_48 = local_68;
local_40 = local_60;
local_38 = param_4;
iVar2 = _mi_ft_segiterator();
if (iVar2 != 0) {
do {
iVar2 = _mi_ft_segiterator(&local_48);
if (iVar2 == 0) {
return 0;
}
if (local_50 != local_30) {
if (local_50 == 0) {
return 1;
}
if (local_30 == 0) {
return 1;
}
iVar2 = ha_compare_text(uVar1,local_50,local_64,local_30,local_44,0);
if (iVar2 != 0) {
return 1;
}
}
iVar2 = _mi_ft_segiterator(&local_68);
} while (iVar2 != 0);
}
return 0;
}
|
|
8,192 |
bool nlohmann::json_abi_v3_11_3::operator!=<bool, 0>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, bool)
|
monkey531[P]llama/common/json.hpp
|
bool operator!=(const_reference lhs, ScalarType rhs) noexcept
{
return lhs != basic_json(rhs);
}
|
O3
|
cpp
|
bool nlohmann::json_abi_v3_11_3::operator!=<bool, 0>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, bool):
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq %r14, %rdi
callq 0x6dcce
movq %r14, %rdi
movl $0x1, %esi
callq 0x66666
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb931d
movl %eax, %ebx
movq %r14, %rdi
xorl %esi, %esi
callq 0x66666
movq %r14, %rdi
callq 0x6bb54
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
|
_ZN8nlohmann16json_abi_v3_11_3neIbTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES3_:
push r14
push rbx
sub rsp, 18h
mov rbx, rdi
xorps xmm0, xmm0
mov r14, rsp
movaps xmmword ptr [r14], xmm0
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE4EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_9boolean_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)4>::construct<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> &,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 rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_3neERKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEESF_; nlohmann::json_abi_v3_11_3::operator!=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov ebx, eax
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov eax, ebx
add rsp, 18h
pop rbx
pop r14
retn
|
long long ZN8nlohmann16json_abi_v3_11_3neIbTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES3_(
unsigned __int8 *a1,
unsigned __int8 a2)
{
unsigned int v2; // eax
unsigned int v3; // ebx
_OWORD v5[2]; // [rsp+0h] [rbp-28h] BYREF
v5[0] = 0LL;
nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)4>::construct<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>>(
(unsigned __int8 *)v5,
a2);
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 *)v5);
LOBYTE(v2) = nlohmann::json_abi_v3_11_3::operator!=(a1, (unsigned __int8 *)v5, (__m128d)0LL);
v3 = v2;
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 *)v5);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v5);
return v3;
}
|
_ZN8nlohmann16json_abi_v3_11_3neIbTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES3_:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
XORPS XMM0,XMM0
MOV R14,RSP
MOVAPS xmmword ptr [R14],XMM0
MOV RDI,R14
CALL 0x0016dcce
MOV RDI,R14
MOV ESI,0x1
CALL 0x00166666
MOV RDI,RBX
MOV RSI,R14
CALL 0x001b931d
MOV EBX,EAX
MOV RDI,R14
XOR ESI,ESI
CALL 0x00166666
MOV RDI,R14
CALL 0x0016bb54
MOV EAX,EBX
ADD RSP,0x18
POP RBX
POP R14
RET
|
int4
_ZN8nlohmann16json_abi_v3_11_3neIbTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES3_
(basic_json *param_1)
{
int4 uVar1;
int8 local_28;
int8 uStack_20;
local_28 = 0;
uStack_20 = 0;
nlohmann::json_abi_v3_11_3::detail::
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)4>::
construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(&local_28);
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(&local_28,0));
uVar1 = nlohmann::json_abi_v3_11_3::operator!=(param_1,(basic_json *)&local_28);
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(&local_28,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_28);
return uVar1;
}
|
|
8,193 |
my_coll_rules_realloc
|
eloqsql/strings/ctype-uca.c
|
static int
my_coll_rules_realloc(MY_COLL_RULES *rules, size_t n)
{
if (rules->nrules < rules->mrules ||
(rules->rule= rules->loader->realloc(rules->rule,
sizeof(MY_COLL_RULE) *
(rules->mrules= n + 128))))
return 0;
return -1;
}
|
O0
|
c
|
my_coll_rules_realloc:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jb 0xb20c3
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x90(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rdi
movq -0x18(%rbp), %rcx
addq $0x80, %rcx
movq -0x10(%rbp), %rdx
movq %rcx, 0x18(%rdx)
imulq $0xa0, %rcx, %rsi
callq *%rax
movq -0x10(%rbp), %rcx
movq %rax, 0x20(%rcx)
cmpq $0x0, %rax
je 0xb20cc
movl $0x0, -0x4(%rbp)
jmp 0xb20d3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
|
my_coll_rules_realloc:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov rcx, [rbp+var_10]
cmp rax, [rcx+18h]
jb short loc_B20C3
mov rax, [rbp+var_10]
mov rax, [rax+28h]
mov rax, [rax+90h]
mov rcx, [rbp+var_10]
mov rdi, [rcx+20h]
mov rcx, [rbp+var_18]
add rcx, 80h
mov rdx, [rbp+var_10]
mov [rdx+18h], rcx
imul rsi, rcx, 0A0h
call rax
mov rcx, [rbp+var_10]
mov [rcx+20h], rax
cmp rax, 0
jz short loc_B20CC
loc_B20C3:
mov [rbp+var_4], 0
jmp short loc_B20D3
loc_B20CC:
mov [rbp+var_4], 0FFFFFFFFh
loc_B20D3:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
|
long long my_coll_rules_realloc(_QWORD *a1, long long a2)
{
long long ( *v2)(long long, long long); // rax
long long v3; // rdi
long long v4; // rax
if ( a1[2] < a1[3] )
return 0;
v2 = *(long long ( **)(long long, long long))(a1[5] + 144LL);
v3 = a1[4];
a1[3] = a2 + 128;
v4 = v2(v3, 160 * (a2 + 128));
if ( (a1[4] = v4) != 0LL )
return 0;
else
return (unsigned int)-1;
}
|
my_coll_rules_realloc:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x18]
JC 0x001b20c3
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x28]
MOV RAX,qword ptr [RAX + 0x90]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RCX + 0x20]
MOV RCX,qword ptr [RBP + -0x18]
ADD RCX,0x80
MOV RDX,qword ptr [RBP + -0x10]
MOV qword ptr [RDX + 0x18],RCX
IMUL RSI,RCX,0xa0
CALL RAX
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x20],RAX
CMP RAX,0x0
JZ 0x001b20cc
LAB_001b20c3:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001b20d3
LAB_001b20cc:
MOV dword ptr [RBP + -0x4],0xffffffff
LAB_001b20d3:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 my_coll_rules_realloc(long param_1,long param_2)
{
code *pcVar1;
long lVar2;
if (*(ulong *)(param_1 + 0x18) <= *(ulong *)(param_1 + 0x10)) {
pcVar1 = *(code **)(*(long *)(param_1 + 0x28) + 0x90);
*(long *)(param_1 + 0x18) = param_2 + 0x80;
lVar2 = (*pcVar1)(*(int8 *)(param_1 + 0x20),(param_2 + 0x80) * 0xa0);
*(long *)(param_1 + 0x20) = lVar2;
if (lVar2 == 0) {
return 0xffffffff;
}
}
return 0;
}
|
|
8,194 |
js_typed_array___speciesCreate
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_typed_array___speciesCreate(JSContext *ctx,
JSValue this_val,
int argc, JSValue *argv)
{
JSValue obj;
JSObject *p;
JSValue ctor, ret;
int argc1;
obj = argv[0];
p = get_typed_array(ctx, obj);
if (!p)
return JS_EXCEPTION;
ctor = JS_SpeciesConstructor(ctx, obj, JS_UNDEFINED);
if (JS_IsException(ctor))
return ctor;
argc1 = max_int(argc - 1, 0);
if (JS_IsUndefined(ctor)) {
ret = js_typed_array_constructor(ctx, JS_UNDEFINED, argc1, argv + 1,
p->class_id);
} else {
ret = js_typed_array_create(ctx, ctor, argc1, argv + 1);
JS_FreeValue(ctx, ctor);
}
return ret;
}
|
O0
|
c
|
js_typed_array___speciesCreate:
subq $0xc8, %rsp
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xb0(%rsp)
movq %rdi, 0xa0(%rsp)
movl %ecx, 0x9c(%rsp)
movq %r8, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x80(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x88(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rdx
callq 0x58940
movq %rax, 0x78(%rsp)
cmpq $0x0, 0x78(%rsp)
jne 0xce453
movl $0x0, 0xb8(%rsp)
movq $0x6, 0xc0(%rsp)
jmp 0xce5db
movq 0xa0(%rsp), %rdi
movl $0x0, 0x30(%rsp)
movq $0x3, 0x38(%rsp)
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %r8
callq 0x74810
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x68(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0xce4dc
movq 0x68(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0xc0(%rsp)
jmp 0xce5db
movl 0x9c(%rsp), %edi
subl $0x1, %edi
xorl %esi, %esi
callq 0x5d310
movl %eax, 0x54(%rsp)
movq 0x68(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x2e260
cmpl $0x0, %eax
je 0xce567
movq 0xa0(%rsp), %rdi
movl $0x0, 0x10(%rsp)
movq $0x3, 0x18(%rsp)
movl 0x54(%rsp), %ecx
movq 0x90(%rsp), %r8
addq $0x10, %r8
movq 0x78(%rsp), %rax
movzwl 0x6(%rax), %r9d
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x58220
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0xce5c1
movq 0xa0(%rsp), %rdi
movl 0x54(%rsp), %ecx
movq 0x90(%rsp), %r8
addq $0x10, %r8
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
callq 0xce600
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq (%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
callq 0x23c90
movq 0x58(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq 0xb8(%rsp), %rax
movq 0xc0(%rsp), %rdx
addq $0xc8, %rsp
retq
nopw %cs:(%rax,%rax)
|
js_typed_array___speciesCreate:
sub rsp, 0C8h
mov [rsp+0C8h+var_20], rsi
mov [rsp+0C8h+var_18], rdx
mov [rsp+0C8h+var_28], rdi
mov [rsp+0C8h+var_2C], ecx
mov [rsp+0C8h+var_38], r8
mov rax, [rsp+0C8h+var_38]
mov rcx, [rax]
mov [rsp+0C8h+var_48], rcx
mov rax, [rax+8]
mov [rsp+0C8h+var_40], rax
mov rdi, [rsp+0C8h+var_28]
mov rsi, [rsp+0C8h+var_48]
mov rdx, [rsp+0C8h+var_40]
call get_typed_array
mov [rsp+0C8h+var_50], rax
cmp [rsp+0C8h+var_50], 0
jnz short loc_CE453
mov dword ptr [rsp+0C8h+var_10], 0
mov [rsp+0C8h+var_8], 6
jmp loc_CE5DB
loc_CE453:
mov rdi, [rsp+0C8h+var_28]
mov dword ptr [rsp+0C8h+var_98], 0
mov [rsp+0C8h+var_90], 3
mov rsi, [rsp+0C8h+var_48]
mov rdx, [rsp+0C8h+var_40]
mov rcx, [rsp+0C8h+var_98]
mov r8, [rsp+0C8h+var_90]
call JS_SpeciesConstructor
mov [rsp+0C8h+var_88], rax
mov [rsp+0C8h+var_80], rdx
mov rax, [rsp+0C8h+var_88]
mov [rsp+0C8h+var_60], rax
mov rax, [rsp+0C8h+var_80]
mov [rsp+0C8h+var_58], rax
mov rdi, [rsp+0C8h+var_60]
mov rsi, [rsp+0C8h+var_58]
call JS_IsException_1
cmp eax, 0
jz short loc_CE4DC
mov rax, [rsp+0C8h+var_60]
mov [rsp+0C8h+var_10], rax
mov rax, [rsp+0C8h+var_58]
mov [rsp+0C8h+var_8], rax
jmp loc_CE5DB
loc_CE4DC:
mov edi, [rsp+0C8h+var_2C]
sub edi, 1
xor esi, esi
call max_int_0
mov [rsp+0C8h+var_74], eax
mov rdi, [rsp+0C8h+var_60]
mov rsi, [rsp+0C8h+var_58]
call JS_IsUndefined_0
cmp eax, 0
jz short loc_CE567
mov rdi, [rsp+0C8h+var_28]
mov dword ptr [rsp+0C8h+var_B8], 0
mov [rsp+0C8h+var_B0], 3
mov ecx, [rsp+0C8h+var_74]
mov r8, [rsp+0C8h+var_38]
add r8, 10h
mov rax, [rsp+0C8h+var_50]
movzx r9d, word ptr [rax+6]
mov rsi, [rsp+0C8h+var_B8]
mov rdx, [rsp+0C8h+var_B0]
call js_typed_array_constructor
mov [rsp+0C8h+var_A8], rax
mov [rsp+0C8h+var_A0], rdx
mov rax, [rsp+0C8h+var_A8]
mov [rsp+0C8h+var_70], rax
mov rax, [rsp+0C8h+var_A0]
mov [rsp+0C8h+var_68], rax
jmp short loc_CE5C1
loc_CE567:
mov rdi, [rsp+0C8h+var_28]
mov ecx, [rsp+0C8h+var_74]
mov r8, [rsp+0C8h+var_38]
add r8, 10h
mov rsi, [rsp+0C8h+var_60]
mov rdx, [rsp+0C8h+var_58]
call js_typed_array_create
mov [rsp+0C8h+var_C8], rax
mov [rsp+0C8h+var_C0], rdx
mov rax, [rsp+0C8h+var_C8]
mov [rsp+0C8h+var_70], rax
mov rax, [rsp+0C8h+var_C0]
mov [rsp+0C8h+var_68], rax
mov rdi, [rsp+0C8h+var_28]
mov rsi, [rsp+0C8h+var_60]
mov rdx, [rsp+0C8h+var_58]
call JS_FreeValue
loc_CE5C1:
mov rax, [rsp+0C8h+var_70]
mov [rsp+0C8h+var_10], rax
mov rax, [rsp+0C8h+var_68]
mov [rsp+0C8h+var_8], rax
loc_CE5DB:
mov rax, [rsp+0C8h+var_10]
mov rdx, [rsp+0C8h+var_8]
add rsp, 0C8h
retn
|
long long js_typed_array___speciesCreate(
long long a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
int a12,
long long *a13,
long long a14)
{
double v14; // xmm4_8
double v15; // xmm5_8
long long v16; // rdx
double v17; // xmm4_8
double v18; // xmm5_8
long long v20; // [rsp+10h] [rbp-B8h]
_DWORD *v21; // [rsp+30h] [rbp-98h]
_DWORD *v22; // [rsp+40h] [rbp-88h]
unsigned int v23; // [rsp+54h] [rbp-74h]
long long v24; // [rsp+58h] [rbp-70h]
long long v25; // [rsp+70h] [rbp-58h]
long long typed_array; // [rsp+78h] [rbp-50h]
long long v27; // [rsp+80h] [rbp-48h]
long long v28; // [rsp+88h] [rbp-40h]
long long v31; // [rsp+B8h] [rbp-10h]
v27 = *a13;
v28 = a13[1];
typed_array = get_typed_array(a1, *a13, v28, *a13, (long long)a13, a14, a2, a3, a4, a5, a6, a7, a8, a9);
if ( typed_array )
{
LODWORD(v21) = 0;
v22 = JS_SpeciesConstructor(a1, v27, v28, v21, 3u, a2, a3, a4, a5, v14, v15, a8, a9);
v25 = v16;
if ( JS_IsException_1((long long)v22, v16) )
{
return (long long)v22;
}
else
{
v23 = max_int_0(a12 - 1, 0);
if ( JS_IsUndefined_0((long long)v22, v25) )
{
LODWORD(v20) = 0;
return js_typed_array_constructor(
a1,
v20,
3LL,
v23,
a13 + 2,
*(unsigned __int16 *)(typed_array + 6),
a2,
a3,
a4,
a5,
v17,
v18,
a8,
a9);
}
else
{
v24 = js_typed_array_create(a1, v22, v25, v23, a13 + 2);
JS_FreeValue(a1, (long long)v22, v25);
}
return v24;
}
}
else
{
LODWORD(v31) = 0;
}
return v31;
}
|
js_typed_array___speciesCreate:
SUB RSP,0xc8
MOV qword ptr [RSP + 0xa8],RSI
MOV qword ptr [RSP + 0xb0],RDX
MOV qword ptr [RSP + 0xa0],RDI
MOV dword ptr [RSP + 0x9c],ECX
MOV qword ptr [RSP + 0x90],R8
MOV RAX,qword ptr [RSP + 0x90]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP + 0x80],RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x88],RAX
MOV RDI,qword ptr [RSP + 0xa0]
MOV RSI,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [RSP + 0x88]
CALL 0x00158940
MOV qword ptr [RSP + 0x78],RAX
CMP qword ptr [RSP + 0x78],0x0
JNZ 0x001ce453
MOV dword ptr [RSP + 0xb8],0x0
MOV qword ptr [RSP + 0xc0],0x6
JMP 0x001ce5db
LAB_001ce453:
MOV RDI,qword ptr [RSP + 0xa0]
MOV dword ptr [RSP + 0x30],0x0
MOV qword ptr [RSP + 0x38],0x3
MOV RSI,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [RSP + 0x88]
MOV RCX,qword ptr [RSP + 0x30]
MOV R8,qword ptr [RSP + 0x38]
CALL 0x00174810
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],RDX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x68],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x70],RAX
MOV RDI,qword ptr [RSP + 0x68]
MOV RSI,qword ptr [RSP + 0x70]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x001ce4dc
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0xb8],RAX
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0xc0],RAX
JMP 0x001ce5db
LAB_001ce4dc:
MOV EDI,dword ptr [RSP + 0x9c]
SUB EDI,0x1
XOR ESI,ESI
CALL 0x0015d310
MOV dword ptr [RSP + 0x54],EAX
MOV RDI,qword ptr [RSP + 0x68]
MOV RSI,qword ptr [RSP + 0x70]
CALL 0x0012e260
CMP EAX,0x0
JZ 0x001ce567
MOV RDI,qword ptr [RSP + 0xa0]
MOV dword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x3
MOV ECX,dword ptr [RSP + 0x54]
MOV R8,qword ptr [RSP + 0x90]
ADD R8,0x10
MOV RAX,qword ptr [RSP + 0x78]
MOVZX R9D,word ptr [RAX + 0x6]
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x18]
CALL 0x00158220
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x28],RDX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x60],RAX
JMP 0x001ce5c1
LAB_001ce567:
MOV RDI,qword ptr [RSP + 0xa0]
MOV ECX,dword ptr [RSP + 0x54]
MOV R8,qword ptr [RSP + 0x90]
ADD R8,0x10
MOV RSI,qword ptr [RSP + 0x68]
MOV RDX,qword ptr [RSP + 0x70]
CALL 0x001ce600
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],RDX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x60],RAX
MOV RDI,qword ptr [RSP + 0xa0]
MOV RSI,qword ptr [RSP + 0x68]
MOV RDX,qword ptr [RSP + 0x70]
CALL 0x00123c90
LAB_001ce5c1:
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0xb8],RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0xc0],RAX
LAB_001ce5db:
MOV RAX,qword ptr [RSP + 0xb8]
MOV RDX,qword ptr [RSP + 0xc0]
ADD RSP,0xc8
RET
|
int1 [16]
js_typed_array___speciesCreate
(int8 param_1,int8 param_2,int8 param_3,int param_4,int8 *param_5)
{
int8 uVar1;
int iVar2;
int4 uVar3;
long lVar4;
int1 auVar6 [16];
uint uStack_b4;
uint uStack_94;
int8 local_68;
int4 local_10;
int4 uStack_c;
int8 local_8;
int8 uVar5;
uVar5 = *param_5;
uVar1 = param_5[1];
lVar4 = get_typed_array(param_1,uVar5,uVar1);
if (lVar4 == 0) {
local_10 = 0;
local_8 = 6;
}
else {
auVar6 = JS_SpeciesConstructor(param_1,uVar5,uVar1,(ulong)uStack_94 << 0x20,3);
local_8 = auVar6._8_8_;
uVar5 = auVar6._0_8_;
iVar2 = JS_IsException(uVar5,local_8);
if (iVar2 == 0) {
uVar3 = max_int(param_4 + -1,0);
iVar2 = JS_IsUndefined(uVar5,local_8);
if (iVar2 == 0) {
auVar6 = js_typed_array_create(param_1,uVar5,local_8,uVar3,param_5 + 2);
JS_FreeValue(param_1,uVar5,local_8);
}
else {
auVar6 = js_typed_array_constructor
(param_1,(ulong)uStack_b4 << 0x20,3,uVar3,param_5 + 2,
*(int2 *)(lVar4 + 6));
}
local_68 = auVar6._8_8_;
local_10 = auVar6._0_4_;
uStack_c = auVar6._4_4_;
local_8 = local_68;
}
else {
local_10 = auVar6._0_4_;
uStack_c = auVar6._4_4_;
}
}
auVar6._4_4_ = uStack_c;
auVar6._0_4_ = local_10;
auVar6._8_8_ = local_8;
return auVar6;
}
|
|
8,195 |
js_typed_array___speciesCreate
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_typed_array___speciesCreate(JSContext *ctx,
JSValue this_val,
int argc, JSValue *argv)
{
JSValue obj;
JSObject *p;
JSValue ctor, ret;
int argc1;
obj = argv[0];
p = get_typed_array(ctx, obj);
if (!p)
return JS_EXCEPTION;
ctor = JS_SpeciesConstructor(ctx, obj, JS_UNDEFINED);
if (JS_IsException(ctor))
return ctor;
argc1 = max_int(argc - 1, 0);
if (JS_IsUndefined(ctor)) {
ret = js_typed_array_constructor(ctx, JS_UNDEFINED, argc1, argv + 1,
p->class_id);
} else {
ret = js_typed_array_create(ctx, ctor, argc1, argv + 1);
JS_FreeValue(ctx, ctor);
}
return ret;
}
|
O1
|
c
|
js_typed_array___speciesCreate:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movl %esi, %r13d
movq %rdi, %rbx
movq (%rdx), %r15
movq 0x8(%rdx), %r12
movq %r15, 0x10(%rsp)
cmpl $-0x1, %r12d
jne 0x77fdc
movq 0x10(%rsp), %rbp
movzwl 0x6(%rbp), %eax
addl $-0x15, %eax
cmpw $0xc, %ax
jb 0x77fef
leaq 0x2a42e(%rip), %rsi # 0xa2411
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22567
testq %rbp, %rbp
je 0x7806e
movl %r13d, 0xc(%rsp)
movabsq $-0x100000000, %r13 # imm = 0xFFFFFFFF00000000
movl $0x3, %r8d
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x440b7
movq %rdx, %r15
cmpl $0x3, %r15d
je 0x7807c
movq %rax, %r12
cmpl $0x6, %r15d
je 0x7809d
movl 0xc(%rsp), %eax
cmpl $0x2, %eax
movl $0x1, %ecx
cmovgel %eax, %ecx
decl %ecx
addq $0x10, %r14
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %r8
callq 0x780b8
movq %rax, %r14
movq %rdx, %rbp
movq 0x18(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1d8c6
movq %r14, %r12
movq %rbp, %r15
jmp 0x7809d
movl $0x6, %r15d
xorl %r12d, %r12d
xorl %r13d, %r13d
jmp 0x780a0
addq $0x10, %r14
movzwl 0x6(%rbp), %r9d
movl $0x3, %edx
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %r8
callq 0x39038
movq %rax, %r12
movq %rdx, %r15
andq %r12, %r13
movl %r12d, %eax
orq %r13, %rax
movq %r15, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
js_typed_array___speciesCreate:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r14, rdx
mov r13d, esi
mov rbx, rdi
mov r15, [rdx]
mov r12, [rdx+8]
mov [rsp+48h+var_38], r15
cmp r12d, 0FFFFFFFFh
jnz short loc_77FDC
mov rbp, [rsp+48h+var_38]
movzx eax, word ptr [rbp+6]
add eax, 0FFFFFFEBh
cmp ax, 0Ch
jb short loc_77FEF
loc_77FDC:
lea rsi, aNotATypedarray; "not a TypedArray"
xor ebp, ebp
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
loc_77FEF:
test rbp, rbp
jz short loc_7806E
mov [rsp+48h+var_3C], r13d
mov r13, 0FFFFFFFF00000000h
mov r8d, 3
mov rdi, rbx
mov rsi, r15
mov rdx, r12
xor ecx, ecx
call JS_SpeciesConstructor
mov r15, rdx
cmp r15d, 3
jz short loc_7807C
mov r12, rax
cmp r15d, 6
jz short loc_7809D
mov eax, [rsp+48h+var_3C]
cmp eax, 2
mov ecx, 1
cmovge ecx, eax
dec ecx
add r14, 10h
mov rdi, rbx
mov rsi, r12
mov rdx, r15
mov r8, r14
call js_typed_array_create
mov r14, rax
mov rbp, rdx
mov rdi, [rbx+18h]
mov rsi, r12
mov rdx, r15
call JS_FreeValueRT
mov r12, r14
mov r15, rbp
jmp short loc_7809D
loc_7806E:
mov r15d, 6
xor r12d, r12d
xor r13d, r13d
jmp short loc_780A0
loc_7807C:
add r14, 10h
movzx r9d, word ptr [rbp+6]
mov edx, 3
mov rdi, rbx
xor esi, esi
mov r8, r14
call js_typed_array_constructor
mov r12, rax
mov r15, rdx
loc_7809D:
and r13, r12
loc_780A0:
mov eax, r12d
or rax, r13
mov rdx, r15
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
unsigned long long js_typed_array___speciesCreate(
long long a1,
int 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; // r12
long long v17; // rbp
_DWORD *v18; // rax
long long v19; // rdx
long long v20; // rcx
double v21; // xmm4_8
double v22; // xmm5_8
long long v23; // r15
unsigned long long v24; // r12
int v25; // ecx
long long v26; // r14
unsigned long long v27; // r13
char v29; // [rsp+0h] [rbp-48h]
v15 = *a3;
v16 = a3[1];
if ( (_DWORD)v16 != -1 || (v17 = *a3, (unsigned __int16)(*(_WORD *)(*a3 + 6) - 21) >= 0xCu) )
{
v17 = 0LL;
JS_ThrowTypeError(
a1,
(long long)"not a TypedArray",
(long long)a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v29);
}
if ( v17 )
{
v18 = JS_SpeciesConstructor(a1, v15, v16, 0LL, 3LL, a6, a7, a8, a9, a10, a11, a12, a13, a14);
v23 = v19;
if ( (_DWORD)v19 == 3 )
{
v24 = js_typed_array_constructor(
a1,
0LL,
3LL,
a7,
a8,
a9,
a10,
v21,
v22,
a13,
a14,
v20,
a3 + 2,
*(unsigned __int16 *)(v17 + 6));
}
else
{
v24 = (unsigned long long)v18;
if ( (_DWORD)v19 != 6 )
{
v25 = 1;
if ( a2 >= 2 )
v25 = a2;
v26 = js_typed_array_create(a1, v18, v19, (unsigned int)(v25 - 1), a3 + 2);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), (_DWORD *)v24, v23);
v24 = v26;
}
}
v27 = v24 & 0xFFFFFFFF00000000LL;
}
else
{
LODWORD(v24) = 0;
v27 = 0LL;
}
return v27 | (unsigned int)v24;
}
| |||
8,196 |
js_typed_array___speciesCreate
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_typed_array___speciesCreate(JSContext *ctx,
JSValue this_val,
int argc, JSValue *argv)
{
JSValue obj;
JSObject *p;
JSValue ctor, ret;
int argc1;
obj = argv[0];
p = get_typed_array(ctx, obj);
if (!p)
return JS_EXCEPTION;
ctor = JS_SpeciesConstructor(ctx, obj, JS_UNDEFINED);
if (JS_IsException(ctor))
return ctor;
argc1 = max_int(argc - 1, 0);
if (JS_IsUndefined(ctor)) {
ret = js_typed_array_constructor(ctx, JS_UNDEFINED, argc1, argv + 1,
p->class_id);
} else {
ret = js_typed_array_create(ctx, ctor, argc1, argv + 1);
JS_FreeValue(ctx, ctor);
}
return ret;
}
|
O2
|
c
|
js_typed_array___speciesCreate:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r15
movq (%rdx), %rbx
movq 0x8(%rdx), %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3280b
testq %rax, %rax
je 0x64f1d
movq %rax, %r13
movl %ebp, 0x4(%rsp)
movabsq $-0x100000000, %rbp # imm = 0xFFFFFFFF00000000
pushq $0x3
popq %r8
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x3bad8
movq %rax, %r14
movq %rdx, %rbx
movl %ebx, %eax
cmpq $0x6, %rax
je 0x64f61
addq $0x10, %r12
cmpl $0x3, %eax
jne 0x64f27
movzwl 0x6(%r13), %r9d
pushq $0x3
popq %rdx
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %r8
callq 0x32165
movq %rax, %r14
movq %rdx, %rbx
jmp 0x64f61
pushq $0x6
popq %rbx
xorl %r14d, %r14d
xorl %ebp, %ebp
jmp 0x64f64
movl 0x4(%rsp), %eax
cmpl $0x2, %eax
pushq $0x1
popq %rcx
cmovgel %eax, %ecx
decl %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %r8
callq 0x64f7c
movq %rax, %r12
movq %rdx, %r13
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1801e
movq %r12, %r14
movq %r13, %rbx
andq %r14, %rbp
movl %r14d, %eax
orq %rbp, %rax
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
js_typed_array___speciesCreate:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r12, rdx
mov ebp, esi
mov r15, rdi
mov rbx, [rdx]
mov r14, [rdx+8]
mov rsi, rbx
mov rdx, r14
call get_typed_array
test rax, rax
jz short loc_64F1D
mov r13, rax
mov [rsp+38h+var_34], ebp
mov rbp, 0FFFFFFFF00000000h
push 3
pop r8
mov rdi, r15
mov rsi, rbx
mov rdx, r14
xor ecx, ecx
call JS_SpeciesConstructor
mov r14, rax
mov rbx, rdx
mov eax, ebx
cmp rax, 6
jz short loc_64F61
add r12, 10h
cmp eax, 3
jnz short loc_64F27
movzx r9d, word ptr [r13+6]
push 3
pop rdx
mov rdi, r15
xor esi, esi
mov r8, r12
call js_typed_array_constructor
mov r14, rax
mov rbx, rdx
jmp short loc_64F61
loc_64F1D:
push 6
pop rbx
xor r14d, r14d
xor ebp, ebp
jmp short loc_64F64
loc_64F27:
mov eax, [rsp+38h+var_34]
cmp eax, 2
push 1
pop rcx
cmovge ecx, eax
dec ecx
mov rdi, r15
mov rsi, r14
mov rdx, rbx
mov r8, r12
call js_typed_array_create
mov r12, rax
mov r13, rdx
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call JS_FreeValue
mov r14, r12
mov rbx, r13
loc_64F61:
and rbp, r14
loc_64F64:
mov eax, r14d
or rax, rbp
mov rdx, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
unsigned long long js_typed_array___speciesCreate(
long long a1,
int 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; // rbx
long long v16; // r14
long long typed_array; // rax
long long v18; // r9
__m128 v19; // xmm4
__m128 v20; // xmm5
long long v21; // r13
long long v22; // rdx
long long v23; // rcx
long long v24; // r14
double v25; // xmm4_8
double v26; // xmm5_8
long long v27; // rbx
long long v28; // r12
unsigned long long v29; // rbp
int v30; // ecx
long long v31; // r12
v15 = *a3;
v16 = a3[1];
typed_array = get_typed_array(a1, *a3, v16, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
if ( typed_array )
{
v21 = typed_array;
v24 = (long long)JS_SpeciesConstructor(a1, v15, v16, 0LL, 3LL, v18, a7, a8, a9, a10, v19, v20, a13, a14);
v27 = v22;
if ( (unsigned int)v22 != 6LL )
{
v28 = (long long)(a3 + 2);
if ( (_DWORD)v22 == 3 )
{
v24 = js_typed_array_constructor(
a1,
0LL,
3LL,
a7,
a8,
a9,
a10,
v25,
v26,
a13,
a14,
v23,
v28,
*(unsigned __int16 *)(v21 + 6));
}
else
{
v30 = 1;
if ( a2 >= 2 )
v30 = a2;
v31 = js_typed_array_create(a1, v24, v22, (unsigned int)(v30 - 1), v28);
JS_FreeValue(a1, v24, v27);
v24 = v31;
}
}
v29 = v24 & 0xFFFFFFFF00000000LL;
}
else
{
LODWORD(v24) = 0;
v29 = 0LL;
}
return v29 | (unsigned int)v24;
}
|
js_typed_array___speciesCreate:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R12,RDX
MOV EBP,ESI
MOV R15,RDI
MOV RBX,qword ptr [RDX]
MOV R14,qword ptr [RDX + 0x8]
MOV RSI,RBX
MOV RDX,R14
CALL 0x0013280b
TEST RAX,RAX
JZ 0x00164f1d
MOV R13,RAX
MOV dword ptr [RSP + 0x4],EBP
MOV RBP,-0x100000000
PUSH 0x3
POP R8
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R14
XOR ECX,ECX
CALL 0x0013bad8
MOV R14,RAX
MOV RBX,RDX
MOV EAX,EBX
CMP RAX,0x6
JZ 0x00164f61
ADD R12,0x10
CMP EAX,0x3
JNZ 0x00164f27
MOVZX R9D,word ptr [R13 + 0x6]
PUSH 0x3
POP RDX
MOV RDI,R15
XOR ESI,ESI
MOV R8,R12
CALL 0x00132165
MOV R14,RAX
MOV RBX,RDX
JMP 0x00164f61
LAB_00164f1d:
PUSH 0x6
POP RBX
XOR R14D,R14D
XOR EBP,EBP
JMP 0x00164f64
LAB_00164f27:
MOV EAX,dword ptr [RSP + 0x4]
CMP EAX,0x2
PUSH 0x1
POP RCX
CMOVGE ECX,EAX
DEC ECX
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
MOV R8,R12
CALL 0x00164f7c
MOV R12,RAX
MOV R13,RDX
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x0011801e
MOV R14,R12
MOV RBX,R13
LAB_00164f61:
AND RBP,R14
LAB_00164f64:
MOV EAX,R14D
OR RAX,RBP
MOV RDX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int1 [16] js_typed_array___speciesCreate(int8 param_1,int param_2,int8 *param_3)
{
int8 uVar1;
long lVar2;
int8 uVar3;
int iVar4;
ulong uVar5;
int1 auVar6 [16];
int1 auVar7 [16];
uVar3 = *param_3;
uVar1 = param_3[1];
lVar2 = get_typed_array(param_1,uVar3,uVar1);
if (lVar2 == 0) {
auVar6 = ZEXT816(6) << 0x40;
uVar5 = 0;
}
else {
auVar6 = JS_SpeciesConstructor(param_1,uVar3,uVar1,0,3);
uVar5 = auVar6._8_8_;
uVar3 = auVar6._0_8_;
if ((uVar5 & 0xffffffff) != 6) {
if (auVar6._8_4_ == 3) {
auVar6 = js_typed_array_constructor(param_1,0,3);
}
else {
iVar4 = 1;
if (1 < param_2) {
iVar4 = param_2;
}
auVar6 = js_typed_array_create(param_1,uVar3,uVar5,iVar4 + -1,param_3 + 2);
JS_FreeValue(param_1,uVar3,uVar5);
}
}
uVar5 = auVar6._0_8_ & 0xffffffff00000000;
}
auVar7._0_8_ = auVar6._0_8_ & 0xffffffff | uVar5;
auVar7._8_8_ = auVar6._8_8_;
return auVar7;
}
|
|
8,197 |
get_collation_number
|
eloqsql/mysys/charset.c
|
uint get_collation_number(const char *name, myf flags)
{
uint id;
char alias[64];
my_pthread_once(&charsets_initialized, init_available_charsets);
if ((id= get_collation_number_internal(name)))
return id;
if ((name= get_collation_name_alias(name, alias, sizeof(alias),flags)))
return get_collation_number_internal(name);
return 0;
}
|
O0
|
c
|
get_collation_number:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x60(%rbp)
movq %rsi, -0x68(%rbp)
leaq 0x362aa0(%rip), %rdi # 0x3914f4
leaq 0x85(%rip), %rsi # 0x2eae0
callq 0x242d0
movq -0x60(%rbp), %rdi
callq 0x2ec70
movl %eax, -0x6c(%rbp)
cmpl $0x0, %eax
je 0x2ea79
movl -0x6c(%rbp), %eax
movl %eax, -0x54(%rbp)
jmp 0x2eaae
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movq -0x68(%rbp), %rcx
movl $0x40, %edx
callq 0x2ed10
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x2eaa7
movq -0x60(%rbp), %rdi
callq 0x2ec70
movl %eax, -0x54(%rbp)
jmp 0x2eaae
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
movl %eax, -0x70(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x2eacf
movl -0x70(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
callq 0x24370
nopw %cs:(%rax,%rax)
|
get_collation_number:
push rbp
mov rbp, rsp
sub rsp, 70h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_60], rdi
mov [rbp+var_68], rsi
lea rdi, charsets_initialized
lea rsi, init_available_charsets
call _pthread_once
mov rdi, [rbp+var_60]
call get_collation_number_internal
mov [rbp+var_6C], eax
cmp eax, 0
jz short loc_2EA79
mov eax, [rbp+var_6C]
mov [rbp+var_54], eax
jmp short loc_2EAAE
loc_2EA79:
mov rdi, [rbp+var_60]
lea rsi, [rbp+var_50]
mov rcx, [rbp+var_68]
mov edx, 40h ; '@'
call get_collation_name_alias
mov [rbp+var_60], rax
cmp rax, 0
jz short loc_2EAA7
mov rdi, [rbp+var_60]
call get_collation_number_internal
mov [rbp+var_54], eax
jmp short loc_2EAAE
loc_2EAA7:
mov [rbp+var_54], 0
loc_2EAAE:
mov eax, [rbp+var_54]
mov [rbp+var_70], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_2EACF
mov eax, [rbp+var_70]
add rsp, 70h
pop rbp
retn
loc_2EACF:
call ___stack_chk_fail
|
long long get_collation_number(long long a1, long long a2)
{
unsigned int collation_number_internal; // [rsp+4h] [rbp-6Ch]
long long collation_name_alias; // [rsp+10h] [rbp-60h]
_BYTE v6[72]; // [rsp+20h] [rbp-50h] BYREF
unsigned long long v7; // [rsp+68h] [rbp-8h]
v7 = __readfsqword(0x28u);
pthread_once(&charsets_initialized, init_available_charsets);
collation_number_internal = get_collation_number_internal(a1);
if ( collation_number_internal )
{
return collation_number_internal;
}
else
{
collation_name_alias = get_collation_name_alias(a1, v6, 64LL, a2);
if ( collation_name_alias )
return (unsigned int)get_collation_number_internal(collation_name_alias);
else
return 0;
}
}
|
get_collation_number:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x60],RDI
MOV qword ptr [RBP + -0x68],RSI
LEA RDI,[0x4914f4]
LEA RSI,[0x12eae0]
CALL 0x001242d0
MOV RDI,qword ptr [RBP + -0x60]
CALL 0x0012ec70
MOV dword ptr [RBP + -0x6c],EAX
CMP EAX,0x0
JZ 0x0012ea79
MOV EAX,dword ptr [RBP + -0x6c]
MOV dword ptr [RBP + -0x54],EAX
JMP 0x0012eaae
LAB_0012ea79:
MOV RDI,qword ptr [RBP + -0x60]
LEA RSI,[RBP + -0x50]
MOV RCX,qword ptr [RBP + -0x68]
MOV EDX,0x40
CALL 0x0012ed10
MOV qword ptr [RBP + -0x60],RAX
CMP RAX,0x0
JZ 0x0012eaa7
MOV RDI,qword ptr [RBP + -0x60]
CALL 0x0012ec70
MOV dword ptr [RBP + -0x54],EAX
JMP 0x0012eaae
LAB_0012eaa7:
MOV dword ptr [RBP + -0x54],0x0
LAB_0012eaae:
MOV EAX,dword ptr [RBP + -0x54]
MOV dword ptr [RBP + -0x70],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0012eacf
MOV EAX,dword ptr [RBP + -0x70]
ADD RSP,0x70
POP RBP
RET
LAB_0012eacf:
CALL 0x00124370
|
int get_collation_number(int8 param_1,int8 param_2)
{
long lVar1;
long in_FS_OFFSET;
int local_5c;
int1 local_58 [72];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
pthread_once(&charsets_initialized,init_available_charsets);
local_5c = get_collation_number_internal(param_1);
if (local_5c == 0) {
lVar1 = get_collation_name_alias(param_1,local_58,0x40,param_2);
if (lVar1 == 0) {
local_5c = 0;
}
else {
local_5c = get_collation_number_internal(lVar1);
}
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_5c;
}
|
|
8,198 |
end_io_cache
|
eloqsql/mysys/mf_iocache.c
|
int end_io_cache(IO_CACHE *info)
{
int error=0;
DBUG_ENTER("end_io_cache");
DBUG_PRINT("enter",("cache: %p", info));
/*
Every thread must call remove_io_thread(). The last one destroys
the share elements.
*/
DBUG_ASSERT(!info->share || !info->share->total_threads);
if (info->alloced_buffer)
{
info->alloced_buffer=0;
if (info->file != -1) /* File doesn't exist */
error= my_b_flush_io_cache(info,1);
my_free(info->buffer);
info->buffer=info->read_pos=(uchar*) 0;
}
if (info->type == SEQ_READ_APPEND)
{
/* Destroy allocated mutex */
mysql_mutex_destroy(&info->append_buffer_lock);
}
info->share= 0;
info->type= TYPE_NOT_SET; /* Ensure that flush_io_cache() does nothing */
info->write_end= 0; /* Ensure that my_b_write() fails */
info->write_function= 0; /* my_b_write will crash if used */
DBUG_RETURN(error);
}
|
O0
|
c
|
end_io_cache:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
jmp 0xe6515
jmp 0xe6517
jmp 0xe6519
movq -0x8(%rbp), %rax
cmpq $0x0, 0x100(%rax)
je 0xe6579
movq -0x8(%rbp), %rax
movq $0x0, 0x100(%rax)
movq -0x8(%rbp), %rax
cmpl $-0x1, 0xd4(%rax)
je 0xe6554
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xe4f00
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xfc3a0
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
cmpl $0x3, 0xb0(%rax)
jne 0xe6593
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
callq 0xe5ce0
movq -0x8(%rbp), %rax
movq $0x0, 0x98(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xb0(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0xa8(%rax)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
end_io_cache:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov [rbp+var_C], 0
jmp short $+2
loc_E6515:
jmp short $+2
loc_E6517:
jmp short $+2
loc_E6519:
mov rax, [rbp+var_8]
cmp qword ptr [rax+100h], 0
jz short loc_E6579
mov rax, [rbp+var_8]
mov qword ptr [rax+100h], 0
mov rax, [rbp+var_8]
cmp dword ptr [rax+0D4h], 0FFFFFFFFh
jz short loc_E6554
mov rdi, [rbp+var_8]
mov esi, 1
call my_b_flush_io_cache
mov [rbp+var_C], eax
loc_E6554:
mov rax, [rbp+var_8]
mov rdi, [rax+20h]
call my_free
mov rax, [rbp+var_8]
mov qword ptr [rax+10h], 0
mov rax, [rbp+var_8]
mov qword ptr [rax+20h], 0
loc_E6579:
mov rax, [rbp+var_8]
cmp dword ptr [rax+0B0h], 3
jnz short loc_E6593
mov rdi, [rbp+var_8]
add rdi, 50h ; 'P'
call inline_mysql_mutex_destroy_6
loc_E6593:
mov rax, [rbp+var_8]
mov qword ptr [rax+98h], 0
mov rax, [rbp+var_8]
mov dword ptr [rax+0B0h], 0
mov rax, [rbp+var_8]
mov qword ptr [rax+48h], 0
mov rax, [rbp+var_8]
mov qword ptr [rax+0A8h], 0
mov eax, [rbp+var_C]
mov [rbp+var_10], eax
mov eax, [rbp+var_10]
add rsp, 10h
pop rbp
retn
|
long long end_io_cache(long long a1)
{
unsigned int v2; // [rsp+4h] [rbp-Ch]
v2 = 0;
if ( *(_QWORD *)(a1 + 256) )
{
*(_QWORD *)(a1 + 256) = 0LL;
if ( *(_DWORD *)(a1 + 212) != -1 )
v2 = my_b_flush_io_cache(a1, 1);
my_free(*(_QWORD *)(a1 + 32));
*(_QWORD *)(a1 + 16) = 0LL;
*(_QWORD *)(a1 + 32) = 0LL;
}
if ( *(_DWORD *)(a1 + 176) == 3 )
inline_mysql_mutex_destroy_6(a1 + 80);
*(_QWORD *)(a1 + 152) = 0LL;
*(_DWORD *)(a1 + 176) = 0;
*(_QWORD *)(a1 + 72) = 0LL;
*(_QWORD *)(a1 + 168) = 0LL;
return v2;
}
|
end_io_cache:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001e6515
LAB_001e6515:
JMP 0x001e6517
LAB_001e6517:
JMP 0x001e6519
LAB_001e6519:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x100],0x0
JZ 0x001e6579
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x100],0x0
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0xd4],-0x1
JZ 0x001e6554
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,0x1
CALL 0x001e4f00
MOV dword ptr [RBP + -0xc],EAX
LAB_001e6554:
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x20]
CALL 0x001fc3a0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x10],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x20],0x0
LAB_001e6579:
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0xb0],0x3
JNZ 0x001e6593
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x50
CALL 0x001e5ce0
LAB_001e6593:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x98],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0xb0],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x48],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xa8],0x0
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x10],EAX
MOV EAX,dword ptr [RBP + -0x10]
ADD RSP,0x10
POP RBP
RET
|
int4 end_io_cache(long param_1)
{
int4 local_14;
local_14 = 0;
if (*(long *)(param_1 + 0x100) != 0) {
*(int8 *)(param_1 + 0x100) = 0;
if (*(int *)(param_1 + 0xd4) != -1) {
local_14 = my_b_flush_io_cache(param_1,1);
}
my_free(*(int8 *)(param_1 + 0x20));
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(param_1 + 0x20) = 0;
}
if (*(int *)(param_1 + 0xb0) == 3) {
inline_mysql_mutex_destroy(param_1 + 0x50);
}
*(int8 *)(param_1 + 0x98) = 0;
*(int4 *)(param_1 + 0xb0) = 0;
*(int8 *)(param_1 + 0x48) = 0;
*(int8 *)(param_1 + 0xa8) = 0;
return local_14;
}
|
|
8,199 |
translog_free_link
|
eloqsql/storage/maria/ma_loghandler.c
|
static void translog_free_link(PAGECACHE_BLOCK_LINK *direct_link)
{
DBUG_ENTER("translog_free_link");
DBUG_PRINT("info", ("Direct link: %p",
direct_link));
if (direct_link)
pagecache_unlock_by_link(log_descriptor.pagecache, direct_link,
PAGECACHE_LOCK_READ_UNLOCK, PAGECACHE_UNPIN,
LSN_IMPOSSIBLE, LSN_IMPOSSIBLE, 0, FALSE);
DBUG_VOID_RETURN;
}
|
O0
|
c
|
translog_free_link:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x4a8ce
cmpq $0x0, -0x8(%rbp)
je 0x4a908
movq 0x463e64(%rip), %rdi # 0x4ae740
movq -0x8(%rbp), %rsi
movl $0x5, %edx
movl $0x3, %ecx
xorl %eax, %eax
movl %eax, %r9d
xorl %eax, %eax
movq %r9, %r8
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x54a90
jmp 0x4a90a
jmp 0x4a90c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
translog_free_link:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
jmp short $+2
loc_4A8CE:
cmp [rbp+var_8], 0
jz short loc_4A908
mov rdi, cs:log_descriptor
mov rsi, [rbp+var_8]
mov edx, 5
mov ecx, 3
xor eax, eax
mov r9d, eax
xor eax, eax
mov r8, r9
mov [rsp+20h+var_20], 0
mov [rsp+20h+var_18], 0
call pagecache_unlock_by_link
loc_4A908:
jmp short $+2
loc_4A90A:
jmp short $+2
loc_4A90C:
add rsp, 20h
pop rbp
retn
|
long long translog_free_link(long long a1)
{
long long result; // rax
if ( a1 )
return pagecache_unlock_by_link(log_descriptor[0], a1, 5, 3, 0, 0, 0, 0);
return result;
}
|
translog_free_link:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
JMP 0x0014a8ce
LAB_0014a8ce:
CMP qword ptr [RBP + -0x8],0x0
JZ 0x0014a908
MOV RDI,qword ptr [0x005ae740]
MOV RSI,qword ptr [RBP + -0x8]
MOV EDX,0x5
MOV ECX,0x3
XOR EAX,EAX
MOV R9D,EAX
XOR EAX,EAX
MOV R8,R9
MOV dword ptr [RSP],0x0
MOV dword ptr [RSP + 0x8],0x0
CALL 0x00154a90
LAB_0014a908:
JMP 0x0014a90a
LAB_0014a90a:
JMP 0x0014a90c
LAB_0014a90c:
ADD RSP,0x20
POP RBP
RET
|
void translog_free_link(long param_1)
{
if (param_1 != 0) {
pagecache_unlock_by_link(log_descriptor,param_1,5,3,0,0,0,0);
}
return;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.