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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
18,400
|
my_b_cache_read
|
eloqsql/mysys/mf_iocache.c
|
int _my_b_cache_read(IO_CACHE *info, uchar *Buffer, size_t Count)
{
size_t length= 0, diff_length, left_length= 0, max_length;
my_off_t pos_in_file;
DBUG_ENTER("_my_b_cache_read");
/* pos_in_file always point on where info->buffer was read */
pos_in_file=info->pos_in_file+ (size_t) (info->read_end - info->buffer);
/*
Whenever a function which operates on IO_CACHE flushes/writes
some part of the IO_CACHE to disk it will set the property
"seek_not_done" to indicate this to other functions operating
on the IO_CACHE.
*/
if (info->seek_not_done)
{
if ((mysql_file_seek(info->file, pos_in_file, MY_SEEK_SET, MYF(0))
!= MY_FILEPOS_ERROR))
{
/* No error, reset seek_not_done flag. */
info->seek_not_done= 0;
if (info->next_file_user)
{
IO_CACHE *c;
for (c= info->next_file_user;
c!= info;
c= c->next_file_user)
{
c->seek_not_done= 1;
}
}
}
else
{
/*
If the seek failed and the error number is ESPIPE, it is because
info->file is a pipe or socket or FIFO. We never should have tried
to seek on that. See Bugs#25807 and #22828 for more info.
*/
DBUG_ASSERT(my_errno != ESPIPE);
info->error= -1;
DBUG_RETURN(1);
}
}
/*
Calculate, how much we are within a IO_SIZE block. Ideally this
should be zero.
*/
diff_length= (size_t) (pos_in_file & (IO_SIZE-1));
/*
If more than a block plus the rest of the current block is wanted,
we do read directly, without filling the buffer.
*/
if (Count >= (size_t) (IO_SIZE+(IO_SIZE-diff_length)))
{ /* Fill first intern buffer */
size_t read_length;
if (info->end_of_file <= pos_in_file)
{
/* End of file. Return, what we did copy from the buffer. */
info->error= (int) left_length;
info->seek_not_done=1;
DBUG_RETURN(1);
}
/*
Crop the wanted count to a multiple of IO_SIZE and subtract,
what we did already read from a block. That way, the read will
end aligned with a block.
*/
length= IO_ROUND_DN(Count) - diff_length;
if ((read_length= mysql_file_read(info->file,Buffer, length, info->myflags))
!= length)
{
/*
If we didn't get, what we wanted, we either return -1 for a read
error, or (it's end of file), how much we got in total.
*/
info->error= (read_length == (size_t) -1 ? -1 :
(int) (read_length+left_length));
info->seek_not_done=1;
DBUG_RETURN(1);
}
Count-=length;
Buffer+=length;
pos_in_file+=length;
left_length+=length;
diff_length=0;
}
/*
At this point, we want less than one and a partial block.
We will read a full cache, minus the number of bytes, we are
within a block already. So we will reach new alignment.
*/
max_length= info->read_length-diff_length;
/* We will not read past end of file. */
if (info->type != READ_FIFO &&
max_length > (info->end_of_file - pos_in_file))
max_length= (size_t) (info->end_of_file - pos_in_file);
/*
If there is nothing left to read,
we either are done, or we failed to fulfill the request.
Otherwise, we read max_length into the cache.
*/
if (!max_length)
{
if (Count)
{
/* We couldn't fulfil the request. Return, how much we got. */
info->error= (int) left_length;
DBUG_RETURN(1);
}
else
{
info->error= 0;
if (length == 0) /* nothing was read */
DBUG_RETURN(0); /* EOF */
length= 0; /* non-zero size read was done */
}
}
else
{
if (info->next_file_user)
{
IO_CACHE *c;
for (c= info->next_file_user;
c!= info;
c= c->next_file_user)
{
c->seek_not_done= 1;
}
}
if ((length= mysql_file_read(info->file,info->buffer, max_length,
info->myflags)) < Count ||
length == (size_t) -1)
{
/*
We got an read error, or less than requested (end of file).
If not a read error, copy, what we got.
*/
if (length != (size_t) -1)
memcpy(Buffer, info->buffer, length);
info->pos_in_file= pos_in_file;
/* For a read error, return -1, otherwise, what we got in total. */
info->error= length == (size_t) -1 ? -1 : (int) (length+left_length);
info->read_pos=info->read_end=info->buffer;
info->seek_not_done=1;
DBUG_RETURN(1);
}
}
/*
Count is the remaining number of bytes requested.
length is the amount of data in the cache.
Read Count bytes from the cache.
*/
info->read_pos=info->buffer+Count;
info->read_end=info->buffer+length;
info->pos_in_file=pos_in_file;
if (Count)
memcpy(Buffer, info->buffer, Count);
DBUG_RETURN(0);
}
|
O3
|
c
|
my_b_cache_read:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
movq 0x18(%rdi), %r14
subq 0x20(%rdi), %r14
addq (%rdi), %r14
cmpl $0x0, 0xe0(%rdi)
je 0x96b0d
movl 0xd4(%rbx), %r15d
leaq 0x2ef574(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0xa0(%rbp), %rdi
movl %r15d, %esi
movl $0x8, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x96d57
movl %r15d, %edi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xa0ba0
cmpq $-0x1, %rax
je 0x96cbd
movl $0x0, 0xe0(%rbx)
movq 0xd8(%rbx), %rax
testq %rax, %rax
sete %cl
cmpq %rbx, %rax
sete %dl
orb %cl, %dl
jne 0x96b0d
movl $0x1, 0xe0(%rax)
movq 0xd8(%rax), %rax
cmpq %rbx, %rax
jne 0x96af7
movl %r14d, %eax
andl $0xfff, %eax # imm = 0xFFF
movl $0x2000, %ecx # imm = 0x2000
subq %rax, %rcx
cmpq %r13, %rcx
jbe 0x96c3a
xorl %ecx, %ecx
movq 0xf0(%rbx), %r15
subq %rax, %r15
cmpl $0x4, 0xb0(%rbx)
je 0x96b49
movq 0x8(%rbx), %rax
subq %r14, %rax
cmpq %rax, %r15
cmovaeq %rax, %r15
testq %r15, %r15
je 0x96cd6
movq %rcx, -0x48(%rbp)
movq %r13, -0x38(%rbp)
movq %r12, -0x40(%rbp)
movq 0xd8(%rbx), %rax
testq %rax, %rax
sete %cl
cmpq %rbx, %rax
sete %dl
orb %cl, %dl
jne 0x96b8b
movl $0x1, 0xe0(%rax)
movq 0xd8(%rax), %rax
cmpq %rbx, %rax
jne 0x96b75
movl 0xd4(%rbx), %r13d
movq 0x20(%rbx), %r12
movq 0xf8(%rbx), %rax
movq %rax, -0x30(%rbp)
leaq 0x2ef468(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0xa0(%rbp), %rdi
movl %r13d, %esi
movl $0x6, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x96d83
movl %r13d, %edi
movq %r12, %rsi
movq %r15, %rdx
movq -0x30(%rbp), %rcx
callq 0xa09a0
movq %rax, %r12
movq -0x38(%rbp), %rdx
cmpq %rdx, %r12
setae %al
cmpq $-0x1, %r12
setne %cl
testb %cl, %al
jne 0x96ce3
cmpq $-0x1, %r12
je 0x96c0d
movq 0x20(%rbx), %rsi
movq -0x40(%rbp), %rdi
movq %r12, %rdx
callq 0x29080
movq -0x48(%rbp), %rcx
addl %r12d, %ecx
cmpq $-0x1, %r12
movq %r14, (%rbx)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmovnel %ecx, %eax
movl %eax, 0xe4(%rbx)
movq 0x20(%rbx), %rax
movq %rax, 0x18(%rbx)
movq %rax, 0x10(%rbx)
jmp 0x96d12
cmpq %r14, 0x8(%rbx)
jbe 0x96cc9
movq %r13, -0x38(%rbp)
movl %r13d, %r15d
andl $0xfffff000, %r15d # imm = 0xFFFFF000
subq %rax, %r15
movl 0xd4(%rbx), %r13d
movq 0xf8(%rbx), %rax
movq %rax, -0x30(%rbp)
leaq 0x2ef3a2(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0xa0(%rbp), %rdi
movl %r13d, %esi
movl $0x6, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x96df6
movl %r13d, %edi
movq %r12, %rsi
movq %r15, %rdx
movq -0x30(%rbp), %rcx
callq 0xa09a0
cmpq %r15, %rax
movq -0x38(%rbp), %r13
jne 0x96d0c
movq %r15, %rcx
subq %r15, %r13
addq %r15, %r12
addq %r15, %r14
xorl %eax, %eax
jmp 0x96b28
movl $0xffffffff, 0xe4(%rbx) # imm = 0xFFFFFFFF
jmp 0x96d1c
movq $0x1, 0xe0(%rbx)
jmp 0x96d1c
testq %r13, %r13
je 0x96d34
movl %ecx, 0xe4(%rbx)
jmp 0x96d1c
movq 0x20(%rbx), %rsi
leaq (%rsi,%rdx), %rax
movq %rax, 0x10(%rbx)
addq %rsi, %r12
movq %r12, 0x18(%rbx)
movq %r14, (%rbx)
xorl %r15d, %r15d
testq %rdx, %rdx
je 0x96d22
movq -0x40(%rbp), %rdi
callq 0x29080
jmp 0x96d22
movl %eax, 0xe4(%rbx)
movl $0x1, 0xe0(%rbx)
movl $0x1, %r15d
movl %r15d, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x0, 0xe4(%rbx)
xorl %r15d, %r15d
testq %rcx, %rcx
je 0x96d22
movq 0x20(%rbx), %rax
movq %rax, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movq %r14, (%rbx)
jmp 0x96d22
movq %r13, -0x38(%rbp)
movq %r12, %r13
leaq -0x58(%rbp), %r12
movq %rax, %rdi
movl %r15d, %esi
movq %r14, %rdx
movq %r12, %rcx
callq 0x2eafc
movq (%r12), %rax
movq %r13, %r12
movq -0x38(%rbp), %r13
jmp 0x96acc
movq %rax, %rcx
leaq 0x2ef283(%rip), %rax # 0x386010
movq (%rax), %rax
leaq 0x45598(%rip), %rdx # 0xdc32f
movq %rcx, -0x50(%rbp)
movq %rcx, %rdi
movq %r15, %rsi
movl $0x2eb, %ecx # imm = 0x2EB
callq *0x210(%rax)
movl %r13d, %edi
movq %r12, %rsi
movq %r15, %rdx
movq -0x30(%rbp), %r13
movq %r13, %rcx
callq 0xa09a0
movq %rax, %r12
xorl %esi, %esi
testq %rax, %rax
cmovneq %rsi, %r15
cmpq $-0x1, %rax
cmovneq %rax, %rsi
testb $0x6, %r13b
cmovneq %r15, %rsi
leaq 0x2ef22c(%rip), %rax # 0x386010
movq (%rax), %rax
movq -0x50(%rbp), %rdi
callq *0x218(%rax)
jmp 0x96bde
movq %rax, %rcx
leaq 0x2ef210(%rip), %rax # 0x386010
movq (%rax), %rax
leaq 0x45525(%rip), %rdx # 0xdc32f
movq %rcx, -0x48(%rbp)
movq %rcx, %rdi
movq %r15, %rsi
movl $0x2ab, %ecx # imm = 0x2AB
callq *0x210(%rax)
movl %r13d, %edi
movq %r12, -0x40(%rbp)
movq %r12, %rsi
movq %r15, %rdx
movq -0x30(%rbp), %r12
movq %r12, %rcx
callq 0xa09a0
movq %rax, %r13
xorl %esi, %esi
testq %rax, %rax
movl $0x0, %eax
cmoveq %r15, %rax
cmpq $-0x1, %r13
cmovneq %r13, %rsi
testb $0x6, %r12b
cmovneq %rax, %rsi
leaq 0x2ef1b0(%rip), %rax # 0x386010
movq (%rax), %rax
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %r12
callq *0x218(%rax)
movq %r13, %rax
jmp 0x96ca1
|
_my_b_cache_read:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov r13, rdx
mov r12, rsi
mov rbx, rdi
mov r14, [rdi+18h]
sub r14, [rdi+20h]
add r14, [rdi]
cmp dword ptr [rdi+0E0h], 0
jz short loc_96B0D
mov r15d, [rbx+0D4h]
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_A0]
mov esi, r15d
mov edx, 8
call qword ptr [rax+158h]
test rax, rax
jnz loc_96D57
mov edi, r15d
mov rsi, r14
xor edx, edx
xor ecx, ecx
call my_seek
loc_96ACC:
cmp rax, 0FFFFFFFFFFFFFFFFh
jz loc_96CBD
mov dword ptr [rbx+0E0h], 0
mov rax, [rbx+0D8h]
test rax, rax
setz cl
cmp rax, rbx
setz dl
or dl, cl
jnz short loc_96B0D
loc_96AF7:
mov dword ptr [rax+0E0h], 1
mov rax, [rax+0D8h]
cmp rax, rbx
jnz short loc_96AF7
loc_96B0D:
mov eax, r14d
and eax, 0FFFh
mov ecx, 2000h
sub rcx, rax
cmp rcx, r13
jbe loc_96C3A
xor ecx, ecx
loc_96B28:
mov r15, [rbx+0F0h]
sub r15, rax
cmp dword ptr [rbx+0B0h], 4
jz short loc_96B49
mov rax, [rbx+8]
sub rax, r14
cmp r15, rax
cmovnb r15, rax
loc_96B49:
test r15, r15
jz loc_96CD6
mov [rbp+var_48], rcx
mov [rbp+var_38], r13
mov [rbp+var_40], r12
mov rax, [rbx+0D8h]
test rax, rax
setz cl
cmp rax, rbx
setz dl
or dl, cl
jnz short loc_96B8B
loc_96B75:
mov dword ptr [rax+0E0h], 1
mov rax, [rax+0D8h]
cmp rax, rbx
jnz short loc_96B75
loc_96B8B:
mov r13d, [rbx+0D4h]
mov r12, [rbx+20h]
mov rax, [rbx+0F8h]
mov [rbp+var_30], rax
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_A0]
mov esi, r13d
mov edx, 6
call qword ptr [rax+158h]
test rax, rax
jnz loc_96D83
mov edi, r13d
mov rsi, r12
mov rdx, r15
mov rcx, [rbp+var_30]
call my_read
mov r12, rax
loc_96BDE:
mov rdx, [rbp+var_38]
cmp r12, rdx
setnb al
cmp r12, 0FFFFFFFFFFFFFFFFh
setnz cl
test al, cl
jnz loc_96CE3
cmp r12, 0FFFFFFFFFFFFFFFFh
jz short loc_96C0D
mov rsi, [rbx+20h]
mov rdi, [rbp+var_40]
mov rdx, r12
call _memcpy
loc_96C0D:
mov rcx, [rbp+var_48]
add ecx, r12d
cmp r12, 0FFFFFFFFFFFFFFFFh
mov [rbx], r14
mov eax, 0FFFFFFFFh
cmovnz eax, ecx
mov [rbx+0E4h], eax
mov rax, [rbx+20h]
mov [rbx+18h], rax
mov [rbx+10h], rax
jmp loc_96D12
loc_96C3A:
cmp [rbx+8], r14
jbe loc_96CC9
mov [rbp+var_38], r13
mov r15d, r13d
and r15d, 0FFFFF000h
sub r15, rax
mov r13d, [rbx+0D4h]
mov rax, [rbx+0F8h]
mov [rbp+var_30], rax
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_A0]
mov esi, r13d
mov edx, 6
call qword ptr [rax+158h]
test rax, rax
jnz loc_96DF6
mov edi, r13d
mov rsi, r12
mov rdx, r15
mov rcx, [rbp+var_30]
call my_read
loc_96CA1:
cmp rax, r15
mov r13, [rbp+var_38]
jnz short loc_96D0C
mov rcx, r15
sub r13, r15
add r12, r15
add r14, r15
xor eax, eax
jmp loc_96B28
loc_96CBD:
mov dword ptr [rbx+0E4h], 0FFFFFFFFh
jmp short loc_96D1C
loc_96CC9:
mov qword ptr [rbx+0E0h], 1
jmp short loc_96D1C
loc_96CD6:
test r13, r13
jz short loc_96D34
mov [rbx+0E4h], ecx
jmp short loc_96D1C
loc_96CE3:
mov rsi, [rbx+20h]
lea rax, [rsi+rdx]
mov [rbx+10h], rax
add r12, rsi
mov [rbx+18h], r12
mov [rbx], r14
xor r15d, r15d
test rdx, rdx
jz short loc_96D22
mov rdi, [rbp+var_40]
call _memcpy
jmp short loc_96D22
loc_96D0C:
mov [rbx+0E4h], eax
loc_96D12:
mov dword ptr [rbx+0E0h], 1
loc_96D1C:
mov r15d, 1
loc_96D22:
mov eax, r15d
add rsp, 78h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_96D34:
mov dword ptr [rbx+0E4h], 0
xor r15d, r15d
test rcx, rcx
jz short loc_96D22
mov rax, [rbx+20h]
mov [rbx+10h], rax
mov [rbx+18h], rax
mov [rbx], r14
jmp short loc_96D22
loc_96D57:
mov [rbp+var_38], r13
mov r13, r12
lea r12, [rbp+var_58]
mov rdi, rax
mov esi, r15d
mov rdx, r14
mov rcx, r12
call _my_b_cache_read_cold_1
mov rax, [r12]
mov r12, r13
mov r13, [rbp+var_38]
jmp loc_96ACC
loc_96D83:
mov rcx, rax
lea rax, PSI_server
mov rax, [rax]
lea rdx, aWorkspaceLlm4b_21; "/workspace/llm4binary/github2025/eloqsq"...
mov [rbp+var_50], rcx
mov rdi, rcx
mov rsi, r15
mov ecx, 2EBh
call qword ptr [rax+210h]
mov edi, r13d
mov rsi, r12
mov rdx, r15
mov r13, [rbp+var_30]
mov rcx, r13
call my_read
mov r12, rax
xor esi, esi
test rax, rax
cmovnz r15, rsi
cmp rax, 0FFFFFFFFFFFFFFFFh
cmovnz rsi, rax
test r13b, 6
cmovnz rsi, r15
lea rax, PSI_server
mov rax, [rax]
mov rdi, [rbp+var_50]
call qword ptr [rax+218h]
jmp loc_96BDE
loc_96DF6:
mov rcx, rax
lea rax, PSI_server
mov rax, [rax]
lea rdx, aWorkspaceLlm4b_21; "/workspace/llm4binary/github2025/eloqsq"...
mov [rbp+var_48], rcx
mov rdi, rcx
mov rsi, r15
mov ecx, 2ABh
call qword ptr [rax+210h]
mov edi, r13d
mov [rbp+var_40], r12
mov rsi, r12
mov rdx, r15
mov r12, [rbp+var_30]
mov rcx, r12
call my_read
mov r13, rax
xor esi, esi
test rax, rax
mov eax, 0
cmovz rax, r15
cmp r13, 0FFFFFFFFFFFFFFFFh
cmovnz rsi, r13
test r12b, 6
cmovnz rsi, rax
lea rax, PSI_server
mov rax, [rax]
mov rdi, [rbp+var_48]
mov r12, [rbp+var_40]
call qword ptr [rax+218h]
mov rax, r13
jmp loc_96CA1
|
long long my_b_cache_read(long long a1, long long a2, unsigned long long a3)
{
long long v4; // r12
unsigned long long v5; // r14
unsigned int v6; // r15d
long long v7; // rax
long long v8; // rax
long long v9; // rax
unsigned long long v10; // rax
long long v11; // rcx
unsigned long long v12; // r15
long long v13; // rax
unsigned int v14; // r13d
long long v15; // r12
long long v16; // rax
unsigned long long v17; // r12
unsigned long long v18; // rdx
int v19; // ecx
int v20; // eax
long long v21; // rax
unsigned long long v22; // r15
unsigned int v23; // r13d
long long v24; // rax
long long v25; // rax
long long v26; // rsi
unsigned int v27; // r15d
long long v29; // rax
char v30; // r12
long long v31; // r13
long long v32; // rsi
long long v33; // rax
_BYTE v34[72]; // [rsp+0h] [rbp-A0h] BYREF
long long v35; // [rsp+48h] [rbp-58h] BYREF
long long v36; // [rsp+50h] [rbp-50h]
long long v37; // [rsp+58h] [rbp-48h]
long long v38; // [rsp+60h] [rbp-40h]
unsigned long long v39; // [rsp+68h] [rbp-38h]
long long v40; // [rsp+70h] [rbp-30h]
v4 = a2;
v5 = *(_QWORD *)a1 + *(_QWORD *)(a1 + 24) - *(_QWORD *)(a1 + 32);
if ( *(_DWORD *)(a1 + 224) )
{
v6 = *(_DWORD *)(a1 + 212);
v7 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v34, v6, 8LL);
if ( v7 )
{
v39 = a3;
my_b_cache_read_cold_1(v7, v6, v5, &v35);
v8 = v35;
a3 = v39;
}
else
{
v8 = my_seek(v6, v5, 0LL, 0LL);
}
if ( v8 == -1 )
{
*(_DWORD *)(a1 + 228) = -1;
return 1;
}
*(_DWORD *)(a1 + 224) = 0;
v9 = *(_QWORD *)(a1 + 216);
if ( v9 != 0 && v9 != a1 )
{
do
{
*(_DWORD *)(v9 + 224) = 1;
v9 = *(_QWORD *)(v9 + 216);
}
while ( v9 != a1 );
}
}
v10 = v5 & 0xFFF;
if ( 0x2000 - v10 <= a3 )
{
if ( *(_QWORD *)(a1 + 8) <= v5 )
{
*(_QWORD *)(a1 + 224) = 1LL;
return 1;
}
v39 = a3;
v22 = ((unsigned int)a3 & 0xFFFFF000) - v10;
v23 = *(_DWORD *)(a1 + 212);
v40 = *(_QWORD *)(a1 + 248);
v24 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v34, v23, 6LL);
if ( v24 )
{
v37 = v24;
((void ( *)(long long, unsigned long long, const char *, long long))PSI_server[66])(
v24,
v22,
"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",
683LL);
v38 = a2;
v30 = v40;
v31 = my_read(v23, a2, v22, v40);
v32 = 0LL;
v33 = 0LL;
if ( !v31 )
v33 = v22;
if ( v31 != -1 )
v32 = v31;
if ( (v30 & 6) != 0 )
v32 = v33;
v4 = v38;
((void ( *)(long long, long long))PSI_server[67])(v37, v32);
v25 = v31;
}
else
{
v25 = my_read(v23, a2, v22, v40);
}
if ( v25 != v22 )
{
*(_DWORD *)(a1 + 228) = v25;
LABEL_35:
*(_DWORD *)(a1 + 224) = 1;
return 1;
}
v11 = v22;
a3 = v39 - v22;
v4 += v22;
v5 += v22;
v10 = 0LL;
}
else
{
v11 = 0LL;
}
v12 = *(_QWORD *)(a1 + 240) - v10;
if ( *(_DWORD *)(a1 + 176) != 4 && v12 >= *(_QWORD *)(a1 + 8) - v5 )
v12 = *(_QWORD *)(a1 + 8) - v5;
if ( !v12 )
{
if ( !a3 )
{
*(_DWORD *)(a1 + 228) = 0;
v27 = 0;
if ( v11 )
{
v29 = *(_QWORD *)(a1 + 32);
*(_QWORD *)(a1 + 16) = v29;
*(_QWORD *)(a1 + 24) = v29;
*(_QWORD *)a1 = v5;
}
return v27;
}
*(_DWORD *)(a1 + 228) = v11;
return 1;
}
v37 = v11;
v39 = a3;
v38 = v4;
v13 = *(_QWORD *)(a1 + 216);
if ( v13 != 0 && v13 != a1 )
{
do
{
*(_DWORD *)(v13 + 224) = 1;
v13 = *(_QWORD *)(v13 + 216);
}
while ( v13 != a1 );
}
v14 = *(_DWORD *)(a1 + 212);
v15 = *(_QWORD *)(a1 + 32);
v40 = *(_QWORD *)(a1 + 248);
v16 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v34, v14, 6LL);
if ( v16 )
{
v36 = v16;
((void ( *)(long long, unsigned long long, const char *, long long))PSI_server[66])(
v16,
v12,
"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",
747LL);
v17 = my_read(v14, v15, v12, v40);
((void ( *)(long long))PSI_server[67])(v36);
}
else
{
v17 = my_read(v14, v15, v12, v40);
}
v18 = v39;
if ( v17 == -1LL || v17 < v39 )
{
if ( v17 != -1LL )
memcpy(v38, *(_QWORD *)(a1 + 32), v17);
v19 = v17 + v37;
*(_QWORD *)a1 = v5;
v20 = -1;
if ( v17 != -1LL )
v20 = v19;
*(_DWORD *)(a1 + 228) = v20;
v21 = *(_QWORD *)(a1 + 32);
*(_QWORD *)(a1 + 24) = v21;
*(_QWORD *)(a1 + 16) = v21;
goto LABEL_35;
}
v26 = *(_QWORD *)(a1 + 32);
*(_QWORD *)(a1 + 16) = v26 + v39;
*(_QWORD *)(a1 + 24) = v26 + v17;
*(_QWORD *)a1 = v5;
v27 = 0;
if ( v18 )
memcpy(v38, v26, v18);
return v27;
}
|
_my_b_cache_read:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV R13,RDX
MOV R12,RSI
MOV RBX,RDI
MOV R14,qword ptr [RDI + 0x18]
SUB R14,qword ptr [RDI + 0x20]
ADD R14,qword ptr [RDI]
CMP dword ptr [RDI + 0xe0],0x0
JZ 0x00196b0d
MOV R15D,dword ptr [RBX + 0xd4]
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0xa0]
MOV ESI,R15D
MOV EDX,0x8
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x00196d57
MOV EDI,R15D
MOV RSI,R14
XOR EDX,EDX
XOR ECX,ECX
CALL 0x001a0ba0
LAB_00196acc:
CMP RAX,-0x1
JZ 0x00196cbd
MOV dword ptr [RBX + 0xe0],0x0
MOV RAX,qword ptr [RBX + 0xd8]
TEST RAX,RAX
SETZ CL
CMP RAX,RBX
SETZ DL
OR DL,CL
JNZ 0x00196b0d
LAB_00196af7:
MOV dword ptr [RAX + 0xe0],0x1
MOV RAX,qword ptr [RAX + 0xd8]
CMP RAX,RBX
JNZ 0x00196af7
LAB_00196b0d:
MOV EAX,R14D
AND EAX,0xfff
MOV ECX,0x2000
SUB RCX,RAX
CMP RCX,R13
JBE 0x00196c3a
XOR ECX,ECX
LAB_00196b28:
MOV R15,qword ptr [RBX + 0xf0]
SUB R15,RAX
CMP dword ptr [RBX + 0xb0],0x4
JZ 0x00196b49
MOV RAX,qword ptr [RBX + 0x8]
SUB RAX,R14
CMP R15,RAX
CMOVNC R15,RAX
LAB_00196b49:
TEST R15,R15
JZ 0x00196cd6
MOV qword ptr [RBP + -0x48],RCX
MOV qword ptr [RBP + -0x38],R13
MOV qword ptr [RBP + -0x40],R12
MOV RAX,qword ptr [RBX + 0xd8]
TEST RAX,RAX
SETZ CL
CMP RAX,RBX
SETZ DL
OR DL,CL
JNZ 0x00196b8b
LAB_00196b75:
MOV dword ptr [RAX + 0xe0],0x1
MOV RAX,qword ptr [RAX + 0xd8]
CMP RAX,RBX
JNZ 0x00196b75
LAB_00196b8b:
MOV R13D,dword ptr [RBX + 0xd4]
MOV R12,qword ptr [RBX + 0x20]
MOV RAX,qword ptr [RBX + 0xf8]
MOV qword ptr [RBP + -0x30],RAX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0xa0]
MOV ESI,R13D
MOV EDX,0x6
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x00196d83
MOV EDI,R13D
MOV RSI,R12
MOV RDX,R15
MOV RCX,qword ptr [RBP + -0x30]
CALL 0x001a09a0
MOV R12,RAX
LAB_00196bde:
MOV RDX,qword ptr [RBP + -0x38]
CMP R12,RDX
SETNC AL
CMP R12,-0x1
SETNZ CL
TEST AL,CL
JNZ 0x00196ce3
CMP R12,-0x1
JZ 0x00196c0d
MOV RSI,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [RBP + -0x40]
MOV RDX,R12
CALL 0x00129080
LAB_00196c0d:
MOV RCX,qword ptr [RBP + -0x48]
ADD ECX,R12D
CMP R12,-0x1
MOV qword ptr [RBX],R14
MOV EAX,0xffffffff
CMOVNZ EAX,ECX
MOV dword ptr [RBX + 0xe4],EAX
MOV RAX,qword ptr [RBX + 0x20]
MOV qword ptr [RBX + 0x18],RAX
MOV qword ptr [RBX + 0x10],RAX
JMP 0x00196d12
LAB_00196c3a:
CMP qword ptr [RBX + 0x8],R14
JBE 0x00196cc9
MOV qword ptr [RBP + -0x38],R13
MOV R15D,R13D
AND R15D,0xfffff000
SUB R15,RAX
MOV R13D,dword ptr [RBX + 0xd4]
MOV RAX,qword ptr [RBX + 0xf8]
MOV qword ptr [RBP + -0x30],RAX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0xa0]
MOV ESI,R13D
MOV EDX,0x6
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x00196df6
MOV EDI,R13D
MOV RSI,R12
MOV RDX,R15
MOV RCX,qword ptr [RBP + -0x30]
CALL 0x001a09a0
LAB_00196ca1:
CMP RAX,R15
MOV R13,qword ptr [RBP + -0x38]
JNZ 0x00196d0c
MOV RCX,R15
SUB R13,R15
ADD R12,R15
ADD R14,R15
XOR EAX,EAX
JMP 0x00196b28
LAB_00196cbd:
MOV dword ptr [RBX + 0xe4],0xffffffff
JMP 0x00196d1c
LAB_00196cc9:
MOV qword ptr [RBX + 0xe0],0x1
JMP 0x00196d1c
LAB_00196cd6:
TEST R13,R13
JZ 0x00196d34
MOV dword ptr [RBX + 0xe4],ECX
JMP 0x00196d1c
LAB_00196ce3:
MOV RSI,qword ptr [RBX + 0x20]
LEA RAX,[RSI + RDX*0x1]
MOV qword ptr [RBX + 0x10],RAX
ADD R12,RSI
MOV qword ptr [RBX + 0x18],R12
MOV qword ptr [RBX],R14
XOR R15D,R15D
TEST RDX,RDX
JZ 0x00196d22
MOV RDI,qword ptr [RBP + -0x40]
CALL 0x00129080
JMP 0x00196d22
LAB_00196d0c:
MOV dword ptr [RBX + 0xe4],EAX
LAB_00196d12:
MOV dword ptr [RBX + 0xe0],0x1
LAB_00196d1c:
MOV R15D,0x1
LAB_00196d22:
MOV EAX,R15D
ADD RSP,0x78
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00196d34:
MOV dword ptr [RBX + 0xe4],0x0
XOR R15D,R15D
TEST RCX,RCX
JZ 0x00196d22
MOV RAX,qword ptr [RBX + 0x20]
MOV qword ptr [RBX + 0x10],RAX
MOV qword ptr [RBX + 0x18],RAX
MOV qword ptr [RBX],R14
JMP 0x00196d22
LAB_00196d57:
MOV qword ptr [RBP + -0x38],R13
MOV R13,R12
LEA R12,[RBP + -0x58]
MOV RDI,RAX
MOV ESI,R15D
MOV RDX,R14
MOV RCX,R12
CALL 0x0012eafc
MOV RAX,qword ptr [R12]
MOV R12,R13
MOV R13,qword ptr [RBP + -0x38]
JMP 0x00196acc
LAB_00196d83:
MOV RCX,RAX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDX,[0x1dc32f]
MOV qword ptr [RBP + -0x50],RCX
MOV RDI,RCX
MOV RSI,R15
MOV ECX,0x2eb
CALL qword ptr [RAX + 0x210]
MOV EDI,R13D
MOV RSI,R12
MOV RDX,R15
MOV R13,qword ptr [RBP + -0x30]
MOV RCX,R13
CALL 0x001a09a0
MOV R12,RAX
XOR ESI,ESI
TEST RAX,RAX
CMOVNZ R15,RSI
CMP RAX,-0x1
CMOVNZ RSI,RAX
TEST R13B,0x6
CMOVNZ RSI,R15
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RBP + -0x50]
CALL qword ptr [RAX + 0x218]
JMP 0x00196bde
LAB_00196df6:
MOV RCX,RAX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDX,[0x1dc32f]
MOV qword ptr [RBP + -0x48],RCX
MOV RDI,RCX
MOV RSI,R15
MOV ECX,0x2ab
CALL qword ptr [RAX + 0x210]
MOV EDI,R13D
MOV qword ptr [RBP + -0x40],R12
MOV RSI,R12
MOV RDX,R15
MOV R12,qword ptr [RBP + -0x30]
MOV RCX,R12
CALL 0x001a09a0
MOV R13,RAX
XOR ESI,ESI
TEST RAX,RAX
MOV EAX,0x0
CMOVZ RAX,R15
CMP R13,-0x1
CMOVNZ RSI,R13
TEST R12B,0x6
CMOVNZ RSI,RAX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RBP + -0x48]
MOV R12,qword ptr [RBP + -0x40]
CALL qword ptr [RAX + 0x218]
MOV RAX,R13
JMP 0x00196ca1
|
int8 _my_b_cache_read(ulong *param_1,void *param_2,ulong param_3)
{
int4 uVar1;
void *__src;
ulong uVar2;
int iVar3;
long lVar4;
ulong *puVar5;
ulong uVar6;
long lVar7;
long lVar8;
ulong uVar9;
long lVar10;
ulong uVar11;
ulong uVar12;
int1 local_a8 [72];
long local_60;
long local_58;
long local_50;
void *local_48;
ulong local_40;
ulong local_38;
uVar11 = (param_1[3] - param_1[4]) + *param_1;
if ((int)param_1[0x1c] != 0) {
uVar1 = *(int4 *)((long)param_1 + 0xd4);
lVar4 = (**(code **)(PSI_server + 0x158))(local_a8,uVar1,8);
if (lVar4 == 0) {
local_60 = my_seek(uVar1,uVar11,0,0);
}
else {
local_40 = param_3;
_my_b_cache_read_cold_1(lVar4,uVar1,uVar11,&local_60);
param_3 = local_40;
}
if (local_60 == -1) {
*(int4 *)((long)param_1 + 0xe4) = 0xffffffff;
return 1;
}
*(int4 *)(param_1 + 0x1c) = 0;
puVar5 = (ulong *)param_1[0x1b];
if (puVar5 != param_1 && puVar5 != (ulong *)0x0) {
do {
*(int4 *)(puVar5 + 0x1c) = 1;
puVar5 = (ulong *)puVar5[0x1b];
} while (puVar5 != param_1);
}
}
uVar12 = (ulong)((uint)uVar11 & 0xfff);
if (param_3 < 0x2000 - uVar12) {
lVar4 = 0;
}
else {
if (param_1[1] <= uVar11) {
param_1[0x1c] = 1;
return 1;
}
lVar4 = ((uint)param_3 & 0xfffff000) - uVar12;
uVar1 = *(int4 *)((long)param_1 + 0xd4);
local_38 = param_1[0x1f];
local_40 = param_3;
local_50 = (**(code **)(PSI_server + 0x158))(local_a8,uVar1,6);
if (local_50 == 0) {
lVar7 = my_read(uVar1,param_2,lVar4,local_38);
}
else {
(**(code **)(PSI_server + 0x210))
(local_50,lVar4,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x2ab)
;
uVar12 = local_38;
local_48 = param_2;
lVar7 = my_read(uVar1,param_2,lVar4,local_38);
param_2 = local_48;
lVar8 = 0;
if (lVar7 == 0) {
lVar8 = lVar4;
}
lVar10 = 0;
if (lVar7 != -1) {
lVar10 = lVar7;
}
if ((uVar12 & 6) != 0) {
lVar10 = lVar8;
}
(**(code **)(PSI_server + 0x218))(local_50,lVar10);
}
if (lVar7 != lVar4) {
*(int *)((long)param_1 + 0xe4) = (int)lVar7;
goto LAB_00196d12;
}
param_3 = local_40 - lVar4;
param_2 = (void *)((long)param_2 + lVar4);
uVar11 = uVar11 + lVar4;
uVar12 = 0;
}
uVar12 = param_1[0x1e] - uVar12;
if (((int)param_1[0x16] != 4) && (param_1[1] - uVar11 <= uVar12)) {
uVar12 = param_1[1] - uVar11;
}
if (uVar12 == 0) {
if (param_3 != 0) {
*(int *)((long)param_1 + 0xe4) = (int)lVar4;
return 1;
}
*(int4 *)((long)param_1 + 0xe4) = 0;
if (lVar4 != 0) {
param_1[2] = param_1[4];
param_1[3] = param_1[4];
*param_1 = uVar11;
return 0;
}
return 0;
}
puVar5 = (ulong *)param_1[0x1b];
if (puVar5 != param_1 && puVar5 != (ulong *)0x0) {
do {
*(int4 *)(puVar5 + 0x1c) = 1;
puVar5 = (ulong *)puVar5[0x1b];
} while (puVar5 != param_1);
}
uVar1 = *(int4 *)((long)param_1 + 0xd4);
uVar6 = param_1[4];
local_38 = param_1[0x1f];
local_50 = lVar4;
local_48 = param_2;
local_40 = param_3;
lVar4 = (**(code **)(PSI_server + 0x158))(local_a8,uVar1,6);
if (lVar4 == 0) {
uVar6 = my_read(uVar1,uVar6,uVar12,local_38);
}
else {
local_58 = lVar4;
(**(code **)(PSI_server + 0x210))
(lVar4,uVar12,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x2eb);
uVar2 = local_38;
uVar6 = my_read(uVar1,uVar6,uVar12,local_38);
if (uVar6 != 0) {
uVar12 = 0;
}
uVar9 = 0;
if (uVar6 != 0xffffffffffffffff) {
uVar9 = uVar6;
}
if ((uVar2 & 6) != 0) {
uVar9 = uVar12;
}
(**(code **)(PSI_server + 0x218))(local_58,uVar9);
}
if (local_40 <= uVar6 && uVar6 != 0xffffffffffffffff) {
__src = (void *)param_1[4];
param_1[2] = (long)__src + local_40;
param_1[3] = uVar6 + (long)__src;
*param_1 = uVar11;
if (local_40 != 0) {
memcpy(local_48,__src,local_40);
return 0;
}
return 0;
}
if (uVar6 != 0xffffffffffffffff) {
memcpy(local_48,(void *)param_1[4],uVar6);
}
*param_1 = uVar11;
iVar3 = -1;
if (uVar6 != 0xffffffffffffffff) {
iVar3 = (int)local_50 + (int)uVar6;
}
*(int *)((long)param_1 + 0xe4) = iVar3;
param_1[3] = param_1[4];
param_1[2] = param_1[4];
LAB_00196d12:
*(int4 *)(param_1 + 0x1c) = 1;
return 1;
}
|
|
18,401
|
js_call_bound_function
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_call_bound_function(JSContext *ctx, JSValue func_obj,
JSValue this_obj,
int argc, JSValue *argv, int flags)
{
JSObject *p;
JSBoundFunction *bf;
JSValue *arg_buf, new_target;
int arg_count, i;
p = JS_VALUE_GET_OBJ(func_obj);
bf = p->u.bound_function;
arg_count = bf->argc + argc;
if (js_check_stack_overflow(ctx->rt, sizeof(JSValue) * arg_count))
return JS_ThrowStackOverflow(ctx);
arg_buf = alloca(sizeof(JSValue) * arg_count);
for(i = 0; i < bf->argc; i++) {
arg_buf[i] = bf->argv[i];
}
for(i = 0; i < argc; i++) {
arg_buf[bf->argc + i] = argv[i];
}
if (flags & JS_CALL_FLAG_CONSTRUCTOR) {
new_target = this_obj;
if (js_same_value(ctx, func_obj, new_target))
new_target = bf->func_obj;
return JS_CallConstructor2(ctx, bf->func_obj, new_target,
arg_count, arg_buf);
} else {
return JS_Call(ctx, bf->func_obj, bf->this_val,
arg_count, arg_buf);
}
}
|
O0
|
c
|
js_call_bound_function:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rsi, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x28(%rbp)
movq %rdi, -0x38(%rbp)
movl %r9d, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movl 0x20(%rax), %eax
addl -0x3c(%rbp), %eax
movl %eax, -0x6c(%rbp)
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdi
movslq -0x6c(%rbp), %rsi
shlq $0x4, %rsi
callq 0x4dce0
cmpl $0x0, %eax
je 0x22fd8
movq -0x38(%rbp), %rdi
callq 0x601e0
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x2314c
movslq -0x6c(%rbp), %rcx
shlq $0x4, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x58(%rbp)
movl $0x0, -0x70(%rbp)
movl -0x70(%rbp), %eax
movq -0x50(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x2303b
movq -0x58(%rbp), %rax
movslq -0x70(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x50(%rbp), %rcx
addq $0x28, %rcx
movslq -0x70(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movl -0x70(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x70(%rbp)
jmp 0x22ff4
movl $0x0, -0x70(%rbp)
movl -0x70(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jge 0x2308a
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rcx
movl 0x20(%rcx), %ecx
addl -0x70(%rbp), %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x10(%rbp), %rcx
movslq -0x70(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movl -0x70(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x70(%rbp)
jmp 0x23042
movl 0x18(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x23110
movq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x68(%rbp), %rcx
movq -0x60(%rbp), %r8
callq 0x35b10
cmpl $0x0, %eax
je 0x230d6
movq -0x50(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x68(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rcx
movl -0x6c(%rbp), %r9d
movq -0x58(%rbp), %rax
movq (%rcx), %rsi
movq 0x8(%rcx), %rdx
movq -0x68(%rbp), %rcx
movq -0x60(%rbp), %r8
subq $0x10, %rsp
movq %rax, (%rsp)
callq 0x48090
addq $0x10, %rsp
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x2314c
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rcx
movq -0x50(%rbp), %r8
movl -0x6c(%rbp), %r9d
movq -0x58(%rbp), %rax
movq (%rcx), %rsi
movq 0x8(%rcx), %rdx
movq 0x10(%r8), %rcx
movq 0x18(%r8), %r8
subq $0x10, %rsp
movq %rax, (%rsp)
callq 0x3a050
addq $0x10, %rsp
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax)
|
js_call_bound_function:
push rbp
mov rbp, rsp
sub rsp, 70h
mov eax, [rbp+arg_8]
mov rax, [rbp+arg_0]
mov [rbp+var_20], rsi
mov [rbp+var_18], rdx
mov [rbp+var_30], rcx
mov [rbp+var_28], r8
mov [rbp+var_38], rdi
mov [rbp+var_3C], r9d
mov rax, [rbp+var_20]
mov [rbp+var_48], rax
mov rax, [rbp+var_48]
mov rax, [rax+30h]
mov [rbp+var_50], rax
mov rax, [rbp+var_50]
mov eax, [rax+20h]
add eax, [rbp+var_3C]
mov [rbp+var_6C], eax
mov rax, [rbp+var_38]
mov rdi, [rax+18h]
movsxd rsi, [rbp+var_6C]
shl rsi, 4
call js_check_stack_overflow
cmp eax, 0
jz short loc_22FD8
mov rdi, [rbp+var_38]
call JS_ThrowStackOverflow
mov [rbp+var_10], rax
mov [rbp+var_8], rdx
jmp loc_2314C
loc_22FD8:
movsxd rcx, [rbp+var_6C]
shl rcx, 4
mov rax, rsp
sub rax, rcx
mov rsp, rax
mov [rbp+var_58], rax
mov [rbp+var_70], 0
loc_22FF4:
mov eax, [rbp+var_70]
mov rcx, [rbp+var_50]
cmp eax, [rcx+20h]
jge short loc_2303B
mov rax, [rbp+var_58]
movsxd rcx, [rbp+var_70]
shl rcx, 4
add rax, rcx
mov rcx, [rbp+var_50]
add rcx, 28h ; '('
movsxd rdx, [rbp+var_70]
shl rdx, 4
add rcx, rdx
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
mov eax, [rbp+var_70]
add eax, 1
mov [rbp+var_70], eax
jmp short loc_22FF4
loc_2303B:
mov [rbp+var_70], 0
loc_23042:
mov eax, [rbp+var_70]
cmp eax, [rbp+var_3C]
jge short loc_2308A
mov rax, [rbp+var_58]
mov rcx, [rbp+var_50]
mov ecx, [rcx+20h]
add ecx, [rbp+var_70]
movsxd rcx, ecx
shl rcx, 4
add rax, rcx
mov rcx, [rbp+arg_0]
movsxd rdx, [rbp+var_70]
shl rdx, 4
add rcx, rdx
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
mov eax, [rbp+var_70]
add eax, 1
mov [rbp+var_70], eax
jmp short loc_23042
loc_2308A:
mov eax, [rbp+arg_8]
and eax, 1
cmp eax, 0
jz short loc_23110
mov rax, [rbp+var_30]
mov [rbp+var_68], rax
mov rax, [rbp+var_28]
mov [rbp+var_60], rax
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_68]
mov r8, [rbp+var_60]
call js_same_value
cmp eax, 0
jz short loc_230D6
mov rax, [rbp+var_50]
mov rcx, [rax]
mov [rbp+var_68], rcx
mov rax, [rax+8]
mov [rbp+var_60], rax
loc_230D6:
mov rdi, [rbp+var_38]
mov rcx, [rbp+var_50]
mov r9d, [rbp+var_6C]
mov rax, [rbp+var_58]
mov rsi, [rcx]
mov rdx, [rcx+8]
mov rcx, [rbp+var_68]
mov r8, [rbp+var_60]
sub rsp, 10h
mov [rsp+80h+var_80], rax
call JS_CallConstructor2
add rsp, 10h
mov [rbp+var_10], rax
mov [rbp+var_8], rdx
jmp short loc_2314C
loc_23110:
mov rdi, [rbp+var_38]
mov rcx, [rbp+var_50]
mov r8, [rbp+var_50]
mov r9d, [rbp+var_6C]
mov rax, [rbp+var_58]
mov rsi, [rcx]
mov rdx, [rcx+8]
mov rcx, [r8+10h]
mov r8, [r8+18h]
sub rsp, 10h
mov [rsp+80h+var_80], rax
call JS_Call
add rsp, 10h
mov [rbp+var_10], rax
mov [rbp+var_8], rdx
loc_2314C:
mov rax, [rbp+var_10]
mov rdx, [rbp+var_8]
mov rsp, rbp
pop rbp
retn
|
long long js_call_bound_function(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
int a6,
long long a7,
char a8)
{
long long v8; // rdx
int *v9; // rax
long long *v10; // rcx
int *v11; // rax
_QWORD *v12; // rcx
long long v13; // rdx
long long v14; // rdx
int i; // [rsp+10h] [rbp-70h] BYREF
int v17; // [rsp+14h] [rbp-6Ch]
long long v18; // [rsp+18h] [rbp-68h]
long long v19; // [rsp+20h] [rbp-60h]
int *v20; // [rsp+28h] [rbp-58h]
long long *v21; // [rsp+30h] [rbp-50h]
long long v22; // [rsp+38h] [rbp-48h]
int v23; // [rsp+44h] [rbp-3Ch]
long long v24; // [rsp+48h] [rbp-38h]
long long v25; // [rsp+50h] [rbp-30h]
long long v26; // [rsp+58h] [rbp-28h]
long long v27; // [rsp+60h] [rbp-20h]
long long v28; // [rsp+68h] [rbp-18h]
long long v29; // [rsp+70h] [rbp-10h]
long long v30; // [rsp+78h] [rbp-8h]
v27 = a2;
v28 = a3;
v25 = a4;
v26 = a5;
v24 = a1;
v23 = a6;
v22 = a2;
v21 = *(long long **)(a2 + 48);
v17 = a6 + *((_DWORD *)v21 + 8);
if ( (unsigned int)js_check_stack_overflow(*(_QWORD *)(a1 + 24), 16LL * v17) )
{
v29 = JS_ThrowStackOverflow(v24);
v30 = v8;
}
else
{
v20 = &i - 4 * v17;
for ( i = 0; i < *((_DWORD *)v21 + 8); ++i )
{
v9 = &v20[4 * i];
v10 = &v21[2 * i + 5];
*(_QWORD *)v9 = *v10;
*((_QWORD *)v9 + 1) = v10[1];
}
for ( i = 0; i < v23; ++i )
{
v11 = &v20[4 * i + 4 * *((_DWORD *)v21 + 8)];
v12 = (_QWORD *)(16LL * i + a7);
*(_QWORD *)v11 = *v12;
*((_QWORD *)v11 + 1) = v12[1];
}
if ( (a8 & 1) != 0 )
{
v18 = v25;
v19 = v26;
if ( (unsigned int)js_same_value(v24, v27, v28, v25, v26) )
{
v18 = *v21;
v19 = v21[1];
}
v29 = JS_CallConstructor2(v24, *v21, v21[1], v18, v19, v17, (long long)v20);
v30 = v13;
}
else
{
v29 = JS_Call(v24, *v21, v21[1], v21[2], v21[3], v17, (long long)v20);
v30 = v14;
}
}
return v29;
}
|
js_call_bound_function:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV EAX,dword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x30],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],R9D
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RAX + 0x20]
ADD EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x6c],EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RAX + 0x18]
MOVSXD RSI,dword ptr [RBP + -0x6c]
SHL RSI,0x4
CALL 0x0014dce0
CMP EAX,0x0
JZ 0x00122fd8
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x001601e0
MOV qword ptr [RBP + -0x10],RAX
MOV qword ptr [RBP + -0x8],RDX
JMP 0x0012314c
LAB_00122fd8:
MOVSXD RCX,dword ptr [RBP + -0x6c]
SHL RCX,0x4
MOV RAX,RSP
SUB RAX,RCX
MOV RSP,RAX
MOV qword ptr [RBP + -0x58],RAX
MOV dword ptr [RBP + -0x70],0x0
LAB_00122ff4:
MOV EAX,dword ptr [RBP + -0x70]
MOV RCX,qword ptr [RBP + -0x50]
CMP EAX,dword ptr [RCX + 0x20]
JGE 0x0012303b
MOV RAX,qword ptr [RBP + -0x58]
MOVSXD RCX,dword ptr [RBP + -0x70]
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x50]
ADD RCX,0x28
MOVSXD RDX,dword ptr [RBP + -0x70]
SHL RDX,0x4
ADD RCX,RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV EAX,dword ptr [RBP + -0x70]
ADD EAX,0x1
MOV dword ptr [RBP + -0x70],EAX
JMP 0x00122ff4
LAB_0012303b:
MOV dword ptr [RBP + -0x70],0x0
LAB_00123042:
MOV EAX,dword ptr [RBP + -0x70]
CMP EAX,dword ptr [RBP + -0x3c]
JGE 0x0012308a
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RCX + 0x20]
ADD ECX,dword ptr [RBP + -0x70]
MOVSXD RCX,ECX
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RBP + 0x10]
MOVSXD RDX,dword ptr [RBP + -0x70]
SHL RDX,0x4
ADD RCX,RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV EAX,dword ptr [RBP + -0x70]
ADD EAX,0x1
MOV dword ptr [RBP + -0x70],EAX
JMP 0x00123042
LAB_0012308a:
MOV EAX,dword ptr [RBP + 0x18]
AND EAX,0x1
CMP EAX,0x0
JZ 0x00123110
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x60],RAX
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x68]
MOV R8,qword ptr [RBP + -0x60]
CALL 0x00135b10
CMP EAX,0x0
JZ 0x001230d6
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RBP + -0x68],RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x60],RAX
LAB_001230d6:
MOV RDI,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x50]
MOV R9D,dword ptr [RBP + -0x6c]
MOV RAX,qword ptr [RBP + -0x58]
MOV RSI,qword ptr [RCX]
MOV RDX,qword ptr [RCX + 0x8]
MOV RCX,qword ptr [RBP + -0x68]
MOV R8,qword ptr [RBP + -0x60]
SUB RSP,0x10
MOV qword ptr [RSP],RAX
CALL 0x00148090
ADD RSP,0x10
MOV qword ptr [RBP + -0x10],RAX
MOV qword ptr [RBP + -0x8],RDX
JMP 0x0012314c
LAB_00123110:
MOV RDI,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x50]
MOV R8,qword ptr [RBP + -0x50]
MOV R9D,dword ptr [RBP + -0x6c]
MOV RAX,qword ptr [RBP + -0x58]
MOV RSI,qword ptr [RCX]
MOV RDX,qword ptr [RCX + 0x8]
MOV RCX,qword ptr [R8 + 0x10]
MOV R8,qword ptr [R8 + 0x18]
SUB RSP,0x10
MOV qword ptr [RSP],RAX
CALL 0x0013a050
ADD RSP,0x10
MOV qword ptr [RBP + -0x10],RAX
MOV qword ptr [RBP + -0x8],RDX
LAB_0012314c:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
MOV RSP,RBP
POP RBP
RET
|
int1 [16]
js_call_bound_function
(long param_1,long param_2,int8 param_3,int8 param_4,int8 param_5,
int param_6,long param_7,uint param_8)
{
int8 uVar1;
int8 uVar2;
int8 uVar3;
int8 uVar4;
int iVar5;
long lVar6;
long lVar7;
int iVar8;
long lVar9;
int8 *puVar10;
int1 auVar11 [16];
long alStack_90 [3];
int local_78 [2];
int8 local_70;
int8 local_68;
int *local_60;
int8 *local_58;
long local_50;
int local_44;
long local_40;
int8 local_38;
int8 local_30;
long local_28;
int8 local_20;
local_58 = *(int8 **)(param_2 + 0x30);
local_78[1] = *(int *)(local_58 + 4) + param_6;
alStack_90[2] = 0x122fbd;
local_50 = param_2;
local_44 = param_6;
local_40 = param_1;
local_38 = param_4;
local_30 = param_5;
local_28 = param_2;
local_20 = param_3;
iVar8 = js_check_stack_overflow(*(int8 *)(param_1 + 0x18),(long)local_78[1] << 4);
uVar3 = local_20;
lVar7 = local_28;
uVar2 = local_30;
uVar1 = local_38;
lVar6 = local_40;
iVar5 = local_78[1];
if (iVar8 == 0) {
lVar9 = (long)local_78[1];
local_60 = local_78 + lVar9 * -4;
for (local_78[0] = 0; local_78[0] < *(int *)(local_58 + 4); local_78[0] = local_78[0] + 1) {
*(int8 *)(local_60 + (long)local_78[0] * 4) = local_58[(long)local_78[0] * 2 + 5];
*(int8 *)(local_60 + (long)local_78[0] * 4 + 2) =
(local_58 + (long)local_78[0] * 2 + 5)[1];
}
for (local_78[0] = 0; local_78[0] < local_44; local_78[0] = local_78[0] + 1) {
iVar8 = *(int *)(local_58 + 4);
puVar10 = (int8 *)(param_7 + (long)local_78[0] * 0x10);
*(int8 *)(local_60 + (long)(iVar8 + local_78[0]) * 4) = *puVar10;
*(int8 *)(local_60 + (long)(iVar8 + local_78[0]) * 4 + 2) = puVar10[1];
}
if ((param_8 & 1) == 0) {
uVar1 = *local_58;
uVar2 = local_58[1];
uVar3 = local_58[2];
uVar4 = local_58[3];
alStack_90[lVar9 * -2 + 1] = (long)local_60;
alStack_90[lVar9 * -2] = 0x123140;
auVar11 = JS_Call(lVar6,uVar1,uVar2,uVar3,uVar4,iVar5);
}
else {
local_70 = local_38;
local_68 = local_30;
alStack_90[lVar9 * -2 + 2] = 0x1230be;
iVar8 = js_same_value(lVar6,lVar7,uVar3,uVar1,uVar2);
lVar6 = local_40;
iVar5 = local_78[1];
if (iVar8 != 0) {
local_70 = *local_58;
local_68 = local_58[1];
}
uVar4 = local_68;
uVar3 = local_70;
uVar1 = *local_58;
uVar2 = local_58[1];
alStack_90[lVar9 * -2 + 1] = (long)local_60;
alStack_90[lVar9 * -2] = 0x123102;
auVar11 = JS_CallConstructor2(lVar6,uVar1,uVar2,uVar3,uVar4,iVar5);
}
}
else {
alStack_90[2] = 0x122fcb;
auVar11 = JS_ThrowStackOverflow(local_40);
}
return auVar11;
}
|
|
18,402
|
js_call_bound_function
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_call_bound_function(JSContext *ctx, JSValue func_obj,
JSValue this_obj,
int argc, JSValue *argv, int flags)
{
JSObject *p;
JSBoundFunction *bf;
JSValue *arg_buf, new_target;
int arg_count, i;
p = JS_VALUE_GET_OBJ(func_obj);
bf = p->u.bound_function;
arg_count = bf->argc + argc;
if (js_check_stack_overflow(ctx->rt, sizeof(JSValue) * arg_count))
return JS_ThrowStackOverflow(ctx);
arg_buf = alloca(sizeof(JSValue) * arg_count);
for(i = 0; i < bf->argc; i++) {
arg_buf[i] = bf->argv[i];
}
for(i = 0; i < argc; i++) {
arg_buf[bf->argc + i] = argv[i];
}
if (flags & JS_CALL_FLAG_CONSTRUCTOR) {
new_target = this_obj;
if (js_same_value(ctx, func_obj, new_target))
new_target = bf->func_obj;
return JS_CallConstructor2(ctx, bf->func_obj, new_target,
arg_count, arg_buf);
} else {
return JS_Call(ctx, bf->func_obj, bf->this_val,
arg_count, arg_buf);
}
}
|
O1
|
c
|
js_call_bound_function:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rbp, %r10
movq 0x30(%rsi), %r13
movslq 0x20(%r13), %rax
movslq %r9d, %r14
addq %rax, %r14
movq 0x18(%rdi), %rdi
movq %r14, %rax
shlq $0x4, %rax
subq %rax, %r10
cmpq 0xe8(%rdi), %r10
jae 0x1d3d6
leaq 0x81c17(%rip), %rsi # 0x9efd6
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x20add
movl $0x6, %edx
jmp 0x1d4d0
movq %rsp, %r15
addq $0xf, %rax
andq $-0x10, %rax
subq %rax, %r15
movq %r15, %rsp
cmpl $0x0, 0x20(%r13)
jle 0x1d411
leaq 0x28(%r13), %rax
xorl %r11d, %r11d
xorl %edi, %edi
movups (%rax,%r11), %xmm0
movups %xmm0, (%r15,%r11)
incq %rdi
movslq 0x20(%r13), %r10
addq $0x10, %r11
cmpq %r10, %rdi
jl 0x1d3f7
movl 0x18(%rbp), %eax
testl %r9d, %r9d
jle 0x1d443
movq 0x10(%rbp), %r11
movl %r9d, %edi
xorl %r10d, %r10d
movslq 0x20(%r13), %r9
addq %r10, %r9
shlq $0x4, %r9
movups (%r11), %xmm0
movups %xmm0, (%r15,%r9)
incq %r10
addq $0x10, %r11
cmpq %r10, %rdi
jne 0x1d423
testb $0x1, %al
jne 0x1d490
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq 0x10(%r13), %rcx
movq 0x18(%r13), %r8
movl $0x0, -0x40(%rbp)
movq $0x3, -0x38(%rbp)
subq $0x20, %rsp
movups -0x40(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %r15, 0x10(%rsp)
movl $0x2, 0x18(%rsp)
movq %rbx, %rdi
movl %r14d, %r9d
callq 0x284ca
addq $0x20, %rsp
jmp 0x1d4cd
movq %rbx, %rdi
movq %r8, -0x30(%rbp)
movq %rcx, %r12
callq 0x26461
movq -0x30(%rbp), %r8
testl %eax, %eax
je 0x1d4af
movq (%r13), %r12
movq 0x8(%r13), %r8
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %rbx, %rdi
movq %r12, %rcx
movl %r14d, %r9d
pushq $0x2
pushq %r15
callq 0x2fa61
addq $0x10, %rsp
movq %rax, %r14
movq %r14, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
js_call_bound_function:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
mov r10, rbp
mov r13, [rsi+30h]
movsxd rax, dword ptr [r13+20h]
movsxd r14, r9d
add r14, rax
mov rdi, [rdi+18h]
mov rax, r14
shl rax, 4
sub r10, rax
cmp r10, [rdi+0E8h]
jnb short loc_1D3D6
lea rsi, aMaximumCallSta; "Maximum call stack size exceeded"
xor r14d, r14d
mov rdi, rbx
xor eax, eax
call JS_ThrowRangeError
mov edx, 6
jmp loc_1D4D0
loc_1D3D6:
mov r15, rsp
add rax, 0Fh
and rax, 0FFFFFFFFFFFFFFF0h
sub r15, rax
mov rsp, r15
cmp dword ptr [r13+20h], 0
jle short loc_1D411
lea rax, [r13+28h]
xor r11d, r11d
xor edi, edi
loc_1D3F7:
movups xmm0, xmmword ptr [rax+r11]
movups xmmword ptr [r15+r11], xmm0
inc rdi
movsxd r10, dword ptr [r13+20h]
add r11, 10h
cmp rdi, r10
jl short loc_1D3F7
loc_1D411:
mov eax, [rbp+arg_8]
test r9d, r9d
jle short loc_1D443
mov r11, [rbp+arg_0]
mov edi, r9d
xor r10d, r10d
loc_1D423:
movsxd r9, dword ptr [r13+20h]
add r9, r10
shl r9, 4
movups xmm0, xmmword ptr [r11]
movups xmmword ptr [r15+r9], xmm0
inc r10
add r11, 10h
cmp rdi, r10
jnz short loc_1D423
loc_1D443:
test al, 1
jnz short loc_1D490
mov rsi, [r13+0]
mov rdx, [r13+8]
mov rcx, [r13+10h]
mov r8, [r13+18h]
mov dword ptr [rbp+var_40], 0
mov qword ptr [rbp+var_40+8], 3
sub rsp, 20h
movups xmm0, [rbp+var_40]
movups [rsp+60h+var_60], xmm0
mov [rsp+60h+var_50], r15
mov [rsp+60h+var_48], 2
mov rdi, rbx
mov r9d, r14d
call JS_CallInternal
add rsp, 20h
jmp short loc_1D4CD
loc_1D490:
mov rdi, rbx
mov [rbp+var_30], r8
mov r12, rcx
call js_same_value
mov r8, [rbp+var_30]
test eax, eax
jz short loc_1D4AF
mov r12, [r13+0]
mov r8, [r13+8]
loc_1D4AF:
mov rsi, [r13+0]
mov rdx, [r13+8]
mov rdi, rbx
mov rcx, r12
mov r9d, r14d
push 2
push r15
call JS_CallConstructorInternal
add rsp, 10h
loc_1D4CD:
mov r14, rax
loc_1D4D0:
mov rax, r14
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long js_call_bound_function(
long long a1,
long long a2,
int a3,
int a4,
long long a5,
int a6,
_OWORD *a7,
char a8)
{
long long *v9; // r13
int v10; // r14d
long long v11; // rax
long long v12; // r14
char *v13; // r15
long long v14; // r11
long long v15; // rdi
long long i; // r10
long long v18; // rsi
long long v19; // rdx
long long v20; // rcx
long long v21; // r8
long long v23; // r12
int v24; // eax
long long v25; // r8
int v27; // [rsp+20h] [rbp-40h] BYREF
long long v28; // [rsp+28h] [rbp-38h]
long long v29; // [rsp+30h] [rbp-30h]
long long savedregs; // [rsp+60h] [rbp+0h] BYREF
v9 = *(long long **)(a2 + 48);
v10 = *((_DWORD *)v9 + 8) + a6;
v11 = 16 * (*((int *)v9 + 8) + (long long)a6);
if ( (unsigned long long)&savedregs - v11 >= *(_QWORD *)(*(_QWORD *)(a1 + 24) + 232LL) )
{
v13 = (char *)&v27 - ((v11 + 15) & 0xFFFFFFFFFFFFFFF0LL);
if ( *((int *)v9 + 8) > 0 )
{
v14 = 0LL;
v15 = 0LL;
do
{
*(_OWORD *)&v13[v14 * 8] = *(_OWORD *)&v9[v14 + 5];
++v15;
v14 += 2LL;
}
while ( v15 < *((int *)v9 + 8) );
}
if ( a6 > 0 )
{
for ( i = 0LL; i != a6; ++i )
*(_OWORD *)&v13[16 * i + 16 * *((int *)v9 + 8)] = *a7++;
}
if ( (a8 & 1) != 0 )
{
v29 = a5;
LODWORD(v23) = a4;
v24 = js_same_value(a1);
LODWORD(v25) = v29;
if ( v24 )
{
v23 = *v9;
v25 = v9[1];
}
return JS_CallConstructorInternal(a1, *v9, v9[1], v23, v25, v10, (long long)v13, 2);
}
else
{
v18 = *v9;
v19 = v9[1];
v20 = v9[2];
v21 = v9[3];
v27 = 0;
v28 = 3LL;
return JS_CallInternal(a1, v18, v19, v20, v21, v10, 0, 3, (long long)v13, 2);
}
}
else
{
v12 = 0LL;
JS_ThrowRangeError(a1, (unsigned int)"Maximum call stack size exceeded", a3, a4, a5, a6);
}
return v12;
}
| |||
18,403
|
js_call_bound_function
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_call_bound_function(JSContext *ctx, JSValue func_obj,
JSValue this_obj,
int argc, JSValue *argv, int flags)
{
JSObject *p;
JSBoundFunction *bf;
JSValue *arg_buf, new_target;
int arg_count, i;
p = JS_VALUE_GET_OBJ(func_obj);
bf = p->u.bound_function;
arg_count = bf->argc + argc;
if (js_check_stack_overflow(ctx->rt, sizeof(JSValue) * arg_count))
return JS_ThrowStackOverflow(ctx);
arg_buf = alloca(sizeof(JSValue) * arg_count);
for(i = 0; i < bf->argc; i++) {
arg_buf[i] = bf->argv[i];
}
for(i = 0; i < argc; i++) {
arg_buf[bf->argc + i] = argv[i];
}
if (flags & JS_CALL_FLAG_CONSTRUCTOR) {
new_target = this_obj;
if (js_same_value(ctx, func_obj, new_target))
new_target = bf->func_obj;
return JS_CallConstructor2(ctx, bf->func_obj, new_target,
arg_count, arg_buf);
} else {
return JS_Call(ctx, bf->func_obj, bf->this_val,
arg_count, arg_buf);
}
}
|
O2
|
c
|
js_call_bound_function:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rbp, %r11
movq 0x30(%rsi), %r13
movl 0x20(%r13), %eax
leal (%rax,%r9), %r14d
movq 0x18(%rdi), %rdi
movslq %r14d, %r10
shlq $0x4, %r10
subq %r10, %r11
cmpq 0xe8(%rdi), %r11
jae 0x17a9c
movq %rbx, %rdi
callq 0x35d91
pushq $0x6
popq %rdx
xorl %eax, %eax
jmp 0x17b71
movl %r14d, -0x2c(%rbp)
movq %rcx, %r12
movq %r8, %r15
movl 0x18(%rbp), %ecx
movq 0x10(%rbp), %rdi
movslq %eax, %r8
movq %rsp, %r14
addq $0xf, %r10
andq $-0x10, %r10
subq %r10, %r14
movq %r14, %rsp
xorl %r10d, %r10d
xorl %r11d, %r11d
cmpq %r8, %r11
jge 0x17ae0
movups 0x28(%r13,%r10), %xmm0
movups %xmm0, (%r14,%r10)
incq %r11
addq $0x10, %r10
jmp 0x17ac7
xorl %r8d, %r8d
testl %r9d, %r9d
cmovlel %r8d, %r9d
shlq $0x4, %r9
cmpq %r8, %r9
je 0x17b0e
cltq
movq %rax, %r10
shlq $0x4, %r10
movups (%rdi,%r8), %xmm0
movups %xmm0, (%r14,%r10)
addq $0x10, %r8
incl %eax
jmp 0x17aee
testb $0x1, %cl
jne 0x17b37
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq 0x10(%r13), %rcx
movq 0x18(%r13), %r8
subq $0x8, %rsp
movq %rbx, %rdi
movl -0x2c(%rbp), %r9d
pushq %r14
callq 0x21eb6
jmp 0x17b6f
movq %rbx, %rdi
movq %r12, %rcx
movq %r15, %r8
callq 0x1ff32
testl %eax, %eax
movq (%r13), %rsi
movq 0x8(%r13), %rdx
cmovneq %rdx, %r15
cmovneq %rsi, %r12
subq $0x8, %rsp
movq %rbx, %rdi
movq %r12, %rcx
movq %r15, %r8
movl -0x2c(%rbp), %r9d
pushq %r14
callq 0x28200
popq %rcx
popq %rsi
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
js_call_bound_function:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
mov r11, rbp
mov r13, [rsi+30h]
mov eax, [r13+20h]
lea r14d, [rax+r9]
mov rdi, [rdi+18h]
movsxd r10, r14d
shl r10, 4
sub r11, r10
cmp r11, [rdi+0E8h]
jnb short loc_17A9C
mov rdi, rbx
call JS_ThrowStackOverflow
push 6
pop rdx
xor eax, eax
jmp loc_17B71
loc_17A9C:
mov [rbp+var_2C], r14d
mov r12, rcx
mov r15, r8
mov ecx, [rbp+arg_8]
mov rdi, [rbp+arg_0]
movsxd r8, eax
mov r14, rsp
add r10, 0Fh
and r10, 0FFFFFFFFFFFFFFF0h
sub r14, r10
mov rsp, r14
xor r10d, r10d
xor r11d, r11d
loc_17AC7:
cmp r11, r8
jge short loc_17AE0
movups xmm0, xmmword ptr [r13+r10+28h]
movups xmmword ptr [r14+r10], xmm0
inc r11
add r10, 10h
jmp short loc_17AC7
loc_17AE0:
xor r8d, r8d
test r9d, r9d
cmovle r9d, r8d
shl r9, 4
loc_17AEE:
cmp r9, r8
jz short loc_17B0E
cdqe
mov r10, rax
shl r10, 4
movups xmm0, xmmword ptr [rdi+r8]
movups xmmword ptr [r14+r10], xmm0
add r8, 10h
inc eax
jmp short loc_17AEE
loc_17B0E:
test cl, 1
jnz short loc_17B37
mov rsi, [r13+0]
mov rdx, [r13+8]
mov rcx, [r13+10h]
mov r8, [r13+18h]
sub rsp, 8
mov rdi, rbx
mov r9d, [rbp+var_2C]
push r14
call JS_Call
jmp short loc_17B6F
loc_17B37:
mov rdi, rbx
mov rcx, r12
mov r8, r15
call js_same_value
test eax, eax
mov rsi, [r13+0]
mov rdx, [r13+8]
cmovnz r15, rdx
cmovnz r12, rsi
sub rsp, 8
mov rdi, rbx
mov rcx, r12
mov r8, r15
mov r9d, [rbp+var_2C]
push r14
call JS_CallConstructor2
loc_17B6F:
pop rcx
pop rsi
loc_17B71:
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long js_call_bound_function(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
long long a7,
char a8)
{
long long v8; // rax
long long *v9; // r13
int v10; // eax
long long v11; // r10
long long v13; // r12
char *v15; // r14
long long v16; // r10
long long i; // r11
long long v18; // r8
long long v19; // r9
long long v20; // [rsp-4h] [rbp-30h] BYREF
long long savedregs; // [rsp+2Ch] [rbp+0h] BYREF
v20 = v8;
v9 = *(long long **)(a2 + 48);
v10 = *((_DWORD *)v9 + 8);
v11 = 16LL * (v10 + (int)a6);
if ( (unsigned long long)&savedregs - v11 >= *(_QWORD *)(*(_QWORD *)(a1 + 24) + 232LL) )
{
HIDWORD(v20) = v10 + a6;
LODWORD(v13) = a4;
v15 = (char *)&v20 - ((v11 + 15) & 0xFFFFFFFFFFFFFFF0LL);
v16 = 0LL;
for ( i = 0LL; i < v10; ++i )
{
*(_OWORD *)&v15[v16 * 8] = *(_OWORD *)&v9[v16 + 5];
v16 += 2LL;
}
v18 = 0LL;
if ( (int)a6 <= 0 )
a6 = 0LL;
v19 = 16 * a6;
while ( v19 != v18 )
{
*(_OWORD *)&v15[16 * v10] = *(_OWORD *)(a7 + v18);
v18 += 16LL;
++v10;
}
if ( (a8 & 1) != 0 )
{
if ( (unsigned int)js_same_value(a1, a2, a3, a4, a5) )
{
a5 = v9[1];
v13 = *v9;
}
return JS_CallConstructor2(a1, *v9, v9[1], v13, a5, HIDWORD(v20), (long long)v15);
}
else
{
return JS_Call(a1, *v9, v9[1], v9[2], v9[3], HIDWORD(v20), (long long)v15);
}
}
else
{
JS_ThrowStackOverflow(a1);
return 0LL;
}
}
|
js_call_bound_function:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R11,RBP
MOV R13,qword ptr [RSI + 0x30]
MOV EAX,dword ptr [R13 + 0x20]
LEA R14D,[RAX + R9*0x1]
MOV RDI,qword ptr [RDI + 0x18]
MOVSXD R10,R14D
SHL R10,0x4
SUB R11,R10
CMP R11,qword ptr [RDI + 0xe8]
JNC 0x00117a9c
MOV RDI,RBX
CALL 0x00135d91
PUSH 0x6
POP RDX
XOR EAX,EAX
JMP 0x00117b71
LAB_00117a9c:
MOV dword ptr [RBP + -0x2c],R14D
MOV R12,RCX
MOV R15,R8
MOV ECX,dword ptr [RBP + 0x18]
MOV RDI,qword ptr [RBP + 0x10]
MOVSXD R8,EAX
MOV R14,RSP
ADD R10,0xf
AND R10,-0x10
SUB R14,R10
MOV RSP,R14
XOR R10D,R10D
XOR R11D,R11D
LAB_00117ac7:
CMP R11,R8
JGE 0x00117ae0
MOVUPS XMM0,xmmword ptr [R13 + R10*0x1 + 0x28]
MOVUPS xmmword ptr [R14 + R10*0x1],XMM0
INC R11
ADD R10,0x10
JMP 0x00117ac7
LAB_00117ae0:
XOR R8D,R8D
TEST R9D,R9D
CMOVLE R9D,R8D
SHL R9,0x4
LAB_00117aee:
CMP R9,R8
JZ 0x00117b0e
CDQE
MOV R10,RAX
SHL R10,0x4
MOVUPS XMM0,xmmword ptr [RDI + R8*0x1]
MOVUPS xmmword ptr [R14 + R10*0x1],XMM0
ADD R8,0x10
INC EAX
JMP 0x00117aee
LAB_00117b0e:
TEST CL,0x1
JNZ 0x00117b37
MOV RSI,qword ptr [R13]
MOV RDX,qword ptr [R13 + 0x8]
MOV RCX,qword ptr [R13 + 0x10]
MOV R8,qword ptr [R13 + 0x18]
SUB RSP,0x8
MOV RDI,RBX
MOV R9D,dword ptr [RBP + -0x2c]
PUSH R14
CALL 0x00121eb6
JMP 0x00117b6f
LAB_00117b37:
MOV RDI,RBX
MOV RCX,R12
MOV R8,R15
CALL 0x0011ff32
TEST EAX,EAX
MOV RSI,qword ptr [R13]
MOV RDX,qword ptr [R13 + 0x8]
CMOVNZ R15,RDX
CMOVNZ R12,RSI
SUB RSP,0x8
MOV RDI,RBX
MOV RCX,R12
MOV R8,R15
MOV R9D,dword ptr [RBP + -0x2c]
PUSH R14
CALL 0x00128200
LAB_00117b6f:
POP RCX
POP RSI
LAB_00117b71:
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
js_call_bound_function
(long param_1,long param_2,int8 param_3,int8 param_4,int8 param_5,
uint param_6,long param_7,uint param_8)
{
int4 *puVar1;
int *piVar2;
int *piVar3;
int4 *puVar4;
int8 *puVar5;
int8 uVar6;
int8 uVar7;
int8 uVar8;
int4 uVar9;
int4 uVar10;
int4 uVar11;
int iVar12;
int iVar13;
int iVar14;
int4 in_EAX;
int iVar15;
int8 uVar16;
ulong uVar17;
ulong uVar18;
long lVar19;
long lVar20;
long lVar21;
int *piVar22;
long alStack_50 [3];
int aiStack_38 [2];
puVar5 = *(int8 **)(param_2 + 0x30);
iVar15 = *(int *)(puVar5 + 4);
lVar19 = (long)(int)(iVar15 + param_6);
if (&stack0xfffffffffffffff8 + lVar19 * -0x10 < *(int1 **)(*(long *)(param_1 + 0x18) + 0xe8)
) {
alStack_50[2] = 0x117a92;
JS_ThrowStackOverflow(param_1);
uVar16 = 0;
}
else {
aiStack_38[1] = iVar15 + param_6;
aiStack_38[0] = in_EAX;
piVar22 = aiStack_38 + lVar19 * -4;
lVar20 = 0;
for (lVar21 = 0; lVar21 < iVar15; lVar21 = lVar21 + 1) {
puVar4 = (int4 *)((long)puVar5 + lVar20 + 0x28);
uVar9 = puVar4[1];
uVar10 = puVar4[2];
uVar11 = puVar4[3];
puVar1 = (int4 *)((long)piVar22 + lVar20);
*puVar1 = *puVar4;
puVar1[1] = uVar9;
puVar1[2] = uVar10;
puVar1[3] = uVar11;
lVar20 = lVar20 + 0x10;
}
uVar17 = 0;
uVar18 = (ulong)param_6;
if ((int)param_6 < 1) {
uVar18 = uVar17;
}
for (; uVar18 * 0x10 != uVar17; uVar17 = uVar17 + 0x10) {
piVar2 = (int *)(param_7 + uVar17);
iVar12 = piVar2[1];
iVar13 = piVar2[2];
iVar14 = piVar2[3];
piVar3 = piVar22 + (long)iVar15 * 4;
*piVar3 = *piVar2;
piVar3[1] = iVar12;
piVar3[2] = iVar13;
piVar3[3] = iVar14;
iVar15 = iVar15 + 1;
}
if ((param_8 & 1) == 0) {
uVar16 = *puVar5;
uVar6 = puVar5[1];
uVar7 = puVar5[2];
uVar8 = puVar5[3];
iVar15 = aiStack_38[1];
alStack_50[lVar19 * -2 + 1] = (long)piVar22;
alStack_50[lVar19 * -2] = 0x117b35;
uVar16 = JS_Call(param_1,uVar16,uVar6,uVar7,uVar8,iVar15);
}
else {
(aiStack_38 + lVar19 * -4 + -2)[0] = 0x117b45;
(aiStack_38 + lVar19 * -4 + -2)[1] = 0;
iVar15 = js_same_value(param_1,param_2,param_3,param_4,param_5);
uVar16 = *puVar5;
uVar6 = puVar5[1];
if (iVar15 != 0) {
param_4 = uVar16;
param_5 = uVar6;
}
iVar15 = aiStack_38[1];
alStack_50[lVar19 * -2 + 1] = (long)piVar22;
alStack_50[lVar19 * -2] = 0x117b6f;
uVar16 = JS_CallConstructor2(param_1,uVar16,uVar6,param_4,param_5,iVar15);
}
}
return uVar16;
}
|
|
18,404
|
init_alloc_root
|
eloqsql/mysys/my_alloc.c
|
void init_alloc_root(PSI_memory_key key, MEM_ROOT *mem_root, size_t block_size,
size_t pre_alloc_size __attribute__((unused)),
myf my_flags)
{
DBUG_ENTER("init_alloc_root");
DBUG_PRINT("enter",("root: %p prealloc: %zu", mem_root, 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 - ALLOC_ROOT_MIN_BLOCK_SIZE) & ~1;
if (my_flags & MY_THREAD_SPECIFIC)
mem_root->block_size|= 1;
mem_root->error_handler= 0;
mem_root->block_num= 4; /* We shift this with >>2 */
mem_root->first_block_usage= 0;
mem_root->m_psi_key= key;
#if !(defined(HAVE_valgrind) && defined(EXTRA_DEBUG))
if (pre_alloc_size)
{
size_t size= pre_alloc_size + ALIGN_SIZE(sizeof(USED_MEM));
if ((mem_root->free= mem_root->pre_alloc=
(USED_MEM*) my_malloc(key, size, MYF(my_flags))))
{
mem_root->free->size= size;
mem_root->free->left= pre_alloc_size;
mem_root->free->next= 0;
TRASH_MEM(mem_root->free);
}
}
#endif
DBUG_VOID_RETURN;
}
|
O3
|
c
|
init_alloc_root:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
xorl %eax, %eax
movq %rax, 0x10(%rsi)
movq $0x20, 0x18(%rsi)
andq $-0x2, %rdx
movl %r8d, %ecx
shrl $0x10, %ecx
andl $0x1, %ecx
addq %rdx, %rcx
addq $-0x28, %rcx
movq %rcx, 0x20(%rsi)
movq %rax, 0x30(%rsi)
movq $0x4, 0x28(%rsi)
movl %edi, 0x38(%rsi)
testq %rbx, %rbx
je 0x2e22c
movq %rsi, %r14
leaq 0x18(%rbx), %r15
movq %r15, %rsi
movq %r8, %rdx
callq 0x28289
movq %rax, 0x10(%r14)
movq %rax, (%r14)
testq %rax, %rax
je 0x2e22c
movq %r15, 0x10(%rax)
movq (%r14), %rax
movq %rbx, 0x8(%rax)
movq (%r14), %rax
movq $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
init_alloc_root:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rcx
xorps xmm0, xmm0
movups xmmword ptr [rsi], xmm0
xor eax, eax
mov [rsi+10h], rax
mov qword ptr [rsi+18h], 20h ; ' '
and rdx, 0FFFFFFFFFFFFFFFEh
mov ecx, r8d
shr ecx, 10h
and ecx, 1
add rcx, rdx
add rcx, 0FFFFFFFFFFFFFFD8h
mov [rsi+20h], rcx
mov [rsi+30h], rax
mov qword ptr [rsi+28h], 4
mov [rsi+38h], edi
test rbx, rbx
jz short loc_2E22C
mov r14, rsi
lea r15, [rbx+18h]
mov rsi, r15
mov rdx, r8
call my_malloc
mov [r14+10h], rax
mov [r14], rax
test rax, rax
jz short loc_2E22C
mov [rax+10h], r15
mov rax, [r14]
mov [rax+8], rbx
mov rax, [r14]
mov qword ptr [rax], 0
loc_2E22C:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long init_alloc_root(unsigned int a1, long long *a2, long long a3, long long a4, unsigned int a5)
{
long long result; // rax
*(_OWORD *)a2 = 0LL;
result = 0LL;
a2[2] = 0LL;
a2[3] = 32LL;
a2[4] = (a3 & 0xFFFFFFFFFFFFFFFELL) + (HIWORD(a5) & 1) - 40;
a2[6] = 0LL;
a2[5] = 4LL;
*((_DWORD *)a2 + 14) = a1;
if ( a4 )
{
result = my_malloc(a1, a4 + 24, a5);
a2[2] = result;
*a2 = result;
if ( result )
{
*(_QWORD *)(result + 16) = a4 + 24;
*(_QWORD *)(*a2 + 8) = a4;
result = *a2;
*(_QWORD *)*a2 = 0LL;
}
}
return result;
}
|
init_alloc_root:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RCX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSI],XMM0
XOR EAX,EAX
MOV qword ptr [RSI + 0x10],RAX
MOV qword ptr [RSI + 0x18],0x20
AND RDX,-0x2
MOV ECX,R8D
SHR ECX,0x10
AND ECX,0x1
ADD RCX,RDX
ADD RCX,-0x28
MOV qword ptr [RSI + 0x20],RCX
MOV qword ptr [RSI + 0x30],RAX
MOV qword ptr [RSI + 0x28],0x4
MOV dword ptr [RSI + 0x38],EDI
TEST RBX,RBX
JZ 0x0012e22c
MOV R14,RSI
LEA R15,[RBX + 0x18]
MOV RSI,R15
MOV RDX,R8
CALL 0x00128289
MOV qword ptr [R14 + 0x10],RAX
MOV qword ptr [R14],RAX
TEST RAX,RAX
JZ 0x0012e22c
MOV qword ptr [RAX + 0x10],R15
MOV RAX,qword ptr [R14]
MOV qword ptr [RAX + 0x8],RBX
MOV RAX,qword ptr [R14]
MOV qword ptr [RAX],0x0
LAB_0012e22c:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void init_alloc_root(int4 param_1,long *param_2,ulong param_3,long param_4,int8 param_5)
{
long lVar1;
*param_2 = 0;
param_2[1] = 0;
param_2[2] = 0;
param_2[3] = 0x20;
param_2[4] = (ulong)((uint)param_5 >> 0x10 & 1) + (param_3 & 0xfffffffffffffffe) + -0x28;
param_2[6] = 0;
param_2[5] = 4;
*(int4 *)(param_2 + 7) = param_1;
if (param_4 != 0) {
lVar1 = my_malloc(param_1,param_4 + 0x18,param_5);
param_2[2] = lVar1;
*param_2 = lVar1;
if (lVar1 != 0) {
*(long *)(lVar1 + 0x10) = param_4 + 0x18;
*(long *)(*param_2 + 8) = param_4;
*(int8 *)*param_2 = 0;
}
}
return;
}
|
|
18,405
|
buffer_add_be
|
corpus-core[P]colibri-stateless/src/util/bytes.c
|
void buffer_add_be(buffer_t* buffer, uint64_t value, uint32_t len) {
buffer_grow(buffer, buffer->data.len + len);
uint32_t s = buffer->data.len;
for (uint32_t i = 0; i < len; i++)
buffer->data.data[s + len - i - 1] = (value >> (i << 3)) & 0xFF;
buffer->data.len += len;
}
|
O0
|
c
|
buffer_add_be:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x18af0
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x1972c
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shrq %cl, %rax
andq $0xff, %rax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x18(%rbp), %ecx
addl -0x14(%rbp), %ecx
subl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x196e9
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
|
buffer_add_be:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov rdi, [rbp+var_8]
mov rax, [rbp+var_8]
mov eax, [rax]
add eax, [rbp+var_14]
mov eax, eax
mov esi, eax
call buffer_grow
mov rax, [rbp+var_8]
mov eax, [rax]
mov [rbp+var_18], eax
mov [rbp+var_1C], 0
loc_196E9:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_14]
jnb short loc_1972C
mov rax, [rbp+var_10]
mov ecx, [rbp+var_1C]
shl ecx, 3
mov ecx, ecx
shr rax, cl
and rax, 0FFh
mov dl, al
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov ecx, [rbp+var_18]
add ecx, [rbp+var_14]
sub ecx, [rbp+var_1C]
sub ecx, 1
mov ecx, ecx
mov [rax+rcx], dl
mov eax, [rbp+var_1C]
add eax, 1
mov [rbp+var_1C], eax
jmp short loc_196E9
loc_1972C:
mov ecx, [rbp+var_14]
mov rax, [rbp+var_8]
add ecx, [rax]
mov [rax], ecx
add rsp, 20h
pop rbp
retn
|
unsigned long long buffer_add_be(unsigned long long a1, unsigned long long a2, unsigned int a3)
{
unsigned long long result; // rax
unsigned int i; // [rsp+4h] [rbp-1Ch]
int v5; // [rsp+8h] [rbp-18h]
buffer_grow(a1, a3 + *(_DWORD *)a1);
v5 = *(_DWORD *)a1;
for ( i = 0; i < a3; ++i )
*(_BYTE *)(*(_QWORD *)(a1 + 8) + a3 + v5 - i - 1) = a2 >> (8 * (unsigned __int8)i);
result = a1;
*(_DWORD *)a1 += a3;
return result;
}
|
buffer_add_be:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV RDI,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX]
ADD EAX,dword ptr [RBP + -0x14]
MOV EAX,EAX
MOV ESI,EAX
CALL 0x00118af0
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x18],EAX
MOV dword ptr [RBP + -0x1c],0x0
LAB_001196e9:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x14]
JNC 0x0011972c
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x1c]
SHL ECX,0x3
MOV ECX,ECX
SHR RAX,CL
AND RAX,0xff
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RBP + -0x18]
ADD ECX,dword ptr [RBP + -0x14]
SUB ECX,dword ptr [RBP + -0x1c]
SUB ECX,0x1
MOV ECX,ECX
MOV byte ptr [RAX + RCX*0x1],DL
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x001196e9
LAB_0011972c:
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x8]
ADD ECX,dword ptr [RAX]
MOV dword ptr [RAX],ECX
ADD RSP,0x20
POP RBP
RET
|
void buffer_add_be(int *param_1,ulong param_2,uint param_3)
{
int iVar1;
uint local_24;
buffer_grow(param_1,*param_1 + param_3);
iVar1 = *param_1;
for (local_24 = 0; local_24 < param_3; local_24 = local_24 + 1) {
*(char *)(*(long *)(param_1 + 2) + (ulong)(((iVar1 + param_3) - local_24) - 1)) =
(char)(param_2 >> ((byte)(local_24 << 3) & 0x3f));
}
*param_1 = param_3 + *param_1;
return;
}
|
|
18,406
|
buffer_add_be
|
corpus-core[P]colibri-stateless/src/util/bytes.c
|
void buffer_add_be(buffer_t* buffer, uint64_t value, uint32_t len) {
buffer_grow(buffer, buffer->data.len + len);
uint32_t s = buffer->data.len;
for (uint32_t i = 0; i < len; i++)
buffer->data.data[s + len - i - 1] = (value >> (i << 3)) & 0xFF;
buffer->data.len += len;
}
|
O3
|
c
|
buffer_add_be:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl (%rdi), %esi
addl %edx, %esi
callq 0x125e5
testl %ebx, %ebx
je 0x12d9f
movl (%r14), %ecx
movl %ebx, %eax
leal (%rcx,%rbx), %edx
decl %edx
shlq $0x3, %rax
xorl %esi, %esi
movl %esi, %ecx
andb $-0x8, %cl
movq %r15, %rdi
shrq %cl, %rdi
movq 0x8(%r14), %rcx
movl %edx, %r8d
movb %dil, (%rcx,%r8)
addq $0x8, %rsi
decl %edx
cmpq %rsi, %rax
jne 0x12d7e
addl %ebx, (%r14)
popq %rbx
popq %r14
popq %r15
retq
|
buffer_add_be:
push r15
push r14
push rbx
mov ebx, edx
mov r15, rsi
mov r14, rdi
mov esi, [rdi]
add esi, edx
call buffer_grow
test ebx, ebx
jz short loc_12D9F
mov ecx, [r14]
mov eax, ebx
lea edx, [rcx+rbx]
dec edx
shl rax, 3
xor esi, esi
loc_12D7E:
mov ecx, esi
and cl, 0F8h
mov rdi, r15
shr rdi, cl
mov rcx, [r14+8]
mov r8d, edx
mov [rcx+r8], dil
add rsi, 8
dec edx
cmp rax, rsi
jnz short loc_12D7E
loc_12D9F:
add [r14], ebx
pop rbx
pop r14
pop r15
retn
|
char buffer_add_be(long long a1, unsigned long long a2, unsigned int a3)
{
long long v5; // rax
unsigned int v6; // edx
long long v7; // rsi
LOBYTE(v5) = buffer_grow(a1, a3 + *(_DWORD *)a1);
if ( a3 )
{
v6 = *(_DWORD *)a1 + a3 - 1;
v5 = 8LL * a3;
v7 = 0LL;
do
{
*(_BYTE *)(*(_QWORD *)(a1 + 8) + v6) = a2 >> (v7 & 0xF8);
v7 += 8LL;
--v6;
}
while ( v5 != v7 );
}
*(_DWORD *)a1 += a3;
return v5;
}
|
buffer_add_be:
PUSH R15
PUSH R14
PUSH RBX
MOV EBX,EDX
MOV R15,RSI
MOV R14,RDI
MOV ESI,dword ptr [RDI]
ADD ESI,EDX
CALL 0x001125e5
TEST EBX,EBX
JZ 0x00112d9f
MOV ECX,dword ptr [R14]
MOV EAX,EBX
LEA EDX,[RCX + RBX*0x1]
DEC EDX
SHL RAX,0x3
XOR ESI,ESI
LAB_00112d7e:
MOV ECX,ESI
AND CL,0xf8
MOV RDI,R15
SHR RDI,CL
MOV RCX,qword ptr [R14 + 0x8]
MOV R8D,EDX
MOV byte ptr [RCX + R8*0x1],DIL
ADD RSI,0x8
DEC EDX
CMP RAX,RSI
JNZ 0x00112d7e
LAB_00112d9f:
ADD dword ptr [R14],EBX
POP RBX
POP R14
POP R15
RET
|
void buffer_add_be(int *param_1,ulong param_2,uint param_3)
{
uint uVar1;
long lVar2;
buffer_grow();
if (param_3 != 0) {
uVar1 = *param_1 + param_3;
lVar2 = 0;
do {
uVar1 = uVar1 - 1;
*(char *)(*(long *)(param_1 + 2) + (ulong)uVar1) = (char)(param_2 >> ((byte)lVar2 & 0x38));
lVar2 = lVar2 + 8;
} while ((ulong)param_3 << 3 != lVar2);
}
*param_1 = *param_1 + param_3;
return;
}
|
|
18,407
|
LefDefParser::lefwLayerACCurrentDensity(char const*, double)
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp
|
int
lefwLayerACCurrentDensity(const char *type,
double value)
{
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (lefwState != LEFW_LAYERROUTING_START && lefwState != LEFW_LAYERROUTING
&& lefwState != LEFW_LAYER_START && lefwState != LEFW_LAYER)
return LEFW_BAD_ORDER;
if (strcmp(type, "PEAK") && strcmp(type, "AVERAGE") && strcmp(type, "RMS"))
return LEFW_BAD_DATA; // type is PEAK, AVERAGE & RMS only
if (lefwWriteEncrypt) {
encPrint(lefwFile, (char*) " ACCURRENTDENSITY %s", type);
lefwLines++;
lefwTableLen = 5;
if (value)
encPrint(lefwFile, (char*) " %.11g\n", value);
// that's it for accurrentdensity
else {
encPrint(lefwFile, (char*) "\n");
// expect to have frequency & tableentries
lefwOldState = lefwState; // save the previous state
lefwState = LEFW_LAYERACCURRENT;
}
} else {
fprintf(lefwFile, " ACCURRENTDENSITY %s", type);
lefwLines++;
lefwTableLen = 5;
if (value)
fprintf(lefwFile, " %.11g\n", value); // that's it for accurrentdensity
else {
fprintf(lefwFile, "\n"); // expect to have frequency & tableentries
lefwOldState = lefwState; // save the previous state
lefwState = LEFW_LAYERACCURRENT;
}
}
return LEFW_OK;
}
|
O3
|
cpp
|
LefDefParser::lefwLayerACCurrentDensity(char const*, double):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0x77f82(%rip), %r13 # 0x8d0f0
movq (%r13), %r15
testq %r15, %r15
je 0x1524c
leaq 0x781be(%rip), %r12 # 0x8d340
movl (%r12), %eax
movl $0x2, %ebx
cmpl $0x1f, %eax
ja 0x152e1
movsd %xmm0, 0x8(%rsp)
movl $0x900000c0, %ecx # imm = 0x900000C0
btl %eax, %ecx
jae 0x152e1
movq %rdi, %r14
leaq 0x460c7(%rip), %rsi # 0x5b279
callq 0x22d0
testl %eax, %eax
je 0x151ea
leaq 0x460bc(%rip), %rsi # 0x5b27e
movq %r14, %rdi
callq 0x22d0
testl %eax, %eax
je 0x151ea
leaq 0x460b1(%rip), %rsi # 0x5b286
movq %r14, %rdi
callq 0x22d0
movl $0x3, %ebx
testl %eax, %eax
jne 0x152e1
cmpb $0x1, 0x781eb(%rip) # 0x8d3dc
jne 0x15256
leaq 0x46090(%rip), %rsi # 0x5b28a
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x55afd
leaq 0x7812c(%rip), %rax # 0x8d33c
incl (%rax)
xorpd %xmm0, %xmm0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
leaq 0x781a9(%rip), %rax # 0x8d3d0
movl $0x5, (%rax)
movq (%r13), %rdi
jne 0x15235
jnp 0x152af
movapd %xmm1, %xmm0
leaq 0x4733c(%rip), %rsi # 0x5c57c
movb $0x1, %al
callq 0x55afd
jmp 0x152e1
movl $0x1, %ebx
jmp 0x152e1
leaq 0x4602d(%rip), %rsi # 0x5b28a
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x22e0
leaq 0x780c9(%rip), %rax # 0x8d33c
incl (%rax)
xorpd %xmm0, %xmm0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
leaq 0x78146(%rip), %rax # 0x8d3d0
movl $0x5, (%rax)
movq (%r13), %rax
jne 0x15298
jnp 0x152bf
movapd %xmm1, %xmm0
leaq 0x472d9(%rip), %rsi # 0x5c57c
movq %rax, %rdi
movb $0x1, %al
callq 0x22e0
jmp 0x152e1
leaq 0x46c39(%rip), %rsi # 0x5beef
xorl %eax, %eax
callq 0x55afd
jmp 0x152cc
movl $0xa, %edi
movq %rax, %rsi
callq 0x2290
movl (%r12), %eax
leaq 0x780f5(%rip), %rcx # 0x8d3cc
movl %eax, (%rcx)
movl $0x1d, (%r12)
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
_ZN12LefDefParser25lefwLayerACCurrentDensityEPKcd:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
lea r13, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov r15, [r13+0]
test r15, r15
jz loc_1524C
lea r12, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
mov eax, [r12]
mov ebx, 2
cmp eax, 1Fh
ja loc_152E1
movsd [rsp+38h+var_30], xmm0
mov ecx, 900000C0h
bt ecx, eax
jnb loc_152E1
mov r14, rdi
lea rsi, aPeak; "PEAK"
call _strcmp
test eax, eax
jz short loc_151EA
lea rsi, aAverage; "AVERAGE"
mov rdi, r14
call _strcmp
test eax, eax
jz short loc_151EA
lea rsi, aRms; "RMS"
mov rdi, r14
call _strcmp
mov ebx, 3
test eax, eax
jnz loc_152E1
loc_151EA:
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 1; LefDefParser::lefwWriteEncrypt
jnz short loc_15256
lea rsi, aAccurrentdensi; " ACCURRENTDENSITY %s"
xor ebx, ebx
mov rdi, r15
mov rdx, r14
xor eax, eax
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
inc dword ptr [rax]
xorpd xmm0, xmm0
movsd xmm1, [rsp+38h+var_30]
ucomisd xmm1, xmm0
lea rax, _ZN12LefDefParser12lefwTableLenE; LefDefParser::lefwTableLen
mov dword ptr [rax], 5
mov rdi, [r13+0]
jnz short loc_15235
jnp short loc_152AF
loc_15235:
movapd xmm0, xmm1
lea rsi, a11g11g_3+14h; " %.11g\n"
mov al, 1
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp loc_152E1
loc_1524C:
mov ebx, 1
jmp loc_152E1
loc_15256:
lea rsi, aAccurrentdensi; " ACCURRENTDENSITY %s"
xor ebx, ebx
mov rdi, r15
mov rdx, r14
xor eax, eax
call _fprintf
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
inc dword ptr [rax]
xorpd xmm0, xmm0
movsd xmm1, [rsp+38h+var_30]
ucomisd xmm1, xmm0
lea rax, _ZN12LefDefParser12lefwTableLenE; LefDefParser::lefwTableLen
mov dword ptr [rax], 5
mov rax, [r13+0]
jnz short loc_15298
jnp short loc_152BF
loc_15298:
movapd xmm0, xmm1
lea rsi, a11g11g_3+14h; " %.11g\n"
mov rdi, rax
mov al, 1
call _fprintf
jmp short loc_152E1
loc_152AF:
lea rsi, aEnd_0+7; "\n"
xor eax, eax
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_152CC
loc_152BF:
mov edi, 0Ah
mov rsi, rax
call _fputc
loc_152CC:
mov eax, [r12]
lea rcx, _ZN12LefDefParser12lefwOldStateE; LefDefParser::lefwOldState
mov [rcx], eax
mov dword ptr [r12], 1Dh
loc_152E1:
mov eax, ebx
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
|
long long LefDefParser::lefwLayerACCurrentDensity(LefDefParser *this, const char *a2, double a3)
{
long long v3; // r15
unsigned int v4; // ebx
int v5; // ecx
int v6; // ecx
int v7; // r8d
int v8; // r9d
int v9; // edx
int v10; // ecx
int v11; // r8d
int v12; // r9d
v3 = *(_QWORD *)&LefDefParser::lefwFile;
if ( *(_QWORD *)&LefDefParser::lefwFile )
{
v4 = 2;
if ( LefDefParser::lefwState <= 0x1F )
{
v5 = -1879048000;
if ( _bittest(&v5, LefDefParser::lefwState) )
{
if ( !(unsigned int)strcmp(this, "PEAK")
|| !(unsigned int)strcmp(this, "AVERAGE")
|| (v4 = 3, !(unsigned int)strcmp(this, "RMS")) )
{
if ( LefDefParser::lefwWriteEncrypt == 1 )
{
v4 = 0;
LefDefParser::encPrint(v3, (unsigned int)" ACCURRENTDENSITY %s", (_DWORD)this, v6, v7, v8);
++LefDefParser::lefwLines;
LefDefParser::lefwTableLen = 5;
if ( a3 == 0.0 )
{
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)"\n", v9, v10, v11, v12);
LABEL_15:
LefDefParser::lefwOldState = LefDefParser::lefwState;
LefDefParser::lefwState = 29;
return v4;
}
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)" %.11g\n", v9, v10, v11, v12);
}
else
{
v4 = 0;
fprintf(v3, " ACCURRENTDENSITY %s", (const char *)this);
++LefDefParser::lefwLines;
LefDefParser::lefwTableLen = 5;
if ( a3 == 0.0 )
{
fputc(10LL, *(_QWORD *)&LefDefParser::lefwFile);
goto LABEL_15;
}
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " %.11g\n", a3);
}
}
}
}
}
else
{
return 1;
}
return v4;
}
|
lefwLayerACCurrentDensity:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
LEA R13,[0x18d0f0]
MOV R15,qword ptr [R13]
TEST R15,R15
JZ 0x0011524c
LEA R12,[0x18d340]
MOV EAX,dword ptr [R12]
MOV EBX,0x2
CMP EAX,0x1f
JA 0x001152e1
MOVSD qword ptr [RSP + 0x8],XMM0
MOV ECX,0x900000c0
BT ECX,EAX
JNC 0x001152e1
MOV R14,RDI
LEA RSI,[0x15b279]
CALL 0x001022d0
TEST EAX,EAX
JZ 0x001151ea
LEA RSI,[0x15b27e]
MOV RDI,R14
CALL 0x001022d0
TEST EAX,EAX
JZ 0x001151ea
LEA RSI,[0x15b286]
MOV RDI,R14
CALL 0x001022d0
MOV EBX,0x3
TEST EAX,EAX
JNZ 0x001152e1
LAB_001151ea:
CMP byte ptr [0x0018d3dc],0x1
JNZ 0x00115256
LEA RSI,[0x15b28a]
XOR EBX,EBX
MOV RDI,R15
MOV RDX,R14
XOR EAX,EAX
CALL 0x00155afd
LEA RAX,[0x18d33c]
INC dword ptr [RAX]
XORPD XMM0,XMM0
MOVSD XMM1,qword ptr [RSP + 0x8]
UCOMISD XMM1,XMM0
LEA RAX,[0x18d3d0]
MOV dword ptr [RAX],0x5
MOV RDI,qword ptr [R13]
JNZ 0x00115235
JNP 0x001152af
LAB_00115235:
MOVAPD XMM0,XMM1
LEA RSI,[0x15c57c]
MOV AL,0x1
CALL 0x00155afd
JMP 0x001152e1
LAB_0011524c:
MOV EBX,0x1
JMP 0x001152e1
LAB_00115256:
LEA RSI,[0x15b28a]
XOR EBX,EBX
MOV RDI,R15
MOV RDX,R14
XOR EAX,EAX
CALL 0x001022e0
LEA RAX,[0x18d33c]
INC dword ptr [RAX]
XORPD XMM0,XMM0
MOVSD XMM1,qword ptr [RSP + 0x8]
UCOMISD XMM1,XMM0
LEA RAX,[0x18d3d0]
MOV dword ptr [RAX],0x5
MOV RAX,qword ptr [R13]
JNZ 0x00115298
JNP 0x001152bf
LAB_00115298:
MOVAPD XMM0,XMM1
LEA RSI,[0x15c57c]
MOV RDI,RAX
MOV AL,0x1
CALL 0x001022e0
JMP 0x001152e1
LAB_001152af:
LEA RSI,[0x15beef]
XOR EAX,EAX
CALL 0x00155afd
JMP 0x001152cc
LAB_001152bf:
MOV EDI,0xa
MOV RSI,RAX
CALL 0x00102290
LAB_001152cc:
MOV EAX,dword ptr [R12]
LEA RCX,[0x18d3cc]
MOV dword ptr [RCX],EAX
MOV dword ptr [R12],0x1d
LAB_001152e1:
MOV EAX,EBX
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* LefDefParser::lefwLayerACCurrentDensity(char const*, double) */
int8 LefDefParser::lefwLayerACCurrentDensity(char *param_1,double param_2)
{
_IO_FILE *__stream;
int iVar1;
int8 uVar2;
__stream = lefwFile;
if (lefwFile == (_IO_FILE *)0x0) {
uVar2 = 1;
}
else {
uVar2 = 2;
if ((lefwState < 0x20) && ((0x900000c0U >> (lefwState & 0x1f) & 1) != 0)) {
iVar1 = strcmp(param_1,"PEAK");
if ((iVar1 != 0) &&
((iVar1 = strcmp(param_1,"AVERAGE"), iVar1 != 0 &&
(iVar1 = strcmp(param_1,"RMS"), iVar1 != 0)))) {
return 3;
}
if (lefwWriteEncrypt == '\x01') {
encPrint(__stream," ACCURRENTDENSITY %s",param_1);
lefwLines = lefwLines + 1;
lefwTableLen = 5;
if ((param_2 != 0.0) || (NAN(param_2))) {
encPrint(lefwFile," %.11g\n",param_2);
return 0;
}
encPrint(lefwFile,"\n");
}
else {
fprintf(__stream," ACCURRENTDENSITY %s",param_1);
lefwLines = lefwLines + 1;
lefwTableLen = 5;
if ((param_2 != 0.0) || (NAN(param_2))) {
fprintf(lefwFile," %.11g\n",param_2);
return 0;
}
fputc(10,lefwFile);
}
uVar2 = 0;
lefwOldState = lefwState;
lefwState = 0x1d;
}
}
return uVar2;
}
|
|
18,408
|
google::protobuf::io::CodedInputStream::ReadVarint32Fallback(unsigned int)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/coded_stream.cc
|
int64_t CodedInputStream::ReadVarint32Fallback(uint32_t first_byte_or_zero) {
if (BufferSize() >= kMaxVarintBytes ||
// Optimization: We're also safe if the buffer is non-empty and it ends
// with a byte that would terminate a varint.
(buffer_end_ > buffer_ && !(buffer_end_[-1] & 0x80))) {
GOOGLE_DCHECK_NE(first_byte_or_zero, 0)
<< "Caller should provide us with *buffer_ when buffer is non-empty";
uint32_t temp;
::std::pair<bool, const uint8_t*> p =
ReadVarint32FromArray(first_byte_or_zero, buffer_, &temp);
if (!p.first) return -1;
buffer_ = p.second;
return temp;
} else {
// Really slow case: we will incur the cost of an extra function call here,
// but moving this out of line reduces the size of this function, which
// improves the common case. In micro benchmarks, this is worth about 10-15%
uint32_t temp;
return ReadVarint32Slow(&temp) ? static_cast<int64_t>(temp) : -1;
}
}
|
O0
|
cpp
|
google::protobuf::io::CodedInputStream::ReadVarint32Fallback(unsigned int):
subq $0xf8, %rsp
movq %rdi, 0xa8(%rsp)
movl %esi, 0xa4(%rsp)
movq 0xa8(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x21f90
cmpl $0xa, %eax
jge 0x1f87a
movq 0x28(%rsp), %rcx
movq 0x8(%rcx), %rax
cmpq (%rcx), %rax
jbe 0x1fc26
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movzbl -0x1(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x1fc26
jmp 0x1f87c
xorl %eax, %eax
testb $0x1, %al
jne 0x1f887
jmp 0x1f940
movl 0xa4(%rsp), %eax
movb $0x0, 0x67(%rsp)
cmpl $0x0, %eax
je 0x1f89a
jmp 0x1f902
leaq 0x1cc2e2(%rip), %rdx # 0x1ebb83
leaq 0x68(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x3, %esi
movl $0x1cf, %ecx # imm = 0x1CF
callq 0x237e0
movq 0x18(%rsp), %rdi
movb $0x1, 0x67(%rsp)
leaq 0x1cc458(%rip), %rsi # 0x1ebd23
callq 0x230a0
movq %rax, 0x20(%rsp)
jmp 0x1f8d7
movq 0x20(%rsp), %rdi
leaq 0x1cc46c(%rip), %rsi # 0x1ebd4f
callq 0x230a0
movq %rax, 0x10(%rsp)
jmp 0x1f8ef
movq 0x10(%rsp), %rsi
leaq 0x53(%rsp), %rdi
callq 0x23250
jmp 0x1f900
jmp 0x1f902
testb $0x1, 0x67(%rsp)
jne 0x1f90b
jmp 0x1f915
leaq 0x68(%rsp), %rdi
callq 0x23820
jmp 0x1f87c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
testb $0x1, 0x67(%rsp)
jne 0x1f931
jmp 0x1f93b
leaq 0x68(%rsp), %rdi
callq 0x23820
jmp 0x1fc71
movq 0x28(%rsp), %rax
movl 0xa4(%rsp), %ecx
movq (%rax), %rax
movl %ecx, 0xe4(%rsp)
movq %rax, 0xd8(%rsp)
leaq 0x4c(%rsp), %rax
movq %rax, 0xd0(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0xc8(%rsp)
movl 0xe4(%rsp), %eax
subl $0x80, %eax
movl %eax, 0xc0(%rsp)
movq 0xc8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xc8(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0xc8(%rsp)
movzbl (%rax), %eax
movl %eax, 0xc4(%rsp)
movl 0xc4(%rsp), %eax
shll $0x7, %eax
addl 0xc0(%rsp), %eax
movl %eax, 0xc0(%rsp)
movl 0xc4(%rsp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x1f9f1
jmp 0x1fba1
movl 0xc0(%rsp), %eax
subl $0x4000, %eax # imm = 0x4000
movl %eax, 0xc0(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0xc8(%rsp)
movzbl (%rax), %eax
movl %eax, 0xc4(%rsp)
movl 0xc4(%rsp), %eax
shll $0xe, %eax
addl 0xc0(%rsp), %eax
movl %eax, 0xc0(%rsp)
movl 0xc4(%rsp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x1fa53
jmp 0x1fba1
movl 0xc0(%rsp), %eax
subl $0x200000, %eax # imm = 0x200000
movl %eax, 0xc0(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0xc8(%rsp)
movzbl (%rax), %eax
movl %eax, 0xc4(%rsp)
movl 0xc4(%rsp), %eax
shll $0x15, %eax
addl 0xc0(%rsp), %eax
movl %eax, 0xc0(%rsp)
movl 0xc4(%rsp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x1fab5
jmp 0x1fba1
movl 0xc0(%rsp), %eax
subl $0x10000000, %eax # imm = 0x10000000
movl %eax, 0xc0(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0xc8(%rsp)
movzbl (%rax), %eax
movl %eax, 0xc4(%rsp)
movl 0xc4(%rsp), %eax
shll $0x1c, %eax
addl 0xc0(%rsp), %eax
movl %eax, 0xc0(%rsp)
movl 0xc4(%rsp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x1fb17
jmp 0x1fba1
movl $0x0, 0xbc(%rsp)
cmpl $0x5, 0xbc(%rsp)
jge 0x1fb73
movq 0xc8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0xc8(%rsp)
movzbl (%rax), %eax
movl %eax, 0xc4(%rsp)
movl 0xc4(%rsp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x1fb60
jmp 0x1fba1
movl 0xbc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xbc(%rsp)
jmp 0x1fb22
movb $0x0, 0xbb(%rsp)
leaq 0xbb(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x22b70
movb %al, 0xe8(%rsp)
movq %rdx, 0xf0(%rsp)
jmp 0x1fbde
movl 0xc0(%rsp), %ecx
movq 0xd0(%rsp), %rax
movl %ecx, (%rax)
movb $0x1, 0xba(%rsp)
leaq 0xba(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x22b70
movb %al, 0xe8(%rsp)
movq %rdx, 0xf0(%rsp)
movq 0xf0(%rsp), %rax
movb 0xe8(%rsp), %cl
movb %cl, 0x38(%rsp)
movq %rax, 0x40(%rsp)
testb $0x1, 0x38(%rsp)
jne 0x1fc0b
movq $-0x1, 0xb0(%rsp)
jmp 0x1fc61
movq 0x28(%rsp), %rax
movq 0x40(%rsp), %rcx
movq %rcx, (%rax)
movl 0x4c(%rsp), %eax
movq %rax, 0xb0(%rsp)
jmp 0x1fc61
movq 0x28(%rsp), %rdi
leaq 0x34(%rsp), %rsi
callq 0x1f410
testb $0x1, %al
jne 0x1fc3b
jmp 0x1fc46
movl 0x34(%rsp), %eax
movq %rax, 0x8(%rsp)
jmp 0x1fc54
movq $-0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1fc54
movq 0x8(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
addq $0xf8, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x13750
nopl (%rax,%rax)
|
_ZN6google8protobuf2io16CodedInputStream20ReadVarint32FallbackEj:
sub rsp, 0F8h
mov [rsp+0F8h+var_50], rdi
mov [rsp+0F8h+var_54], esi
mov rdi, [rsp+0F8h+var_50]; this
mov [rsp+0F8h+var_D0], rdi
call _ZNK6google8protobuf2io16CodedInputStream10BufferSizeEv; google::protobuf::io::CodedInputStream::BufferSize(void)
cmp eax, 0Ah
jge short loc_1F87A
mov rcx, [rsp+0F8h+var_D0]
mov rax, [rcx+8]
cmp rax, [rcx]
jbe loc_1FC26
mov rax, [rsp+0F8h+var_D0]
mov rax, [rax+8]
movzx eax, byte ptr [rax-1]
and eax, 80h
cmp eax, 0
jnz loc_1FC26
loc_1F87A:
jmp short $+2
loc_1F87C:
xor eax, eax
test al, 1
jnz short loc_1F887
jmp loc_1F940
loc_1F887:
mov eax, [rsp+0F8h+var_54]
mov [rsp+0F8h+var_91], 0
cmp eax, 0
jz short loc_1F89A
jmp short loc_1F902
loc_1F89A:
lea rdx, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+0F8h+var_90]
mov [rsp+0F8h+var_E0], rdi
mov esi, 3
mov ecx, 1CFh
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+0F8h+var_E0]
mov [rsp+0F8h+var_91], 1
lea rsi, aCheckFailedFir; "CHECK failed: (first_byte_or_zero) != ("...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+0F8h+var_D8], rax
jmp short $+2
loc_1F8D7:
mov rdi, [rsp+0F8h+var_D8]
lea rsi, aCallerShouldPr; "Caller should provide us with *buffer_ "...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+0F8h+var_E8], rax
jmp short $+2
loc_1F8EF:
mov rsi, [rsp+0F8h+var_E8]
lea rdi, [rsp+0F8h+var_A5]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_1F900:
jmp short $+2
loc_1F902:
test [rsp+0F8h+var_91], 1
jnz short loc_1F90B
jmp short loc_1F915
loc_1F90B:
lea rdi, [rsp+0F8h+var_90]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_1F915:
jmp loc_1F87C
mov rcx, rax
mov eax, edx
mov [rsp+arg_50], rcx
mov [rsp+arg_4C], eax
test [rsp+arg_5F], 1
jnz short loc_1F931
jmp short loc_1F93B
loc_1F931:
lea rdi, [rsp+arg_60]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_1F93B:
jmp loc_1FC71
loc_1F940:
mov rax, [rsp+0F8h+var_D0]
mov ecx, [rsp+0F8h+var_54]
mov rax, [rax]
mov [rsp+0F8h+var_14], ecx
mov [rsp+0F8h+var_20], rax
lea rax, [rsp+0F8h+var_AC]
mov [rsp+0F8h+var_28], rax
mov rax, [rsp+0F8h+var_20]
mov [rsp+0F8h+var_30], rax
mov eax, [rsp+0F8h+var_14]
sub eax, 80h
mov [rsp+0F8h+var_38], eax
mov rax, [rsp+0F8h+var_30]
add rax, 1
mov [rsp+0F8h+var_30], rax
mov rax, [rsp+0F8h+var_30]
mov rcx, rax
add rcx, 1
mov [rsp+0F8h+var_30], rcx
movzx eax, byte ptr [rax]
mov [rsp+0F8h+var_34], eax
mov eax, [rsp+0F8h+var_34]
shl eax, 7
add eax, [rsp+0F8h+var_38]
mov [rsp+0F8h+var_38], eax
mov eax, [rsp+0F8h+var_34]
and eax, 80h
cmp eax, 0
jnz short loc_1F9F1
jmp loc_1FBA1
loc_1F9F1:
mov eax, [rsp+0F8h+var_38]
sub eax, 4000h
mov [rsp+0F8h+var_38], eax
mov rax, [rsp+0F8h+var_30]
mov rcx, rax
add rcx, 1
mov [rsp+0F8h+var_30], rcx
movzx eax, byte ptr [rax]
mov [rsp+0F8h+var_34], eax
mov eax, [rsp+0F8h+var_34]
shl eax, 0Eh
add eax, [rsp+0F8h+var_38]
mov [rsp+0F8h+var_38], eax
mov eax, [rsp+0F8h+var_34]
and eax, 80h
cmp eax, 0
jnz short loc_1FA53
jmp loc_1FBA1
loc_1FA53:
mov eax, [rsp+0F8h+var_38]
sub eax, offset unk_200000
mov [rsp+0F8h+var_38], eax
mov rax, [rsp+0F8h+var_30]
mov rcx, rax
add rcx, 1
mov [rsp+0F8h+var_30], rcx
movzx eax, byte ptr [rax]
mov [rsp+0F8h+var_34], eax
mov eax, [rsp+0F8h+var_34]
shl eax, 15h
add eax, [rsp+0F8h+var_38]
mov [rsp+0F8h+var_38], eax
mov eax, [rsp+0F8h+var_34]
and eax, 80h
cmp eax, 0
jnz short loc_1FAB5
jmp loc_1FBA1
loc_1FAB5:
mov eax, [rsp+0F8h+var_38]
sub eax, 10000000h
mov [rsp+0F8h+var_38], eax
mov rax, [rsp+0F8h+var_30]
mov rcx, rax
add rcx, 1
mov [rsp+0F8h+var_30], rcx
movzx eax, byte ptr [rax]
mov [rsp+0F8h+var_34], eax
mov eax, [rsp+0F8h+var_34]
shl eax, 1Ch
add eax, [rsp+0F8h+var_38]
mov [rsp+0F8h+var_38], eax
mov eax, [rsp+0F8h+var_34]
and eax, 80h
cmp eax, 0
jnz short loc_1FB17
jmp loc_1FBA1
loc_1FB17:
mov [rsp+0F8h+var_3C], 0
loc_1FB22:
cmp [rsp+0F8h+var_3C], 5
jge short loc_1FB73
mov rax, [rsp+0F8h+var_30]
mov rcx, rax
add rcx, 1
mov [rsp+0F8h+var_30], rcx
movzx eax, byte ptr [rax]
mov [rsp+0F8h+var_34], eax
mov eax, [rsp+0F8h+var_34]
and eax, 80h
cmp eax, 0
jnz short loc_1FB60
jmp short loc_1FBA1
loc_1FB60:
mov eax, [rsp+0F8h+var_3C]
add eax, 1
mov [rsp+0F8h+var_3C], eax
jmp short loc_1FB22
loc_1FB73:
mov [rsp+0F8h+var_3D], 0
lea rdi, [rsp+0F8h+var_3D]
lea rsi, [rsp+0F8h+var_30]
call _ZSt9make_pairIbRPKhESt4pairINSt25__strip_reference_wrapperINSt5decayIT_E4typeEE6__typeENS4_INS5_IT0_E4typeEE6__typeEEOS6_OSB_; std::make_pair<bool,uchar const*&>(bool&&,uchar const*&&&)
mov [rsp+0F8h+var_10], al
mov [rsp+0F8h+var_8], rdx
jmp short loc_1FBDE
loc_1FBA1:
mov ecx, [rsp+0F8h+var_38]
mov rax, [rsp+0F8h+var_28]
mov [rax], ecx
mov [rsp+0F8h+var_3E], 1
lea rdi, [rsp+0F8h+var_3E]
lea rsi, [rsp+0F8h+var_30]
call _ZSt9make_pairIbRPKhESt4pairINSt25__strip_reference_wrapperINSt5decayIT_E4typeEE6__typeENS4_INS5_IT0_E4typeEE6__typeEEOS6_OSB_; std::make_pair<bool,uchar const*&>(bool&&,uchar const*&&&)
mov [rsp+0F8h+var_10], al
mov [rsp+0F8h+var_8], rdx
loc_1FBDE:
mov rax, [rsp+0F8h+var_8]
mov cl, [rsp+0F8h+var_10]
mov [rsp+0F8h+var_C0], cl
mov [rsp+0F8h+var_B8], rax
test [rsp+0F8h+var_C0], 1
jnz short loc_1FC0B
mov [rsp+0F8h+var_48], 0FFFFFFFFFFFFFFFFh
jmp short loc_1FC61
loc_1FC0B:
mov rax, [rsp+0F8h+var_D0]
mov rcx, [rsp+0F8h+var_B8]
mov [rax], rcx
mov eax, [rsp+0F8h+var_AC]
mov [rsp+0F8h+var_48], rax
jmp short loc_1FC61
loc_1FC26:
mov rdi, [rsp+0F8h+var_D0]; this
lea rsi, [rsp+0F8h+var_C4]; unsigned int *
call _ZN6google8protobuf2io16CodedInputStream16ReadVarint32SlowEPj; google::protobuf::io::CodedInputStream::ReadVarint32Slow(uint *)
test al, 1
jnz short loc_1FC3B
jmp short loc_1FC46
loc_1FC3B:
mov eax, [rsp+0F8h+var_C4]
mov [rsp+0F8h+var_F0], rax
jmp short loc_1FC54
loc_1FC46:
mov rax, 0FFFFFFFFFFFFFFFFh
mov [rsp+0F8h+var_F0], rax
jmp short $+2
loc_1FC54:
mov rax, [rsp+0F8h+var_F0]
mov [rsp+0F8h+var_48], rax
loc_1FC61:
mov rax, [rsp+0F8h+var_48]
add rsp, 0F8h
retn
loc_1FC71:
mov rdi, [rsp+arg_50]
call __Unwind_Resume
|
long long google::protobuf::io::CodedInputStream::ReadVarint32Fallback(
google::protobuf::io::CodedInputStream *this,
int a2)
{
unsigned __int8 *v2; // rax
unsigned __int8 *v3; // rax
unsigned __int8 *v4; // rax
unsigned __int8 *v5; // rax
unsigned __int8 *v6; // rax
long long v7; // rdx
long long v8; // rdx
unsigned int v11; // [rsp+34h] [rbp-C4h] BYREF
char v12; // [rsp+38h] [rbp-C0h]
long long v13; // [rsp+40h] [rbp-B8h]
unsigned int v14; // [rsp+4Ch] [rbp-ACh] BYREF
int v15; // [rsp+A4h] [rbp-54h]
google::protobuf::io::CodedInputStream *v16; // [rsp+A8h] [rbp-50h]
char v18; // [rsp+BAh] [rbp-3Eh] BYREF
char v19; // [rsp+BBh] [rbp-3Dh] BYREF
int i; // [rsp+BCh] [rbp-3Ch]
int v21; // [rsp+C0h] [rbp-38h]
int v22; // [rsp+C4h] [rbp-34h]
long long v23; // [rsp+C8h] [rbp-30h] BYREF
int *v24; // [rsp+D0h] [rbp-28h]
unsigned __int8 *v25; // [rsp+D8h] [rbp-20h]
int v26; // [rsp+E4h] [rbp-14h]
char v27; // [rsp+E8h] [rbp-10h]
long long v28; // [rsp+F0h] [rbp-8h]
v16 = this;
v15 = a2;
if ( (int)google::protobuf::io::CodedInputStream::BufferSize(this) < 10
&& (*((_QWORD *)this + 1) <= *(_QWORD *)this || (*(_BYTE *)(*((_QWORD *)this + 1) - 1LL) & 0x80) != 0) )
{
if ( (google::protobuf::io::CodedInputStream::ReadVarint32Slow(this, &v11) & 1) != 0 )
return v11;
else
return -1LL;
}
else
{
v2 = *(unsigned __int8 **)this;
v26 = v15;
v25 = v2;
v24 = (int *)&v14;
v21 = v15 - 128;
v23 = (long long)(++v2 + 1);
v22 = *v2;
v21 = v15 - 128 + (v22 << 7);
if ( (v22 & 0x80) == 0 )
goto LABEL_13;
v21 -= 0x4000;
v3 = (unsigned __int8 *)v23++;
v22 = *v3;
v21 += v22 << 14;
if ( (v22 & 0x80) == 0 )
goto LABEL_13;
v21 -= (int)&unk_200000;
v4 = (unsigned __int8 *)v23++;
v22 = *v4;
v21 += v22 << 21;
if ( (v22 & 0x80) == 0 )
goto LABEL_13;
v21 -= 0x10000000;
v5 = (unsigned __int8 *)v23++;
v22 = *v5;
v21 += v22 << 28;
if ( (v22 & 0x80) != 0 )
{
for ( i = 0; i < 5; ++i )
{
v6 = (unsigned __int8 *)v23++;
v22 = *v6;
if ( (v22 & 0x80) == 0 )
goto LABEL_13;
}
v19 = 0;
v27 = std::make_pair<bool,unsigned char const*&>(&v19, &v23);
v28 = v7;
}
else
{
LABEL_13:
*v24 = v21;
v18 = 1;
v27 = std::make_pair<bool,unsigned char const*&>(&v18, &v23);
v28 = v8;
}
v12 = v27;
v13 = v28;
if ( (v27 & 1) != 0 )
{
*(_QWORD *)this = v13;
return v14;
}
else
{
return -1LL;
}
}
}
|
ReadVarint32Fallback:
SUB RSP,0xf8
MOV qword ptr [RSP + 0xa8],RDI
MOV dword ptr [RSP + 0xa4],ESI
MOV RDI,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0x28],RDI
CALL 0x00121f90
CMP EAX,0xa
JGE 0x0011f87a
MOV RCX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RCX + 0x8]
CMP RAX,qword ptr [RCX]
JBE 0x0011fc26
MOV RAX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOVZX EAX,byte ptr [RAX + -0x1]
AND EAX,0x80
CMP EAX,0x0
JNZ 0x0011fc26
LAB_0011f87a:
JMP 0x0011f87c
LAB_0011f87c:
XOR EAX,EAX
TEST AL,0x1
JNZ 0x0011f887
JMP 0x0011f940
LAB_0011f887:
MOV EAX,dword ptr [RSP + 0xa4]
MOV byte ptr [RSP + 0x67],0x0
CMP EAX,0x0
JZ 0x0011f89a
JMP 0x0011f902
LAB_0011f89a:
LEA RDX,[0x2ebb83]
LEA RDI,[RSP + 0x68]
MOV qword ptr [RSP + 0x18],RDI
MOV ESI,0x3
MOV ECX,0x1cf
CALL 0x001237e0
MOV RDI,qword ptr [RSP + 0x18]
MOV byte ptr [RSP + 0x67],0x1
LAB_0011f8c4:
LEA RSI,[0x2ebd23]
CALL 0x001230a0
MOV qword ptr [RSP + 0x20],RAX
JMP 0x0011f8d7
LAB_0011f8d7:
MOV RDI,qword ptr [RSP + 0x20]
LEA RSI,[0x2ebd4f]
CALL 0x001230a0
MOV qword ptr [RSP + 0x10],RAX
JMP 0x0011f8ef
LAB_0011f8ef:
MOV RSI,qword ptr [RSP + 0x10]
LEA RDI,[RSP + 0x53]
CALL 0x00123250
LAB_0011f8fe:
JMP 0x0011f900
LAB_0011f900:
JMP 0x0011f902
LAB_0011f902:
TEST byte ptr [RSP + 0x67],0x1
JNZ 0x0011f90b
JMP 0x0011f915
LAB_0011f90b:
LEA RDI,[RSP + 0x68]
CALL 0x00123820
LAB_0011f915:
JMP 0x0011f87c
LAB_0011f940:
MOV RAX,qword ptr [RSP + 0x28]
MOV ECX,dword ptr [RSP + 0xa4]
MOV RAX,qword ptr [RAX]
MOV dword ptr [RSP + 0xe4],ECX
MOV qword ptr [RSP + 0xd8],RAX
LEA RAX,[RSP + 0x4c]
MOV qword ptr [RSP + 0xd0],RAX
MOV RAX,qword ptr [RSP + 0xd8]
MOV qword ptr [RSP + 0xc8],RAX
MOV EAX,dword ptr [RSP + 0xe4]
SUB EAX,0x80
MOV dword ptr [RSP + 0xc0],EAX
MOV RAX,qword ptr [RSP + 0xc8]
ADD RAX,0x1
MOV qword ptr [RSP + 0xc8],RAX
MOV RAX,qword ptr [RSP + 0xc8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RSP + 0xc8],RCX
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RSP + 0xc4],EAX
MOV EAX,dword ptr [RSP + 0xc4]
SHL EAX,0x7
ADD EAX,dword ptr [RSP + 0xc0]
MOV dword ptr [RSP + 0xc0],EAX
MOV EAX,dword ptr [RSP + 0xc4]
AND EAX,0x80
CMP EAX,0x0
JNZ 0x0011f9f1
JMP 0x0011fba1
LAB_0011f9f1:
MOV EAX,dword ptr [RSP + 0xc0]
SUB EAX,0x4000
MOV dword ptr [RSP + 0xc0],EAX
MOV RAX,qword ptr [RSP + 0xc8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RSP + 0xc8],RCX
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RSP + 0xc4],EAX
MOV EAX,dword ptr [RSP + 0xc4]
SHL EAX,0xe
ADD EAX,dword ptr [RSP + 0xc0]
MOV dword ptr [RSP + 0xc0],EAX
MOV EAX,dword ptr [RSP + 0xc4]
AND EAX,0x80
CMP EAX,0x0
JNZ 0x0011fa53
JMP 0x0011fba1
LAB_0011fa53:
MOV EAX,dword ptr [RSP + 0xc0]
SUB EAX,0x200000
MOV dword ptr [RSP + 0xc0],EAX
MOV RAX,qword ptr [RSP + 0xc8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RSP + 0xc8],RCX
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RSP + 0xc4],EAX
MOV EAX,dword ptr [RSP + 0xc4]
SHL EAX,0x15
ADD EAX,dword ptr [RSP + 0xc0]
MOV dword ptr [RSP + 0xc0],EAX
MOV EAX,dword ptr [RSP + 0xc4]
AND EAX,0x80
CMP EAX,0x0
JNZ 0x0011fab5
JMP 0x0011fba1
LAB_0011fab5:
MOV EAX,dword ptr [RSP + 0xc0]
SUB EAX,0x10000000
MOV dword ptr [RSP + 0xc0],EAX
MOV RAX,qword ptr [RSP + 0xc8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RSP + 0xc8],RCX
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RSP + 0xc4],EAX
MOV EAX,dword ptr [RSP + 0xc4]
SHL EAX,0x1c
ADD EAX,dword ptr [RSP + 0xc0]
MOV dword ptr [RSP + 0xc0],EAX
MOV EAX,dword ptr [RSP + 0xc4]
AND EAX,0x80
CMP EAX,0x0
JNZ 0x0011fb17
JMP 0x0011fba1
LAB_0011fb17:
MOV dword ptr [RSP + 0xbc],0x0
LAB_0011fb22:
CMP dword ptr [RSP + 0xbc],0x5
JGE 0x0011fb73
MOV RAX,qword ptr [RSP + 0xc8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RSP + 0xc8],RCX
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RSP + 0xc4],EAX
MOV EAX,dword ptr [RSP + 0xc4]
AND EAX,0x80
CMP EAX,0x0
JNZ 0x0011fb60
JMP 0x0011fba1
LAB_0011fb60:
MOV EAX,dword ptr [RSP + 0xbc]
ADD EAX,0x1
MOV dword ptr [RSP + 0xbc],EAX
JMP 0x0011fb22
LAB_0011fb73:
MOV byte ptr [RSP + 0xbb],0x0
LEA RDI,[RSP + 0xbb]
LEA RSI,[RSP + 0xc8]
CALL 0x00122b70
MOV byte ptr [RSP + 0xe8],AL
MOV qword ptr [RSP + 0xf0],RDX
JMP 0x0011fbde
LAB_0011fba1:
MOV ECX,dword ptr [RSP + 0xc0]
MOV RAX,qword ptr [RSP + 0xd0]
MOV dword ptr [RAX],ECX
MOV byte ptr [RSP + 0xba],0x1
LEA RDI,[RSP + 0xba]
LEA RSI,[RSP + 0xc8]
CALL 0x00122b70
MOV byte ptr [RSP + 0xe8],AL
MOV qword ptr [RSP + 0xf0],RDX
LAB_0011fbde:
MOV RAX,qword ptr [RSP + 0xf0]
MOV CL,byte ptr [RSP + 0xe8]
MOV byte ptr [RSP + 0x38],CL
MOV qword ptr [RSP + 0x40],RAX
TEST byte ptr [RSP + 0x38],0x1
JNZ 0x0011fc0b
MOV qword ptr [RSP + 0xb0],-0x1
JMP 0x0011fc61
LAB_0011fc0b:
MOV RAX,qword ptr [RSP + 0x28]
MOV RCX,qword ptr [RSP + 0x40]
MOV qword ptr [RAX],RCX
MOV EAX,dword ptr [RSP + 0x4c]
MOV qword ptr [RSP + 0xb0],RAX
JMP 0x0011fc61
LAB_0011fc26:
MOV RDI,qword ptr [RSP + 0x28]
LEA RSI,[RSP + 0x34]
CALL 0x0011f410
TEST AL,0x1
JNZ 0x0011fc3b
JMP 0x0011fc46
LAB_0011fc3b:
MOV EAX,dword ptr [RSP + 0x34]
MOV qword ptr [RSP + 0x8],RAX
JMP 0x0011fc54
LAB_0011fc46:
MOV RAX,-0x1
MOV qword ptr [RSP + 0x8],RAX
JMP 0x0011fc54
LAB_0011fc54:
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0xb0],RAX
LAB_0011fc61:
MOV RAX,qword ptr [RSP + 0xb0]
ADD RSP,0xf8
RET
|
/* WARNING: Removing unreachable block (ram,0x0011f887) */
/* WARNING: Removing unreachable block (ram,0x0011f89a) */
/* WARNING: Removing unreachable block (ram,0x0011f898) */
/* WARNING: Removing unreachable block (ram,0x0011f902) */
/* WARNING: Removing unreachable block (ram,0x0011f90b) */
/* WARNING: Removing unreachable block (ram,0x0011f909) */
/* WARNING: Removing unreachable block (ram,0x0011f915) */
/* google::protobuf::io::CodedInputStream::ReadVarint32Fallback(unsigned int) */
ulong __thiscall
google::protobuf::io::CodedInputStream::ReadVarint32Fallback(CodedInputStream *this,uint param_1)
{
byte bVar1;
int iVar2;
ulong uVar3;
byte *pbVar4;
int8 extraout_RDX;
int8 extraout_RDX_00;
ulong local_f0;
uint local_c4 [6];
uint local_ac [22];
uint local_54;
CodedInputStream *local_50;
ulong local_48;
bool local_3e;
bool local_3d;
int local_3c;
uint local_38;
uint local_34;
byte *local_30;
uint *local_28;
long local_20;
uint local_14;
byte local_10;
int8 local_8;
local_54 = param_1;
local_50 = this;
iVar2 = BufferSize(this);
if ((iVar2 < 10) &&
((*(ulong *)(this + 8) <= *(ulong *)this || ((*(byte *)(*(long *)(this + 8) + -1) & 0x80) != 0)
))) {
uVar3 = ReadVarint32Slow(this,local_c4);
if ((uVar3 & 1) == 0) {
local_f0 = 0xffffffffffffffff;
}
else {
local_f0 = (ulong)local_c4[0];
}
return local_f0;
}
local_20 = *(long *)this;
local_14 = local_54;
local_28 = local_ac;
local_30 = (byte *)(local_20 + 2);
local_34 = (uint)*(byte *)(local_20 + 1);
local_38 = local_34 * 0x80 + (local_54 - 0x80);
if ((*(byte *)(local_20 + 1) & 0x80) != 0) {
bVar1 = *local_30;
local_34 = (uint)bVar1;
local_38 = local_34 * 0x4000 + (local_38 - 0x4000);
local_30 = (byte *)(local_20 + 3);
if ((bVar1 & 0x80) != 0) {
bVar1 = *(byte *)(local_20 + 3);
local_34 = (uint)bVar1;
local_38 = local_34 * 0x200000 + (local_38 - 0x200000);
local_30 = (byte *)(local_20 + 4);
if ((bVar1 & 0x80) != 0) {
bVar1 = *(byte *)(local_20 + 4);
local_34 = (uint)bVar1;
local_38 = local_34 * 0x10000000 + local_38 + 0xf0000000;
local_30 = (byte *)(local_20 + 5);
if ((bVar1 & 0x80) != 0) {
for (local_3c = 0; local_3c < 5; local_3c = local_3c + 1) {
pbVar4 = local_30 + 1;
bVar1 = *local_30;
local_34 = (uint)bVar1;
local_30 = pbVar4;
if ((bVar1 & 0x80) == 0) goto LAB_0011fba1;
}
local_3d = false;
local_10 = std::make_pair<bool,unsigned_char_const*&>(&local_3d,&local_30);
local_8 = extraout_RDX;
goto LAB_0011fbde;
}
}
}
}
LAB_0011fba1:
local_ac[0] = local_38;
local_3e = true;
local_10 = std::make_pair<bool,unsigned_char_const*&>(&local_3e,&local_30);
local_8 = extraout_RDX_00;
LAB_0011fbde:
if ((local_10 & 1) == 0) {
local_48 = 0xffffffffffffffff;
}
else {
*(int8 *)this = local_8;
local_48 = (ulong)local_ac[0];
}
return local_48;
}
|
|
18,409
|
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> intx::to_string<256u>(intx::uint<256u>, int)
|
corpus-core[P]colibri-stateless/build_O0/_deps/intx-src/include/intx/intx.hpp
|
inline std::string to_string(uint<N> x, int base = 10)
{
if (base < 2 || base > 36)
throw_<std::invalid_argument>("invalid base");
if (x == 0)
return "0";
auto s = std::string{};
while (x != 0)
{
// TODO: Use constexpr udivrem_1?
const auto res = udivrem(x, uint<N>{base});
const auto d = int(res.rem);
const auto c = d < 10 ? '0' + d : 'a' + d - 10;
s.push_back(char(c));
x = res.quot;
}
std::reverse(s.begin(), s.end());
return s;
}
|
O0
|
cpp
|
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> intx::to_string<256u>(intx::uint<256u>, int):
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x2, -0xc(%rbp)
jl 0x9025a
cmpl $0x24, -0xc(%rbp)
jle 0x90266
leaq 0x569fa(%rip), %rdi # 0xe6c5b
callq 0x90440
movq -0xb0(%rbp), %rdi
movl $0x0, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x67060
testb $0x1, %al
jne 0x90283
jmp 0x902d7
leaq -0x11(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x23470
movq -0xc0(%rbp), %rdi
movq -0xc8(%rbp), %rdx
leaq 0x5a244(%rip), %rsi # 0xea4ec
callq 0x8ec50
jmp 0x902af
leaq -0x11(%rbp), %rdi
callq 0x23580
jmp 0x90425
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x23580
jmp 0x90435
movq -0xc0(%rbp), %rdi
movb $0x0, -0x25(%rbp)
callq 0x904a0
movq -0xb0(%rbp), %rdi
movl $0x0, -0x2c(%rbp)
leaq -0x2c(%rbp), %rsi
callq 0x61c20
testb $0x1, %al
jne 0x90307
jmp 0x903d2
movl -0xc(%rbp), %esi
leaq -0x90(%rbp), %rdi
callq 0x61cc0
movq -0xb0(%rbp), %rsi
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rdx
callq 0x61db0
leaq -0x70(%rbp), %rdi
addq $0x20, %rdi
callq 0x90510
movl %eax, -0x94(%rbp)
cmpl $0xa, -0x94(%rbp)
jge 0x9035a
movl -0x94(%rbp), %eax
addl $0x30, %eax
movl %eax, -0xcc(%rbp)
jmp 0x9036c
movl -0x94(%rbp), %eax
addl $0x61, %eax
subl $0xa, %eax
movl %eax, -0xcc(%rbp)
movq -0xc0(%rbp), %rdi
movl -0xcc(%rbp), %eax
movl %eax, -0x98(%rbp)
movsbl -0x98(%rbp), %esi
callq 0x90530
jmp 0x9038d
movq -0xb0(%rbp), %rax
movq -0x70(%rbp), %rcx
movq %rcx, (%rax)
movq -0x68(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x60(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x58(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x902e7
movq -0xc0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x8ec10
jmp 0x90435
movq -0xc0(%rbp), %rdi
callq 0x90600
movq -0xc0(%rbp), %rdi
movq %rax, -0xa0(%rbp)
callq 0x90630
movq %rax, -0xa8(%rbp)
movq -0xa0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0x905c0
jmp 0x9040d
movb $0x1, -0x25(%rbp)
testb $0x1, -0x25(%rbp)
jne 0x90423
movq -0xc0(%rbp), %rdi
callq 0x8ec10
jmp 0x90425
movq -0xb8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x23320
nop
|
_ZN4intx9to_stringILj256EEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_4uintIXT_EEEi:
push rbp
mov rbp, rsp
sub rsp, 0D0h
mov [rbp+var_C0], rdi
mov rax, rdi
mov [rbp+var_B8], rax
lea rax, [rbp+arg_0]
mov [rbp+var_B0], rax
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
cmp [rbp+var_C], 2
jl short loc_9025A
cmp [rbp+var_C], 24h ; '$'
jle short loc_90266
loc_9025A:
lea rdi, aInvalidBase; "invalid base"
call _ZN4intx6throw_ISt16invalid_argumentEEvPKc; intx::throw_<std::invalid_argument>(char const*)
loc_90266:
mov rdi, [rbp+var_B0]
mov [rbp+var_10], 0
lea rsi, [rbp+var_10]
call _ZN4intxeqILj256EivEEbRKNS_4uintIXT_EEERKT0_; intx::operator==<256u,int,void>(intx::uint<256u> const&,int const&)
test al, 1
jnz short loc_90283
jmp short loc_902D7
loc_90283:
lea rdi, [rbp+var_11]
mov [rbp+var_C8], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdi, [rbp+var_C0]
mov rdx, [rbp+var_C8]
lea rsi, aAVal010+12h; "0"
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_902AF:
lea rdi, [rbp+var_11]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_90425
mov rcx, rax
mov eax, edx
mov [rbp+var_20], rcx
mov [rbp+var_24], eax
lea rdi, [rbp+var_11]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_90435
loc_902D7:
mov rdi, [rbp+var_C0]
mov [rbp+var_25], 0
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2Ev; std::string::basic_string(void)
loc_902E7:
mov rdi, [rbp+var_B0]
mov [rbp+var_2C], 0
lea rsi, [rbp+var_2C]
call _ZN4intxneILj256EivEEbRKNS_4uintIXT_EEERKT0_; intx::operator!=<256u,int,void>(intx::uint<256u> const&,int const&)
test al, 1
jnz short loc_90307
jmp loc_903D2
loc_90307:
mov esi, [rbp+var_C]
lea rdi, [rbp+var_90]
call _ZN4intx4uintILj256EEC2IJiEvEEDpT_; intx::uint<256u>::uint<int,void>(int)
mov rsi, [rbp+var_B0]
lea rdi, [rbp+var_70]
lea rdx, [rbp+var_90]
call _ZN4intx7udivremILj256ELj256EEENS_10div_resultINS_4uintIXT_EEENS2_IXT0_EEEEERKS3_RKS4_; intx::udivrem<256u,256u>(intx::uint<256u> const&,intx::uint<256u> const&)
lea rdi, [rbp+var_70]
add rdi, 20h ; ' '
call _ZNK4intx4uintILj256EEcvT_IivEEv; intx::uint<256u>::operator int<int,void>(void)
mov [rbp+var_94], eax
cmp [rbp+var_94], 0Ah
jge short loc_9035A
mov eax, [rbp+var_94]
add eax, 30h ; '0'
mov [rbp+var_CC], eax
jmp short loc_9036C
loc_9035A:
mov eax, [rbp+var_94]
add eax, 61h ; 'a'
sub eax, 0Ah
mov [rbp+var_CC], eax
loc_9036C:
mov rdi, [rbp+var_C0]
mov eax, [rbp+var_CC]
mov [rbp+var_98], eax
movsx esi, byte ptr [rbp+var_98]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
jmp short $+2
loc_9038D:
mov rax, [rbp+var_B0]
mov rcx, [rbp+var_70]
mov [rax], rcx
mov rcx, [rbp+var_68]
mov [rax+8], rcx
mov rcx, [rbp+var_60]
mov [rax+10h], rcx
mov rcx, [rbp+var_58]
mov [rax+18h], rcx
jmp loc_902E7
mov rdi, [rbp+var_C0]
mov rcx, rax
mov eax, edx
mov [rbp+var_20], rcx
mov [rbp+var_24], eax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_90435
loc_903D2:
mov rdi, [rbp+var_C0]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5beginEv; std::string::begin(void)
mov rdi, [rbp+var_C0]
mov [rbp+var_A0], rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE3endEv; std::string::end(void)
mov [rbp+var_A8], rax
mov rdi, [rbp+var_A0]
mov rsi, [rbp+var_A8]
call _ZSt7reverseIN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEEvT_SA_; std::reverse<__gnu_cxx::__normal_iterator<char *,std::string>>(__gnu_cxx::__normal_iterator<char *,std::string>,__gnu_cxx::__normal_iterator<char *,std::string>)
jmp short $+2
loc_9040D:
mov [rbp+var_25], 1
test [rbp+var_25], 1
jnz short loc_90423
mov rdi, [rbp+var_C0]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_90423:
jmp short $+2
loc_90425:
mov rax, [rbp+var_B8]
add rsp, 0D0h
pop rbp
retn
loc_90435:
mov rdi, [rbp+var_20]
call __Unwind_Resume
|
long long intx::to_string<256u>(
long long a1,
int a2,
_DWORD a3,
_DWORD a4,
_DWORD a5,
_DWORD a6,
long long a7,
long long a8,
long long a9,
long long a10)
{
char v11; // [rsp+4h] [rbp-CCh]
long long v12; // [rsp+28h] [rbp-A8h]
long long v13; // [rsp+30h] [rbp-A0h]
int v14; // [rsp+3Ch] [rbp-94h]
_QWORD v15[4]; // [rsp+40h] [rbp-90h] BYREF
_QWORD v16[4]; // [rsp+60h] [rbp-70h] BYREF
long long v17; // [rsp+80h] [rbp-50h] BYREF
unsigned int v18; // [rsp+A4h] [rbp-2Ch] BYREF
char v19; // [rsp+ABh] [rbp-25h]
char v20; // [rsp+BFh] [rbp-11h] BYREF
int v21; // [rsp+C0h] [rbp-10h] BYREF
int v22; // [rsp+C4h] [rbp-Ch]
long long v23; // [rsp+C8h] [rbp-8h]
v23 = a1;
v22 = a2;
if ( a2 < 2 || v22 > 36 )
intx::throw_<std::invalid_argument>("invalid base");
v21 = 0;
if ( intx::operator==<256u,int,void>((long long)&a7, &v21) )
{
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>(a1, (long long)"0", (long long)&v20);
std::allocator<char>::~allocator(&v20);
}
else
{
v19 = 0;
std::string::basic_string(a1);
while ( 1 )
{
v18 = 0;
if ( (intx::operator!=<256u,int,void>((long long)&a7, &v18) & 1) == 0 )
break;
intx::uint<256u>::uint<int,void>(v15, v22);
intx::udivrem<256u,256u>(v16, (unsigned long long)&a7, v15);
v14 = intx::uint<256u>::operator int<int,void>(&v17);
if ( v14 >= 10 )
v11 = v14 + 87;
else
v11 = v14 + 48;
std::string::push_back(a1, (unsigned int)v11);
a7 = v16[0];
a8 = v16[1];
a9 = v16[2];
a10 = v16[3];
}
v13 = std::string::begin(a1);
v12 = std::string::end(a1);
std::reverse<__gnu_cxx::__normal_iterator<char *,std::string>>(v13, v12);
v19 = 1;
}
return a1;
}
|
to_string<256u>:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
MOV qword ptr [RBP + -0xc0],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0xb8],RAX
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0xb0],RAX
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
CMP dword ptr [RBP + -0xc],0x2
JL 0x0019025a
CMP dword ptr [RBP + -0xc],0x24
JLE 0x00190266
LAB_0019025a:
LEA RDI,[0x1e6c5b]
CALL 0x00190440
LAB_00190266:
MOV RDI,qword ptr [RBP + -0xb0]
MOV dword ptr [RBP + -0x10],0x0
LEA RSI,[RBP + -0x10]
CALL 0x00167060
TEST AL,0x1
JNZ 0x00190283
JMP 0x001902d7
LAB_00190283:
LEA RDI,[RBP + -0x11]
MOV qword ptr [RBP + -0xc8],RDI
CALL 0x00123470
MOV RDI,qword ptr [RBP + -0xc0]
MOV RDX,qword ptr [RBP + -0xc8]
LAB_001902a1:
LEA RSI,[0x1ea4ec]
CALL 0x0018ec50
JMP 0x001902af
LAB_001902af:
LEA RDI,[RBP + -0x11]
CALL 0x00123580
JMP 0x00190425
LAB_001902d7:
MOV RDI,qword ptr [RBP + -0xc0]
MOV byte ptr [RBP + -0x25],0x0
CALL 0x001904a0
LAB_001902e7:
MOV RDI,qword ptr [RBP + -0xb0]
MOV dword ptr [RBP + -0x2c],0x0
LEA RSI,[RBP + -0x2c]
CALL 0x00161c20
TEST AL,0x1
JNZ 0x00190307
JMP 0x001903d2
LAB_00190307:
MOV ESI,dword ptr [RBP + -0xc]
LEA RDI,[RBP + -0x90]
CALL 0x00161cc0
MOV RSI,qword ptr [RBP + -0xb0]
LEA RDI,[RBP + -0x70]
LEA RDX,[RBP + -0x90]
CALL 0x00161db0
LEA RDI,[RBP + -0x70]
ADD RDI,0x20
CALL 0x00190510
MOV dword ptr [RBP + -0x94],EAX
CMP dword ptr [RBP + -0x94],0xa
JGE 0x0019035a
MOV EAX,dword ptr [RBP + -0x94]
ADD EAX,0x30
MOV dword ptr [RBP + -0xcc],EAX
JMP 0x0019036c
LAB_0019035a:
MOV EAX,dword ptr [RBP + -0x94]
ADD EAX,0x61
SUB EAX,0xa
MOV dword ptr [RBP + -0xcc],EAX
LAB_0019036c:
MOV RDI,qword ptr [RBP + -0xc0]
MOV EAX,dword ptr [RBP + -0xcc]
MOV dword ptr [RBP + -0x98],EAX
MOVSX ESI,byte ptr [RBP + -0x98]
LAB_00190386:
CALL 0x00190530
JMP 0x0019038d
LAB_0019038d:
MOV RAX,qword ptr [RBP + -0xb0]
MOV RCX,qword ptr [RBP + -0x70]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x68]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x60]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RBP + -0x58]
MOV qword ptr [RAX + 0x18],RCX
JMP 0x001902e7
LAB_001903d2:
MOV RDI,qword ptr [RBP + -0xc0]
CALL 0x00190600
MOV RDI,qword ptr [RBP + -0xc0]
MOV qword ptr [RBP + -0xa0],RAX
CALL 0x00190630
MOV qword ptr [RBP + -0xa8],RAX
MOV RDI,qword ptr [RBP + -0xa0]
MOV RSI,qword ptr [RBP + -0xa8]
CALL 0x001905c0
LAB_0019040b:
JMP 0x0019040d
LAB_0019040d:
MOV byte ptr [RBP + -0x25],0x1
TEST byte ptr [RBP + -0x25],0x1
JNZ 0x00190423
MOV RDI,qword ptr [RBP + -0xc0]
CALL 0x0018ec10
LAB_00190423:
JMP 0x00190425
LAB_00190425:
MOV RAX,qword ptr [RBP + -0xb8]
ADD RSP,0xd0
POP RBP
RET
|
/* WARNING: Removing unreachable block (ram,0x00190417) */
/* std::__cxx11::string intx::to_string<256u>(intx::uint<256u>, int) */
string * intx::to_string<256u>(string *param_1,int param_2)
{
bool bVar1;
int iVar2;
int8 uVar3;
int8 uVar4;
int8 in_stack_00000008;
int8 in_stack_00000010;
int8 in_stack_00000018;
int8 in_stack_00000020;
char local_d4;
uint<256u> local_98 [32];
int8 local_78;
int8 local_70;
int8 local_68;
int8 local_60;
uint auStack_58 [36];
int local_34;
int1 local_2d;
allocator local_19;
int local_18;
int local_14;
string *local_10;
local_14 = param_2;
local_10 = param_1;
if ((param_2 < 2) || (0x24 < param_2)) {
throw_<std::invalid_argument>("invalid base");
}
local_18 = 0;
bVar1 = operator==((uint *)&stack0x00000008,&local_18);
if (bVar1) {
std::allocator<char>::allocator();
/* try { // try from 001902a1 to 001902ac has its CatchHandler @ 001902bd */
std::__cxx11::string::string<std::allocator<char>>(param_1,"0",&local_19);
std::allocator<char>::~allocator((allocator<char> *)&local_19);
}
else {
local_2d = 0;
std::__cxx11::string::string(param_1);
while( true ) {
local_34 = 0;
bVar1 = operator!=((uint *)&stack0x00000008,&local_34);
if (!bVar1) break;
uint<256u>::uint<int,void>(local_98,local_14);
udivrem<256u,256u>((intx *)&local_78,(uint *)&stack0x00000008,(uint *)local_98);
iVar2 = uint::operator_cast_to_int(auStack_58);
if (iVar2 < 10) {
local_d4 = (char)iVar2 + '0';
}
else {
local_d4 = (char)iVar2 + 'W';
}
/* try { // try from 00190386 to 0019040a has its CatchHandler @ 001903b8 */
std::__cxx11::string::push_back(param_1,local_d4);
in_stack_00000008 = local_78;
in_stack_00000010 = local_70;
in_stack_00000018 = local_68;
in_stack_00000020 = local_60;
}
uVar3 = std::__cxx11::string::begin(param_1);
uVar4 = std::__cxx11::string::end(param_1);
std::reverse<__gnu_cxx::__normal_iterator<char*,std::__cxx11::string>>(uVar3,uVar4);
}
return param_1;
}
|
|
18,410
|
write_dynamic_record
|
eloqsql/storage/maria/ma_dynrec.c
|
static my_bool write_dynamic_record(MARIA_HA *info, const uchar *record,
ulong reclength)
{
int flag;
ulong length;
my_off_t filepos;
DBUG_ENTER("write_dynamic_record");
flag=0;
/*
Check if we have enough room for the new record.
First we do simplified check to make usual case faster.
Then we do more precise check for the space left.
Though it still is not absolutely precise, as
we always use MARIA_MAX_DYN_BLOCK_HEADER while it can be
less in the most of the cases.
*/
if (unlikely(info->s->base.max_data_file_length -
info->state->data_file_length <
reclength + MARIA_MAX_DYN_BLOCK_HEADER))
{
if (info->s->base.max_data_file_length - info->state->data_file_length +
info->state->empty - info->state->del * MARIA_MAX_DYN_BLOCK_HEADER <
reclength + MARIA_MAX_DYN_BLOCK_HEADER)
{
my_errno=HA_ERR_RECORD_FILE_FULL;
DBUG_RETURN(1);
}
}
do
{
if (_ma_find_writepos(info,reclength,&filepos,&length))
goto err;
if (_ma_write_part_record(info,filepos,length,
(info->append_insert_at_end ?
HA_OFFSET_ERROR : info->s->state.dellink),
(uchar**) &record,&reclength,&flag))
goto err;
} while (reclength);
DBUG_RETURN(0);
err:
DBUG_RETURN(1);
}
|
O0
|
c
|
write_dynamic_record:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x368(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq 0x28(%rcx), %rax
movq -0x20(%rbp), %rcx
addq $0x14, %rcx
cmpq %rcx, %rax
setb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3c144
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x368(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq 0x28(%rcx), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
addq 0x10(%rcx), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
imulq $0x14, 0x8(%rcx), %rcx
subq %rcx, %rax
movq -0x20(%rbp), %rcx
addq $0x14, %rcx
cmpq %rcx, %rax
jae 0x3c142
callq 0xf60c0
movl $0x87, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x3c1f3
jmp 0x3c144
jmp 0x3c146
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x38(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x411d0
cmpl $0x0, %eax
je 0x3c165
jmp 0x3c1ed
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x681(%rax), %eax
cmpl $0x0, %eax
je 0x3c19a
movq $-0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x3c1ac
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0xc8(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rcx
leaq -0x18(%rbp), %r8
leaq -0x20(%rbp), %r9
leaq -0x24(%rbp), %rax
movq %rax, (%rsp)
callq 0x3d230
cmpl $0x0, %eax
je 0x3c1d8
jmp 0x3c1ed
jmp 0x3c1da
cmpq $0x0, -0x20(%rbp)
jne 0x3c146
jmp 0x3c1e7
movb $0x0, -0x1(%rbp)
jmp 0x3c1f3
jmp 0x3c1ef
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
|
write_dynamic_record:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], 0
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+368h]
mov rcx, [rbp+var_10]
mov rcx, [rcx+20h]
sub rax, [rcx+28h]
mov rcx, [rbp+var_20]
add rcx, 14h
cmp rax, rcx
setb al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_3C144
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+368h]
mov rcx, [rbp+var_10]
mov rcx, [rcx+20h]
sub rax, [rcx+28h]
mov rcx, [rbp+var_10]
mov rcx, [rcx+20h]
add rax, [rcx+10h]
mov rcx, [rbp+var_10]
mov rcx, [rcx+20h]
imul rcx, [rcx+8], 14h
sub rax, rcx
mov rcx, [rbp+var_20]
add rcx, 14h
cmp rax, rcx
jnb short loc_3C142
call _my_thread_var
mov dword ptr [rax], 87h
mov [rbp+var_1], 1
jmp loc_3C1F3
loc_3C142:
jmp short $+2
loc_3C144:
jmp short $+2
loc_3C146:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
lea rdx, [rbp+var_38]
lea rcx, [rbp+var_30]
call _ma_find_writepos
cmp eax, 0
jz short loc_3C165
jmp loc_3C1ED
loc_3C165:
mov rax, [rbp+var_10]
mov [rbp+var_50], rax
mov rax, [rbp+var_38]
mov [rbp+var_48], rax
mov rax, [rbp+var_30]
mov [rbp+var_40], rax
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax+681h]
cmp eax, 0
jz short loc_3C19A
mov rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_58], rax
jmp short loc_3C1AC
loc_3C19A:
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+0C8h]
mov [rbp+var_58], rax
loc_3C1AC:
mov rdx, [rbp+var_40]
mov rsi, [rbp+var_48]
mov rdi, [rbp+var_50]
mov rcx, [rbp+var_58]
lea r8, [rbp+var_18]
lea r9, [rbp+var_20]
lea rax, [rbp+var_24]
mov [rsp+60h+var_60], rax
call _ma_write_part_record
cmp eax, 0
jz short loc_3C1D8
jmp short loc_3C1ED
loc_3C1D8:
jmp short $+2
loc_3C1DA:
cmp [rbp+var_20], 0
jnz loc_3C146
jmp short $+2
loc_3C1E7:
mov [rbp+var_1], 0
jmp short loc_3C1F3
loc_3C1ED:
jmp short $+2
loc_3C1EF:
mov [rbp+var_1], 1
loc_3C1F3:
mov al, [rbp+var_1]
add rsp, 60h
pop rbp
retn
|
char write_dynamic_record(_QWORD *a1, long long a2, long long a3)
{
long long v5; // [rsp+28h] [rbp-38h] BYREF
long long v6; // [rsp+30h] [rbp-30h] BYREF
int v7; // [rsp+3Ch] [rbp-24h] BYREF
long long v8; // [rsp+40h] [rbp-20h] BYREF
long long v9; // [rsp+48h] [rbp-18h] BYREF
_QWORD *v10; // [rsp+50h] [rbp-10h]
v10 = a1;
v9 = a2;
v8 = a3;
v7 = 0;
if ( *(_QWORD *)(*a1 + 872LL) - *(_QWORD *)(a1[4] + 40LL) >= (unsigned long long)(a3 + 20)
|| *(_QWORD *)(v10[4] + 16LL)
+ *(_QWORD *)(*v10 + 872LL)
- *(_QWORD *)(v10[4] + 40LL)
- 20LL * *(_QWORD *)(v10[4] + 8LL) >= (unsigned long long)(v8 + 20) )
{
while ( !(unsigned int)ma_find_writepos(v10, v8, &v5, &v6) )
{
if ( *((_BYTE *)v10 + 1665)
? ma_write_part_record((_DWORD)v10, v5, v6, -1, (unsigned int)&v9, (unsigned int)&v8, (long long)&v7)
: (unsigned int)ma_write_part_record(
(_DWORD)v10,
v5,
v6,
*(_QWORD *)(*v10 + 200LL),
(unsigned int)&v9,
(unsigned int)&v8,
(long long)&v7) )
{
break;
}
if ( !v8 )
return 0;
}
return 1;
}
else
{
*(_DWORD *)my_thread_var() = 135;
return 1;
}
}
|
write_dynamic_record:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x368]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x20]
SUB RAX,qword ptr [RCX + 0x28]
MOV RCX,qword ptr [RBP + -0x20]
ADD RCX,0x14
CMP RAX,RCX
SETC AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0013c144
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x368]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x20]
SUB RAX,qword ptr [RCX + 0x28]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x20]
ADD RAX,qword ptr [RCX + 0x10]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x20]
IMUL RCX,qword ptr [RCX + 0x8],0x14
SUB RAX,RCX
MOV RCX,qword ptr [RBP + -0x20]
ADD RCX,0x14
CMP RAX,RCX
JNC 0x0013c142
CALL 0x001f60c0
MOV dword ptr [RAX],0x87
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0013c1f3
LAB_0013c142:
JMP 0x0013c144
LAB_0013c144:
JMP 0x0013c146
LAB_0013c146:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
LEA RDX,[RBP + -0x38]
LEA RCX,[RBP + -0x30]
CALL 0x001411d0
CMP EAX,0x0
JZ 0x0013c165
JMP 0x0013c1ed
LAB_0013c165:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX + 0x681]
CMP EAX,0x0
JZ 0x0013c19a
MOV RAX,-0x1
MOV qword ptr [RBP + -0x58],RAX
JMP 0x0013c1ac
LAB_0013c19a:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0xc8]
MOV qword ptr [RBP + -0x58],RAX
LAB_0013c1ac:
MOV RDX,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x48]
MOV RDI,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RBP + -0x58]
LEA R8,[RBP + -0x18]
LEA R9,[RBP + -0x20]
LEA RAX,[RBP + -0x24]
MOV qword ptr [RSP],RAX
CALL 0x0013d230
CMP EAX,0x0
JZ 0x0013c1d8
JMP 0x0013c1ed
LAB_0013c1d8:
JMP 0x0013c1da
LAB_0013c1da:
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x0013c146
JMP 0x0013c1e7
LAB_0013c1e7:
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0013c1f3
LAB_0013c1ed:
JMP 0x0013c1ef
LAB_0013c1ef:
MOV byte ptr [RBP + -0x1],0x1
LAB_0013c1f3:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x60
POP RBP
RET
|
int1 write_dynamic_record(long *param_1,int8 param_2,long param_3)
{
int iVar1;
int4 *puVar2;
int8 local_60;
int8 local_40;
int8 local_38;
int4 local_2c;
long local_28;
int8 local_20;
long *local_18;
int1 local_9;
local_2c = 0;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
if (((ulong)(*(long *)(*param_1 + 0x368) - *(long *)(param_1[4] + 0x28)) < param_3 + 0x14U) &&
((ulong)((*(long *)(*param_1 + 0x368) - *(long *)(param_1[4] + 0x28)) +
*(long *)(param_1[4] + 0x10) + *(long *)(param_1[4] + 8) * -0x14) < param_3 + 0x14U))
{
puVar2 = (int4 *)_my_thread_var();
*puVar2 = 0x87;
local_9 = 1;
}
else {
do {
iVar1 = _ma_find_writepos(local_18,local_28,&local_40,&local_38);
if (iVar1 != 0) {
return 1;
}
if (*(char *)((long)local_18 + 0x681) == '\0') {
local_60 = *(int8 *)(*local_18 + 200);
}
else {
local_60 = 0xffffffffffffffff;
}
iVar1 = _ma_write_part_record
(local_18,local_40,local_38,local_60,&local_20,&local_28,&local_2c);
if (iVar1 != 0) {
return 1;
}
} while (local_28 != 0);
local_9 = 0;
}
return local_9;
}
|
|
18,411
|
write_dynamic_record
|
eloqsql/storage/maria/ma_dynrec.c
|
static my_bool write_dynamic_record(MARIA_HA *info, const uchar *record,
ulong reclength)
{
int flag;
ulong length;
my_off_t filepos;
DBUG_ENTER("write_dynamic_record");
flag=0;
/*
Check if we have enough room for the new record.
First we do simplified check to make usual case faster.
Then we do more precise check for the space left.
Though it still is not absolutely precise, as
we always use MARIA_MAX_DYN_BLOCK_HEADER while it can be
less in the most of the cases.
*/
if (unlikely(info->s->base.max_data_file_length -
info->state->data_file_length <
reclength + MARIA_MAX_DYN_BLOCK_HEADER))
{
if (info->s->base.max_data_file_length - info->state->data_file_length +
info->state->empty - info->state->del * MARIA_MAX_DYN_BLOCK_HEADER <
reclength + MARIA_MAX_DYN_BLOCK_HEADER)
{
my_errno=HA_ERR_RECORD_FILE_FULL;
DBUG_RETURN(1);
}
}
do
{
if (_ma_find_writepos(info,reclength,&filepos,&length))
goto err;
if (_ma_write_part_record(info,filepos,length,
(info->append_insert_at_end ?
HA_OFFSET_ERROR : info->s->state.dellink),
(uchar**) &record,&reclength,&flag))
goto err;
} while (reclength);
DBUG_RETURN(0);
err:
DBUG_RETURN(1);
}
|
O3
|
c
|
write_dynamic_record:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsi, -0x50(%rbp)
movq %rdx, -0x38(%rbp)
movl $0x0, -0x2c(%rbp)
movq (%rdi), %rax
movq 0x20(%rdi), %rsi
movq 0x368(%rax), %rax
subq 0x28(%rsi), %rax
leaq 0x14(%rdx), %rcx
cmpq %rcx, %rax
jb 0x3ca0a
leaq -0x48(%rbp), %r15
leaq -0x50(%rbp), %r12
leaq -0x38(%rbp), %r13
movq %rbx, %rdi
movq %rdx, %rsi
leaq -0x40(%rbp), %rdx
movq %r15, %rcx
callq 0x3f5a9
movb $0x1, %r14b
testl %eax, %eax
jne 0x3c9f8
movq $-0x1, %rcx
cmpb $0x0, 0x681(%rbx)
jne 0x3c9ca
movq (%rbx), %rax
movq 0xc8(%rax), %rcx
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq -0x2c(%rbp), %rax
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r12, %r8
movq %r13, %r9
callq 0x3d30e
testl %eax, %eax
jne 0x3c9f8
movq -0x38(%rbp), %rdx
testq %rdx, %rdx
jne 0x3c997
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq 0x10(%rsi), %rax
movq 0x8(%rsi), %rsi
shlq $0x2, %rsi
leaq (%rsi,%rsi,4), %rsi
subq %rsi, %rax
cmpq %rcx, %rax
jae 0x3c98b
callq 0xa1b22
movl $0x87, (%rax)
movb $0x1, %r14b
jmp 0x3c9f8
|
write_dynamic_record:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov rbx, rdi
mov [rbp+var_50], rsi
mov [rbp+var_38], rdx
mov [rbp+var_2C], 0
mov rax, [rdi]
mov rsi, [rdi+20h]
mov rax, [rax+368h]
sub rax, [rsi+28h]
lea rcx, [rdx+14h]
cmp rax, rcx
jb short loc_3CA0A
loc_3C98B:
lea r15, [rbp+var_48]
lea r12, [rbp+var_50]
lea r13, [rbp+var_38]
loc_3C997:
mov rdi, rbx
mov rsi, rdx
lea rdx, [rbp+var_40]
mov rcx, r15
call _ma_find_writepos
mov r14b, 1
test eax, eax
jnz short loc_3C9F8
mov rcx, 0FFFFFFFFFFFFFFFFh
cmp byte ptr [rbx+681h], 0
jnz short loc_3C9CA
mov rax, [rbx]
mov rcx, [rax+0C8h]
loc_3C9CA:
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_48]
lea rax, [rbp+var_2C]
mov [rsp+60h+var_60], rax
mov rdi, rbx
mov r8, r12
mov r9, r13
call _ma_write_part_record
test eax, eax
jnz short loc_3C9F8
mov rdx, [rbp+var_38]
test rdx, rdx
jnz short loc_3C997
xor r14d, r14d
loc_3C9F8:
mov eax, r14d
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3CA0A:
add rax, [rsi+10h]
mov rsi, [rsi+8]
shl rsi, 2
lea rsi, [rsi+rsi*4]
sub rax, rsi
cmp rax, rcx
jnb loc_3C98B
call _my_thread_var
mov dword ptr [rax], 87h
mov r14b, 1
jmp short loc_3C9F8
|
long long write_dynamic_record(_BYTE *a1, long long a2, long long a3, long long a4, long long a5)
{
unsigned int v5; // r14d
_QWORD *v6; // rsi
unsigned long long v7; // rax
unsigned long long v8; // rcx
long long v9; // rcx
unsigned long long v11; // rax
long long v12; // rsi
long long v13; // [rsp+10h] [rbp-50h] BYREF
long long v14; // [rsp+18h] [rbp-48h] BYREF
long long v15; // [rsp+20h] [rbp-40h] BYREF
long long v16; // [rsp+28h] [rbp-38h] BYREF
_DWORD v17[11]; // [rsp+34h] [rbp-2Ch] BYREF
v13 = a2;
v16 = a3;
v17[0] = 0;
v6 = (_QWORD *)*((_QWORD *)a1 + 4);
v7 = *(_QWORD *)(*(_QWORD *)a1 + 872LL) - v6[5];
v8 = a3 + 20;
if ( v7 >= a3 + 20 || (v11 = v6[2] + v7, v12 = 20LL * v6[1], v11 - v12 >= v8) )
{
while ( 1 )
{
LOBYTE(v5) = 1;
if ( (unsigned int)ma_find_writepos(a1, a3, &v15, &v14) )
break;
LODWORD(v9) = -1;
if ( !a1[1665] )
v9 = *(_QWORD *)(*(_QWORD *)a1 + 200LL);
if ( (unsigned int)ma_write_part_record(
(_DWORD)a1,
v15,
v14,
v9,
(unsigned int)&v13,
(unsigned int)&v16,
(long long)v17) )
break;
a3 = v16;
if ( !v16 )
return 0;
}
}
else
{
*(_DWORD *)my_thread_var(a1, v12, a3, v8, a5) = 135;
LOBYTE(v5) = 1;
}
return v5;
}
|
write_dynamic_record:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RBX,RDI
MOV qword ptr [RBP + -0x50],RSI
MOV qword ptr [RBP + -0x38],RDX
MOV dword ptr [RBP + -0x2c],0x0
MOV RAX,qword ptr [RDI]
MOV RSI,qword ptr [RDI + 0x20]
MOV RAX,qword ptr [RAX + 0x368]
SUB RAX,qword ptr [RSI + 0x28]
LEA RCX,[RDX + 0x14]
CMP RAX,RCX
JC 0x0013ca0a
LAB_0013c98b:
LEA R15,[RBP + -0x48]
LEA R12,[RBP + -0x50]
LEA R13,[RBP + -0x38]
LAB_0013c997:
MOV RDI,RBX
MOV RSI,RDX
LEA RDX,[RBP + -0x40]
MOV RCX,R15
CALL 0x0013f5a9
MOV R14B,0x1
TEST EAX,EAX
JNZ 0x0013c9f8
MOV RCX,-0x1
CMP byte ptr [RBX + 0x681],0x0
JNZ 0x0013c9ca
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [RAX + 0xc8]
LAB_0013c9ca:
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x48]
LEA RAX,[RBP + -0x2c]
MOV qword ptr [RSP],RAX
MOV RDI,RBX
MOV R8,R12
MOV R9,R13
CALL 0x0013d30e
TEST EAX,EAX
JNZ 0x0013c9f8
MOV RDX,qword ptr [RBP + -0x38]
TEST RDX,RDX
JNZ 0x0013c997
XOR R14D,R14D
LAB_0013c9f8:
MOV EAX,R14D
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013ca0a:
ADD RAX,qword ptr [RSI + 0x10]
MOV RSI,qword ptr [RSI + 0x8]
SHL RSI,0x2
LEA RSI,[RSI + RSI*0x4]
SUB RAX,RSI
CMP RAX,RCX
JNC 0x0013c98b
CALL 0x001a1b22
MOV dword ptr [RAX],0x87
MOV R14B,0x1
JMP 0x0013c9f8
|
ulong write_dynamic_record(long *param_1,int8 param_2,long param_3)
{
long lVar1;
int iVar2;
ulong uVar3;
int4 *puVar4;
int8 uVar5;
ulong unaff_R14;
int8 local_58;
int8 local_50;
int8 local_48;
long local_40;
int4 local_34;
local_34 = 0;
lVar1 = param_1[4];
uVar3 = *(long *)(*param_1 + 0x368) - *(long *)(lVar1 + 0x28);
local_58 = param_2;
local_40 = param_3;
if ((uVar3 < param_3 + 0x14U) &&
(uVar3 + *(long *)(lVar1 + 0x10) + *(long *)(lVar1 + 8) * -0x14 < param_3 + 0x14U)) {
puVar4 = (int4 *)_my_thread_var();
*puVar4 = 0x87;
unaff_R14 = CONCAT71((int7)(unaff_R14 >> 8),1);
}
else {
do {
iVar2 = _ma_find_writepos(param_1,local_40,&local_48,&local_50);
unaff_R14 = CONCAT71((int7)(unaff_R14 >> 8),1);
if (iVar2 != 0) goto LAB_0013c9f8;
uVar5 = 0xffffffffffffffff;
if (*(char *)((long)param_1 + 0x681) == '\0') {
uVar5 = *(int8 *)(*param_1 + 200);
}
iVar2 = _ma_write_part_record(param_1,local_48,local_50,uVar5,&local_58,&local_40,&local_34);
if (iVar2 != 0) goto LAB_0013c9f8;
} while (local_40 != 0);
unaff_R14 = 0;
}
LAB_0013c9f8:
return unaff_R14 & 0xffffffff;
}
|
|
18,412
|
translog_read_record_header
|
eloqsql/storage/maria/ma_loghandler.c
|
int translog_read_record_header(LSN lsn, TRANSLOG_HEADER_BUFFER *buff)
{
TRANSLOG_PAGE_SIZE_BUFF psize_buff;
uchar *page;
translog_size_t res, page_offset= LSN_OFFSET(lsn) % TRANSLOG_PAGE_SIZE;
PAGECACHE_BLOCK_LINK *direct_link;
TRANSLOG_ADDRESS addr;
TRANSLOG_VALIDATOR_DATA data;
DBUG_ENTER("translog_read_record_header");
DBUG_PRINT("enter", ("LSN: " LSN_FMT, LSN_IN_PARTS(lsn)));
DBUG_ASSERT(LSN_OFFSET(lsn) % TRANSLOG_PAGE_SIZE != 0);
DBUG_ASSERT(translog_status == TRANSLOG_OK ||
translog_status == TRANSLOG_READONLY);
buff->lsn= lsn;
buff->groups_no= 0;
data.addr= &addr;
data.was_recovered= 0;
addr= lsn;
addr-= page_offset; /* offset decreasing */
res= (!(page= translog_get_page(&data, psize_buff.buffer, &direct_link))) ?
RECHEADER_READ_ERROR :
translog_read_record_header_from_buffer(page, page_offset, buff, 0);
translog_free_link(direct_link);
DBUG_RETURN(res);
}
|
O0
|
c
|
translog_read_record_header:
pushq %rbp
movq %rsp, %rbp
subq $0x2050, %rsp # imm = 0x2050
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x2010(%rbp)
movq %rsi, -0x2018(%rbp)
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq -0x2010(%rbp), %rax
andq $0x1fff, %rax # imm = 0x1FFF
movl %eax, -0x2028(%rbp)
jmp 0x52a65
jmp 0x52a67
jmp 0x52a69
jmp 0x52a6b
jmp 0x52a6d
movq -0x2010(%rbp), %rcx
movq -0x2018(%rbp), %rax
movq %rcx, (%rax)
movq -0x2018(%rbp), %rax
movl $0x0, 0x418(%rax)
leaq -0x2038(%rbp), %rax
movq %rax, -0x2048(%rbp)
movb $0x0, -0x2040(%rbp)
movq -0x2010(%rbp), %rax
movq %rax, -0x2038(%rbp)
movl -0x2028(%rbp), %eax
movl %eax, %ecx
movq -0x2038(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x2038(%rbp)
leaq -0x2008(%rbp), %rsi
leaq -0x2048(%rbp), %rdi
leaq -0x2030(%rbp), %rdx
callq 0x51b40
movq %rax, -0x2020(%rbp)
cmpq $0x0, %rax
jne 0x52aff
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movl %eax, -0x204c(%rbp)
jmp 0x52b23
movq -0x2020(%rbp), %rdi
movl -0x2028(%rbp), %eax
movq -0x2018(%rbp), %rdx
xorl %ecx, %ecx
movzwl %ax, %esi
callq 0x54780
movl %eax, -0x204c(%rbp)
movl -0x204c(%rbp), %eax
movl %eax, -0x2024(%rbp)
movq -0x2030(%rbp), %rdi
callq 0x54720
movl -0x2024(%rbp), %eax
movl %eax, -0x2050(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x52b68
movl -0x2050(%rbp), %eax
addq $0x2050, %rsp # imm = 0x2050
popq %rbp
retq
callq 0x2a270
nopl (%rax)
|
translog_read_record_header:
push rbp
mov rbp, rsp
sub rsp, 2050h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_2010], rdi
mov [rbp+var_2018], rsi
mov rax, 0FFFFFFFFh
and rax, [rbp+var_2010]
and rax, 1FFFh
mov [rbp+var_2028], eax
jmp short $+2
loc_52A65:
jmp short $+2
loc_52A67:
jmp short $+2
loc_52A69:
jmp short $+2
loc_52A6B:
jmp short $+2
loc_52A6D:
mov rcx, [rbp+var_2010]
mov rax, [rbp+var_2018]
mov [rax], rcx
mov rax, [rbp+var_2018]
mov dword ptr [rax+418h], 0
lea rax, [rbp+var_2038]
mov [rbp+var_2048], rax
mov [rbp+var_2040], 0
mov rax, [rbp+var_2010]
mov [rbp+var_2038], rax
mov eax, [rbp+var_2028]
mov ecx, eax
mov rax, [rbp+var_2038]
sub rax, rcx
mov [rbp+var_2038], rax
lea rsi, [rbp+var_2008]
lea rdi, [rbp+var_2048]
lea rdx, [rbp+var_2030]
call translog_get_page
mov [rbp+var_2020], rax
cmp rax, 0
jnz short loc_52AFF
mov eax, 0FFFFFFFFh
mov [rbp+var_204C], eax
jmp short loc_52B23
loc_52AFF:
mov rdi, [rbp+var_2020]
mov eax, [rbp+var_2028]
mov rdx, [rbp+var_2018]
xor ecx, ecx
movzx esi, ax
call translog_read_record_header_from_buffer
mov [rbp+var_204C], eax
loc_52B23:
mov eax, [rbp+var_204C]
mov [rbp+var_2024], eax
mov rdi, [rbp+var_2030]
call translog_free_link
mov eax, [rbp+var_2024]
mov [rbp+var_2050], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_52B68
mov eax, [rbp+var_2050]
add rsp, 2050h
pop rbp
retn
loc_52B68:
call ___stack_chk_fail
|
long long translog_read_record_header(long long a1, _QWORD *a2)
{
int record_header_from_buffer; // [rsp+4h] [rbp-204Ch]
long long *v4; // [rsp+8h] [rbp-2048h] BYREF
char v5; // [rsp+10h] [rbp-2040h]
long long v6; // [rsp+18h] [rbp-2038h] BYREF
long long v7; // [rsp+20h] [rbp-2030h] BYREF
unsigned int v8; // [rsp+28h] [rbp-2028h]
unsigned int v9; // [rsp+2Ch] [rbp-2024h]
long long page; // [rsp+30h] [rbp-2020h]
_QWORD *v11; // [rsp+38h] [rbp-2018h]
long long v12; // [rsp+40h] [rbp-2010h]
_BYTE v13[8192]; // [rsp+48h] [rbp-2008h] BYREF
unsigned long long v14; // [rsp+2048h] [rbp-8h]
v14 = __readfsqword(0x28u);
v12 = a1;
v11 = a2;
v8 = a1 & 0x1FFF;
*a2 = a1;
*((_DWORD *)v11 + 262) = 0;
v4 = &v6;
v5 = 0;
v6 = v12 - v8;
page = translog_get_page(&v4, (long long)v13, (char *)&v7);
if ( page )
record_header_from_buffer = translog_read_record_header_from_buffer(page, (unsigned __int16)v8, v11, 0LL);
else
record_header_from_buffer = -1;
v9 = record_header_from_buffer;
translog_free_link(v7);
return v9;
}
|
translog_read_record_header:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x2050
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x2010],RDI
MOV qword ptr [RBP + -0x2018],RSI
MOV RAX,0xffffffff
AND RAX,qword ptr [RBP + -0x2010]
AND RAX,0x1fff
MOV dword ptr [RBP + -0x2028],EAX
JMP 0x00152a65
LAB_00152a65:
JMP 0x00152a67
LAB_00152a67:
JMP 0x00152a69
LAB_00152a69:
JMP 0x00152a6b
LAB_00152a6b:
JMP 0x00152a6d
LAB_00152a6d:
MOV RCX,qword ptr [RBP + -0x2010]
MOV RAX,qword ptr [RBP + -0x2018]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x2018]
MOV dword ptr [RAX + 0x418],0x0
LEA RAX,[RBP + -0x2038]
MOV qword ptr [RBP + -0x2048],RAX
MOV byte ptr [RBP + -0x2040],0x0
MOV RAX,qword ptr [RBP + -0x2010]
MOV qword ptr [RBP + -0x2038],RAX
MOV EAX,dword ptr [RBP + -0x2028]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x2038]
SUB RAX,RCX
MOV qword ptr [RBP + -0x2038],RAX
LEA RSI,[RBP + -0x2008]
LEA RDI,[RBP + -0x2048]
LEA RDX,[RBP + -0x2030]
CALL 0x00151b40
MOV qword ptr [RBP + -0x2020],RAX
CMP RAX,0x0
JNZ 0x00152aff
MOV EAX,0xffffffff
MOV dword ptr [RBP + -0x204c],EAX
JMP 0x00152b23
LAB_00152aff:
MOV RDI,qword ptr [RBP + -0x2020]
MOV EAX,dword ptr [RBP + -0x2028]
MOV RDX,qword ptr [RBP + -0x2018]
XOR ECX,ECX
MOVZX ESI,AX
CALL 0x00154780
MOV dword ptr [RBP + -0x204c],EAX
LAB_00152b23:
MOV EAX,dword ptr [RBP + -0x204c]
MOV dword ptr [RBP + -0x2024],EAX
MOV RDI,qword ptr [RBP + -0x2030]
CALL 0x00154720
MOV EAX,dword ptr [RBP + -0x2024]
MOV dword ptr [RBP + -0x2050],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00152b68
MOV EAX,dword ptr [RBP + -0x2050]
ADD RSP,0x2050
POP RBP
RET
LAB_00152b68:
CALL 0x0012a270
|
int4 translog_read_record_header(long param_1,long *param_2)
{
long in_FS_OFFSET;
int4 local_2054;
long *local_2050;
int1 local_2048;
long local_2040;
int8 local_2038;
uint local_2030;
int4 local_202c;
long local_2028;
long *local_2020;
long local_2018;
int1 local_2010 [8192];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_2030 = (uint)param_1 & 0x1fff;
*param_2 = param_1;
*(int4 *)(param_2 + 0x83) = 0;
local_2050 = &local_2040;
local_2048 = 0;
local_2040 = param_1 - (ulong)local_2030;
local_2020 = param_2;
local_2018 = param_1;
local_2028 = translog_get_page(&local_2050,local_2010,&local_2038);
if (local_2028 == 0) {
local_2054 = 0xffffffff;
}
else {
local_2054 = translog_read_record_header_from_buffer
(local_2028,local_2030 & 0xffff,local_2020,0);
}
local_202c = local_2054;
translog_free_link(local_2038);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_202c;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
18,413
|
minja::ArgumentsValue::get_named(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
monkey531[P]llama/common/minja.hpp
|
Value get_named(const std::string & name) {
for (const auto & [key, value] : kwargs) {
if (key == name) return value;
}
return Value();
}
|
O2
|
cpp
|
minja::ArgumentsValue::get_named(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %rbx
movq 0x18(%rsi), %r14
movq 0x20(%rsi), %r12
cmpq %r12, %r14
je 0x810a4
movq %r14, %rdi
movq %r15, %rsi
callq 0x3b2d6
testb %al, %al
jne 0x810ae
addq $0x70, %r14
jmp 0x8108a
movq %rbx, %rdi
callq 0x66ce6
jmp 0x810bd
addq $0x20, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x69380
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
_ZN5minja14ArgumentsValue9get_namedERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push r12
push rbx
push rax
mov r15, rdx
mov rbx, rdi
mov r14, [rsi+18h]
mov r12, [rsi+20h]
loc_8108A:
cmp r14, r12
jz short loc_810A4
mov rdi, r14
mov rsi, r15
call _ZSteqIcEN9__gnu_cxx11__enable_ifIXsr9__is_charIT_EE7__valueEbE6__typeERKNSt7__cxx1112basic_stringIS2_St11char_traitsIS2_ESaIS2_EEESC_
test al, al
jnz short loc_810AE
add r14, 70h ; 'p'
jmp short loc_8108A
loc_810A4:
mov rdi, rbx; this
call _ZN5minja5ValueC2Ev; minja::Value::Value(void)
jmp short loc_810BD
loc_810AE:
add r14, 20h ; ' '
mov rdi, rbx; this
mov rsi, r14; minja::Value *
call _ZN5minja5ValueC2ERKS0_; minja::Value::Value(minja::Value const&)
loc_810BD:
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
minja::Value * minja::ArgumentsValue::get_named(minja::Value *this, long long a2, _QWORD *a3)
{
_QWORD *v4; // r14
_QWORD *v5; // r12
v4 = *(_QWORD **)(a2 + 24);
v5 = *(_QWORD **)(a2 + 32);
while ( 1 )
{
if ( v4 == v5 )
{
minja::Value::Value(this);
return this;
}
if ( std::operator==<char>(v4, a3) )
break;
v4 += 14;
}
minja::Value::Value(this, (const minja::Value *)(v4 + 4));
return this;
}
|
get_named:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDX
MOV RBX,RDI
MOV R14,qword ptr [RSI + 0x18]
MOV R12,qword ptr [RSI + 0x20]
LAB_0018108a:
CMP R14,R12
JZ 0x001810a4
MOV RDI,R14
MOV RSI,R15
CALL 0x0013b2d6
TEST AL,AL
JNZ 0x001810ae
ADD R14,0x70
JMP 0x0018108a
LAB_001810a4:
MOV RDI,RBX
CALL 0x00166ce6
JMP 0x001810bd
LAB_001810ae:
ADD R14,0x20
MOV RDI,RBX
MOV RSI,R14
CALL 0x00169380
LAB_001810bd:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* minja::ArgumentsValue::get_named(std::__cxx11::string const&) */
string * minja::ArgumentsValue::get_named(string *param_1)
{
string *psVar1;
char cVar2;
string *in_RDX;
long in_RSI;
string *psVar3;
psVar3 = *(string **)(in_RSI + 0x18);
psVar1 = *(string **)(in_RSI + 0x20);
while( true ) {
if (psVar3 == psVar1) {
Value::Value((Value *)param_1);
return param_1;
}
cVar2 = std::operator==(psVar3,in_RDX);
if (cVar2 != '\0') break;
psVar3 = psVar3 + 0x70;
}
Value::Value((Value *)param_1,(Value *)(psVar3 + 0x20));
return param_1;
}
|
|
18,414
|
CameraMoveToTarget
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rcamera.h
|
void CameraMoveToTarget(Camera *camera, float delta)
{
float distance = Vector3Distance(camera->position, camera->target);
// Apply delta
distance += delta;
// Distance must be greater than 0
if (distance <= 0) distance = 0.001f;
// Set new distance by moving the position along the forward vector
Vector3 forward = GetCameraForward(camera);
camera->position = Vector3Add(camera->target, Vector3Scale(forward, -distance));
}
|
O2
|
c
|
CameraMoveToTarget:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movsd (%rdi), %xmm1
movsd 0xc(%rdi), %xmm2
movaps %xmm2, 0x20(%rsp)
movss 0x14(%rdi), %xmm3
movss %xmm3, 0xc(%rsp)
subps %xmm1, %xmm2
movaps %xmm3, %xmm1
subss 0x8(%rdi), %xmm1
movaps %xmm2, %xmm3
mulps %xmm2, %xmm3
shufps $0x55, %xmm3, %xmm3 # xmm3 = xmm3[1,1,1,1]
mulss %xmm2, %xmm2
addss %xmm3, %xmm2
mulss %xmm1, %xmm1
addss %xmm2, %xmm1
sqrtss %xmm1, %xmm1
addss %xmm0, %xmm1
movaps %xmm1, 0x10(%rsp)
callq 0x5ac80
movaps 0x5a2d2(%rip), %xmm2 # 0xb5140
movaps 0x10(%rsp), %xmm4
xorps %xmm4, %xmm2
cmpnless %xmm2, %xmm4
andps %xmm4, %xmm2
movss 0x68682(%rip), %xmm3 # 0xc3508
andnps %xmm3, %xmm4
orps %xmm2, %xmm4
movaps %xmm4, %xmm2
mulss %xmm1, %xmm2
unpcklps %xmm4, %xmm4 # xmm4 = xmm4[0,0,1,1]
mulps %xmm0, %xmm4
addps 0x20(%rsp), %xmm4
addss 0xc(%rsp), %xmm2
movlps %xmm4, (%rbx)
movss %xmm2, 0x8(%rbx)
addq $0x30, %rsp
popq %rbx
retq
|
CameraMoveToTarget:
push rbx
sub rsp, 30h
mov rbx, rdi
movsd xmm1, qword ptr [rdi]
movsd xmm2, qword ptr [rdi+0Ch]
movaps [rsp+38h+var_18], xmm2
movss xmm3, dword ptr [rdi+14h]
movss [rsp+38h+var_2C], xmm3
subps xmm2, xmm1
movaps xmm1, xmm3
subss xmm1, dword ptr [rdi+8]
movaps xmm3, xmm2
mulps xmm3, xmm2
shufps xmm3, xmm3, 55h ; 'U'
mulss xmm2, xmm2
addss xmm2, xmm3
mulss xmm1, xmm1
addss xmm1, xmm2
sqrtss xmm1, xmm1
addss xmm1, xmm0
movaps [rsp+38h+var_28], xmm1
call GetCameraForward
movaps xmm2, cs:xmmword_B5140
movaps xmm4, [rsp+38h+var_28]
xorps xmm2, xmm4
cmpnless xmm4, xmm2
andps xmm2, xmm4
movss xmm3, cs:dword_C3508
andnps xmm4, xmm3
orps xmm4, xmm2
movaps xmm2, xmm4
mulss xmm2, xmm1
unpcklps xmm4, xmm4
mulps xmm4, xmm0
addps xmm4, [rsp+38h+var_18]
addss xmm2, [rsp+38h+var_2C]
movlps qword ptr [rbx], xmm4
movss dword ptr [rbx+8], xmm2
add rsp, 30h
pop rbx
retn
|
void CameraMoveToTarget(unsigned long long *a1, float a2)
{
__m128 v2; // xmm2
__m128 v3; // xmm1
__m128 v4; // xmm3
__m128 CameraForward; // xmm0
__m128 v6; // xmm2
__m128 v7; // xmm4
__m128 v8; // xmm2
float v9; // [rsp+Ch] [rbp-2Ch]
__m128 v10; // [rsp+20h] [rbp-18h]
v10 = (__m128)*(unsigned long long *)((char *)a1 + 12);
v9 = *((float *)a1 + 5);
v2 = _mm_sub_ps(v10, (__m128)*a1);
v3 = (__m128)LODWORD(v9);
v4 = _mm_mul_ps(v2, v2);
v3.m128_f32[0] = fsqrt(
(float)((float)(v9 - *((float *)a1 + 2)) * (float)(v9 - *((float *)a1 + 2)))
+ (float)((float)(v2.m128_f32[0] * v2.m128_f32[0]) + _mm_shuffle_ps(v4, v4, 85).m128_f32[0]))
+ a2;
CameraForward = GetCameraForward(a1);
v6 = _mm_xor_ps((__m128)xmmword_B5140, v3);
v7 = _mm_cmpgt_ss(v3, v6);
v8 = _mm_or_ps(_mm_andnot_ps(v7, (__m128)0xBA83126F), _mm_and_ps(v6, v7));
_mm_storel_ps((double *)a1, _mm_add_ps(_mm_mul_ps(_mm_unpacklo_ps(v8, v8), CameraForward), v10));
*((float *)a1 + 2) = (float)(v8.m128_f32[0] * v3.m128_f32[0]) + v9;
}
|
CameraMoveToTarget:
PUSH RBX
SUB RSP,0x30
MOV RBX,RDI
MOVSD XMM1,qword ptr [RDI]
MOVSD XMM2,qword ptr [RDI + 0xc]
MOVAPS xmmword ptr [RSP + 0x20],XMM2
MOVSS XMM3,dword ptr [RDI + 0x14]
MOVSS dword ptr [RSP + 0xc],XMM3
SUBPS XMM2,XMM1
MOVAPS XMM1,XMM3
SUBSS XMM1,dword ptr [RDI + 0x8]
MOVAPS XMM3,XMM2
MULPS XMM3,XMM2
SHUFPS XMM3,XMM3,0x55
MULSS XMM2,XMM2
ADDSS XMM2,XMM3
MULSS XMM1,XMM1
ADDSS XMM1,XMM2
SQRTSS XMM1,XMM1
ADDSS XMM1,XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM1
CALL 0x0015ac80
MOVAPS XMM2,xmmword ptr [0x001b5140]
MOVAPS XMM4,xmmword ptr [RSP + 0x10]
XORPS XMM2,XMM4
CMPNLESS XMM4,XMM2
ANDPS XMM2,XMM4
MOVSS XMM3,dword ptr [0x001c3508]
ANDNPS XMM4,XMM3
ORPS XMM4,XMM2
MOVAPS XMM2,XMM4
MULSS XMM2,XMM1
UNPCKLPS XMM4,XMM4
MULPS XMM4,XMM0
ADDPS XMM4,xmmword ptr [RSP + 0x20]
ADDSS XMM2,dword ptr [RSP + 0xc]
MOVLPS qword ptr [RBX],XMM4
MOVSS dword ptr [RBX + 0x8],XMM2
ADD RSP,0x30
POP RBX
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void CameraMoveToTarget(float param_1,int8 *param_2)
{
float fVar1;
uint uVar2;
int8 uVar3;
float fVar4;
float fVar5;
float fVar6;
float fVar7;
float fVar8;
fVar5 = (float)*(int8 *)((long)param_2 + 0xc);
fVar7 = (float)((ulong)*(int8 *)((long)param_2 + 0xc) >> 0x20);
fVar1 = *(float *)((long)param_2 + 0x14);
fVar6 = fVar5 - (float)*param_2;
fVar8 = fVar7 - (float)((ulong)*param_2 >> 0x20);
fVar4 = fVar1 - *(float *)(param_2 + 1);
param_1 = SQRT(fVar4 * fVar4 + fVar6 * fVar6 + fVar8 * fVar8) + param_1;
fVar4 = param_1;
uVar3 = GetCameraForward();
uVar2 = -(uint)((float)(_DAT_001b5140 ^ (uint)param_1) < param_1);
fVar6 = (float)(~uVar2 & DAT_001c3508 | (_DAT_001b5140 ^ (uint)param_1) & uVar2);
*param_2 = CONCAT44(fVar6 * (float)((ulong)uVar3 >> 0x20) + fVar7,fVar6 * (float)uVar3 + fVar5);
*(float *)(param_2 + 1) = fVar6 * fVar4 + fVar1;
return;
}
|
|
18,415
|
CameraMoveToTarget
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rcamera.h
|
void CameraMoveToTarget(Camera *camera, float delta)
{
float distance = Vector3Distance(camera->position, camera->target);
// Apply delta
distance += delta;
// Distance must be greater than 0
if (distance <= 0) distance = 0.001f;
// Set new distance by moving the position along the forward vector
Vector3 forward = GetCameraForward(camera);
camera->position = Vector3Add(camera->target, Vector3Scale(forward, -distance));
}
|
O3
|
c
|
CameraMoveToTarget:
movsd (%rdi), %xmm3
movsd 0xc(%rdi), %xmm1
movss 0x14(%rdi), %xmm2
movaps %xmm1, %xmm7
subps %xmm3, %xmm7
movaps %xmm2, %xmm6
subss 0x8(%rdi), %xmm6
movaps %xmm7, %xmm3
mulps %xmm7, %xmm3
shufps $0x55, %xmm3, %xmm3 # xmm3 = xmm3[1,1,1,1]
movaps %xmm7, %xmm4
mulss %xmm7, %xmm4
addss %xmm3, %xmm4
movaps %xmm6, %xmm3
mulss %xmm6, %xmm3
addss %xmm4, %xmm3
sqrtss %xmm3, %xmm3
xorps %xmm4, %xmm4
ucomiss %xmm4, %xmm3
movss 0x68886(%rip), %xmm5 # 0xd3b1c
divss %xmm3, %xmm5
movaps %xmm5, %xmm4
shufps $0x0, %xmm5, %xmm4 # xmm4 = xmm4[0,0],xmm5[0,0]
mulps %xmm7, %xmm4
jne 0x6b2ab
jp 0x6b2ab
movaps %xmm7, %xmm4
mulss %xmm6, %xmm5
jne 0x6b2b6
jp 0x6b2b6
movaps %xmm6, %xmm5
addss %xmm0, %xmm3
movaps 0x63e8f(%rip), %xmm0 # 0xcf150
xorps %xmm3, %xmm0
cmpnless %xmm0, %xmm3
andps %xmm3, %xmm0
movss 0x72034(%rip), %xmm6 # 0xdd308
andnps %xmm6, %xmm3
orps %xmm0, %xmm3
movaps %xmm3, %xmm0
mulss %xmm5, %xmm0
unpcklps %xmm3, %xmm3 # xmm3 = xmm3[0,0,1,1]
mulps %xmm4, %xmm3
addps %xmm3, %xmm1
addss %xmm0, %xmm2
movlps %xmm1, (%rdi)
movss %xmm2, 0x8(%rdi)
retq
|
CameraMoveToTarget:
movsd xmm3, qword ptr [rdi]
movsd xmm1, qword ptr [rdi+0Ch]
movss xmm2, dword ptr [rdi+14h]
movaps xmm7, xmm1
subps xmm7, xmm3
movaps xmm6, xmm2
subss xmm6, dword ptr [rdi+8]
movaps xmm3, xmm7
mulps xmm3, xmm7
shufps xmm3, xmm3, 55h ; 'U'
movaps xmm4, xmm7
mulss xmm4, xmm7
addss xmm4, xmm3
movaps xmm3, xmm6
mulss xmm3, xmm6
addss xmm3, xmm4
sqrtss xmm3, xmm3
xorps xmm4, xmm4
ucomiss xmm3, xmm4
movss xmm5, cs:dword_D3B1C
divss xmm5, xmm3
movaps xmm4, xmm5
shufps xmm4, xmm5, 0
mulps xmm4, xmm7
jnz short loc_6B2AB
jp short loc_6B2AB
movaps xmm4, xmm7
loc_6B2AB:
mulss xmm5, xmm6
jnz short loc_6B2B6
jp short loc_6B2B6
movaps xmm5, xmm6
loc_6B2B6:
addss xmm3, xmm0
movaps xmm0, cs:xmmword_CF150
xorps xmm0, xmm3
cmpnless xmm3, xmm0
andps xmm0, xmm3
movss xmm6, cs:dword_DD308
andnps xmm3, xmm6
orps xmm3, xmm0
movaps xmm0, xmm3
mulss xmm0, xmm5
unpcklps xmm3, xmm3
mulps xmm3, xmm4
addps xmm1, xmm3
addss xmm2, xmm0
movlps qword ptr [rdi], xmm1
movss dword ptr [rdi+8], xmm2
retn
|
void CameraMoveToTarget(unsigned long long *a1, float a2)
{
float v2; // xmm2_4
__m128 v3; // xmm7
__m128 v4; // xmm6
__m128 v5; // xmm3
float v6; // xmm4_4
__m128 v7; // xmm3
__m128 v8; // xmm5
__m128 v9; // xmm4
float v10; // xmm5_4
__m128 v11; // xmm0
__m128 v12; // xmm3
__m128 v13; // xmm3
v2 = *((float *)a1 + 5);
v3 = _mm_sub_ps((__m128)*(unsigned long long *)((char *)a1 + 12), (__m128)*a1);
v4 = (__m128)LODWORD(v2);
v4.m128_f32[0] = v2 - *((float *)a1 + 2);
v5 = _mm_mul_ps(v3, v3);
v6 = (float)(v3.m128_f32[0] * v3.m128_f32[0]) + _mm_shuffle_ps(v5, v5, 85).m128_f32[0];
v7 = v4;
v7.m128_f32[0] = fsqrt((float)(v4.m128_f32[0] * v4.m128_f32[0]) + v6);
v8 = (__m128)0x3F800000u;
v8.m128_f32[0] = 1.0 / v7.m128_f32[0];
v9 = _mm_mul_ps(_mm_shuffle_ps(v8, v8, 0), v3);
if ( v7.m128_f32[0] == 0.0 )
v9 = v3;
v10 = v8.m128_f32[0] * v4.m128_f32[0];
if ( v7.m128_f32[0] == 0.0 )
v10 = v2 - *((float *)a1 + 2);
v7.m128_f32[0] = v7.m128_f32[0] + a2;
v11 = _mm_xor_ps((__m128)xmmword_CF150, v7);
v12 = _mm_cmpgt_ss(v7, v11);
v13 = _mm_or_ps(_mm_andnot_ps(v12, (__m128)0xBA83126F), _mm_and_ps(v11, v12));
_mm_storel_ps(
(double *)a1,
_mm_add_ps((__m128)*(unsigned long long *)((char *)a1 + 12), _mm_mul_ps(_mm_unpacklo_ps(v13, v13), v9)));
*((float *)a1 + 2) = v2 + (float)(v13.m128_f32[0] * v10);
}
|
CameraMoveToTarget:
MOVSD XMM3,qword ptr [RDI]
MOVSD XMM1,qword ptr [RDI + 0xc]
MOVSS XMM2,dword ptr [RDI + 0x14]
MOVAPS XMM7,XMM1
SUBPS XMM7,XMM3
MOVAPS XMM6,XMM2
SUBSS XMM6,dword ptr [RDI + 0x8]
MOVAPS XMM3,XMM7
MULPS XMM3,XMM7
SHUFPS XMM3,XMM3,0x55
MOVAPS XMM4,XMM7
MULSS XMM4,XMM7
ADDSS XMM4,XMM3
MOVAPS XMM3,XMM6
MULSS XMM3,XMM6
ADDSS XMM3,XMM4
SQRTSS XMM3,XMM3
XORPS XMM4,XMM4
UCOMISS XMM3,XMM4
MOVSS XMM5,dword ptr [0x001d3b1c]
DIVSS XMM5,XMM3
MOVAPS XMM4,XMM5
SHUFPS XMM4,XMM5,0x0
MULPS XMM4,XMM7
JNZ 0x0016b2ab
JP 0x0016b2ab
MOVAPS XMM4,XMM7
LAB_0016b2ab:
MULSS XMM5,XMM6
JNZ 0x0016b2b6
JP 0x0016b2b6
MOVAPS XMM5,XMM6
LAB_0016b2b6:
ADDSS XMM3,XMM0
MOVAPS XMM0,xmmword ptr [0x001cf150]
XORPS XMM0,XMM3
CMPNLESS XMM3,XMM0
ANDPS XMM0,XMM3
MOVSS XMM6,dword ptr [0x001dd308]
ANDNPS XMM3,XMM6
ORPS XMM3,XMM0
MOVAPS XMM0,XMM3
MULSS XMM0,XMM5
UNPCKLPS XMM3,XMM3
MULPS XMM3,XMM4
ADDPS XMM1,XMM3
ADDSS XMM2,XMM0
MOVLPS qword ptr [RDI],XMM1
MOVSS dword ptr [RDI + 0x8],XMM2
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void CameraMoveToTarget(float param_1,int8 *param_2)
{
uint uVar1;
float fVar2;
float fVar3;
float fVar4;
float fVar5;
float fVar6;
float fVar7;
float fVar8;
float fVar9;
float fVar10;
fVar2 = (float)*(int8 *)((long)param_2 + 0xc);
fVar3 = (float)((ulong)*(int8 *)((long)param_2 + 0xc) >> 0x20);
fVar9 = fVar2 - (float)*param_2;
fVar10 = fVar3 - (float)((ulong)*param_2 >> 0x20);
fVar8 = *(float *)((long)param_2 + 0x14) - *(float *)(param_2 + 1);
fVar4 = SQRT(fVar8 * fVar8 + fVar9 * fVar9 + fVar10 * fVar10);
fVar7 = DAT_001d3b1c / fVar4;
fVar5 = fVar7 * fVar9;
fVar6 = fVar7 * fVar10;
if ((fVar4 == 0.0) && (!NAN(fVar4))) {
fVar5 = fVar9;
fVar6 = fVar10;
}
fVar7 = fVar7 * fVar8;
if ((fVar4 == 0.0) && (!NAN(fVar4))) {
fVar7 = fVar8;
}
fVar8 = (float)(_DAT_001cf150 ^ (uint)(fVar4 + param_1));
uVar1 = -(uint)(fVar8 < fVar4 + param_1);
fVar4 = (float)(~uVar1 & DAT_001dd308 | (uint)fVar8 & uVar1);
*param_2 = CONCAT44(fVar3 + fVar4 * fVar6,fVar2 + fVar4 * fVar5);
*(float *)(param_2 + 1) = *(float *)((long)param_2 + 0x14) + fVar4 * fVar7;
return;
}
|
|
18,416
|
change_key_cache_param
|
eloqsql/mysys/mf_keycache.c
|
void change_key_cache_param(KEY_CACHE *keycache, uint division_limit,
uint age_threshold)
{
if (keycache->key_cache_inited)
{
pthread_mutex_lock(&keycache->op_lock);
keycache->interface_funcs->change_param(keycache->keycache_cb,
division_limit,
age_threshold);
pthread_mutex_unlock(&keycache->op_lock);
}
}
|
O0
|
c
|
change_key_cache_param:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x48(%rax)
je 0xe8dc2
movq -0x8(%rbp), %rdi
addq $0x58, %rdi
callq 0x2a220
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq *%rax
movq -0x8(%rbp), %rdi
addq $0x58, %rdi
callq 0x2a1f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
change_key_cache_param:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_10], edx
mov rax, [rbp+var_8]
cmp byte ptr [rax+48h], 0
jz short loc_E8DC2
mov rdi, [rbp+var_8]
add rdi, 58h ; 'X'
call _pthread_mutex_lock
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov rax, [rax+10h]
mov rcx, [rbp+var_8]
mov rdi, [rcx+8]
mov esi, [rbp+var_C]
mov edx, [rbp+var_10]
call rax
mov rdi, [rbp+var_8]
add rdi, 58h ; 'X'
call _pthread_mutex_unlock
loc_E8DC2:
add rsp, 10h
pop rbp
retn
|
long long change_key_cache_param(long long a1, unsigned int a2, unsigned int a3)
{
long long result; // rax
result = a1;
if ( *(_BYTE *)(a1 + 72) )
{
pthread_mutex_lock(a1 + 88);
(*(void ( **)(_QWORD, _QWORD, _QWORD))(*(_QWORD *)(a1 + 16) + 16LL))(*(_QWORD *)(a1 + 8), a2, a3);
return pthread_mutex_unlock(a1 + 88);
}
return result;
}
|
change_key_cache_param:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [RBP + -0x10],EDX
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX + 0x48],0x0
JZ 0x001e8dc2
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x58
CALL 0x0012a220
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RCX + 0x8]
MOV ESI,dword ptr [RBP + -0xc]
MOV EDX,dword ptr [RBP + -0x10]
CALL RAX
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x58
CALL 0x0012a1f0
LAB_001e8dc2:
ADD RSP,0x10
POP RBP
RET
|
void change_key_cache_param(long param_1,int4 param_2,int4 param_3)
{
if (*(char *)(param_1 + 0x48) != '\0') {
pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x58));
(**(code **)(*(long *)(param_1 + 0x10) + 0x10))(*(int8 *)(param_1 + 8),param_2,param_3);
pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x58));
}
return;
}
|
|
18,417
|
change_key_cache_param
|
eloqsql/mysys/mf_keycache.c
|
void change_key_cache_param(KEY_CACHE *keycache, uint division_limit,
uint age_threshold)
{
if (keycache->key_cache_inited)
{
pthread_mutex_lock(&keycache->op_lock);
keycache->interface_funcs->change_param(keycache->keycache_cb,
division_limit,
age_threshold);
pthread_mutex_unlock(&keycache->op_lock);
}
}
|
O3
|
c
|
change_key_cache_param:
cmpb $0x0, 0x48(%rdi)
je 0x9c043
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
leaq 0x58(%rdi), %r12
movq %r12, %rdi
callq 0x2a220
movq 0x8(%r15), %rdi
movq 0x10(%r15), %rax
movl %r14d, %esi
movl %ebx, %edx
callq *0x10(%rax)
movq %r12, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2a1e0
retq
|
change_key_cache_param:
cmp byte ptr [rdi+48h], 0
jz short locret_9C043
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov ebx, edx
mov r14d, esi
mov r15, rdi
lea r12, [rdi+58h]
mov rdi, r12
call _pthread_mutex_lock
mov rdi, [r15+8]
mov rax, [r15+10h]
mov esi, r14d
mov edx, ebx
call qword ptr [rax+10h]
mov rdi, r12
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp _pthread_mutex_unlock
locret_9C043:
retn
|
long long change_key_cache_param(long long a1, unsigned int a2, unsigned int a3)
{
long long result; // rax
if ( *(_BYTE *)(a1 + 72) )
{
pthread_mutex_lock(a1 + 88);
(*(void ( **)(_QWORD, _QWORD, _QWORD))(*(_QWORD *)(a1 + 16) + 16LL))(*(_QWORD *)(a1 + 8), a2, a3);
return pthread_mutex_unlock(a1 + 88);
}
return result;
}
|
change_key_cache_param:
CMP byte ptr [RDI + 0x48],0x0
JZ 0x0019c043
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV EBX,EDX
MOV R14D,ESI
MOV R15,RDI
LEA R12,[RDI + 0x58]
MOV RDI,R12
CALL 0x0012a220
MOV RDI,qword ptr [R15 + 0x8]
MOV RAX,qword ptr [R15 + 0x10]
MOV ESI,R14D
MOV EDX,EBX
CALL qword ptr [RAX + 0x10]
MOV RDI,R12
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x0012a1e0
LAB_0019c043:
RET
|
void change_key_cache_param(long param_1,int4 param_2,int4 param_3)
{
if (*(char *)(param_1 + 0x48) != '\0') {
pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x58));
(**(code **)(*(long *)(param_1 + 0x10) + 0x10))(*(int8 *)(param_1 + 8),param_2,param_3);
pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x58));
return;
}
return;
}
|
|
18,418
|
CLI::ArgumentMismatch::PartialType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
|
MikePodsytnik[P]TCRtrie/build_O1/_deps/cli11-src/include/CLI/Error.hpp
|
static ArgumentMismatch PartialType(std::string name, int num, std::string type) {
return ArgumentMismatch(name + ": " + type + " only partially specified: " + std::to_string(num) +
" required for each element");
}
|
O1
|
cpp
|
CLI::ArgumentMismatch::PartialType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, %r15
movl %edx, %r14d
movq %rdi, %rbx
leaq 0x78(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x68(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x178c0
leaq 0x1019d(%rip), %rsi # 0x37c47
movq %r12, %rdi
callq 0x77e0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq 0x68(%rsp), %rdi
callq 0x7140
leaq 0x98(%rsp), %rsi
movq %rsi, -0x10(%rsi)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x27af3
movq %rdx, 0x88(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x98(%rsp)
jmp 0x27af9
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
leaq 0x88(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x1010f(%rip), %rsi # 0x37c2e
callq 0x77e0
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x27b4b
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
jmp 0x27b53
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, 0x50(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl %r14d, %ebp
negl %ebp
cmovsl %r14d, %ebp
movl $0x1, %r15d
cmpl $0xa, %ebp
jb 0x27bc8
movl $0x4, %r15d
movl $0xd1b71759, %eax # imm = 0xD1B71759
movl %ebp, %ecx
cmpl $0x63, %ecx
jbe 0x27bbf
cmpl $0x3e7, %ecx # imm = 0x3E7
jbe 0x27bc5
cmpl $0x2710, %ecx # imm = 0x2710
jb 0x27bc8
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r15d
cmpl $0x1869f, %ecx # imm = 0x1869F
movl %edx, %ecx
ja 0x27b8c
addl $-0x3, %r15d
jmp 0x27bc8
addl $-0x2, %r15d
jmp 0x27bc8
decl %r15d
shrl $0x1f, %r14d
leal (%r15,%r14), %esi
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x28(%rsp), %rdi
movl $0x2d, %edx
callq 0x74d0
movl %r14d, %edi
addq 0x28(%rsp), %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x17a2f
movq 0x48(%rsp), %rcx
movq 0x50(%rsp), %r8
movq 0x30(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r13, %rcx
je 0x27c1d
movq 0x58(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x27c38
movl $0xf, %esi
cmpq %r12, 0x28(%rsp)
je 0x27c33
movq 0x38(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x27c49
movq 0x28(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x7140
jmp 0x27c57
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x74a0
leaq 0x18(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x27c7b
movq %rsi, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x27c81
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0xffa5(%rip), %rsi # 0x37c4a
leaq 0x8(%rsp), %rdi
callq 0x77e0
leaq 0xb8(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x27cdf
movq %rdx, 0xa8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xb8(%rsp)
jmp 0x27ce6
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq 0xa8(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
callq 0x17950
movq 0xa8(%rsp), %rdi
cmpq %r14, %rdi
je 0x27d2a
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x7430
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27d45
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7430
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x27d5c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7430
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x27d73
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x7430
movq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
leaq 0x78(%rsp), %r14
je 0x27d9d
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x7430
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0x27db4
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x7430
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0xa8(%rsp), %rdi
cmpq %r14, %rdi
je 0x27dee
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x7430
jmp 0x27dee
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27e0e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7430
jmp 0x27e0e
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x27e2a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7430
jmp 0x27e2a
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x27e46
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x7430
jmp 0x27e46
movq %rax, %rbx
movq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
je 0x27e70
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x7430
jmp 0x27e70
movq %rax, %rbx
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x27e8c
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x7430
movq %rbx, %rdi
callq 0x7780
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r13, %rdi
jne 0x27e7f
jmp 0x27e8c
|
_ZN3CLI16ArgumentMismatch11PartialTypeENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiS6_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0C8h
mov r15, rcx
mov r14d, edx
mov rbx, rdi
lea r13, [rsp+0F8h+var_80]
mov [r13-10h], r13
mov rax, [rsi]
mov rdx, [rsi+8]
add rdx, rax
lea r12, [rsp+0F8h+var_90]
mov rdi, r12
mov rsi, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea rsi, aOnlyPartiallyS+19h; ": "
mov rdi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rsi, [r15]
mov rdx, [r15+8]
lea rdi, [rsp+0F8h+var_90]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
lea rsi, [rsp+0F8h+var_60]
mov [rsi-10h], rsi
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_27AF3
mov [rsp+0F8h+var_70], rdx
mov rdx, [rcx]
mov [rsp+0F8h+var_60], rdx
jmp short loc_27AF9
loc_27AF3:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rsi], xmm0
loc_27AF9:
mov rdx, [rax+8]
lea rdi, [rsp+0F8h+var_70]
mov [rdi+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
lea rsi, aOnlyPartiallyS; " only partially specified: "
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea r13, [rsp+0F8h+var_A0]
mov [r13-10h], r13
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_27B4B
mov [rsp+0F8h+var_B0], rdx
mov rdx, [rcx]
mov [rsp+0F8h+var_A0], rdx
jmp short loc_27B53
loc_27B4B:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r13+0], xmm0
loc_27B53:
mov rdx, [rax+8]
mov [rsp+0F8h+var_A8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov ebp, r14d
neg ebp
cmovs ebp, r14d
mov r15d, 1
cmp ebp, 0Ah
jb short loc_27BC8
mov r15d, 4
mov eax, 0D1B71759h
mov ecx, ebp
loc_27B8C:
cmp ecx, 63h ; 'c'
jbe short loc_27BBF
cmp ecx, 3E7h
jbe short loc_27BC5
cmp ecx, 2710h
jb short loc_27BC8
mov edx, ecx
imul rdx, rax
shr rdx, 2Dh
add r15d, 4
cmp ecx, 1869Fh
mov ecx, edx
ja short loc_27B8C
add r15d, 0FFFFFFFDh
jmp short loc_27BC8
loc_27BBF:
add r15d, 0FFFFFFFEh
jmp short loc_27BC8
loc_27BC5:
dec r15d
loc_27BC8:
shr r14d, 1Fh
lea esi, [r15+r14]
lea r12, [rsp+0F8h+var_C0]
mov [r12-10h], r12
lea rdi, [rsp+0F8h+var_D0]
mov edx, 2Dh ; '-'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
mov edi, r14d
add rdi, [rsp+0F8h+var_D0]
mov esi, r15d
mov edx, ebp
call _ZNSt8__detail18__to_chars_10_implIjEEvPcjT_; std::__detail::__to_chars_10_impl<uint>(char *,uint,uint)
mov rcx, [rsp+0F8h+var_B0]
mov r8, [rsp+0F8h+var_A8]
mov rdx, [rsp+0F8h+var_C8]
lea rax, [rdx+r8]
mov esi, 0Fh
cmp rcx, r13
jz short loc_27C1D
mov rsi, [rsp+0F8h+var_A0]
loc_27C1D:
cmp rax, rsi
jbe short loc_27C38
mov esi, 0Fh
cmp [rsp+0F8h+var_D0], r12
jz short loc_27C33
mov rsi, [rsp+0F8h+var_C0]
loc_27C33:
cmp rax, rsi
jbe short loc_27C49
loc_27C38:
mov rsi, [rsp+0F8h+var_D0]
lea rdi, [rsp+0F8h+var_B0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
jmp short loc_27C57
loc_27C49:
lea rdi, [rsp+0F8h+var_D0]
xor esi, esi
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7replaceEmmPKcm; std::string::replace(ulong,ulong,char const*,ulong)
loc_27C57:
lea rdx, [rsp+0F8h+var_E0]
mov [rdx-10h], rdx
mov rsi, [rax]
lea rcx, [rax+10h]
cmp rsi, rcx
jz short loc_27C7B
mov [rsp+0F8h+var_F0], rsi
mov rdx, [rcx]
mov [rsp+0F8h+var_E0], rdx
jmp short loc_27C81
loc_27C7B:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rdx], xmm0
loc_27C81:
mov rdx, rax
add rdx, 8
mov rsi, [rax+8]
mov [rsp+0F8h+var_E8], rsi; __int64
mov [rax], rcx
mov qword ptr [rdx], 0
mov byte ptr [rcx], 0
lea rsi, aRequiredForEac; " required for each element"
lea rdi, [rsp+0F8h+var_F0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea r14, [rsp+0F8h+var_40]
mov [r14-10h], r14
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_27CDF
mov [rsp+0F8h+var_50], rdx
mov rdx, [rcx]
mov [rsp+0F8h+var_40], rdx
jmp short loc_27CE6
loc_27CDF:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r14], xmm0
loc_27CE6:
mov rdx, [rax+8]
lea rsi, [rsp+0F8h+var_50]
mov [rsi+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rdi, rbx; int
call _ZN3CLI16ArgumentMismatchC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; CLI::ArgumentMismatch::ArgumentMismatch(std::string)
mov rdi, [rsp+0F8h+var_50]; void *
cmp rdi, r14
jz short loc_27D2A
mov rsi, [rsp+0F8h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_27D2A:
lea rax, [rsp+0F8h+var_E0]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_27D45
mov rsi, [rsp+0F8h+var_E0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_27D45:
mov rdi, [rsp+0F8h+var_D0]; void *
cmp rdi, r12
jz short loc_27D5C
mov rsi, [rsp+0F8h+var_C0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_27D5C:
mov rdi, [rsp+0F8h+var_B0]; void *
cmp rdi, r13
jz short loc_27D73
mov rsi, [rsp+0F8h+var_A0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_27D73:
mov rdi, [rsp+0F8h+var_70]; void *
lea rax, [rsp+0F8h+var_60]
cmp rdi, rax
lea r14, [rsp+0F8h+var_80]
jz short loc_27D9D
mov rsi, [rsp+0F8h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_27D9D:
mov rdi, [rsp+0F8h+var_90]; void *
cmp rdi, r14
jz short loc_27DB4
mov rsi, [rsp+0F8h+var_80]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_27DB4:
mov rax, rbx
add rsp, 0C8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rsp+arg_A0]; void *
cmp rdi, r14
jz short loc_27DEE
mov rsi, [rsp+arg_B0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_27DEE
mov rbx, rax
loc_27DEE:
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_27E0E
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_27E0E
mov rbx, rax
loc_27E0E:
mov rdi, [rsp+arg_20]; void *
cmp rdi, r12
jz short loc_27E2A
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_27E2A
mov rbx, rax
loc_27E2A:
mov rdi, [rsp+arg_40]; void *
cmp rdi, r13
jz short loc_27E46
mov rsi, [rsp+arg_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_27E46
mov rbx, rax
loc_27E46:
mov rdi, [rsp+arg_80]; void *
lea rax, [rsp+arg_90]
cmp rdi, rax
jz short loc_27E70
mov rsi, [rsp+arg_90]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_27E70
mov rbx, rax
loc_27E70:
mov rdi, [rsp+arg_60]; void *
lea rax, [rsp+arg_70]
cmp rdi, rax
jz short loc_27E8C
loc_27E7F:
mov rsi, [rsp+arg_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_27E8C:
mov rdi, rbx
call __Unwind_Resume
mov rbx, rax
mov rdi, [rsp+arg_60]
cmp rdi, r13
jnz short loc_27E7F
jmp short loc_27E8C
|
long long CLI::ArgumentMismatch::PartialType(long long a1, long long a2, int a3, _QWORD *a4)
{
long long v6; // rax
__int128 *v7; // rcx
long long v8; // rax
__int128 *v9; // rcx
unsigned int v10; // ebp
int v11; // r15d
unsigned int v12; // ecx
bool v13; // cc
unsigned int v14; // r14d
unsigned long long v15; // rax
unsigned long long v16; // rsi
unsigned long long v17; // rsi
void **v18; // rax
__int128 *v19; // rcx
long long v20; // rax
_OWORD *v21; // rcx
void *v23[2]; // [rsp+8h] [rbp-F0h] BYREF
__int128 v24; // [rsp+18h] [rbp-E0h] BYREF
void *v25; // [rsp+28h] [rbp-D0h] BYREF
long long v26; // [rsp+30h] [rbp-C8h]
_QWORD v27[2]; // [rsp+38h] [rbp-C0h] BYREF
void *v28; // [rsp+48h] [rbp-B0h] BYREF
long long v29; // [rsp+50h] [rbp-A8h]
__int128 v30; // [rsp+58h] [rbp-A0h] BYREF
void *v31[2]; // [rsp+68h] [rbp-90h] BYREF
_QWORD v32[2]; // [rsp+78h] [rbp-80h] BYREF
void *v33[2]; // [rsp+88h] [rbp-70h] BYREF
__int128 v34; // [rsp+98h] [rbp-60h] BYREF
void *v35[2]; // [rsp+A8h] [rbp-50h] BYREF
_OWORD v36[4]; // [rsp+B8h] [rbp-40h] BYREF
v31[0] = v32;
std::string::_M_construct<char *>(v31, *(_BYTE **)a2, *(_QWORD *)a2 + *(_QWORD *)(a2 + 8));
std::string::append(v31, ": ");
v6 = std::string::_M_append(v31, *a4, a4[1]);
v33[0] = &v34;
v7 = (__int128 *)(v6 + 16);
if ( *(_QWORD *)v6 == v6 + 16 )
{
v34 = *v7;
}
else
{
v33[0] = *(void **)v6;
*(_QWORD *)&v34 = *(_QWORD *)v7;
}
v33[1] = *(void **)(v6 + 8);
*(_QWORD *)v6 = v7;
*(_QWORD *)(v6 + 8) = 0LL;
*(_BYTE *)(v6 + 16) = 0;
v8 = std::string::append(v33, " only partially specified: ");
v28 = &v30;
v9 = (__int128 *)(v8 + 16);
if ( *(_QWORD *)v8 == v8 + 16 )
{
v30 = *v9;
}
else
{
v28 = *(void **)v8;
*(_QWORD *)&v30 = *(_QWORD *)v9;
}
v29 = *(_QWORD *)(v8 + 8);
*(_QWORD *)v8 = v9;
*(_QWORD *)(v8 + 8) = 0LL;
*(_BYTE *)(v8 + 16) = 0;
v10 = -a3;
if ( a3 > 0 )
v10 = a3;
v11 = 1;
if ( v10 >= 0xA )
{
v11 = 4;
v12 = v10;
while ( 1 )
{
if ( v12 <= 0x63 )
{
v11 -= 2;
goto LABEL_18;
}
if ( v12 <= 0x3E7 )
break;
if ( v12 < 0x2710 )
goto LABEL_18;
v11 += 4;
v13 = v12 <= 0x1869F;
v12 /= 0x2710u;
if ( v13 )
{
v11 -= 3;
goto LABEL_18;
}
}
--v11;
}
LABEL_18:
v14 = (unsigned int)a3 >> 31;
v25 = v27;
std::string::_M_construct(&v25, v11 + v14, 45LL);
std::__detail::__to_chars_10_impl<unsigned int>((char *)v25 + v14, v11, v10);
v15 = v26 + v29;
v16 = 15LL;
if ( v28 != &v30 )
v16 = v30;
if ( v15 <= v16 )
goto LABEL_24;
v17 = 15LL;
if ( v25 != v27 )
v17 = v27[0];
if ( v15 <= v17 )
v18 = (void **)std::string::replace(&v25, 0LL, 0LL);
else
LABEL_24:
v18 = (void **)std::string::_M_append(&v28, v25, v26);
v23[0] = &v24;
v19 = (__int128 *)(v18 + 2);
if ( *v18 == v18 + 2 )
{
v24 = *v19;
}
else
{
v23[0] = *v18;
*(_QWORD *)&v24 = *(_QWORD *)v19;
}
v23[1] = v18[1];
*v18 = v19;
v18[1] = 0LL;
*(_BYTE *)v19 = 0;
v20 = std::string::append(v23, " required for each element");
v35[0] = v36;
v21 = (_OWORD *)(v20 + 16);
if ( *(_QWORD *)v20 == v20 + 16 )
{
v36[0] = *v21;
}
else
{
v35[0] = *(void **)v20;
*(_QWORD *)&v36[0] = *(_QWORD *)v21;
}
v35[1] = *(void **)(v20 + 8);
*(_QWORD *)v20 = v21;
*(_QWORD *)(v20 + 8) = 0LL;
*(_BYTE *)(v20 + 16) = 0;
CLI::ArgumentMismatch::ArgumentMismatch(a1, (long long)v35);
if ( v35[0] != v36 )
operator delete(v35[0], *(_QWORD *)&v36[0] + 1LL);
if ( v23[0] != &v24 )
operator delete(v23[0], v24 + 1);
if ( v25 != v27 )
operator delete(v25, v27[0] + 1LL);
if ( v28 != &v30 )
operator delete(v28, v30 + 1);
if ( v33[0] != &v34 )
operator delete(v33[0], v34 + 1);
if ( v31[0] != v32 )
operator delete(v31[0], v32[0] + 1LL);
return a1;
}
|
PartialType:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xc8
MOV R15,RCX
MOV R14D,EDX
MOV RBX,RDI
LEA R13,[RSP + 0x78]
MOV qword ptr [R13 + -0x10],R13
MOV RAX,qword ptr [RSI]
MOV RDX,qword ptr [RSI + 0x8]
ADD RDX,RAX
LEA R12,[RSP + 0x68]
MOV RDI,R12
MOV RSI,RAX
CALL 0x001178c0
LAB_00127aa3:
LEA RSI,[0x137c47]
MOV RDI,R12
CALL 0x001077e0
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
LAB_00127ab9:
LEA RDI,[RSP + 0x68]
CALL 0x00107140
LEA RSI,[RSP + 0x98]
MOV qword ptr [RSI + -0x10],RSI
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x00127af3
MOV qword ptr [RSP + 0x88],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x98],RDX
JMP 0x00127af9
LAB_00127af3:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RSI],XMM0
LAB_00127af9:
MOV RDX,qword ptr [RAX + 0x8]
LEA RDI,[RSP + 0x88]
MOV qword ptr [RDI + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LAB_00127b18:
LEA RSI,[0x137c2e]
CALL 0x001077e0
LEA R13,[RSP + 0x58]
MOV qword ptr [R13 + -0x10],R13
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x00127b4b
MOV qword ptr [RSP + 0x48],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x58],RDX
JMP 0x00127b53
LAB_00127b4b:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R13],XMM0
LAB_00127b53:
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x50],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
MOV EBP,R14D
NEG EBP
CMOVS EBP,R14D
MOV R15D,0x1
CMP EBP,0xa
JC 0x00127bc8
MOV R15D,0x4
MOV EAX,0xd1b71759
MOV ECX,EBP
LAB_00127b8c:
CMP ECX,0x63
JBE 0x00127bbf
CMP ECX,0x3e7
JBE 0x00127bc5
CMP ECX,0x2710
JC 0x00127bc8
MOV EDX,ECX
IMUL RDX,RAX
SHR RDX,0x2d
ADD R15D,0x4
CMP ECX,0x1869f
MOV ECX,EDX
JA 0x00127b8c
ADD R15D,-0x3
JMP 0x00127bc8
LAB_00127bbf:
ADD R15D,-0x2
JMP 0x00127bc8
LAB_00127bc5:
DEC R15D
LAB_00127bc8:
SHR R14D,0x1f
LEA ESI,[R15 + R14*0x1]
LEA R12,[RSP + 0x38]
MOV qword ptr [R12 + -0x10],R12
LAB_00127bda:
LEA RDI,[RSP + 0x28]
MOV EDX,0x2d
CALL 0x001074d0
MOV EDI,R14D
ADD RDI,qword ptr [RSP + 0x28]
MOV ESI,R15D
MOV EDX,EBP
CALL 0x00117a2f
MOV RCX,qword ptr [RSP + 0x48]
MOV R8,qword ptr [RSP + 0x50]
MOV RDX,qword ptr [RSP + 0x30]
LEA RAX,[RDX + R8*0x1]
MOV ESI,0xf
CMP RCX,R13
JZ 0x00127c1d
MOV RSI,qword ptr [RSP + 0x58]
LAB_00127c1d:
CMP RAX,RSI
JBE 0x00127c38
MOV ESI,0xf
CMP qword ptr [RSP + 0x28],R12
JZ 0x00127c33
MOV RSI,qword ptr [RSP + 0x38]
LAB_00127c33:
CMP RAX,RSI
JBE 0x00127c49
LAB_00127c38:
MOV RSI,qword ptr [RSP + 0x28]
LAB_00127c3d:
LEA RDI,[RSP + 0x48]
CALL 0x00107140
JMP 0x00127c57
LAB_00127c49:
LEA RDI,[RSP + 0x28]
XOR ESI,ESI
XOR EDX,EDX
CALL 0x001074a0
LAB_00127c57:
LEA RDX,[RSP + 0x18]
MOV qword ptr [RDX + -0x10],RDX
MOV RSI,qword ptr [RAX]
LEA RCX,[RAX + 0x10]
CMP RSI,RCX
JZ 0x00127c7b
MOV qword ptr [RSP + 0x8],RSI
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x18],RDX
JMP 0x00127c81
LAB_00127c7b:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RDX],XMM0
LAB_00127c81:
MOV RDX,RAX
ADD RDX,0x8
MOV RSI,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x10],RSI
MOV qword ptr [RAX],RCX
MOV qword ptr [RDX],0x0
MOV byte ptr [RCX],0x0
LAB_00127c9e:
LEA RSI,[0x137c4a]
LEA RDI,[RSP + 0x8]
CALL 0x001077e0
LEA R14,[RSP + 0xb8]
MOV qword ptr [R14 + -0x10],R14
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x00127cdf
MOV qword ptr [RSP + 0xa8],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0xb8],RDX
JMP 0x00127ce6
LAB_00127cdf:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R14],XMM0
LAB_00127ce6:
MOV RDX,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0xa8]
MOV qword ptr [RSI + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LAB_00127d05:
MOV RDI,RBX
CALL 0x00117950
LAB_00127d0d:
MOV RDI,qword ptr [RSP + 0xa8]
CMP RDI,R14
JZ 0x00127d2a
MOV RSI,qword ptr [RSP + 0xb8]
INC RSI
CALL 0x00107430
LAB_00127d2a:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00127d45
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00107430
LAB_00127d45:
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,R12
JZ 0x00127d5c
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x00107430
LAB_00127d5c:
MOV RDI,qword ptr [RSP + 0x48]
CMP RDI,R13
JZ 0x00127d73
MOV RSI,qword ptr [RSP + 0x58]
INC RSI
CALL 0x00107430
LAB_00127d73:
MOV RDI,qword ptr [RSP + 0x88]
LEA RAX,[RSP + 0x98]
CMP RDI,RAX
LEA R14,[RSP + 0x78]
JZ 0x00127d9d
MOV RSI,qword ptr [RSP + 0x98]
INC RSI
CALL 0x00107430
LAB_00127d9d:
MOV RDI,qword ptr [RSP + 0x68]
CMP RDI,R14
JZ 0x00127db4
MOV RSI,qword ptr [RSP + 0x78]
INC RSI
CALL 0x00107430
LAB_00127db4:
MOV RAX,RBX
ADD RSP,0xc8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* CLI::ArgumentMismatch::PartialType(std::__cxx11::string, int, std::__cxx11::string) */
ArgumentMismatch * __thiscall
CLI::ArgumentMismatch::PartialType(ArgumentMismatch *this,long *param_2,uint param_3,ulong *param_4)
{
uint uVar1;
long *plVar2;
int8 *puVar3;
uint uVar4;
long *plVar5;
ulong *puVar6;
ulong uVar7;
uint uVar8;
uint uVar9;
long *local_f0;
int8 local_e8;
long local_e0;
int8 uStack_d8;
ulong *local_d0;
long local_c8;
ulong local_c0 [2];
ulong *local_b0;
long local_a8;
ulong local_a0;
long lStack_98;
long *local_90 [2];
long local_80 [2];
long *local_70;
long local_68;
long local_60;
long lStack_58;
long *local_50;
long local_48;
long local_40;
int4 uStack_38;
int4 uStack_34;
local_90[0] = local_80;
std::__cxx11::string::_M_construct<char*>(local_90,*param_2,param_2[1] + *param_2);
/* try { // try from 00127aa3 to 00127ab1 has its CatchHandler @ 00127e94 */
std::__cxx11::string::append((char *)local_90);
/* try { // try from 00127ab9 to 00127ac2 has its CatchHandler @ 00127e6d */
plVar2 = (long *)std::__cxx11::string::_M_append((char *)local_90,*param_4);
local_70 = &local_60;
plVar5 = plVar2 + 2;
if ((long *)*plVar2 == plVar5) {
local_60 = *plVar5;
lStack_58 = plVar2[3];
}
else {
local_60 = *plVar5;
local_70 = (long *)*plVar2;
}
local_68 = plVar2[1];
*plVar2 = (long)plVar5;
plVar2[1] = 0;
*(int1 *)(plVar2 + 2) = 0;
/* try { // try from 00127b18 to 00127b23 has its CatchHandler @ 00127e43 */
plVar2 = (long *)std::__cxx11::string::append((char *)&local_70);
puVar6 = (ulong *)(plVar2 + 2);
if ((ulong *)*plVar2 == puVar6) {
local_a0 = *puVar6;
lStack_98 = plVar2[3];
local_b0 = &local_a0;
}
else {
local_a0 = *puVar6;
local_b0 = (ulong *)*plVar2;
}
local_a8 = plVar2[1];
*plVar2 = (long)puVar6;
plVar2[1] = 0;
*(int1 *)(plVar2 + 2) = 0;
uVar8 = -param_3;
if (0 < (int)param_3) {
uVar8 = param_3;
}
uVar9 = 1;
if (9 < uVar8) {
uVar7 = (ulong)uVar8;
uVar1 = 4;
do {
uVar9 = uVar1;
uVar4 = (uint)uVar7;
if (uVar4 < 100) {
uVar9 = uVar9 - 2;
goto LAB_00127bc8;
}
if (uVar4 < 1000) {
uVar9 = uVar9 - 1;
goto LAB_00127bc8;
}
if (uVar4 < 10000) goto LAB_00127bc8;
uVar7 = uVar7 / 10000;
uVar1 = uVar9 + 4;
} while (99999 < uVar4);
uVar9 = uVar9 + 1;
}
LAB_00127bc8:
/* try { // try from 00127bda to 00127be8 has its CatchHandler @ 00127e27 */
local_d0 = local_c0;
std::__cxx11::string::_M_construct((ulong)&local_d0,(char)uVar9 - (char)((int)param_3 >> 0x1f));
std::__detail::__to_chars_10_impl<unsigned_int>
((char *)((ulong)(param_3 >> 0x1f) + (long)local_d0),uVar9,uVar8);
uVar7 = 0xf;
if (local_b0 != &local_a0) {
uVar7 = local_a0;
}
if (uVar7 < (ulong)(local_c8 + local_a8)) {
uVar7 = 0xf;
if (local_d0 != local_c0) {
uVar7 = local_c0[0];
}
if ((ulong)(local_c8 + local_a8) <= uVar7) {
puVar3 = (int8 *)
std::__cxx11::string::replace((ulong)&local_d0,0,(char *)0x0,(ulong)local_b0);
goto LAB_00127c57;
}
}
/* try { // try from 00127c3d to 00127c56 has its CatchHandler @ 00127e0b */
puVar3 = (int8 *)std::__cxx11::string::_M_append((char *)&local_b0,(ulong)local_d0);
LAB_00127c57:
local_f0 = &local_e0;
plVar2 = puVar3 + 2;
if ((long *)*puVar3 == plVar2) {
local_e0 = *plVar2;
uStack_d8 = puVar3[3];
}
else {
local_e0 = *plVar2;
local_f0 = (long *)*puVar3;
}
local_e8 = puVar3[1];
*puVar3 = plVar2;
puVar3[1] = 0;
*(int1 *)plVar2 = 0;
/* try { // try from 00127c9e to 00127cae has its CatchHandler @ 00127deb */
plVar2 = (long *)std::__cxx11::string::append((char *)&local_f0);
plVar5 = plVar2 + 2;
if ((long *)*plVar2 == plVar5) {
local_40 = *plVar5;
uStack_38 = (int4)plVar2[3];
uStack_34 = *(int4 *)((long)plVar2 + 0x1c);
local_50 = &local_40;
}
else {
local_40 = *plVar5;
local_50 = (long *)*plVar2;
}
local_48 = plVar2[1];
*plVar2 = (long)plVar5;
plVar2[1] = 0;
*(int1 *)(plVar2 + 2) = 0;
/* try { // try from 00127d05 to 00127d0c has its CatchHandler @ 00127dc9 */
ArgumentMismatch(this);
if (local_50 != &local_40) {
operator_delete(local_50,local_40 + 1);
}
if (local_f0 != &local_e0) {
operator_delete(local_f0,local_e0 + 1);
}
if (local_d0 != local_c0) {
operator_delete(local_d0,local_c0[0] + 1);
}
if (local_b0 != &local_a0) {
operator_delete(local_b0,local_a0 + 1);
}
if (local_70 != &local_60) {
operator_delete(local_70,local_60 + 1);
}
if (local_90[0] != local_80) {
operator_delete(local_90[0],local_80[0] + 1);
}
return this;
}
|
|
18,419
|
testing::MatcherDescriberInterface const* testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::GetDescriberImpl<testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, false>>(testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
|
giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/include/gtest/gtest-matchers.h
|
static const MatcherDescriberInterface* GetDescriberImpl(
const MatcherBase& m) {
// If the impl is a MatcherDescriberInterface, then return it.
// Otherwise use MatcherBase itself.
// This allows us to implement the GetDescriber() function without support
// from the impl, but some users really want to get their impl back when
// they call GetDescriber().
// We use std::get on a tuple as a workaround of not having `if constexpr`.
return std::get<(
std::is_convertible<decltype(&P::Get(m)),
const MatcherDescriberInterface*>::value
? 1
: 0)>(std::make_tuple(&m, &P::Get(m)));
}
|
O1
|
c
|
testing::MatcherDescriberInterface const* testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::GetDescriberImpl<testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, false>>(testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&):
movq %rdi, %rax
retq
|
_ZN7testing8internal11MatcherBaseINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE16GetDescriberImplINS8_11ValuePolicyINS0_9EqMatcherIS7_EELb0EEEEEPKNS_25MatcherDescriberInterfaceERKS8_:
mov rax, rdi
retn
|
long long testing::internal::MatcherBase<std::string>::GetDescriberImpl<testing::internal::MatcherBase<std::string>::ValuePolicy<testing::internal::EqMatcher<std::string>,false>>(
long long a1)
{
return a1;
}
|
GetDescriberImpl<testing::internal::MatcherBase<std::__cxx11::string>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::string>,false>>:
MOV RAX,RDI
RET
|
/* testing::MatcherDescriberInterface const* testing::internal::MatcherBase<std::__cxx11::string
>::GetDescriberImpl<testing::internal::MatcherBase<std::__cxx11::string
>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::string >, false>
>(testing::internal::MatcherBase<std::__cxx11::string > const&) */
MatcherDescriberInterface *
testing::internal::MatcherBase<std::__cxx11::string>::
GetDescriberImpl<testing::internal::MatcherBase<std::__cxx11::string>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::string>,false>>
(MatcherBase *param_1)
{
return (MatcherDescriberInterface *)param_1;
}
|
|
18,420
|
my_wc_mb_euc_jp
|
eloqsql/strings/ctype-ujis.c
|
static int
my_wc_mb_euc_jp(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int jp;
if ((int) wc < 0x80) /* ASCII [00-7F] */
{
if (s >= e)
return MY_CS_TOOSMALL;
*s= (uchar) wc;
return 1;
}
if (wc > 0xFFFF)
return MY_CS_ILUNI;
if ((jp= unicode_to_jisx0208_eucjp[wc])) /* JIS-X-0208 */
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
MY_PUT_MB2(s, jp);
return 2;
}
if ((jp= unicode_to_jisx0212_eucjp[wc])) /* JIS-X-0212 */
{
if (s + 3 > e)
return MY_CS_TOOSMALL3;
s[0]= 0x8F;
MY_PUT_MB2(s + 1, jp);
return 3;
}
if (wc >= 0xFF61 && wc <= 0xFF9F) /* Half width Katakana */
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
s[0]= 0x8E;
s[1]= (uchar) (wc - 0xFEC0);
return 2;
}
return MY_CS_ILUNI;
}
|
O0
|
c
|
my_wc_mb_euc_jp:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x80, %eax
jge 0x7342d
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x73415
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x73555
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x73555
cmpq $0xffff, -0x18(%rbp) # imm = 0xFFFF
jbe 0x73443
movl $0x0, -0x4(%rbp)
jmp 0x73555
movq -0x18(%rbp), %rcx
leaq 0x2c11c2(%rip), %rax # 0x334610
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x7349f
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0x73474
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x73555
movl -0x2c(%rbp), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl -0x2c(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movl $0x2, -0x4(%rbp)
jmp 0x73555
movq -0x18(%rbp), %rcx
leaq 0x2e1166(%rip), %rax # 0x354610
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x73500
movq -0x20(%rbp), %rax
addq $0x3, %rax
cmpq -0x28(%rbp), %rax
jbe 0x734d0
movl $0xffffff99, -0x4(%rbp) # imm = 0xFFFFFF99
jmp 0x73555
movq -0x20(%rbp), %rax
movb $-0x71, (%rax)
movl -0x2c(%rbp), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x2c(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x2(%rax)
movl $0x3, -0x4(%rbp)
jmp 0x73555
cmpq $0xff61, -0x18(%rbp) # imm = 0xFF61
jb 0x7354e
cmpq $0xff9f, -0x18(%rbp) # imm = 0xFF9F
ja 0x7354e
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0x7352b
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x73555
movq -0x20(%rbp), %rax
movb $-0x72, (%rax)
movq -0x18(%rbp), %rax
subq $0xfec0, %rax # imm = 0xFEC0
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movl $0x2, -0x4(%rbp)
jmp 0x73555
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
|
my_wc_mb_euc_jp:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_18]
cmp eax, 80h
jge short loc_7342D
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_73415
mov [rbp+var_4], 0FFFFFF9Bh
jmp loc_73555
loc_73415:
mov rax, [rbp+var_18]
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov [rbp+var_4], 1
jmp loc_73555
loc_7342D:
cmp [rbp+var_18], 0FFFFh
jbe short loc_73443
mov [rbp+var_4], 0
jmp loc_73555
loc_73443:
mov rcx, [rbp+var_18]
lea rax, unicode_to_jisx0208_eucjp
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_2C], eax
cmp eax, 0
jz short loc_7349F
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_73474
mov [rbp+var_4], 0FFFFFF9Ah
jmp loc_73555
loc_73474:
mov eax, [rbp+var_2C]
sar eax, 8
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov eax, [rbp+var_2C]
and eax, 0FFh
mov cl, al
mov rax, [rbp+var_20]
mov [rax+1], cl
mov [rbp+var_4], 2
jmp loc_73555
loc_7349F:
mov rcx, [rbp+var_18]
lea rax, unicode_to_jisx0212_eucjp
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_2C], eax
cmp eax, 0
jz short loc_73500
mov rax, [rbp+var_20]
add rax, 3
cmp rax, [rbp+var_28]
jbe short loc_734D0
mov [rbp+var_4], 0FFFFFF99h
jmp loc_73555
loc_734D0:
mov rax, [rbp+var_20]
mov byte ptr [rax], 8Fh
mov eax, [rbp+var_2C]
sar eax, 8
mov cl, al
mov rax, [rbp+var_20]
mov [rax+1], cl
mov eax, [rbp+var_2C]
and eax, 0FFh
mov cl, al
mov rax, [rbp+var_20]
mov [rax+2], cl
mov [rbp+var_4], 3
jmp short loc_73555
loc_73500:
cmp [rbp+var_18], 0FF61h
jb short loc_7354E
cmp [rbp+var_18], 0FF9Fh
ja short loc_7354E
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_7352B
mov [rbp+var_4], 0FFFFFF9Ah
jmp short loc_73555
loc_7352B:
mov rax, [rbp+var_20]
mov byte ptr [rax], 8Eh
mov rax, [rbp+var_18]
sub rax, 0FEC0h
mov cl, al
mov rax, [rbp+var_20]
mov [rax+1], cl
mov [rbp+var_4], 2
jmp short loc_73555
loc_7354E:
mov [rbp+var_4], 0
loc_73555:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long my_wc_mb_euc_jp(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
__int16 v5; // [rsp+0h] [rbp-2Ch]
__int16 v6; // [rsp+0h] [rbp-2Ch]
if ( (int)a2 >= 128 )
{
if ( a2 <= 0xFFFF )
{
v5 = unicode_to_jisx0208_eucjp[a2];
if ( v5 )
{
if ( (unsigned long long)(a3 + 2) <= a4 )
{
*a3 = HIBYTE(v5);
a3[1] = v5;
return 2;
}
else
{
return (unsigned int)-102;
}
}
else
{
v6 = unicode_to_jisx0212_eucjp[a2];
if ( v6 )
{
if ( (unsigned long long)(a3 + 3) <= a4 )
{
*a3 = -113;
a3[1] = HIBYTE(v6);
a3[2] = v6;
return 3;
}
else
{
return (unsigned int)-103;
}
}
else if ( a2 < 0xFF61 || a2 > 0xFF9F )
{
return 0;
}
else if ( (unsigned long long)(a3 + 2) <= a4 )
{
*a3 = -114;
a3[1] = a2 + 64;
return 2;
}
else
{
return (unsigned int)-102;
}
}
}
else
{
return 0;
}
}
else if ( (unsigned long long)a3 < a4 )
{
*a3 = a2;
return 1;
}
else
{
return (unsigned int)-101;
}
}
|
my_wc_mb_euc_jp:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x18]
CMP EAX,0x80
JGE 0x0017342d
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x00173415
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x00173555
LAB_00173415:
MOV RAX,qword ptr [RBP + -0x18]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00173555
LAB_0017342d:
CMP qword ptr [RBP + -0x18],0xffff
JBE 0x00173443
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00173555
LAB_00173443:
MOV RCX,qword ptr [RBP + -0x18]
LEA RAX,[0x434610]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JZ 0x0017349f
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x00173474
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x00173555
LAB_00173474:
MOV EAX,dword ptr [RBP + -0x2c]
SAR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RBP + -0x2c]
AND EAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x1],CL
MOV dword ptr [RBP + -0x4],0x2
JMP 0x00173555
LAB_0017349f:
MOV RCX,qword ptr [RBP + -0x18]
LEA RAX,[0x454610]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JZ 0x00173500
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x3
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x001734d0
MOV dword ptr [RBP + -0x4],0xffffff99
JMP 0x00173555
LAB_001734d0:
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],0x8f
MOV EAX,dword ptr [RBP + -0x2c]
SAR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x1],CL
MOV EAX,dword ptr [RBP + -0x2c]
AND EAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x2],CL
MOV dword ptr [RBP + -0x4],0x3
JMP 0x00173555
LAB_00173500:
CMP qword ptr [RBP + -0x18],0xff61
JC 0x0017354e
CMP qword ptr [RBP + -0x18],0xff9f
JA 0x0017354e
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x0017352b
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x00173555
LAB_0017352b:
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],0x8e
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,0xfec0
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x1],CL
MOV dword ptr [RBP + -0x4],0x2
JMP 0x00173555
LAB_0017354e:
MOV dword ptr [RBP + -0x4],0x0
LAB_00173555:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_wc_mb_euc_jp(int8 param_1,ulong param_2,char *param_3,char *param_4)
{
short sVar1;
int4 local_c;
if ((int)param_2 < 0x80) {
if (param_3 < param_4) {
*param_3 = (char)param_2;
local_c = 1;
}
else {
local_c = 0xffffff9b;
}
}
else if (param_2 < 0x10000) {
sVar1 = *(short *)(unicode_to_jisx0208_eucjp + param_2 * 2);
if (sVar1 == 0) {
sVar1 = *(short *)(unicode_to_jisx0212_eucjp + param_2 * 2);
if (sVar1 == 0) {
if ((param_2 < 0xff61) || (0xff9f < param_2)) {
local_c = 0;
}
else if (param_4 < param_3 + 2) {
local_c = 0xffffff9a;
}
else {
*param_3 = -0x72;
param_3[1] = (char)param_2 + '@';
local_c = 2;
}
}
else if (param_4 < param_3 + 3) {
local_c = 0xffffff99;
}
else {
*param_3 = -0x71;
param_3[1] = (char)((ushort)sVar1 >> 8);
param_3[2] = (char)sVar1;
local_c = 3;
}
}
else if (param_4 < param_3 + 2) {
local_c = 0xffffff9a;
}
else {
*param_3 = (char)((ushort)sVar1 >> 8);
param_3[1] = (char)sVar1;
local_c = 2;
}
}
else {
local_c = 0;
}
return local_c;
}
|
|
18,421
|
my_wc_mb_euc_jp
|
eloqsql/strings/ctype-ujis.c
|
static int
my_wc_mb_euc_jp(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int jp;
if ((int) wc < 0x80) /* ASCII [00-7F] */
{
if (s >= e)
return MY_CS_TOOSMALL;
*s= (uchar) wc;
return 1;
}
if (wc > 0xFFFF)
return MY_CS_ILUNI;
if ((jp= unicode_to_jisx0208_eucjp[wc])) /* JIS-X-0208 */
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
MY_PUT_MB2(s, jp);
return 2;
}
if ((jp= unicode_to_jisx0212_eucjp[wc])) /* JIS-X-0212 */
{
if (s + 3 > e)
return MY_CS_TOOSMALL3;
s[0]= 0x8F;
MY_PUT_MB2(s + 1, jp);
return 3;
}
if (wc >= 0xFF61 && wc <= 0xFF9F) /* Half width Katakana */
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
s[0]= 0x8E;
s[1]= (uchar) (wc - 0xFEC0);
return 2;
}
return MY_CS_ILUNI;
}
|
O3
|
c
|
my_wc_mb_euc_jp:
cmpl $0x7f, %esi
jg 0x539ee
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x53a23
movb %sil, (%rdx)
movl $0x1, %eax
retq
xorl %eax, %eax
cmpq $0xffff, %rsi # imm = 0xFFFF
ja 0x53a23
leaq 0x2493d0(%rip), %rdi # 0x29cdd0
movzwl (%rdi,%rsi,2), %edi
testw %di, %di
je 0x53a24
leaq 0x2(%rdx), %rsi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rsi
ja 0x53a23
rolw $0x8, %di
movw %di, (%rdx)
movl $0x2, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
leaq 0x2693a0(%rip), %rdi # 0x2bcdd0
movzwl (%rdi,%rsi,2), %ebx
testw %bx, %bx
je 0x53a57
leaq 0x3(%rdx), %rsi
movl $0xffffff99, %eax # imm = 0xFFFFFF99
cmpq %rcx, %rsi
ja 0x53a82
movb $-0x71, (%rdx)
movb %bh, 0x1(%rdx)
movb %bl, 0x2(%rdx)
movl $0x3, %eax
jmp 0x53a82
leaq -0xff61(%rsi), %rdi
cmpq $0x3e, %rdi
ja 0x53a82
leaq 0x2(%rdx), %rdi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rdi
ja 0x53a82
movb $-0x72, (%rdx)
addb $0x40, %sil
movb %sil, 0x1(%rdx)
movl $0x2, %eax
popq %rbx
popq %rbp
retq
|
my_wc_mb_euc_jp:
cmp esi, 7Fh
jg short loc_539EE
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short locret_53A23
mov [rdx], sil
mov eax, 1
retn
loc_539EE:
xor eax, eax
cmp rsi, 0FFFFh
ja short locret_53A23
lea rdi, unicode_to_jisx0208_eucjp
movzx edi, word ptr [rdi+rsi*2]
test di, di
jz short loc_53A24
lea rsi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rsi, rcx
ja short locret_53A23
rol di, 8
mov [rdx], di
mov eax, 2
locret_53A23:
retn
loc_53A24:
push rbp
mov rbp, rsp
push rbx
lea rdi, unicode_to_jisx0212_eucjp
movzx ebx, word ptr [rdi+rsi*2]
test bx, bx
jz short loc_53A57
lea rsi, [rdx+3]
mov eax, 0FFFFFF99h
cmp rsi, rcx
ja short loc_53A82
mov byte ptr [rdx], 8Fh
mov [rdx+1], bh
mov [rdx+2], bl
mov eax, 3
jmp short loc_53A82
loc_53A57:
lea rdi, [rsi-0FF61h]
cmp rdi, 3Eh ; '>'
ja short loc_53A82
lea rdi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rdi, rcx
ja short loc_53A82
mov byte ptr [rdx], 8Eh
add sil, 40h ; '@'
mov [rdx+1], sil
mov eax, 2
loc_53A82:
pop rbx
pop rbp
retn
|
long long my_wc_mb_euc_jp(long long a1, unsigned long long a2, unsigned long long a3, unsigned long long a4)
{
long long result; // rax
__int16 v5; // di
__int16 v6; // bx
if ( (int)a2 > 127 )
{
result = 0LL;
if ( a2 <= 0xFFFF )
{
v5 = unicode_to_jisx0208_eucjp[a2];
if ( v5 )
{
result = 4294967194LL;
if ( a3 + 2 <= a4 )
{
*(_WORD *)a3 = __ROL2__(v5, 8);
return 2LL;
}
}
else
{
v6 = unicode_to_jisx0212_eucjp[a2];
if ( v6 )
{
result = 4294967193LL;
if ( a3 + 3 <= a4 )
{
*(_BYTE *)a3 = -113;
*(_BYTE *)(a3 + 1) = HIBYTE(v6);
*(_BYTE *)(a3 + 2) = v6;
return 3LL;
}
}
else if ( a2 - 65377 <= 0x3E )
{
result = 4294967194LL;
if ( a3 + 2 <= a4 )
{
*(_BYTE *)a3 = -114;
*(_BYTE *)(a3 + 1) = a2 + 64;
return 2LL;
}
}
}
}
}
else
{
result = 4294967195LL;
if ( a3 < a4 )
{
*(_BYTE *)a3 = a2;
return 1LL;
}
}
return result;
}
|
my_wc_mb_euc_jp:
CMP ESI,0x7f
JG 0x001539ee
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x00153a23
MOV byte ptr [RDX],SIL
MOV EAX,0x1
RET
LAB_001539ee:
XOR EAX,EAX
CMP RSI,0xffff
JA 0x00153a23
LEA RDI,[0x39cdd0]
MOVZX EDI,word ptr [RDI + RSI*0x2]
TEST DI,DI
JZ 0x00153a24
LEA RSI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RSI,RCX
JA 0x00153a23
ROL DI,0x8
MOV word ptr [RDX],DI
MOV EAX,0x2
LAB_00153a23:
RET
LAB_00153a24:
PUSH RBP
MOV RBP,RSP
PUSH RBX
LEA RDI,[0x3bcdd0]
MOVZX EBX,word ptr [RDI + RSI*0x2]
TEST BX,BX
JZ 0x00153a57
LEA RSI,[RDX + 0x3]
MOV EAX,0xffffff99
CMP RSI,RCX
JA 0x00153a82
MOV byte ptr [RDX],0x8f
MOV byte ptr [RDX + 0x1],BH
MOV byte ptr [RDX + 0x2],BL
MOV EAX,0x3
JMP 0x00153a82
LAB_00153a57:
LEA RDI,[RSI + -0xff61]
CMP RDI,0x3e
JA 0x00153a82
LEA RDI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RDI,RCX
JA 0x00153a82
MOV byte ptr [RDX],0x8e
ADD SIL,0x40
MOV byte ptr [RDX + 0x1],SIL
MOV EAX,0x2
LAB_00153a82:
POP RBX
POP RBP
RET
|
int8 my_wc_mb_euc_jp(int8 param_1,ulong param_2,ushort *param_3,ushort *param_4)
{
ushort uVar1;
short sVar2;
int8 uVar3;
if ((int)param_2 < 0x80) {
uVar3 = 0xffffff9b;
if (param_3 < param_4) {
*(char *)param_3 = (char)param_2;
return 1;
}
}
else {
uVar3 = 0;
if (param_2 < 0x10000) {
uVar1 = *(ushort *)(unicode_to_jisx0208_eucjp + param_2 * 2);
if (uVar1 == 0) {
sVar2 = *(short *)(unicode_to_jisx0212_eucjp + param_2 * 2);
if (sVar2 == 0) {
if ((param_2 - 0xff61 < 0x3f) && (uVar3 = 0xffffff9a, param_3 + 1 <= param_4)) {
*(char *)param_3 = -0x72;
*(char *)((long)param_3 + 1) = (char)param_2 + '@';
uVar3 = 2;
}
}
else {
uVar3 = 0xffffff99;
if ((ushort *)((long)param_3 + 3) <= param_4) {
*(char *)param_3 = -0x71;
*(char *)((long)param_3 + 1) = (char)((ushort)sVar2 >> 8);
*(char *)(param_3 + 1) = (char)sVar2;
uVar3 = 3;
}
}
return uVar3;
}
uVar3 = 0xffffff9a;
if (param_3 + 1 <= param_4) {
*param_3 = uVar1 << 8 | uVar1 >> 8;
uVar3 = 2;
}
}
}
return uVar3;
}
|
|
18,422
|
clip_free
|
monkey531[P]llama/examples/llava/clip.cpp
|
void clip_free(clip_ctx * ctx) {
ggml_free(ctx->ctx_data);
gguf_free(ctx->ctx_gguf);
ggml_backend_buffer_free(ctx->params_buffer);
ggml_backend_free(ctx->backend);
ggml_gallocr_free(ctx->compute_alloc);
delete ctx;
}
|
O2
|
cpp
|
clip_free:
pushq %rbx
movq %rdi, %rbx
movq 0x368(%rdi), %rdi
callq 0x261b0
movq 0x360(%rbx), %rdi
callq 0x267a0
movq 0x388(%rbx), %rdi
callq 0x27590
movq 0x390(%rbx), %rdi
callq 0x26170
movq 0x398(%rbx), %rdi
callq 0x275c0
movq %rbx, %rdi
callq 0x427d2
movl $0x3a8, %esi # imm = 0x3A8
movq %rbx, %rdi
popq %rbx
jmp 0x26c70
|
clip_free:
push rbx
mov rbx, rdi
mov rdi, [rdi+368h]
call _ggml_free
mov rdi, [rbx+360h]
call _gguf_free
mov rdi, [rbx+388h]
call _ggml_backend_buffer_free
mov rdi, [rbx+390h]
call _ggml_backend_free
mov rdi, [rbx+398h]
call _ggml_gallocr_free
mov rdi, rbx; this
call _ZN8clip_ctxD2Ev; clip_ctx::~clip_ctx()
mov esi, 3A8h; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
|
void clip_free(clip_ctx *this)
{
ggml_free(*((_QWORD *)this + 109));
gguf_free(*((_QWORD *)this + 108));
ggml_backend_buffer_free(*((_QWORD *)this + 113));
ggml_backend_free(*((_QWORD *)this + 114));
ggml_gallocr_free(*((_QWORD *)this + 115));
clip_ctx::~clip_ctx(this);
operator delete(this, 0x3A8uLL);
}
|
clip_free:
PUSH RBX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x368]
CALL 0x001261b0
MOV RDI,qword ptr [RBX + 0x360]
CALL 0x001267a0
MOV RDI,qword ptr [RBX + 0x388]
CALL 0x00127590
MOV RDI,qword ptr [RBX + 0x390]
CALL 0x00126170
MOV RDI,qword ptr [RBX + 0x398]
CALL 0x001275c0
MOV RDI,RBX
CALL 0x001427d2
MOV ESI,0x3a8
MOV RDI,RBX
POP RBX
JMP 0x00126c70
|
void clip_free(clip_ctx *param_1)
{
ggml_free(*(int8 *)(param_1 + 0x368));
gguf_free(*(int8 *)(param_1 + 0x360));
ggml_backend_buffer_free(*(int8 *)(param_1 + 0x388));
ggml_backend_free(*(int8 *)(param_1 + 0x390));
ggml_gallocr_free(*(int8 *)(param_1 + 0x398));
clip_ctx::~clip_ctx(param_1);
operator_delete(param_1,0x3a8);
return;
}
|
|
18,423
|
ggml_lookup_vec(ggml_context*, ggml_tensor*, ggml_tensor*)
|
ngxson[P]ggml-easy/demo/kyutai-mimi.cpp
|
static ggml_tensor * ggml_lookup_vec(ggml_context * ctx0, ggml_tensor * codebook, ggml_tensor * x) {
ggml_tensor * tmp = ggml_add(ctx0, codebook, ggml_scale(ctx0, x, -1.0f)); // a - x
tmp = ggml_mul(ctx0, tmp, tmp); // (a - x) ** 2
tmp = ggml_sum_rows(ctx0, tmp);
tmp = ggml_sqrt(ctx0, tmp);
tmp = ggml_cont(ctx0, ggml_transpose(ctx0, tmp));
// villain version of argmin :-)
tmp = ggml_argmax(ctx0, ggml_scale(ctx0, tmp, -1.0f));
GGML_ASSERT(ggml_nelements(tmp) == 1);
return tmp;
}
|
O0
|
cpp
|
ggml_lookup_vec(ggml_context*, ggml_tensor*, ggml_tensor*):
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
movss 0x157ef(%rip), %xmm0 # 0x24048
callq 0xa0e0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0xa2d0
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0xa740
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xa840
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xa890
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xa6f0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0xa120
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
movss 0x1574b(%rip), %xmm0 # 0x24048
callq 0xa0e0
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0xa250
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0xa520
cmpq $0x1, %rax
je 0xe945
leaq 0x163ee(%rip), %rdi # 0x24d19
movl $0x7b, %esi
leaq 0x157e0(%rip), %rdx # 0x24117
leaq 0x16450(%rip), %rcx # 0x24d8e
movb $0x0, %al
callq 0xa8c0
movq 0x28(%rsp), %rax
addq $0x48, %rsp
retq
nop
|
_ZL15ggml_lookup_vecP12ggml_contextP11ggml_tensorS2_:
sub rsp, 48h
mov [rsp+48h+var_8], rdi
mov [rsp+48h+var_10], rsi
mov [rsp+48h+var_18], rdx
mov rax, [rsp+48h+var_8]
mov [rsp+48h+var_40], rax
mov rax, [rsp+48h+var_10]
mov [rsp+48h+var_38], rax
mov rdi, [rsp+48h+var_8]
mov rsi, [rsp+48h+var_18]
movss xmm0, cs:dword_24048
call _ggml_scale
mov rdi, [rsp+48h+var_40]
mov rsi, [rsp+48h+var_38]
mov rdx, rax
call _ggml_add
mov [rsp+48h+var_20], rax
mov rdi, [rsp+48h+var_8]
mov rsi, [rsp+48h+var_20]
mov rdx, [rsp+48h+var_20]
call _ggml_mul
mov [rsp+48h+var_20], rax
mov rdi, [rsp+48h+var_8]
mov rsi, [rsp+48h+var_20]
call _ggml_sum_rows
mov [rsp+48h+var_20], rax
mov rdi, [rsp+48h+var_8]
mov rsi, [rsp+48h+var_20]
call _ggml_sqrt
mov [rsp+48h+var_20], rax
mov rax, [rsp+48h+var_8]
mov [rsp+48h+var_30], rax
mov rdi, [rsp+48h+var_8]
mov rsi, [rsp+48h+var_20]
call _ggml_transpose
mov rdi, [rsp+48h+var_30]
mov rsi, rax
call _ggml_cont
mov [rsp+48h+var_20], rax
mov rax, [rsp+48h+var_8]
mov [rsp+48h+var_28], rax
mov rdi, [rsp+48h+var_8]
mov rsi, [rsp+48h+var_20]
movss xmm0, cs:dword_24048
call _ggml_scale
mov rdi, [rsp+48h+var_28]
mov rsi, rax
call _ggml_argmax
mov [rsp+48h+var_20], rax
mov rdi, [rsp+48h+var_20]
call _ggml_nelements
cmp rax, 1
jz short loc_E945
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov esi, 7Bh ; '{'
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlNelementsT; "ggml_nelements(tmp) == 1"
mov al, 0
call _ggml_abort
loc_E945:
mov rax, [rsp+48h+var_20]
add rsp, 48h
retn
|
long long ggml_lookup_vec(long long a1, long long a2, long long a3)
{
long long v3; // rax
long long v4; // rax
long long v5; // rax
long long v6; // rax
long long v7; // rax
long long v8; // rax
long long v9; // rax
long long v10; // rax
long long v12; // [rsp+28h] [rbp-20h]
v3 = ggml_scale(a1, a3, -1.0);
v4 = ggml_add(a1, a2, v3);
v5 = ggml_mul(a1, v4, v4);
v6 = ggml_sum_rows(a1, v5);
v7 = ggml_sqrt(a1, v6);
v8 = ggml_transpose(a1, v7);
v9 = ggml_cont(a1, v8);
v10 = ggml_scale(a1, v9, -1.0);
v12 = ggml_argmax(a1, v10);
if ( ggml_nelements(v12) != 1 )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/demo/kyutai-mimi.cpp",
123LL,
"GGML_ASSERT(%s) failed",
"ggml_nelements(tmp) == 1");
return v12;
}
|
ggml_lookup_vec:
SUB RSP,0x48
MOV qword ptr [RSP + 0x40],RDI
MOV qword ptr [RSP + 0x38],RSI
MOV qword ptr [RSP + 0x30],RDX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x30]
MOVSS XMM0,dword ptr [0x00124048]
CALL 0x0010a0e0
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,RAX
CALL 0x0010a2d0
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x28]
CALL 0x0010a740
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x0010a840
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x0010a890
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x18],RAX
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x0010a6f0
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,RAX
CALL 0x0010a120
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x20],RAX
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x28]
MOVSS XMM0,dword ptr [0x00124048]
CALL 0x0010a0e0
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,RAX
CALL 0x0010a250
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x0010a520
CMP RAX,0x1
JZ 0x0010e945
LEA RDI,[0x124d19]
MOV ESI,0x7b
LEA RDX,[0x124117]
LEA RCX,[0x124d8e]
MOV AL,0x0
CALL 0x0010a8c0
LAB_0010e945:
MOV RAX,qword ptr [RSP + 0x28]
ADD RSP,0x48
RET
|
/* ggml_lookup_vec(ggml_context*, ggml_tensor*, ggml_tensor*) */
int8 ggml_lookup_vec(ggml_context *param_1,ggml_tensor *param_2,ggml_tensor *param_3)
{
int8 uVar1;
long lVar2;
uVar1 = ggml_scale(DAT_00124048,param_1,param_3);
uVar1 = ggml_add(param_1,param_2,uVar1);
uVar1 = ggml_mul(param_1,uVar1,uVar1);
uVar1 = ggml_sum_rows(param_1,uVar1);
uVar1 = ggml_sqrt(param_1,uVar1);
uVar1 = ggml_transpose(param_1,uVar1);
uVar1 = ggml_cont(param_1,uVar1);
uVar1 = ggml_scale(DAT_00124048,param_1,uVar1);
uVar1 = ggml_argmax(param_1,uVar1);
lVar2 = ggml_nelements(uVar1);
if (lVar2 != 1) {
ggml_abort("/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/demo/kyutai-mimi.cpp",
0x7b,"GGML_ASSERT(%s) failed","ggml_nelements(tmp) == 1");
}
return uVar1;
}
|
|
18,424
|
fmt::v10::appender fmt::v10::detail::write_significand<char, fmt::v10::appender, char const*, fmt::v10::detail::digit_grouping<char>>(fmt::v10::appender, char const*, int, int, fmt::v10::detail::digit_grouping<char> const&)
|
AlayaLite/build_O0/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
|
FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand,
int significand_size, int exponent,
const Grouping& grouping) -> OutputIt {
if (!grouping.has_separator()) {
out = write_significand<Char>(out, significand, significand_size);
return detail::fill_n(out, exponent, static_cast<Char>('0'));
}
auto buffer = memory_buffer();
write_significand<char>(appender(buffer), significand, significand_size);
detail::fill_n(appender(buffer), exponent, '0');
return grouping.apply(out, string_view(buffer.data(), buffer.size()));
}
|
O0
|
c
|
fmt::v10::appender fmt::v10::detail::write_significand<char, fmt::v10::appender, char const*, fmt::v10::detail::digit_grouping<char>>(fmt::v10::appender, char const*, int, int, fmt::v10::detail::digit_grouping<char> const&):
subq $0x2f8, %rsp # imm = 0x2F8
movq %rdi, 0x2e8(%rsp)
movq %rsi, 0x2e0(%rsp)
movl %edx, 0x2dc(%rsp)
movl %ecx, 0x2d8(%rsp)
movq %r8, 0x2d0(%rsp)
movq 0x2d0(%rsp), %rdi
callq 0xd46f0
testb $0x1, %al
jne 0xddb77
movq 0x2e8(%rsp), %rax
movq %rax, 0x2c0(%rsp)
movq 0x2e0(%rsp), %rsi
movl 0x2dc(%rsp), %edx
movq 0x2c0(%rsp), %rdi
callq 0xddd20
movq %rax, 0x2c8(%rsp)
movq 0x2c8(%rsp), %rax
movq %rax, 0x2e8(%rsp)
movq 0x2e8(%rsp), %rax
movq %rax, 0x2b8(%rsp)
movl 0x2d8(%rsp), %esi
movb $0x30, 0x2b7(%rsp)
movq 0x2b8(%rsp), %rdi
leaq 0x2b7(%rsp), %rdx
callq 0xd36c0
movq %rax, 0x2f0(%rsp)
jmp 0xddcf7
leaq 0x97(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x15de0
movq 0x38(%rsp), %rsi
leaq 0x98(%rsp), %rdi
callq 0xc7960
jmp 0xddb9d
leaq 0x97(%rsp), %rdi
callq 0x157f0
leaq 0x78(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x23fb0
jmp 0xddbbe
movq 0x2e0(%rsp), %rsi
movl 0x2dc(%rsp), %edx
movq 0x78(%rsp), %rdi
callq 0xddd20
movq %rax, 0x30(%rsp)
jmp 0xddbde
movq 0x30(%rsp), %rax
movq %rax, 0x70(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x23fb0
jmp 0xddbfc
movl 0x2d8(%rsp), %esi
movb $0x30, 0x67(%rsp)
movq 0x68(%rsp), %rdi
leaq 0x67(%rsp), %rdx
callq 0xd36c0
movq %rax, 0x28(%rsp)
jmp 0xddc1e
movq 0x28(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x2d0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x2e8(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x98(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x243d0
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x243e0
movq 0x10(%rsp), %rsi
movq %rax, %rdx
leaq 0x40(%rsp), %rdi
callq 0x243f0
movq 0x18(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x48(%rsp), %rcx
callq 0xd4760
movq %rax, 0x20(%rsp)
jmp 0xddc95
movq 0x20(%rsp), %rax
movq %rax, 0x2f0(%rsp)
leaq 0x98(%rsp), %rdi
callq 0xc79c0
jmp 0xddcf7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x97(%rsp), %rdi
callq 0x157f0
jmp 0xddd07
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x98(%rsp), %rdi
callq 0xc79c0
jmp 0xddd07
movq 0x2f0(%rsp), %rax
addq $0x2f8, %rsp # imm = 0x2F8
retq
movq 0x88(%rsp), %rdi
callq 0x15dd0
nopw %cs:(%rax,%rax)
nop
|
_ZN3fmt3v106detail17write_significandIcNS0_8appenderEPKcNS1_14digit_groupingIcEEEET0_S8_T1_iiRKT2_:
sub rsp, 2F8h
mov [rsp+2F8h+var_10], rdi
mov [rsp+2F8h+var_18], rsi
mov [rsp+2F8h+var_1C], edx
mov [rsp+2F8h+var_20], ecx
mov [rsp+2F8h+var_28], r8
mov rdi, [rsp+2F8h+var_28]
call _ZNK3fmt3v106detail14digit_groupingIcE13has_separatorEv; fmt::v10::detail::digit_grouping<char>::has_separator(void)
test al, 1
jnz loc_DDB77
mov rax, [rsp+2F8h+var_10]
mov [rsp+2F8h+var_38], rax
mov rsi, [rsp+2F8h+var_18]
mov edx, [rsp+2F8h+var_1C]
mov rdi, [rsp+2F8h+var_38]
call _ZN3fmt3v106detail17write_significandIcNS0_8appenderEEET0_S4_PKci; fmt::v10::detail::write_significand<char,fmt::v10::appender>(fmt::v10::appender,char const*,int)
mov [rsp+2F8h+var_30], rax
mov rax, [rsp+2F8h+var_30]
mov [rsp+2F8h+var_10], rax
mov rax, [rsp+2F8h+var_10]
mov [rsp+2F8h+var_40], rax
mov esi, [rsp+2F8h+var_20]
mov [rsp+2F8h+var_41], 30h ; '0'
mov rdi, [rsp+2F8h+var_40]
lea rdx, [rsp+2F8h+var_41]
call _ZN3fmt3v106detail6fill_nINS0_8appenderEicEET_S4_T0_RKT1_; fmt::v10::detail::fill_n<fmt::v10::appender,int,char>(fmt::v10::appender,int,char const&)
mov [rsp+2F8h+var_8], rax
jmp loc_DDCF7
loc_DDB77:
lea rdi, [rsp+2F8h+var_261]
mov [rsp+2F8h+var_2C0], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rsi, [rsp+2F8h+var_2C0]
lea rdi, [rsp+2F8h+var_260]
call _ZN3fmt3v1019basic_memory_bufferIcLm500ESaIcEEC2ERKS2_; fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>::basic_memory_buffer(std::allocator<char> const&)
jmp short $+2
loc_DDB9D:
lea rdi, [rsp+2F8h+var_261]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
lea rdi, [rsp+2F8h+var_280]
lea rsi, [rsp+2F8h+var_260]
call _ZN3fmt3v108appenderCI2St20back_insert_iteratorINS0_6detail6bufferIcEEEERS5_
jmp short $+2
loc_DDBBE:
mov rsi, [rsp+2F8h+var_18]
mov edx, [rsp+2F8h+var_1C]
mov rdi, [rsp+2F8h+var_280]
call _ZN3fmt3v106detail17write_significandIcNS0_8appenderEEET0_S4_PKci; fmt::v10::detail::write_significand<char,fmt::v10::appender>(fmt::v10::appender,char const*,int)
mov [rsp+2F8h+var_2C8], rax
jmp short $+2
loc_DDBDE:
mov rax, [rsp+2F8h+var_2C8]
mov [rsp+2F8h+var_288], rax
lea rdi, [rsp+2F8h+var_290]
lea rsi, [rsp+2F8h+var_260]
call _ZN3fmt3v108appenderCI2St20back_insert_iteratorINS0_6detail6bufferIcEEEERS5_
jmp short $+2
loc_DDBFC:
mov esi, [rsp+2F8h+var_20]
mov [rsp+2F8h+var_291], 30h ; '0'
mov rdi, [rsp+2F8h+var_290]
lea rdx, [rsp+2F8h+var_291]
call _ZN3fmt3v106detail6fill_nINS0_8appenderEicEET_S4_T0_RKT1_; fmt::v10::detail::fill_n<fmt::v10::appender,int,char>(fmt::v10::appender,int,char const&)
mov [rsp+2F8h+var_2D0], rax
jmp short $+2
loc_DDC1E:
mov rax, [rsp+2F8h+var_2D0]
mov [rsp+2F8h+var_2A0], rax
mov rax, [rsp+2F8h+var_28]
mov [rsp+2F8h+var_2E0], rax
mov rax, [rsp+2F8h+var_10]
mov [rsp+2F8h+var_2A8], rax
lea rdi, [rsp+2F8h+var_260]
mov [rsp+2F8h+var_2F0], rdi
call _ZN3fmt3v106detail6bufferIcE4dataEv; fmt::v10::detail::buffer<char>::data(void)
mov rdi, [rsp+2F8h+var_2F0]
mov [rsp+2F8h+var_2E8], rax
call _ZNK3fmt3v106detail6bufferIcE4sizeEv; fmt::v10::detail::buffer<char>::size(void)
mov rsi, [rsp+2F8h+var_2E8]
mov rdx, rax
lea rdi, [rsp+2F8h+var_2B8]
call _ZN3fmt3v1017basic_string_viewIcEC2EPKcm; fmt::v10::basic_string_view<char>::basic_string_view(char const*,ulong)
mov rdi, [rsp+2F8h+var_2E0]
mov rsi, [rsp+2F8h+var_2A8]
mov rdx, [rsp+2F8h+var_2B8]
mov rcx, [rsp+2F8h+var_2B0]
call _ZNK3fmt3v106detail14digit_groupingIcE5applyINS0_8appenderEcEET_S6_NS0_17basic_string_viewIT0_EE; fmt::v10::detail::digit_grouping<char>::apply<fmt::v10::appender,char>(fmt::v10::appender,fmt::v10::basic_string_view<char>)
mov [rsp+2F8h+var_2D8], rax
jmp short $+2
loc_DDC95:
mov rax, [rsp+2F8h+var_2D8]
mov [rsp+2F8h+var_8], rax
lea rdi, [rsp+2F8h+var_260]
call _ZN3fmt3v1019basic_memory_bufferIcLm500ESaIcEED2Ev; fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>::~basic_memory_buffer()
jmp short loc_DDCF7
mov rcx, rax
mov eax, edx
mov [rsp+arg_80], rcx
mov [rsp+arg_7C], eax
lea rdi, [rsp+arg_8F]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_DDD07
mov rcx, rax
mov eax, edx
mov [rsp+arg_80], rcx
mov [rsp+arg_7C], eax
lea rdi, [rsp+arg_90]
call _ZN3fmt3v1019basic_memory_bufferIcLm500ESaIcEED2Ev; fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>::~basic_memory_buffer()
jmp short loc_DDD07
loc_DDCF7:
mov rax, [rsp+2F8h+var_8]
add rsp, 2F8h
retn
loc_DDD07:
mov rdi, [rsp+arg_80]
call __Unwind_Resume
|
long long fmt::v10::detail::write_significand<char,fmt::v10::appender,char const*,fmt::v10::detail::digit_grouping<char>>(
long long a1,
long long a2,
unsigned int a3,
int a4,
long long a5)
{
long long v5; // rdx
long long v6; // rax
const char *v7; // rsi
long long v9; // [rsp+10h] [rbp-2E8h]
long long v10; // [rsp+18h] [rbp-2E0h]
long long v11[2]; // [rsp+40h] [rbp-2B8h] BYREF
const char *v12; // [rsp+50h] [rbp-2A8h]
long long v13; // [rsp+58h] [rbp-2A0h]
char v14; // [rsp+67h] [rbp-291h] BYREF
long long v15[2]; // [rsp+68h] [rbp-290h] BYREF
_QWORD v16[3]; // [rsp+78h] [rbp-280h] BYREF
char v17; // [rsp+97h] [rbp-261h] BYREF
_QWORD v18[67]; // [rsp+98h] [rbp-260h] BYREF
char v19; // [rsp+2B7h] [rbp-41h] BYREF
long long v20; // [rsp+2B8h] [rbp-40h]
long long v21; // [rsp+2C0h] [rbp-38h]
long long v22; // [rsp+2C8h] [rbp-30h]
long long v23; // [rsp+2D0h] [rbp-28h]
int v24; // [rsp+2D8h] [rbp-20h]
unsigned int v25; // [rsp+2DCh] [rbp-1Ch]
long long v26; // [rsp+2E0h] [rbp-18h]
long long v27; // [rsp+2E8h] [rbp-10h]
long long v28; // [rsp+2F0h] [rbp-8h]
v27 = a1;
v26 = a2;
v25 = a3;
v24 = a4;
v23 = a5;
if ( fmt::v10::detail::digit_grouping<char>::has_separator(a5) )
{
std::allocator<char>::allocator(&v17, a2, v5);
fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>::basic_memory_buffer(v18, (long long)&v17);
std::allocator<char>::~allocator(&v17, &v17);
ZN3fmt3v108appenderCI2St20back_insert_iteratorINS0_6detail6bufferIcEEEERS5_((long long)v16, (long long)v18);
v15[1] = fmt::v10::detail::write_significand<char,fmt::v10::appender>(v16[0], v26, v25);
ZN3fmt3v108appenderCI2St20back_insert_iteratorINS0_6detail6bufferIcEEEERS5_((long long)v15, (long long)v18);
v14 = 48;
v13 = fmt::v10::detail::fill_n<fmt::v10::appender,int,char>(v15[0], v24, &v14);
v10 = v23;
v12 = (const char *)v27;
v9 = fmt::v10::detail::buffer<char>::data((long long)v18);
v6 = fmt::v10::detail::buffer<char>::size((long long)v18);
fmt::v10::basic_string_view<char>::basic_string_view(v11, v9, v6);
v7 = v12;
v28 = fmt::v10::detail::digit_grouping<char>::apply<fmt::v10::appender,char>(v10, (long long)v12, v11[0], v11[1]);
fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>::~basic_memory_buffer((long long)v18, v7);
}
else
{
v21 = v27;
v22 = fmt::v10::detail::write_significand<char,fmt::v10::appender>(v27, v26, v25);
v27 = v22;
v20 = v22;
v19 = 48;
return fmt::v10::detail::fill_n<fmt::v10::appender,int,char>(v22, v24, &v19);
}
return v28;
}
|
write_significand<char,fmt::v10::appender,char_const*,fmt::v10::detail::digit_grouping<char>>:
SUB RSP,0x2f8
MOV qword ptr [RSP + 0x2e8],RDI
MOV qword ptr [RSP + 0x2e0],RSI
MOV dword ptr [RSP + 0x2dc],EDX
MOV dword ptr [RSP + 0x2d8],ECX
MOV qword ptr [RSP + 0x2d0],R8
MOV RDI,qword ptr [RSP + 0x2d0]
CALL 0x001d46f0
TEST AL,0x1
JNZ 0x001ddb77
MOV RAX,qword ptr [RSP + 0x2e8]
MOV qword ptr [RSP + 0x2c0],RAX
MOV RSI,qword ptr [RSP + 0x2e0]
MOV EDX,dword ptr [RSP + 0x2dc]
MOV RDI,qword ptr [RSP + 0x2c0]
CALL 0x001ddd20
MOV qword ptr [RSP + 0x2c8],RAX
MOV RAX,qword ptr [RSP + 0x2c8]
MOV qword ptr [RSP + 0x2e8],RAX
MOV RAX,qword ptr [RSP + 0x2e8]
MOV qword ptr [RSP + 0x2b8],RAX
MOV ESI,dword ptr [RSP + 0x2d8]
MOV byte ptr [RSP + 0x2b7],0x30
MOV RDI,qword ptr [RSP + 0x2b8]
LEA RDX,[RSP + 0x2b7]
CALL 0x001d36c0
MOV qword ptr [RSP + 0x2f0],RAX
JMP 0x001ddcf7
LAB_001ddb77:
LEA RDI,[RSP + 0x97]
MOV qword ptr [RSP + 0x38],RDI
CALL 0x00115de0
MOV RSI,qword ptr [RSP + 0x38]
LAB_001ddb8e:
LEA RDI,[RSP + 0x98]
CALL 0x001c7960
JMP 0x001ddb9d
LAB_001ddb9d:
LEA RDI,[RSP + 0x97]
CALL 0x001157f0
LAB_001ddbaa:
LEA RDI,[RSP + 0x78]
LEA RSI,[RSP + 0x98]
CALL 0x00123fb0
JMP 0x001ddbbe
LAB_001ddbbe:
MOV RSI,qword ptr [RSP + 0x2e0]
MOV EDX,dword ptr [RSP + 0x2dc]
MOV RDI,qword ptr [RSP + 0x78]
CALL 0x001ddd20
MOV qword ptr [RSP + 0x30],RAX
JMP 0x001ddbde
LAB_001ddbde:
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x70],RAX
LEA RDI,[RSP + 0x68]
LEA RSI,[RSP + 0x98]
CALL 0x00123fb0
JMP 0x001ddbfc
LAB_001ddbfc:
MOV ESI,dword ptr [RSP + 0x2d8]
MOV byte ptr [RSP + 0x67],0x30
MOV RDI,qword ptr [RSP + 0x68]
LEA RDX,[RSP + 0x67]
CALL 0x001d36c0
MOV qword ptr [RSP + 0x28],RAX
JMP 0x001ddc1e
LAB_001ddc1e:
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,qword ptr [RSP + 0x2d0]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RSP + 0x2e8]
MOV qword ptr [RSP + 0x50],RAX
LEA RDI,[RSP + 0x98]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x001243d0
MOV RDI,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x001243e0
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,RAX
LEA RDI,[RSP + 0x40]
CALL 0x001243f0
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x50]
MOV RDX,qword ptr [RSP + 0x40]
MOV RCX,qword ptr [RSP + 0x48]
CALL 0x001d4760
LAB_001ddc8e:
MOV qword ptr [RSP + 0x20],RAX
JMP 0x001ddc95
LAB_001ddc95:
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x2f0],RAX
LEA RDI,[RSP + 0x98]
CALL 0x001c79c0
JMP 0x001ddcf7
LAB_001ddcf7:
MOV RAX,qword ptr [RSP + 0x2f0]
ADD RSP,0x2f8
RET
|
/* fmt::v10::appender fmt::v10::detail::write_significand<char, fmt::v10::appender, char const*,
fmt::v10::detail::digit_grouping<char> >(fmt::v10::appender, char const*, int, int,
fmt::v10::detail::digit_grouping<char> const&) */
int8
fmt::v10::detail::
write_significand<char,fmt::v10::appender,char_const*,fmt::v10::detail::digit_grouping<char>>
(int8 param_1,int8 param_2,int4 param_3,int4 param_4,
digit_grouping<char> *param_5)
{
digit_grouping<char> *pdVar1;
ulong uVar2;
char *pcVar3;
int8 local_2b8;
int8 local_2b0;
int8 local_2a8;
int8 local_2a0;
int1 local_291;
int8 local_290;
int8 local_288;
int8 local_280 [3];
allocator<char> local_261;
allocator local_260 [543];
int1 local_41;
int8 local_40;
int8 local_38;
int8 local_30;
digit_grouping<char> *local_28;
int4 local_20;
int4 local_1c;
int8 local_18;
int8 local_10;
int8 local_8;
local_28 = param_5;
local_20 = param_4;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
uVar2 = digit_grouping<char>::has_separator(param_5);
if ((uVar2 & 1) == 0) {
local_38 = local_10;
local_40 = write_significand<char,fmt::v10::appender>(local_10,local_18,local_1c);
local_41 = 0x30;
local_30 = local_40;
local_10 = local_40;
local_8 = fill_n<fmt::v10::appender,int,char>(local_40,local_20,&local_41);
}
else {
std::allocator<char>::allocator();
/* try { // try from 001ddb8e to 001ddb9a has its CatchHandler @ 001ddcb1 */
basic_memory_buffer<char,500ul,std::allocator<char>>::basic_memory_buffer(local_260);
std::allocator<char>::~allocator(&local_261);
/* try { // try from 001ddbaa to 001ddc8d has its CatchHandler @ 001ddcd4 */
appender::back_insert_iterator((appender *)local_280,(buffer *)local_260);
local_288 = write_significand<char,fmt::v10::appender>(local_280[0],local_18,local_1c);
appender::back_insert_iterator((appender *)&local_290,(buffer *)local_260);
local_291 = 0x30;
local_2a0 = fill_n<fmt::v10::appender,int,char>(local_290,local_20,&local_291);
pdVar1 = local_28;
local_2a8 = local_10;
pcVar3 = (char *)buffer<char>::data((buffer<char> *)local_260);
uVar2 = buffer<char>::size((buffer<char> *)local_260);
basic_string_view<char>::basic_string_view((basic_string_view<char> *)&local_2b8,pcVar3,uVar2);
local_8 = digit_grouping<char>::apply<fmt::v10::appender,char>
(pdVar1,local_2a8,local_2b8,local_2b0);
basic_memory_buffer<char,500ul,std::allocator<char>>::~basic_memory_buffer
((basic_memory_buffer<char,500ul,std::allocator<char>> *)local_260);
}
return local_8;
}
|
|
18,425
|
my_snprintf_mb2
|
eloqsql/strings/ctype-ucs2.c
|
static size_t
my_snprintf_mb2(CHARSET_INFO *cs __attribute__((unused)),
char* to, size_t n, const char* fmt, ...)
{
size_t ret;
va_list args;
va_start(args,fmt);
ret= my_vsnprintf_mb2(to, n, fmt, args);
va_end(args);
return ret;
}
|
O3
|
c
|
my_snprintf_mb2:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rcx, %r15
movq %rsi, %r14
leaq -0x120(%rbp), %rcx
movq %r8, 0x20(%rcx)
movq %r9, 0x28(%rcx)
testb %al, %al
je 0x7b7dc
movaps %xmm0, -0xf0(%rbp)
movaps %xmm1, -0xe0(%rbp)
movaps %xmm2, -0xd0(%rbp)
movaps %xmm3, -0xc0(%rbp)
movaps %xmm4, -0xb0(%rbp)
movaps %xmm5, -0xa0(%rbp)
movaps %xmm6, -0x90(%rbp)
movaps %xmm7, -0x80(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq %rcx, -0x50(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movabsq $0x3000000020, %rax # imm = 0x3000000020
movq %rax, -0x60(%rbp)
leaq (%rsi,%rdx), %rbx
decq %rbx
leaq -0x40(%rbp), %r12
movq %rsi, -0x68(%rbp)
movzbl (%r15), %eax
cmpl $0x25, %eax
je 0x7b840
testl %eax, %eax
je 0x7b9a6
cmpq %rbx, %r14
je 0x7b9a3
movb $0x0, (%r14)
movb (%r15), %al
movb %al, 0x1(%r14)
addq $0x2, %r14
incq %r15
jmp 0x7b812
addq $0x2, %r15
movb -0x1(%r15), %al
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
jb 0x7b85b
movzbl %al, %ecx
leal -0x2d(%rcx), %edx
cmpl $0x2, %edx
jae 0x7b860
incq %r15
jmp 0x7b844
cmpl $0x6c, %ecx
jne 0x7b86a
movb (%r15), %al
jmp 0x7b86d
decq %r15
cmpb $0x64, %al
je 0x7b89d
movzbl %al, %eax
cmpl $0x75, %eax
je 0x7b89d
cmpl $0x73, %eax
jne 0x7b8c5
movl -0x60(%rbp), %ecx
cmpq $0x28, %rcx
ja 0x7b932
movq %rcx, %rax
addq -0x50(%rbp), %rax
addl $0x8, %ecx
movl %ecx, -0x60(%rbp)
jmp 0x7b93e
movq %rbx, %rax
subq %r14, %rax
cmpq $0x1f, %rax
jbe 0x7b9a6
movl -0x60(%rbp), %ecx
cmpq $0x28, %rcx
ja 0x7b8d9
movq %rcx, %rax
addq -0x50(%rbp), %rax
addl $0x8, %ecx
movl %ecx, -0x60(%rbp)
jmp 0x7b8e5
cmpq %rbx, %r14
je 0x7b9a3
movw $0x2500, (%r14) # imm = 0x2500
jmp 0x7b837
movq -0x58(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x58(%rbp)
movslq (%rax), %rdi
cmpb $0x64, (%r15)
jne 0x7b8f8
movq %r12, %rsi
movl $0xfffffff6, %edx # imm = 0xFFFFFFF6
jmp 0x7b902
movl %edi, %edi
movq %r12, %rsi
movl $0xa, %edx
callq 0x8de9e
cmpb $0x0, -0x40(%rbp)
je 0x7b83b
leaq -0x3f(%rbp), %rax
movb $0x0, (%r14)
movb -0x1(%rax), %cl
movb %cl, 0x1(%r14)
addq $0x2, %r14
cmpb $0x0, (%rax)
leaq 0x1(%rax), %rax
jne 0x7b915
jmp 0x7b83b
movq -0x58(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x58(%rbp)
movq (%rax), %r13
movq %rbx, %r12
subq %r14, %r12
testq %r13, %r13
leaq 0x19c67(%rip), %rax # 0x955b8
cmoveq %rax, %r13
movq %r13, %rdi
callq 0x28130
leaq (%rax,%rax), %rdx
movq %r12, %rcx
shrq %rcx
decq %rcx
cmpq %rdx, %r12
cmovaq %rax, %rcx
testq %rcx, %rcx
je 0x7b99a
xorl %eax, %eax
leaq -0x40(%rbp), %r12
movb $0x0, (%r14)
movb (%r13,%rax), %dl
movb %dl, 0x1(%r14)
addq $0x2, %r14
incq %rax
cmpq %rax, %rcx
jne 0x7b97c
jmp 0x7b83b
leaq -0x40(%rbp), %r12
jmp 0x7b83b
movq %rbx, %r14
movb $0x0, (%r14)
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x7b9d2
subq -0x68(%rbp), %r14
movq %r14, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x283d0
|
my_snprintf_mb2:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0F8h
mov r15, rcx
mov r14, rsi
lea rcx, [rbp+var_120]
mov [rcx+20h], r8
mov [rcx+28h], r9
test al, al
jz short loc_7B7DC
movaps [rbp+var_F0], xmm0
movaps [rbp+var_E0], xmm1
movaps [rbp+var_D0], xmm2
movaps [rbp+var_C0], xmm3
movaps [rbp+var_B0], xmm4
movaps [rbp+var_A0], xmm5
movaps [rbp+var_90], xmm6
movaps [rbp+var_80], xmm7
loc_7B7DC:
mov rax, fs:28h
mov [rbp+var_30], rax
mov [rbp+var_50], rcx
lea rax, [rbp+arg_0]
mov [rbp+var_58], rax
mov rax, 3000000020h
mov [rbp+var_60], rax
lea rbx, [rsi+rdx]
dec rbx
lea r12, [rbp+var_40]
mov [rbp+var_68], rsi
loc_7B812:
movzx eax, byte ptr [r15]
cmp eax, 25h ; '%'
jz short loc_7B840
test eax, eax
jz loc_7B9A6
cmp r14, rbx
jz loc_7B9A3
mov byte ptr [r14], 0
mov al, [r15]
mov [r14+1], al
loc_7B837:
add r14, 2
loc_7B83B:
inc r15
jmp short loc_7B812
loc_7B840:
add r15, 2
loc_7B844:
mov al, [r15-1]
lea ecx, [rax-30h]
cmp cl, 0Ah
jb short loc_7B85B
movzx ecx, al
lea edx, [rcx-2Dh]
cmp edx, 2
jnb short loc_7B860
loc_7B85B:
inc r15
jmp short loc_7B844
loc_7B860:
cmp ecx, 6Ch ; 'l'
jnz short loc_7B86A
mov al, [r15]
jmp short loc_7B86D
loc_7B86A:
dec r15
loc_7B86D:
cmp al, 64h ; 'd'
jz short loc_7B89D
movzx eax, al
cmp eax, 75h ; 'u'
jz short loc_7B89D
cmp eax, 73h ; 's'
jnz short loc_7B8C5
mov ecx, dword ptr [rbp+var_60]
cmp rcx, 28h ; '('
ja loc_7B932
mov rax, rcx
add rax, [rbp+var_50]
add ecx, 8
mov dword ptr [rbp+var_60], ecx
jmp loc_7B93E
loc_7B89D:
mov rax, rbx
sub rax, r14
cmp rax, 1Fh
jbe loc_7B9A6
mov ecx, dword ptr [rbp+var_60]
cmp rcx, 28h ; '('
ja short loc_7B8D9
mov rax, rcx
add rax, [rbp+var_50]
add ecx, 8
mov dword ptr [rbp+var_60], ecx
jmp short loc_7B8E5
loc_7B8C5:
cmp r14, rbx
jz loc_7B9A3
mov word ptr [r14], 2500h
jmp loc_7B837
loc_7B8D9:
mov rax, [rbp+var_58]
lea rcx, [rax+8]
mov [rbp+var_58], rcx
loc_7B8E5:
movsxd rdi, dword ptr [rax]
cmp byte ptr [r15], 64h ; 'd'
jnz short loc_7B8F8
mov rsi, r12
mov edx, 0FFFFFFF6h
jmp short loc_7B902
loc_7B8F8:
mov edi, edi
mov rsi, r12
mov edx, 0Ah
loc_7B902:
call int10_to_str
cmp [rbp+var_40], 0
jz loc_7B83B
lea rax, [rbp+var_3F]
loc_7B915:
mov byte ptr [r14], 0
mov cl, [rax-1]
mov [r14+1], cl
add r14, 2
cmp byte ptr [rax], 0
lea rax, [rax+1]
jnz short loc_7B915
jmp loc_7B83B
loc_7B932:
mov rax, [rbp+var_58]
lea rcx, [rax+8]
mov [rbp+var_58], rcx
loc_7B93E:
mov r13, [rax]
mov r12, rbx
sub r12, r14
test r13, r13
lea rax, aNull; "(null)"
cmovz r13, rax
mov rdi, r13
call _strlen
lea rdx, [rax+rax]
mov rcx, r12
shr rcx, 1
dec rcx
cmp r12, rdx
cmova rcx, rax
test rcx, rcx
jz short loc_7B99A
xor eax, eax
lea r12, [rbp+var_40]
loc_7B97C:
mov byte ptr [r14], 0
mov dl, [r13+rax+0]
mov [r14+1], dl
add r14, 2
inc rax
cmp rcx, rax
jnz short loc_7B97C
jmp loc_7B83B
loc_7B99A:
lea r12, [rbp+var_40]
jmp loc_7B83B
loc_7B9A3:
mov r14, rbx
loc_7B9A6:
mov byte ptr [r14], 0
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_7B9D2
sub r14, [rbp+var_68]
mov rax, r14
add rsp, 0F8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7B9D2:
call ___stack_chk_fail
|
_BYTE * my_snprintf_mb2(
__m128 a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
long long a9,
_BYTE *a10,
long long a11,
unsigned __int8 *a12,
long long a13,
long long a14,
char a15)
{
_BYTE *v16; // r14
long long v17; // rbx
unsigned __int8 v18; // al
const char **v19; // rax
char *v20; // rax
long long v21; // rdi
long long v22; // rdx
char *v23; // rax
const char *v25; // r13
unsigned long long v26; // r12
long long v27; // rax
long long v28; // rcx
long long i; // rax
char v31; // [rsp+0h] [rbp-120h] BYREF
long long v32; // [rsp+20h] [rbp-100h]
long long v33; // [rsp+28h] [rbp-F8h]
__m128 v34; // [rsp+30h] [rbp-F0h]
__m128 v35; // [rsp+40h] [rbp-E0h]
__m128 v36; // [rsp+50h] [rbp-D0h]
__m128 v37; // [rsp+60h] [rbp-C0h]
__m128 v38; // [rsp+70h] [rbp-B0h]
__m128 v39; // [rsp+80h] [rbp-A0h]
__m128 v40; // [rsp+90h] [rbp-90h]
__m128 v41; // [rsp+A0h] [rbp-80h]
_BYTE *v42; // [rsp+B8h] [rbp-68h]
long long v43; // [rsp+C0h] [rbp-60h]
char *v44; // [rsp+C8h] [rbp-58h]
char *v45; // [rsp+D0h] [rbp-50h]
char v46; // [rsp+E0h] [rbp-40h] BYREF
char v47; // [rsp+E1h] [rbp-3Fh] BYREF
unsigned long long v48; // [rsp+F0h] [rbp-30h]
v34 = a1;
v35 = a2;
v36 = a3;
v37 = a4;
v38 = a5;
v39 = a6;
v40 = a7;
v41 = a8;
v16 = a10;
v32 = a13;
v33 = a14;
v48 = __readfsqword(0x28u);
v45 = &v31;
v44 = &a15;
v43 = 0x3000000020LL;
v17 = (long long)&a10[a11 - 1];
v42 = a10;
while ( *a12 == 37 )
{
for ( a12 += 2; ; ++a12 )
{
v18 = *(a12 - 1);
if ( (unsigned __int8)(v18 - 48) >= 0xAu && (unsigned int)v18 - 45 >= 2 )
break;
}
if ( v18 == 108 )
v18 = *a12;
else
--a12;
if ( v18 == 100 || v18 == 117 )
{
if ( (unsigned long long)(v17 - (_QWORD)v16) <= 0x1F )
goto LABEL_44;
if ( (unsigned int)v43 > 0x28uLL )
{
v20 = v44;
v44 += 8;
}
else
{
v20 = &v45[(unsigned int)v43];
LODWORD(v43) = v43 + 8;
}
v21 = *(int *)v20;
if ( *a12 == 100 )
{
v22 = 4294967286LL;
}
else
{
v21 = (unsigned int)v21;
v22 = 10LL;
}
int10_to_str(v21, &v46, v22);
if ( v46 )
{
v23 = &v47;
do
{
*v16 = 0;
v16[1] = *(v23 - 1);
v16 += 2;
}
while ( *v23++ != 0 );
}
}
else
{
if ( v18 != 115 )
{
if ( v16 == (_BYTE *)v17 )
goto LABEL_43;
*(_WORD *)v16 = 9472;
goto LABEL_6;
}
if ( (unsigned int)v43 > 0x28uLL )
{
v19 = (const char **)v44;
v44 += 8;
}
else
{
v19 = (const char **)&v45[(unsigned int)v43];
LODWORD(v43) = v43 + 8;
}
v25 = *v19;
v26 = v17 - (_QWORD)v16;
if ( !*v19 )
v25 = "(null)";
v27 = strlen(v25);
v28 = (v26 >> 1) - 1;
if ( v26 > 2 * v27 )
v28 = v27;
if ( v28 )
{
for ( i = 0LL; i != v28; ++i )
{
*v16 = 0;
v16[1] = v25[i];
v16 += 2;
}
}
}
LABEL_7:
++a12;
}
if ( !*a12 )
goto LABEL_44;
if ( v16 != (_BYTE *)v17 )
{
*v16 = 0;
v16[1] = *a12;
LABEL_6:
v16 += 2;
goto LABEL_7;
}
LABEL_43:
v16 = (_BYTE *)v17;
LABEL_44:
*v16 = 0;
return (_BYTE *)(v16 - v42);
}
|
my_snprintf_mb2:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xf8
MOV R15,RCX
MOV R14,RSI
LEA RCX,[RBP + -0x120]
MOV qword ptr [RCX + 0x20],R8
MOV qword ptr [RCX + 0x28],R9
TEST AL,AL
JZ 0x0017b7dc
MOVAPS xmmword ptr [RBP + -0xf0],XMM0
MOVAPS xmmword ptr [RBP + -0xe0],XMM1
MOVAPS xmmword ptr [RBP + -0xd0],XMM2
MOVAPS xmmword ptr [RBP + -0xc0],XMM3
MOVAPS xmmword ptr [RBP + -0xb0],XMM4
MOVAPS xmmword ptr [RBP + -0xa0],XMM5
MOVAPS xmmword ptr [RBP + -0x90],XMM6
MOVAPS xmmword ptr [RBP + -0x80],XMM7
LAB_0017b7dc:
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV qword ptr [RBP + -0x50],RCX
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,0x3000000020
MOV qword ptr [RBP + -0x60],RAX
LEA RBX,[RSI + RDX*0x1]
DEC RBX
LEA R12,[RBP + -0x40]
MOV qword ptr [RBP + -0x68],RSI
LAB_0017b812:
MOVZX EAX,byte ptr [R15]
CMP EAX,0x25
JZ 0x0017b840
TEST EAX,EAX
JZ 0x0017b9a6
CMP R14,RBX
JZ 0x0017b9a3
MOV byte ptr [R14],0x0
MOV AL,byte ptr [R15]
MOV byte ptr [R14 + 0x1],AL
LAB_0017b837:
ADD R14,0x2
LAB_0017b83b:
INC R15
JMP 0x0017b812
LAB_0017b840:
ADD R15,0x2
LAB_0017b844:
MOV AL,byte ptr [R15 + -0x1]
LEA ECX,[RAX + -0x30]
CMP CL,0xa
JC 0x0017b85b
MOVZX ECX,AL
LEA EDX,[RCX + -0x2d]
CMP EDX,0x2
JNC 0x0017b860
LAB_0017b85b:
INC R15
JMP 0x0017b844
LAB_0017b860:
CMP ECX,0x6c
JNZ 0x0017b86a
MOV AL,byte ptr [R15]
JMP 0x0017b86d
LAB_0017b86a:
DEC R15
LAB_0017b86d:
CMP AL,0x64
JZ 0x0017b89d
MOVZX EAX,AL
CMP EAX,0x75
JZ 0x0017b89d
CMP EAX,0x73
JNZ 0x0017b8c5
MOV ECX,dword ptr [RBP + -0x60]
CMP RCX,0x28
JA 0x0017b932
MOV RAX,RCX
ADD RAX,qword ptr [RBP + -0x50]
ADD ECX,0x8
MOV dword ptr [RBP + -0x60],ECX
JMP 0x0017b93e
LAB_0017b89d:
MOV RAX,RBX
SUB RAX,R14
CMP RAX,0x1f
JBE 0x0017b9a6
MOV ECX,dword ptr [RBP + -0x60]
CMP RCX,0x28
JA 0x0017b8d9
MOV RAX,RCX
ADD RAX,qword ptr [RBP + -0x50]
ADD ECX,0x8
MOV dword ptr [RBP + -0x60],ECX
JMP 0x0017b8e5
LAB_0017b8c5:
CMP R14,RBX
JZ 0x0017b9a3
MOV word ptr [R14],0x2500
JMP 0x0017b837
LAB_0017b8d9:
MOV RAX,qword ptr [RBP + -0x58]
LEA RCX,[RAX + 0x8]
MOV qword ptr [RBP + -0x58],RCX
LAB_0017b8e5:
MOVSXD RDI,dword ptr [RAX]
CMP byte ptr [R15],0x64
JNZ 0x0017b8f8
MOV RSI,R12
MOV EDX,0xfffffff6
JMP 0x0017b902
LAB_0017b8f8:
MOV EDI,EDI
MOV RSI,R12
MOV EDX,0xa
LAB_0017b902:
CALL 0x0018de9e
CMP byte ptr [RBP + -0x40],0x0
JZ 0x0017b83b
LEA RAX,[RBP + -0x3f]
LAB_0017b915:
MOV byte ptr [R14],0x0
MOV CL,byte ptr [RAX + -0x1]
MOV byte ptr [R14 + 0x1],CL
ADD R14,0x2
CMP byte ptr [RAX],0x0
LEA RAX,[RAX + 0x1]
JNZ 0x0017b915
JMP 0x0017b83b
LAB_0017b932:
MOV RAX,qword ptr [RBP + -0x58]
LEA RCX,[RAX + 0x8]
MOV qword ptr [RBP + -0x58],RCX
LAB_0017b93e:
MOV R13,qword ptr [RAX]
MOV R12,RBX
SUB R12,R14
TEST R13,R13
LEA RAX,[0x1955b8]
CMOVZ R13,RAX
MOV RDI,R13
CALL 0x00128130
LEA RDX,[RAX + RAX*0x1]
MOV RCX,R12
SHR RCX,0x1
DEC RCX
CMP R12,RDX
CMOVA RCX,RAX
TEST RCX,RCX
JZ 0x0017b99a
XOR EAX,EAX
LEA R12,[RBP + -0x40]
LAB_0017b97c:
MOV byte ptr [R14],0x0
MOV DL,byte ptr [R13 + RAX*0x1]
MOV byte ptr [R14 + 0x1],DL
ADD R14,0x2
INC RAX
CMP RCX,RAX
JNZ 0x0017b97c
JMP 0x0017b83b
LAB_0017b99a:
LEA R12,[RBP + -0x40]
JMP 0x0017b83b
LAB_0017b9a3:
MOV R14,RBX
LAB_0017b9a6:
MOV byte ptr [R14],0x0
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0017b9d2
SUB R14,qword ptr [RBP + -0x68]
MOV RAX,R14
ADD RSP,0xf8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017b9d2:
CALL 0x001283d0
|
long my_snprintf_mb2(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int8 param_9,int2 *param_10,long param_11,byte *param_12,
int8 param_13,int8 param_14)
{
char in_AL;
byte bVar1;
uint *puVar2;
size_t sVar3;
size_t sVar4;
int8 uVar5;
int2 *puVar6;
ulong uVar7;
char *pcVar8;
int2 *puVar9;
long in_FS_OFFSET;
int1 local_128 [32];
int8 local_108;
int8 local_100;
int8 local_f8;
int8 local_e8;
int8 local_d8;
int8 local_c8;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int2 *local_70;
ulong local_68;
uint *local_60;
int1 *local_58;
char local_48 [16];
long local_38;
local_58 = local_128;
if (in_AL != '\0') {
local_f8 = param_1;
local_e8 = param_2;
local_d8 = param_3;
local_c8 = param_4;
local_b8 = param_5;
local_a8 = param_6;
local_98 = param_7;
local_88 = param_8;
}
local_38 = *(long *)(in_FS_OFFSET + 0x28);
local_60 = (uint *)&stack0x00000008;
local_68 = 0x3000000020;
puVar6 = (int2 *)((long)param_10 + param_11 + -1);
local_108 = param_13;
local_100 = param_14;
local_70 = param_10;
do {
puVar9 = param_10;
if (*param_12 == 0x25) {
param_12 = param_12 + 2;
while ((bVar1 = param_12[-1], (byte)(bVar1 - 0x30) < 10 || (bVar1 - 0x2d < 2))) {
param_12 = param_12 + 1;
}
if (bVar1 == 0x6c) {
bVar1 = *param_12;
}
else {
param_12 = param_12 + -1;
}
if ((bVar1 == 100) || (bVar1 == 0x75)) {
if ((ulong)((long)puVar6 - (long)param_10) < 0x20) {
LAB_0017b9a6:
*(int1 *)puVar9 = 0;
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return (long)puVar9 - (long)local_70;
}
uVar7 = local_68 & 0xffffffff;
if (uVar7 < 0x29) {
local_68 = CONCAT44(local_68._4_4_,(int)local_68 + 8);
puVar2 = (uint *)(local_58 + uVar7);
}
else {
puVar2 = local_60;
local_60 = local_60 + 2;
}
uVar7 = (ulong)(int)*puVar2;
if (*param_12 == 100) {
uVar5 = 0xfffffff6;
}
else {
uVar7 = (ulong)*puVar2;
uVar5 = 10;
}
int10_to_str(uVar7,local_48,uVar5);
if (local_48[0] != '\0') {
pcVar8 = local_48;
do {
pcVar8 = pcVar8 + 1;
*(int1 *)param_10 = 0;
*(char *)((long)param_10 + 1) = pcVar8[-1];
param_10 = param_10 + 1;
} while (*pcVar8 != '\0');
}
}
else {
if (bVar1 != 0x73) {
puVar9 = puVar6;
if (param_10 != puVar6) {
*param_10 = 0x2500;
goto LAB_0017b837;
}
goto LAB_0017b9a6;
}
uVar7 = local_68 & 0xffffffff;
if (uVar7 < 0x29) {
local_68 = CONCAT44(local_68._4_4_,(int)local_68 + 8);
puVar2 = (uint *)(local_58 + uVar7);
}
else {
puVar2 = local_60;
local_60 = local_60 + 2;
}
pcVar8 = *(char **)puVar2;
if (pcVar8 == (char *)0x0) {
pcVar8 = "(null)";
}
sVar3 = strlen(pcVar8);
sVar4 = ((ulong)((long)puVar6 - (long)param_10) >> 1) - 1;
if (sVar3 * 2 < (ulong)((long)puVar6 - (long)param_10)) {
sVar4 = sVar3;
}
if (sVar4 != 0) {
sVar3 = 0;
do {
*(int1 *)param_10 = 0;
*(char *)((long)param_10 + 1) = pcVar8[sVar3];
param_10 = param_10 + 1;
sVar3 = sVar3 + 1;
} while (sVar4 != sVar3);
}
}
}
else {
if ((*param_12 == 0) || (puVar9 = puVar6, param_10 == puVar6)) goto LAB_0017b9a6;
*(int1 *)param_10 = 0;
*(byte *)((long)param_10 + 1) = *param_12;
LAB_0017b837:
param_10 = param_10 + 1;
}
param_12 = param_12 + 1;
} while( true );
}
|
|
18,426
|
LefDefParser::defiSubnet::clear()
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiNet.cpp
|
void defiSubnet::clear() {
int i;
// WMD -- this will be removed by the next release
isFixed_ = 0;
isRouted_ = 0;
isCover_ = 0;
name_[0] = '\0';
for (i = 0; i < numPins_; i++) {
free(instances_[i]);
free(pins_[i]);
instances_[i] = 0;
pins_[i] = 0;
musts_[i] = 0;
synthesized_[i] = 0;
}
numPins_ = 0;
// WMD -- this will be removed by the next release
if (paths_) {
for (i = 0; i < numPaths_; i++) {
delete paths_[i];
}
delete [] paths_;
paths_ = 0;
numPaths_ = 0;
pathsAllocated_ = 0;
}
if (nonDefaultRule_) {
free(nonDefaultRule_);
nonDefaultRule_ = 0;
}
if (numWires_) {
for (i = 0; i < numWires_; i++) {
delete wires_[i];
wires_[i] = 0;
}
free((char*)(wires_));
wires_ = 0;
numWires_ = 0;
wiresAllocated_ = 0;
}
}
|
O0
|
cpp
|
LefDefParser::defiSubnet::clear():
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movb $0x0, 0x38(%rax)
movb $0x0, 0x39(%rax)
movb $0x0, 0x3a(%rax)
movq (%rax), %rax
movb $0x0, (%rax)
movl $0x0, 0x2c(%rsp)
movq 0x20(%rsp), %rcx
movl 0x2c(%rsp), %eax
cmpl 0xc(%rcx), %eax
jge 0x3727a
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x2c(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x72a0
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x2c(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x72a0
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rcx
movslq 0x2c(%rsp), %rdx
movq $0x0, (%rcx,%rdx,8)
movq 0x20(%rax), %rcx
movslq 0x2c(%rsp), %rdx
movq $0x0, (%rcx,%rdx,8)
movq 0x30(%rax), %rcx
movslq 0x2c(%rsp), %rdx
movb $0x0, (%rcx,%rdx)
movq 0x28(%rax), %rax
movslq 0x2c(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x371ed
movq 0x20(%rsp), %rax
movl $0x0, 0xc(%rax)
cmpq $0x0, 0x40(%rax)
je 0x37325
movl $0x0, 0x2c(%rsp)
movq 0x20(%rsp), %rcx
movl 0x2c(%rsp), %eax
cmpl 0x48(%rcx), %eax
jge 0x372ec
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rax
movslq 0x2c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x372dd
movq 0x18(%rsp), %rdi
callq 0x1a6d0
movq 0x18(%rsp), %rdi
movl $0x48, %esi
callq 0x7260
jmp 0x372df
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x37299
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x3730a
movq 0x10(%rsp), %rdi
callq 0x72c0
movq 0x20(%rsp), %rax
movq $0x0, 0x40(%rax)
movl $0x0, 0x48(%rax)
movl $0x0, 0x4c(%rax)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x60(%rax)
je 0x3734c
movq 0x20(%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x72a0
movq 0x20(%rsp), %rax
movq $0x0, 0x60(%rax)
movq 0x20(%rsp), %rax
cmpl $0x0, 0x50(%rax)
je 0x373f3
movl $0x0, 0x2c(%rsp)
movq 0x20(%rsp), %rcx
movl 0x2c(%rsp), %eax
cmpl 0x50(%rcx), %eax
jge 0x373ca
movq 0x20(%rsp), %rax
movq 0x58(%rax), %rax
movslq 0x2c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x373a7
movq 0x8(%rsp), %rdi
callq 0x38da0
movq 0x8(%rsp), %rdi
movl $0x28, %esi
callq 0x7260
movq 0x20(%rsp), %rax
movq 0x58(%rax), %rax
movslq 0x2c(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x37363
movq 0x20(%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x72a0
movq 0x20(%rsp), %rax
movq $0x0, 0x58(%rax)
movl $0x0, 0x50(%rax)
movl $0x0, 0x54(%rax)
addq $0x38, %rsp
retq
nopl (%rax,%rax)
|
_ZN12LefDefParser10defiSubnet5clearEv:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov rax, [rsp+38h+var_8]
mov [rsp+38h+var_18], rax
mov byte ptr [rax+38h], 0
mov byte ptr [rax+39h], 0
mov byte ptr [rax+3Ah], 0
mov rax, [rax]
mov byte ptr [rax], 0
mov [rsp+38h+var_C], 0
loc_371ED:
mov rcx, [rsp+38h+var_18]
mov eax, [rsp+38h+var_C]
cmp eax, [rcx+0Ch]
jge short loc_3727A
mov rax, [rsp+38h+var_18]
mov rax, [rax+18h]
movsxd rcx, [rsp+38h+var_C]
mov rdi, [rax+rcx*8]
call _free
mov rax, [rsp+38h+var_18]
mov rax, [rax+20h]
movsxd rcx, [rsp+38h+var_C]
mov rdi, [rax+rcx*8]
call _free
mov rax, [rsp+38h+var_18]
mov rcx, [rax+18h]
movsxd rdx, [rsp+38h+var_C]
mov qword ptr [rcx+rdx*8], 0
mov rcx, [rax+20h]
movsxd rdx, [rsp+38h+var_C]
mov qword ptr [rcx+rdx*8], 0
mov rcx, [rax+30h]
movsxd rdx, [rsp+38h+var_C]
mov byte ptr [rcx+rdx], 0
mov rax, [rax+28h]
movsxd rcx, [rsp+38h+var_C]
mov byte ptr [rax+rcx], 0
mov eax, [rsp+38h+var_C]
add eax, 1
mov [rsp+38h+var_C], eax
jmp loc_371ED
loc_3727A:
mov rax, [rsp+38h+var_18]
mov dword ptr [rax+0Ch], 0
cmp qword ptr [rax+40h], 0
jz loc_37325
mov [rsp+38h+var_C], 0
loc_37299:
mov rcx, [rsp+38h+var_18]
mov eax, [rsp+38h+var_C]
cmp eax, [rcx+48h]
jge short loc_372EC
mov rax, [rsp+38h+var_18]
mov rax, [rax+40h]
movsxd rcx, [rsp+38h+var_C]
mov rax, [rax+rcx*8]
mov [rsp+38h+var_20], rax
cmp rax, 0
jz short loc_372DD
mov rdi, [rsp+38h+var_20]; this
call _ZN12LefDefParser8defiPathD2Ev; LefDefParser::defiPath::~defiPath()
mov rdi, [rsp+38h+var_20]; void *
mov esi, 48h ; 'H'; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_372DD:
jmp short $+2
loc_372DF:
mov eax, [rsp+38h+var_C]
add eax, 1
mov [rsp+38h+var_C], eax
jmp short loc_37299
loc_372EC:
mov rax, [rsp+38h+var_18]
mov rax, [rax+40h]
mov [rsp+38h+var_28], rax
cmp rax, 0
jz short loc_3730A
mov rdi, [rsp+38h+var_28]; void *
call __ZdaPv; operator delete[](void *)
loc_3730A:
mov rax, [rsp+38h+var_18]
mov qword ptr [rax+40h], 0
mov dword ptr [rax+48h], 0
mov dword ptr [rax+4Ch], 0
loc_37325:
mov rax, [rsp+38h+var_18]
cmp qword ptr [rax+60h], 0
jz short loc_3734C
mov rax, [rsp+38h+var_18]
mov rdi, [rax+60h]
call _free
mov rax, [rsp+38h+var_18]
mov qword ptr [rax+60h], 0
loc_3734C:
mov rax, [rsp+38h+var_18]
cmp dword ptr [rax+50h], 0
jz loc_373F3
mov [rsp+38h+var_C], 0
loc_37363:
mov rcx, [rsp+38h+var_18]
mov eax, [rsp+38h+var_C]
cmp eax, [rcx+50h]
jge short loc_373CA
mov rax, [rsp+38h+var_18]
mov rax, [rax+58h]
movsxd rcx, [rsp+38h+var_C]
mov rax, [rax+rcx*8]
mov [rsp+38h+var_30], rax
cmp rax, 0
jz short loc_373A7
mov rdi, [rsp+38h+var_30]; this
call _ZN12LefDefParser8defiWireD2Ev; LefDefParser::defiWire::~defiWire()
mov rdi, [rsp+38h+var_30]; void *
mov esi, 28h ; '('; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_373A7:
mov rax, [rsp+38h+var_18]
mov rax, [rax+58h]
movsxd rcx, [rsp+38h+var_C]
mov qword ptr [rax+rcx*8], 0
mov eax, [rsp+38h+var_C]
add eax, 1
mov [rsp+38h+var_C], eax
jmp short loc_37363
loc_373CA:
mov rax, [rsp+38h+var_18]
mov rdi, [rax+58h]
call _free
mov rax, [rsp+38h+var_18]
mov qword ptr [rax+58h], 0
mov dword ptr [rax+50h], 0
mov dword ptr [rax+54h], 0
loc_373F3:
add rsp, 38h
retn
|
LefDefParser::defiSubnet * LefDefParser::defiSubnet::clear(LefDefParser::defiSubnet *this)
{
LefDefParser::defiSubnet *result; // rax
LefDefParser::defiWire *v2; // [rsp+8h] [rbp-30h]
void *v3; // [rsp+10h] [rbp-28h]
LefDefParser::defiPath *v4; // [rsp+18h] [rbp-20h]
int i; // [rsp+2Ch] [rbp-Ch]
int j; // [rsp+2Ch] [rbp-Ch]
int k; // [rsp+2Ch] [rbp-Ch]
*((_BYTE *)this + 56) = 0;
*((_BYTE *)this + 57) = 0;
*((_BYTE *)this + 58) = 0;
**(_BYTE **)this = 0;
for ( i = 0; i < *((_DWORD *)this + 3); ++i )
{
free(*(_QWORD *)(*((_QWORD *)this + 3) + 8LL * i));
free(*(_QWORD *)(*((_QWORD *)this + 4) + 8LL * i));
*(_QWORD *)(*((_QWORD *)this + 3) + 8LL * i) = 0LL;
*(_QWORD *)(*((_QWORD *)this + 4) + 8LL * i) = 0LL;
*(_BYTE *)(*((_QWORD *)this + 6) + i) = 0;
*(_BYTE *)(*((_QWORD *)this + 5) + i) = 0;
}
*((_DWORD *)this + 3) = 0;
if ( *((_QWORD *)this + 8) )
{
for ( j = 0; j < *((_DWORD *)this + 18); ++j )
{
v4 = *(LefDefParser::defiPath **)(*((_QWORD *)this + 8) + 8LL * j);
if ( v4 )
{
LefDefParser::defiPath::~defiPath(v4);
operator delete(v4, 0x48uLL);
}
}
v3 = (void *)*((_QWORD *)this + 8);
if ( v3 )
operator delete[](v3);
*((_QWORD *)this + 8) = 0LL;
*((_DWORD *)this + 18) = 0;
*((_DWORD *)this + 19) = 0;
}
if ( *((_QWORD *)this + 12) )
{
free(*((_QWORD *)this + 12));
*((_QWORD *)this + 12) = 0LL;
}
result = this;
if ( *((_DWORD *)this + 20) )
{
for ( k = 0; k < *((_DWORD *)this + 20); ++k )
{
v2 = *(LefDefParser::defiWire **)(*((_QWORD *)this + 11) + 8LL * k);
if ( v2 )
{
LefDefParser::defiWire::~defiWire(v2);
operator delete(v2, 0x28uLL);
}
*(_QWORD *)(*((_QWORD *)this + 11) + 8LL * k) = 0LL;
}
free(*((_QWORD *)this + 11));
result = this;
*((_QWORD *)this + 11) = 0LL;
*((_DWORD *)this + 20) = 0;
*((_DWORD *)this + 21) = 0;
}
return result;
}
|
clear:
SUB RSP,0x38
MOV qword ptr [RSP + 0x30],RDI
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x20],RAX
MOV byte ptr [RAX + 0x38],0x0
MOV byte ptr [RAX + 0x39],0x0
MOV byte ptr [RAX + 0x3a],0x0
MOV RAX,qword ptr [RAX]
MOV byte ptr [RAX],0x0
MOV dword ptr [RSP + 0x2c],0x0
LAB_001371ed:
MOV RCX,qword ptr [RSP + 0x20]
MOV EAX,dword ptr [RSP + 0x2c]
CMP EAX,dword ptr [RCX + 0xc]
JGE 0x0013727a
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + 0x18]
MOVSXD RCX,dword ptr [RSP + 0x2c]
MOV RDI,qword ptr [RAX + RCX*0x8]
CALL 0x001072a0
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + 0x20]
MOVSXD RCX,dword ptr [RSP + 0x2c]
MOV RDI,qword ptr [RAX + RCX*0x8]
CALL 0x001072a0
MOV RAX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RAX + 0x18]
MOVSXD RDX,dword ptr [RSP + 0x2c]
MOV qword ptr [RCX + RDX*0x8],0x0
MOV RCX,qword ptr [RAX + 0x20]
MOVSXD RDX,dword ptr [RSP + 0x2c]
MOV qword ptr [RCX + RDX*0x8],0x0
MOV RCX,qword ptr [RAX + 0x30]
MOVSXD RDX,dword ptr [RSP + 0x2c]
MOV byte ptr [RCX + RDX*0x1],0x0
MOV RAX,qword ptr [RAX + 0x28]
MOVSXD RCX,dword ptr [RSP + 0x2c]
MOV byte ptr [RAX + RCX*0x1],0x0
MOV EAX,dword ptr [RSP + 0x2c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x2c],EAX
JMP 0x001371ed
LAB_0013727a:
MOV RAX,qword ptr [RSP + 0x20]
MOV dword ptr [RAX + 0xc],0x0
CMP qword ptr [RAX + 0x40],0x0
JZ 0x00137325
MOV dword ptr [RSP + 0x2c],0x0
LAB_00137299:
MOV RCX,qword ptr [RSP + 0x20]
MOV EAX,dword ptr [RSP + 0x2c]
CMP EAX,dword ptr [RCX + 0x48]
JGE 0x001372ec
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + 0x40]
MOVSXD RCX,dword ptr [RSP + 0x2c]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RSP + 0x18],RAX
CMP RAX,0x0
JZ 0x001372dd
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x0011a6d0
MOV RDI,qword ptr [RSP + 0x18]
MOV ESI,0x48
CALL 0x00107260
LAB_001372dd:
JMP 0x001372df
LAB_001372df:
MOV EAX,dword ptr [RSP + 0x2c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x2c],EAX
JMP 0x00137299
LAB_001372ec:
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + 0x40]
MOV qword ptr [RSP + 0x10],RAX
CMP RAX,0x0
JZ 0x0013730a
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x001072c0
LAB_0013730a:
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX + 0x40],0x0
MOV dword ptr [RAX + 0x48],0x0
MOV dword ptr [RAX + 0x4c],0x0
LAB_00137325:
MOV RAX,qword ptr [RSP + 0x20]
CMP qword ptr [RAX + 0x60],0x0
JZ 0x0013734c
MOV RAX,qword ptr [RSP + 0x20]
MOV RDI,qword ptr [RAX + 0x60]
CALL 0x001072a0
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX + 0x60],0x0
LAB_0013734c:
MOV RAX,qword ptr [RSP + 0x20]
CMP dword ptr [RAX + 0x50],0x0
JZ 0x001373f3
MOV dword ptr [RSP + 0x2c],0x0
LAB_00137363:
MOV RCX,qword ptr [RSP + 0x20]
MOV EAX,dword ptr [RSP + 0x2c]
CMP EAX,dword ptr [RCX + 0x50]
JGE 0x001373ca
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + 0x58]
MOVSXD RCX,dword ptr [RSP + 0x2c]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RSP + 0x8],RAX
CMP RAX,0x0
JZ 0x001373a7
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x00138da0
MOV RDI,qword ptr [RSP + 0x8]
MOV ESI,0x28
CALL 0x00107260
LAB_001373a7:
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + 0x58]
MOVSXD RCX,dword ptr [RSP + 0x2c]
MOV qword ptr [RAX + RCX*0x8],0x0
MOV EAX,dword ptr [RSP + 0x2c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x2c],EAX
JMP 0x00137363
LAB_001373ca:
MOV RAX,qword ptr [RSP + 0x20]
MOV RDI,qword ptr [RAX + 0x58]
CALL 0x001072a0
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX + 0x58],0x0
MOV dword ptr [RAX + 0x50],0x0
MOV dword ptr [RAX + 0x54],0x0
LAB_001373f3:
ADD RSP,0x38
RET
|
/* LefDefParser::defiSubnet::clear() */
void __thiscall LefDefParser::defiSubnet::clear(defiSubnet *this)
{
defiPath *this_00;
defiWire *this_01;
int local_c;
this[0x38] = (defiSubnet)0x0;
this[0x39] = (defiSubnet)0x0;
this[0x3a] = (defiSubnet)0x0;
**(int1 **)this = 0;
for (local_c = 0; local_c < *(int *)(this + 0xc); local_c = local_c + 1) {
free(*(void **)(*(long *)(this + 0x18) + (long)local_c * 8));
free(*(void **)(*(long *)(this + 0x20) + (long)local_c * 8));
*(int8 *)(*(long *)(this + 0x18) + (long)local_c * 8) = 0;
*(int8 *)(*(long *)(this + 0x20) + (long)local_c * 8) = 0;
*(int1 *)(*(long *)(this + 0x30) + (long)local_c) = 0;
*(int1 *)(*(long *)(this + 0x28) + (long)local_c) = 0;
}
*(int4 *)(this + 0xc) = 0;
if (*(long *)(this + 0x40) != 0) {
for (local_c = 0; local_c < *(int *)(this + 0x48); local_c = local_c + 1) {
this_00 = *(defiPath **)(*(long *)(this + 0x40) + (long)local_c * 8);
if (this_00 != (defiPath *)0x0) {
defiPath::~defiPath(this_00);
operator_delete(this_00,0x48);
}
}
if (*(void **)(this + 0x40) != (void *)0x0) {
operator_delete__(*(void **)(this + 0x40));
}
*(int8 *)(this + 0x40) = 0;
*(int4 *)(this + 0x48) = 0;
*(int4 *)(this + 0x4c) = 0;
}
if (*(long *)(this + 0x60) != 0) {
free(*(void **)(this + 0x60));
*(int8 *)(this + 0x60) = 0;
}
if (*(int *)(this + 0x50) != 0) {
for (local_c = 0; local_c < *(int *)(this + 0x50); local_c = local_c + 1) {
this_01 = *(defiWire **)(*(long *)(this + 0x58) + (long)local_c * 8);
if (this_01 != (defiWire *)0x0) {
defiWire::~defiWire(this_01);
operator_delete(this_01,0x28);
}
*(int8 *)(*(long *)(this + 0x58) + (long)local_c * 8) = 0;
}
free(*(void **)(this + 0x58));
*(int8 *)(this + 0x58) = 0;
*(int4 *)(this + 0x50) = 0;
*(int4 *)(this + 0x54) = 0;
}
return;
}
|
|
18,427
|
LefDefParser::defiSubnet::clear()
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiNet.cpp
|
void defiSubnet::clear() {
int i;
// WMD -- this will be removed by the next release
isFixed_ = 0;
isRouted_ = 0;
isCover_ = 0;
name_[0] = '\0';
for (i = 0; i < numPins_; i++) {
free(instances_[i]);
free(pins_[i]);
instances_[i] = 0;
pins_[i] = 0;
musts_[i] = 0;
synthesized_[i] = 0;
}
numPins_ = 0;
// WMD -- this will be removed by the next release
if (paths_) {
for (i = 0; i < numPaths_; i++) {
delete paths_[i];
}
delete [] paths_;
paths_ = 0;
numPaths_ = 0;
pathsAllocated_ = 0;
}
if (nonDefaultRule_) {
free(nonDefaultRule_);
nonDefaultRule_ = 0;
}
if (numWires_) {
for (i = 0; i < numWires_; i++) {
delete wires_[i];
wires_[i] = 0;
}
free((char*)(wires_));
wires_ = 0;
numWires_ = 0;
wiresAllocated_ = 0;
}
}
|
O3
|
cpp
|
LefDefParser::defiSubnet::clear():
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movw $0x0, 0x38(%rdi)
xorl %eax, %eax
movb %al, 0x3a(%rdi)
movq (%rdi), %rcx
movb %al, (%rcx)
cmpl $0x0, 0xc(%rdi)
jle 0x22ab1
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x7220
movq 0x20(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x7220
movq 0x18(%rbx), %rax
movq %r14, (%rax,%r15,8)
movq 0x20(%rbx), %rax
movq %r14, (%rax,%r15,8)
movq 0x30(%rbx), %rax
movb %r14b, (%rax,%r15)
movq 0x28(%rbx), %rax
movb %r14b, (%rax,%r15)
incq %r15
movslq 0xc(%rbx), %rax
cmpq %rax, %r15
jl 0x22a6b
movl $0x0, 0xc(%rbx)
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x22b0f
leaq 0x40(%rbx), %r15
cmpl $0x0, 0x48(%rbx)
jle 0x22b03
xorl %r12d, %r12d
movq (%r15), %rax
movq (%rax,%r12,8), %r14
testq %r14, %r14
je 0x22ae2
movq %r14, %rdi
callq 0x14132
movl $0x48, %esi
movq %r14, %rdi
callq 0x71c0
incq %r12
movslq 0x48(%rbx), %rax
cmpq %rax, %r12
jl 0x22ace
movq (%r15), %rdi
testq %rdi, %rdi
je 0x22b08
callq 0x7250
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x22b25
callq 0x7220
movq $0x0, 0x60(%rbx)
leaq 0x50(%rbx), %r15
cmpl $0x0, 0x50(%rbx)
je 0x22b7e
jle 0x22b6e
xorl %r12d, %r12d
movq 0x58(%rbx), %rax
movq (%rax,%r12,8), %r14
testq %r14, %r14
je 0x22b49
movq %r14, %rdi
callq 0x237a0
movl $0x28, %esi
movq %r14, %rdi
callq 0x71c0
movq 0x58(%rbx), %rax
movq $0x0, (%rax,%r12,8)
incq %r12
movslq 0x50(%rbx), %rax
cmpq %rax, %r12
jl 0x22b34
movq 0x58(%rbx), %rdi
callq 0x7220
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
_ZN12LefDefParser10defiSubnet5clearEv:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rdi
mov word ptr [rdi+38h], 0
xor eax, eax
mov [rdi+3Ah], al
mov rcx, [rdi]
mov [rcx], al
cmp dword ptr [rdi+0Ch], 0
jle short loc_22AB1
xor r14d, r14d
xor r15d, r15d
loc_22A6B:
mov rax, [rbx+18h]
mov rdi, [rax+r15*8]
call _free
mov rax, [rbx+20h]
mov rdi, [rax+r15*8]
call _free
mov rax, [rbx+18h]
mov [rax+r15*8], r14
mov rax, [rbx+20h]
mov [rax+r15*8], r14
mov rax, [rbx+30h]
mov [rax+r15], r14b
mov rax, [rbx+28h]
mov [rax+r15], r14b
inc r15
movsxd rax, dword ptr [rbx+0Ch]
cmp r15, rax
jl short loc_22A6B
loc_22AB1:
mov dword ptr [rbx+0Ch], 0
mov rdi, [rbx+40h]
test rdi, rdi
jz short loc_22B0F
lea r15, [rbx+40h]
cmp dword ptr [rbx+48h], 0
jle short loc_22B03
xor r12d, r12d
loc_22ACE:
mov rax, [r15]
mov r14, [rax+r12*8]
test r14, r14
jz short loc_22AE2
mov rdi, r14; this
call _ZN12LefDefParser8defiPathD2Ev; LefDefParser::defiPath::~defiPath()
loc_22AE2:
mov esi, 48h ; 'H'; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
inc r12
movsxd rax, dword ptr [rbx+48h]
cmp r12, rax
jl short loc_22ACE
mov rdi, [r15]; void *
test rdi, rdi
jz short loc_22B08
loc_22B03:
call __ZdaPv; operator delete[](void *)
loc_22B08:
xorps xmm0, xmm0
movups xmmword ptr [r15], xmm0
loc_22B0F:
mov rdi, [rbx+60h]
test rdi, rdi
jz short loc_22B25
call _free
mov qword ptr [rbx+60h], 0
loc_22B25:
lea r15, [rbx+50h]
cmp dword ptr [rbx+50h], 0
jz short loc_22B7E
jle short loc_22B6E
xor r12d, r12d
loc_22B34:
mov rax, [rbx+58h]
mov r14, [rax+r12*8]
test r14, r14
jz short loc_22B49
mov rdi, r14; this
call _ZN12LefDefParser8defiWireD2Ev; LefDefParser::defiWire::~defiWire()
loc_22B49:
mov esi, 28h ; '('; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rax, [rbx+58h]
mov qword ptr [rax+r12*8], 0
inc r12
movsxd rax, dword ptr [rbx+50h]
cmp r12, rax
jl short loc_22B34
loc_22B6E:
mov rdi, [rbx+58h]
call _free
xorps xmm0, xmm0
movups xmmword ptr [r15], xmm0
loc_22B7E:
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
void LefDefParser::defiSubnet::clear(LefDefParser::defiSubnet *this)
{
long long v2; // r15
void *v3; // rdi
void **v4; // r15
long long v5; // r12
void *v6; // r14
void *v7; // rdi
long long v8; // r12
long long v9; // rax
void *v10; // r14
*((_WORD *)this + 28) = 0;
*((_BYTE *)this + 58) = 0;
**(_BYTE **)this = 0;
if ( *((int *)this + 3) > 0 )
{
v2 = 0LL;
do
{
free(*(void **)(*((_QWORD *)this + 3) + 8 * v2));
free(*(void **)(*((_QWORD *)this + 4) + 8 * v2));
*(_QWORD *)(*((_QWORD *)this + 3) + 8 * v2) = 0LL;
*(_QWORD *)(*((_QWORD *)this + 4) + 8 * v2) = 0LL;
*(_BYTE *)(*((_QWORD *)this + 6) + v2) = 0;
*(_BYTE *)(*((_QWORD *)this + 5) + v2++) = 0;
}
while ( v2 < *((int *)this + 3) );
}
*((_DWORD *)this + 3) = 0;
v3 = (void *)*((_QWORD *)this + 8);
if ( v3 )
{
v4 = (void **)((char *)this + 64);
if ( *((int *)this + 18) <= 0 )
goto LABEL_11;
v5 = 0LL;
do
{
v6 = (void *)*((_QWORD *)*v4 + v5);
if ( v6 )
LefDefParser::defiPath::~defiPath(*((LefDefParser::defiPath **)*v4 + v5));
operator delete(v6, 0x48uLL);
++v5;
}
while ( v5 < *((int *)this + 18) );
v3 = *v4;
if ( *v4 )
LABEL_11:
operator delete[](v3);
*(_OWORD *)v4 = 0LL;
}
v7 = (void *)*((_QWORD *)this + 12);
if ( v7 )
{
free(v7);
*((_QWORD *)this + 12) = 0LL;
}
if ( *((_DWORD *)this + 20) )
{
if ( *((int *)this + 20) > 0 )
{
v8 = 0LL;
do
{
v9 = *((_QWORD *)this + 11);
v10 = *(void **)(v9 + 8 * v8);
if ( v10 )
LefDefParser::defiWire::~defiWire(*(LefDefParser::defiWire **)(v9 + 8 * v8));
operator delete(v10, 0x28uLL);
*(_QWORD *)(*((_QWORD *)this + 11) + 8 * v8++) = 0LL;
}
while ( v8 < *((int *)this + 20) );
}
free(*((void **)this + 11));
*((_OWORD *)this + 5) = 0LL;
}
}
|
clear:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV word ptr [RDI + 0x38],0x0
XOR EAX,EAX
MOV byte ptr [RDI + 0x3a],AL
MOV RCX,qword ptr [RDI]
MOV byte ptr [RCX],AL
CMP dword ptr [RDI + 0xc],0x0
JLE 0x00122ab1
XOR R14D,R14D
XOR R15D,R15D
LAB_00122a6b:
MOV RAX,qword ptr [RBX + 0x18]
MOV RDI,qword ptr [RAX + R15*0x8]
CALL 0x00107220
MOV RAX,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [RAX + R15*0x8]
CALL 0x00107220
MOV RAX,qword ptr [RBX + 0x18]
MOV qword ptr [RAX + R15*0x8],R14
MOV RAX,qword ptr [RBX + 0x20]
MOV qword ptr [RAX + R15*0x8],R14
MOV RAX,qword ptr [RBX + 0x30]
MOV byte ptr [RAX + R15*0x1],R14B
MOV RAX,qword ptr [RBX + 0x28]
MOV byte ptr [RAX + R15*0x1],R14B
INC R15
MOVSXD RAX,dword ptr [RBX + 0xc]
CMP R15,RAX
JL 0x00122a6b
LAB_00122ab1:
MOV dword ptr [RBX + 0xc],0x0
MOV RDI,qword ptr [RBX + 0x40]
TEST RDI,RDI
JZ 0x00122b0f
LEA R15,[RBX + 0x40]
CMP dword ptr [RBX + 0x48],0x0
JLE 0x00122b03
XOR R12D,R12D
LAB_00122ace:
MOV RAX,qword ptr [R15]
MOV R14,qword ptr [RAX + R12*0x8]
TEST R14,R14
JZ 0x00122ae2
MOV RDI,R14
CALL 0x00114132
LAB_00122ae2:
MOV ESI,0x48
MOV RDI,R14
CALL 0x001071c0
INC R12
MOVSXD RAX,dword ptr [RBX + 0x48]
CMP R12,RAX
JL 0x00122ace
MOV RDI,qword ptr [R15]
TEST RDI,RDI
JZ 0x00122b08
LAB_00122b03:
CALL 0x00107250
LAB_00122b08:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R15],XMM0
LAB_00122b0f:
MOV RDI,qword ptr [RBX + 0x60]
TEST RDI,RDI
JZ 0x00122b25
CALL 0x00107220
MOV qword ptr [RBX + 0x60],0x0
LAB_00122b25:
LEA R15,[RBX + 0x50]
CMP dword ptr [RBX + 0x50],0x0
JZ 0x00122b7e
JLE 0x00122b6e
XOR R12D,R12D
LAB_00122b34:
MOV RAX,qword ptr [RBX + 0x58]
MOV R14,qword ptr [RAX + R12*0x8]
TEST R14,R14
JZ 0x00122b49
MOV RDI,R14
CALL 0x001237a0
LAB_00122b49:
MOV ESI,0x28
MOV RDI,R14
CALL 0x001071c0
MOV RAX,qword ptr [RBX + 0x58]
MOV qword ptr [RAX + R12*0x8],0x0
INC R12
MOVSXD RAX,dword ptr [RBX + 0x50]
CMP R12,RAX
JL 0x00122b34
LAB_00122b6e:
MOV RDI,qword ptr [RBX + 0x58]
CALL 0x00107220
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R15],XMM0
LAB_00122b7e:
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* LefDefParser::defiSubnet::clear() */
void __thiscall LefDefParser::defiSubnet::clear(defiSubnet *this)
{
defiSubnet *pdVar1;
defiPath *this_00;
defiWire *this_01;
void *pvVar2;
long lVar3;
*(int2 *)(this + 0x38) = 0;
this[0x3a] = (defiSubnet)0x0;
**(int1 **)this = 0;
if (0 < *(int *)(this + 0xc)) {
lVar3 = 0;
do {
free(*(void **)(*(long *)(this + 0x18) + lVar3 * 8));
free(*(void **)(*(long *)(this + 0x20) + lVar3 * 8));
*(int8 *)(*(long *)(this + 0x18) + lVar3 * 8) = 0;
*(int8 *)(*(long *)(this + 0x20) + lVar3 * 8) = 0;
*(int1 *)(*(long *)(this + 0x30) + lVar3) = 0;
*(int1 *)(*(long *)(this + 0x28) + lVar3) = 0;
lVar3 = lVar3 + 1;
} while (lVar3 < *(int *)(this + 0xc));
}
*(int4 *)(this + 0xc) = 0;
pvVar2 = *(void **)(this + 0x40);
if (pvVar2 == (void *)0x0) goto LAB_00122b0f;
pdVar1 = this + 0x40;
if (*(int *)(this + 0x48) < 1) {
LAB_00122b03:
operator_delete__(pvVar2);
}
else {
lVar3 = 0;
do {
this_00 = *(defiPath **)(*(long *)pdVar1 + lVar3 * 8);
if (this_00 != (defiPath *)0x0) {
defiPath::~defiPath(this_00);
}
operator_delete(this_00,0x48);
lVar3 = lVar3 + 1;
} while (lVar3 < *(int *)(this + 0x48));
pvVar2 = *(void **)pdVar1;
if (pvVar2 != (void *)0x0) goto LAB_00122b03;
}
*(long *)pdVar1 = 0;
*(int8 *)(this + 0x48) = 0;
LAB_00122b0f:
if (*(void **)(this + 0x60) != (void *)0x0) {
free(*(void **)(this + 0x60));
*(int8 *)(this + 0x60) = 0;
}
if (*(int *)(this + 0x50) != 0) {
if (0 < *(int *)(this + 0x50)) {
lVar3 = 0;
do {
this_01 = *(defiWire **)(*(long *)(this + 0x58) + lVar3 * 8);
if (this_01 != (defiWire *)0x0) {
defiWire::~defiWire(this_01);
}
operator_delete(this_01,0x28);
*(int8 *)(*(long *)(this + 0x58) + lVar3 * 8) = 0;
lVar3 = lVar3 + 1;
} while (lVar3 < *(int *)(this + 0x50));
}
free(*(void **)(this + 0x58));
*(int8 *)(this + 0x50) = 0;
*(int8 *)(this + 0x58) = 0;
}
return;
}
|
|
18,428
|
js_math_clz32
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_math_clz32(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
uint32_t a, r;
if (JS_ToUint32(ctx, &a, argv[0]))
return JS_EXCEPTION;
if (a == 0)
r = 32;
else
r = clz32(a);
return js_int32(r);
}
|
O1
|
c
|
js_math_clz32:
pushq %rbx
subq $0x10, %rsp
movq (%r8), %rdx
movq 0x8(%r8), %rcx
movq %rdx, (%rsp)
cmpl $-0x9, %ecx
jb 0x7e242
movq (%rsp), %rax
incl (%rax)
leaq 0xc(%rsp), %rbx
movq %rbx, %rsi
callq 0x279c3
movl %eax, %ecx
movl (%rbx), %eax
testl %eax, %eax
je 0x7e25f
bsrl %eax, %eax
xorl $0x1f, %eax
jmp 0x7e264
movl $0x20, %eax
xorl %esi, %esi
testl %ecx, %ecx
cmovnel %esi, %eax
movl $0x6, %edx
cmoveq %rsi, %rdx
addq $0x10, %rsp
popq %rbx
retq
|
js_math_clz32:
push rbx
sub rsp, 10h
mov rdx, [r8]
mov rcx, [r8+8]
mov [rsp+18h+var_18], rdx
cmp ecx, 0FFFFFFF7h
jb short loc_7E242
mov rax, [rsp+18h+var_18]
inc dword ptr [rax]
loc_7E242:
lea rbx, [rsp+18h+var_C]
mov rsi, rbx
call JS_ToInt32Free
mov ecx, eax
mov eax, [rbx]
test eax, eax
jz short loc_7E25F
bsr eax, eax
xor eax, 1Fh
jmp short loc_7E264
loc_7E25F:
mov eax, 20h ; ' '
loc_7E264:
xor esi, esi
test ecx, ecx
cmovnz eax, esi
mov edx, 6
cmovz rdx, rsi
add rsp, 10h
pop rbx
retn
|
long long js_math_clz32(long long a1, long long a2, long long a3, long long a4, long long a5)
{
_DWORD *v5; // rdx
long long v6; // rcx
int v7; // ecx
unsigned int v8; // eax
long long result; // rax
unsigned int v10[3]; // [rsp+Ch] [rbp-Ch] BYREF
v5 = *(_DWORD **)a5;
v6 = *(_QWORD *)(a5 + 8);
if ( (unsigned int)v6 >= 0xFFFFFFF7 )
++**(_DWORD **)a5;
v7 = JS_ToInt32Free(a1, (int *)v10, (unsigned long long)v5, v6);
if ( v10[0] )
{
_BitScanReverse(&v8, v10[0]);
result = v8 ^ 0x1F;
}
else
{
result = 32LL;
}
if ( v7 )
return 0LL;
return result;
}
| |||
18,429
|
js_math_clz32
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_math_clz32(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
uint32_t a, r;
if (JS_ToUint32(ctx, &a, argv[0]))
return JS_EXCEPTION;
if (a == 0)
r = 32;
else
r = clz32(a);
return js_int32(r);
}
|
O2
|
c
|
js_math_clz32:
pushq %rbx
subq $0x10, %rsp
movq (%r8), %rdx
movq 0x8(%r8), %rcx
leaq 0xc(%rsp), %rbx
movq %rbx, %rsi
callq 0x215d7
movl %eax, %ecx
movl (%rbx), %eax
testl %eax, %eax
je 0x69dff
bsrl %eax, %eax
xorl $0x1f, %eax
jmp 0x69e02
pushq $0x20
popq %rax
xorl %esi, %esi
testl %ecx, %ecx
cmovnel %esi, %eax
pushq $0x6
popq %rdx
cmoveq %rsi, %rdx
addq $0x10, %rsp
popq %rbx
retq
|
js_math_clz32:
push rbx
sub rsp, 10h
mov rdx, [r8]
mov rcx, [r8+8]
lea rbx, [rsp+18h+var_C]
mov rsi, rbx
call JS_ToInt32
mov ecx, eax
mov eax, [rbx]
test eax, eax
jz short loc_69DFF
bsr eax, eax
xor eax, 1Fh
jmp short loc_69E02
loc_69DFF:
push 20h ; ' '
pop rax
loc_69E02:
xor esi, esi
test ecx, ecx
cmovnz eax, esi
push 6
pop rdx
cmovz rdx, rsi
add rsp, 10h
pop rbx
retn
|
long long js_math_clz32(long long a1, long long a2, long long a3, long long a4, long long a5)
{
int v5; // ecx
unsigned int v6; // eax
long long result; // rax
unsigned int v8[3]; // [rsp+Ch] [rbp-Ch] BYREF
v5 = JS_ToInt32(a1, (long long)v8, *(_DWORD **)a5, *(_QWORD *)(a5 + 8));
if ( v8[0] )
{
_BitScanReverse(&v6, v8[0]);
result = v6 ^ 0x1F;
}
else
{
result = 32LL;
}
if ( v5 )
return 0LL;
return result;
}
|
js_math_clz32:
PUSH RBX
SUB RSP,0x10
MOV RDX,qword ptr [R8]
MOV RCX,qword ptr [R8 + 0x8]
LEA RBX,[RSP + 0xc]
MOV RSI,RBX
CALL 0x001215d7
MOV ECX,EAX
MOV EAX,dword ptr [RBX]
TEST EAX,EAX
JZ 0x00169dff
BSR EAX,EAX
XOR EAX,0x1f
JMP 0x00169e02
LAB_00169dff:
PUSH 0x20
POP RAX
LAB_00169e02:
XOR ESI,ESI
TEST ECX,ECX
CMOVNZ EAX,ESI
PUSH 0x6
POP RDX
CMOVZ RDX,RSI
ADD RSP,0x10
POP RBX
RET
|
int1 [16] js_math_clz32(int8 param_1)
{
uint uVar1;
int iVar2;
ulong uVar3;
ulong uVar4;
int8 *in_R8;
int1 auVar5 [16];
uint local_c;
iVar2 = JS_ToInt32(param_1,&local_c,*in_R8,in_R8[1]);
if (local_c == 0) {
uVar3 = 0x20;
}
else {
uVar1 = 0x1f;
if (local_c != 0) {
for (; local_c >> uVar1 == 0; uVar1 = uVar1 - 1) {
}
}
uVar3 = (ulong)(uVar1 ^ 0x1f);
}
if (iVar2 != 0) {
uVar3 = 0;
}
uVar4 = 6;
if (iVar2 == 0) {
uVar4 = 0;
}
auVar5._8_8_ = uVar4;
auVar5._0_8_ = uVar3;
return auVar5;
}
|
|
18,430
|
Catch::BinaryExpr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [4]>::streamReconstructedExpression(std::ostream&) const
|
11AgReS1SoR11[P]Graph/build_O1/_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 ) );
}
|
O1
|
cpp
|
Catch::BinaryExpr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [4]>::streamReconstructedExpression(std::ostream&) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r12
movq 0x10(%rdi), %rax
movzwl (%rax), %eax
leaq 0x8(%rsp), %rsi
movw %ax, (%rsi)
leaq 0x28(%rsp), %rdi
callq 0x269f0
movq 0x18(%r12), %r14
movq 0x20(%r12), %r15
movq 0x28(%r12), %rax
movzwl (%rax), %eax
leaq 0x6(%rsp), %rsi
movw %ax, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0x269f0
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x3da9c
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x288a5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x154d0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x288c0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x154d0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x288ef
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x154d0
jmp 0x288ef
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2890a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x154d0
movq %rbx, %rdi
callq 0x158e0
|
_ZNK5Catch10BinaryExprIR7color_eS2_E29streamReconstructedExpressionERSo:
push r15
push r14
push r12
push rbx
sub rsp, 48h
mov rbx, rsi
mov r12, rdi
mov rax, [rdi+10h]
movzx eax, word ptr [rax]
lea rsi, [rsp+68h+var_60]
mov [rsi], ax
lea rdi, [rsp+68h+var_40]
call _ZN5Catch11StringMakerIsvE7convertIsEENSt9enable_ifIXgssr5Catch6Detail18IsStreamInsertableIT_EE5valueENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE4typeERKS4_
mov r14, [r12+18h]
mov r15, [r12+20h]
mov rax, [r12+28h]
movzx eax, word ptr [rax]
lea rsi, [rsp+68h+var_62]
mov [rsi], ax
lea rdi, [rsp+68h+var_60]
call _ZN5Catch11StringMakerIsvE7convertIsEENSt9enable_ifIXgssr5Catch6Detail18IsStreamInsertableIT_EE5valueENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE4typeERKS4_
lea rsi, [rsp+68h+var_40]
lea r8, [rsp+68h+var_60]
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_50]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_288A5
mov rsi, [rsp+68h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_288A5:
lea rax, [rsp+68h+var_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_288C0
mov rsi, [rsp+68h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_288C0:
add rsp, 48h
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_288EF
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_288EF
mov rbx, rax
loc_288EF:
lea rax, [rsp+arg_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_2890A
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2890A:
mov rdi, rbx
call __Unwind_Resume
|
void Catch::BinaryExpr<color_e &,color_e &>::streamReconstructedExpression(long long a1, long long a2)
{
long long v2; // r14
long long v3; // r15
__int16 v4; // [rsp+6h] [rbp-62h] BYREF
void *v5[2]; // [rsp+8h] [rbp-60h] BYREF
long long v6; // [rsp+18h] [rbp-50h] BYREF
void *v7[2]; // [rsp+28h] [rbp-40h] BYREF
long long v8; // [rsp+38h] [rbp-30h] BYREF
LOWORD(v5[0]) = **(_WORD **)(a1 + 16);
Catch::StringMaker<short,void>::convert<short>((long long)v7, (__int16 *)v5);
v2 = *(_QWORD *)(a1 + 24);
v3 = *(_QWORD *)(a1 + 32);
v4 = **(_WORD **)(a1 + 40);
Catch::StringMaker<short,void>::convert<short>((long long)v5, &v4);
Catch::formatReconstructedExpression(a2, v7, v2, v3, v5);
if ( v5[0] != &v6 )
operator delete(v5[0], v6 + 1);
if ( v7[0] != &v8 )
operator delete(v7[0], v8 + 1);
}
|
streamReconstructedExpression:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV RBX,RSI
MOV R12,RDI
MOV RAX,qword ptr [RDI + 0x10]
MOVZX EAX,word ptr [RAX]
LEA RSI,[RSP + 0x8]
MOV word ptr [RSI],AX
LEA RDI,[RSP + 0x28]
CALL 0x001269f0
MOV R14,qword ptr [R12 + 0x18]
MOV R15,qword ptr [R12 + 0x20]
MOV RAX,qword ptr [R12 + 0x28]
MOVZX EAX,word ptr [RAX]
LEA RSI,[RSP + 0x6]
MOV word ptr [RSI],AX
LAB_00128868:
LEA RDI,[RSP + 0x8]
CALL 0x001269f0
LAB_00128872:
LEA RSI,[RSP + 0x28]
LEA R8,[RSP + 0x8]
MOV RDI,RBX
MOV RDX,R14
MOV RCX,R15
CALL 0x0013da9c
LAB_0012888a:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001288a5
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001154d0
LAB_001288a5:
LEA RAX,[RSP + 0x38]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001288c0
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x001154d0
LAB_001288c0:
ADD RSP,0x48
POP RBX
POP R12
POP R14
POP R15
RET
|
/* Catch::BinaryExpr<color_e&, color_e&>::streamReconstructedExpression(std::ostream&) const */
void __thiscall
Catch::BinaryExpr<color_e&,color_e&>::streamReconstructedExpression
(BinaryExpr<color_e&,color_e&> *this,ostream *param_1)
{
int8 uVar1;
int8 uVar2;
short local_62;
short local_60;
int6 uStack_5e;
long local_50 [2];
long *local_40 [2];
long local_30 [2];
local_60 = **(short **)(this + 0x10);
StringMaker<short,void>::convert<short>((StringMaker<short,void> *)local_40,&local_60);
uVar1 = *(int8 *)(this + 0x18);
uVar2 = *(int8 *)(this + 0x20);
local_62 = **(short **)(this + 0x28);
/* try { // try from 00128868 to 00128871 has its CatchHandler @ 001288ec */
StringMaker<short,void>::convert<short>((StringMaker<short,void> *)&local_60,&local_62);
/* try { // try from 00128872 to 00128889 has its CatchHandler @ 001288cc */
formatReconstructedExpression((Catch *)param_1,local_40,uVar1,uVar2,&local_60);
if ((long *)CONCAT62(uStack_5e,local_60) != local_50) {
operator_delete((long *)CONCAT62(uStack_5e,local_60),local_50[0] + 1);
}
if (local_40[0] != local_30) {
operator_delete(local_40[0],local_30[0] + 1);
}
return;
}
|
|
18,431
|
verify_storage
|
corpus-core[P]colibri-stateless/src/chains/eth/verifier/eth_account.c
|
static bool verify_storage(verify_ctx_t* ctx, ssz_ob_t storage_proofs, bytes32_t storage_hash, bytes_t values) {
if (values.data) memset(values.data, 0, 32);
int len = ssz_len(storage_proofs);
if (len != 0 && memcmp(storage_hash, EMPTY_ROOT_HASH, 32) == 0) RETURN_VERIFY_ERROR(ctx, "invalid storage proof because an empty storage hash can not have values!");
for (int i = 0; i < len; i++) {
bytes32_t path = {0};
bytes32_t root = {0};
ssz_ob_t storage = ssz_at(storage_proofs, i);
ssz_ob_t proof = ssz_get(&storage, "proof");
ssz_ob_t key = ssz_get(&storage, "key");
bytes_t leaf = {0};
keccak(key.bytes, path);
if (patricia_verify(root, bytes(path, 32), proof, &leaf) == PATRICIA_INVALID) RETURN_VERIFY_ERROR(ctx, "invalid storage proof!");
if (memcmp(root, storage_hash, 32) != 0) RETURN_VERIFY_ERROR(ctx, "invalid storage root!");
if (values.data && values.len >= (i + 1) * 32 && rlp_decode(&leaf, 0, &leaf) == RLP_ITEM)
memcpy(values.data + (i + 1) * 32 - leaf.len, leaf.data, leaf.len);
}
return true;
}
|
O0
|
c
|
verify_storage:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
leaq 0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x12fbc
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x5110
movq -0xe0(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x1b380
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x1302b
movq -0x28(%rbp), %rdi
movq 0x5c213(%rip), %rsi # 0x6f208
movl $0x20, %edx
callq 0x5310
cmpl $0x0, %eax
jne 0x1302b
jmp 0x13006
movq -0x20(%rbp), %rdi
addq $0x70, %rdi
leaq 0x40803(%rip), %rsi # 0x53818
callq 0x22510
movq -0x20(%rbp), %rax
movb $0x0, 0x68(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x1321a
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x13216
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x5110
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x5110
movq -0xe0(%rbp), %rax
movl -0x30(%rbp), %esi
leaq -0x88(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x1b0d0
leaq -0xa0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
leaq 0x41396(%rip), %rdx # 0x54438
callq 0x1c760
leaq -0xb8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
leaq 0x40032(%rip), %rdx # 0x530ee
callq 0x1c760
leaq -0xc8(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x5110
leaq -0x50(%rbp), %rdx
movl -0xb8(%rbp), %edi
movq -0xb0(%rbp), %rsi
callq 0x1f4e0
leaq -0x70(%rbp), %rdi
movl $0x20, -0xd8(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0xd0(%rbp)
movl -0xd8(%rbp), %esi
movq -0xd0(%rbp), %rdx
leaq -0xa0(%rbp), %rax
leaq -0xc8(%rbp), %rcx
movq (%rax), %r8
movq %r8, (%rsp)
movq 0x8(%rax), %r8
movq %r8, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x155e0
cmpl $0x0, %eax
jne 0x13168
jmp 0x13143
movq -0x20(%rbp), %rdi
addq $0x70, %rdi
leaq 0x4058f(%rip), %rsi # 0x536e1
callq 0x22510
movq -0x20(%rbp), %rax
movb $0x0, 0x68(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x1321a
leaq -0x70(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x20, %edx
callq 0x5310
cmpl $0x0, %eax
je 0x131a3
jmp 0x13181
movq -0x20(%rbp), %rdi
addq $0x70, %rdi
leaq 0x406d1(%rip), %rsi # 0x53861
callq 0x22510
movq -0x20(%rbp), %rax
movb $0x0, 0x68(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x1321a
cmpq $0x0, -0x10(%rbp)
je 0x13206
movl -0x18(%rbp), %eax
movl -0x30(%rbp), %ecx
addl $0x1, %ecx
shll $0x5, %ecx
cmpl %ecx, %eax
jb 0x13206
leaq -0xc8(%rbp), %rdx
xorl %esi, %esi
movq %rdx, %rdi
callq 0x15f10
cmpl $0x1, %eax
jne 0x13206
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %eax
addl $0x1, %eax
shll $0x5, %eax
cltq
addq %rax, %rdi
movl -0xc8(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdi
movq -0xc0(%rbp), %rsi
movl -0xc8(%rbp), %eax
movl %eax, %edx
callq 0x5060
jmp 0x13208
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x13032
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x100, %rsp # imm = 0x100
popq %rbp
retq
nopl (%rax,%rax)
|
verify_storage:
push rbp
mov rbp, rsp
sub rsp, 100h
lea rax, [rbp+arg_0]
mov [rbp+var_E0], rax
mov [rbp+var_18], edx
mov [rbp+var_10], rcx
mov [rbp+var_20], rdi
mov [rbp+var_28], rsi
cmp [rbp+var_10], 0
jz short loc_12FBC
mov rdi, [rbp+var_10]
xor esi, esi
mov edx, 20h ; ' '
call _memset
loc_12FBC:
mov rax, [rbp+var_E0]
mov rcx, [rax]
mov [rsp+100h+var_100], rcx
mov rcx, [rax+8]
mov [rsp+100h+var_F8], rcx
mov rax, [rax+10h]
mov [rsp+100h+var_F0], rax
call ssz_len
mov [rbp+var_2C], eax
cmp [rbp+var_2C], 0
jz short loc_1302B
mov rdi, [rbp+var_28]
mov rsi, cs:EMPTY_ROOT_HASH
mov edx, 20h ; ' '
call _memcmp
cmp eax, 0
jnz short loc_1302B
jmp short $+2
loc_13006:
mov rdi, [rbp+var_20]
add rdi, 70h ; 'p'
lea rsi, aInvalidStorage_0; "invalid storage proof because an empty "...
call c4_state_add_error
mov rax, [rbp+var_20]
mov byte ptr [rax+68h], 0
mov [rbp+var_1], 0
jmp loc_1321A
loc_1302B:
mov [rbp+var_30], 0
loc_13032:
mov eax, [rbp+var_30]
cmp eax, [rbp+var_2C]
jge loc_13216
lea rdi, [rbp+var_50]
xor esi, esi
mov edx, 20h ; ' '
call _memset
lea rdi, [rbp+var_70]
xor esi, esi
mov edx, 20h ; ' '
call _memset
mov rax, [rbp+var_E0]
mov esi, [rbp+var_30]
lea rdi, [rbp+var_88]
mov rcx, [rax]
mov [rsp+100h+var_100], rcx
mov rcx, [rax+8]
mov [rsp+100h+var_F8], rcx
mov rax, [rax+10h]
mov [rsp+100h+var_F0], rax
call ssz_at
lea rdi, [rbp+var_A0]
lea rsi, [rbp+var_88]
lea rdx, aMerkleProof+7; "proof"
call ssz_get
lea rdi, [rbp+var_B8]
lea rsi, [rbp+var_88]
lea rdx, aAggregatepubke+0Ch; "key"
call ssz_get
lea rdi, [rbp+var_C8]
xor esi, esi
mov edx, 10h
call _memset
lea rdx, [rbp+var_50]
mov edi, [rbp+var_B8]
mov rsi, [rbp+var_B0]
call keccak
lea rdi, [rbp+var_70]
mov [rbp+var_D8], 20h ; ' '
lea rax, [rbp+var_50]
mov [rbp+var_D0], rax
mov esi, [rbp+var_D8]
mov rdx, [rbp+var_D0]
lea rax, [rbp+var_A0]
lea rcx, [rbp+var_C8]
mov r8, [rax]
mov [rsp+100h+var_100], r8
mov r8, [rax+8]
mov [rsp+100h+var_F8], r8
mov rax, [rax+10h]
mov [rsp+100h+var_F0], rax
call patricia_verify
cmp eax, 0
jnz short loc_13168
jmp short $+2
loc_13143:
mov rdi, [rbp+var_20]
add rdi, 70h ; 'p'
lea rsi, aInvalidStorage; "invalid storage proof!"
call c4_state_add_error
mov rax, [rbp+var_20]
mov byte ptr [rax+68h], 0
mov [rbp+var_1], 0
jmp loc_1321A
loc_13168:
lea rdi, [rbp+var_70]
mov rsi, [rbp+var_28]
mov edx, 20h ; ' '
call _memcmp
cmp eax, 0
jz short loc_131A3
jmp short $+2
loc_13181:
mov rdi, [rbp+var_20]
add rdi, 70h ; 'p'
lea rsi, aInvalidStorage_1; "invalid storage root!"
call c4_state_add_error
mov rax, [rbp+var_20]
mov byte ptr [rax+68h], 0
mov [rbp+var_1], 0
jmp short loc_1321A
loc_131A3:
cmp [rbp+var_10], 0
jz short loc_13206
mov eax, [rbp+var_18]
mov ecx, [rbp+var_30]
add ecx, 1
shl ecx, 5
cmp eax, ecx
jb short loc_13206
lea rdx, [rbp+var_C8]
xor esi, esi
mov rdi, rdx
call rlp_decode
cmp eax, 1
jnz short loc_13206
mov rdi, [rbp+var_10]
mov eax, [rbp+var_30]
add eax, 1
shl eax, 5
cdqe
add rdi, rax
mov eax, [rbp+var_C8]
mov ecx, eax
xor eax, eax
sub rax, rcx
add rdi, rax
mov rsi, [rbp+var_C0]
mov eax, [rbp+var_C8]
mov edx, eax
call _memcpy
loc_13206:
jmp short $+2
loc_13208:
mov eax, [rbp+var_30]
add eax, 1
mov [rbp+var_30], eax
jmp loc_13032
loc_13216:
mov [rbp+var_1], 1
loc_1321A:
mov al, [rbp+var_1]
and al, 1
add rsp, 100h
pop rbp
retn
|
char verify_storage(
long long a1,
long long a2,
unsigned int a3,
long long a4,
int a5,
int a6,
long long a7,
long long a8,
long long a9)
{
int v9; // edx
int v10; // r8d
int v11; // r9d
int v12; // r9d
unsigned int v14; // [rsp+38h] [rbp-C8h] BYREF
long long v15; // [rsp+40h] [rbp-C0h]
unsigned int v16; // [rsp+48h] [rbp-B8h] BYREF
long long v17; // [rsp+50h] [rbp-B0h]
long long v18; // [rsp+60h] [rbp-A0h] BYREF
long long v19; // [rsp+68h] [rbp-98h]
long long v20; // [rsp+70h] [rbp-90h]
_BYTE v21[24]; // [rsp+78h] [rbp-88h] BYREF
_BYTE v22[32]; // [rsp+90h] [rbp-70h] BYREF
_BYTE v23[32]; // [rsp+B0h] [rbp-50h] BYREF
int i; // [rsp+D0h] [rbp-30h]
int v25; // [rsp+D4h] [rbp-2Ch]
long long v26; // [rsp+D8h] [rbp-28h]
long long v27; // [rsp+E0h] [rbp-20h]
unsigned int v28; // [rsp+E8h] [rbp-18h]
long long v29; // [rsp+F0h] [rbp-10h]
v28 = a3;
v29 = a4;
v27 = a1;
v26 = a2;
if ( a4 )
{
LODWORD(a1) = v29;
LODWORD(a2) = 0;
memset(v29, 0LL, 32LL);
}
v25 = ssz_len(a1, a2, a3, a8, a5, a6, a7, a8, a9);
if ( v25 && !(unsigned int)memcmp(v26, EMPTY_ROOT_HASH, 32LL) )
{
c4_state_add_error(v27 + 112, "invalid storage proof because an empty storage hash can not have values!");
*(_BYTE *)(v27 + 104) = 0;
return 0;
}
else
{
for ( i = 0; i < v25; ++i )
{
memset(v23, 0LL, sizeof(v23));
memset(v22, 0LL, sizeof(v22));
ssz_at((unsigned int)v21, i, v9, a8, v10, v11, a7, a8, a9);
ssz_get(&v18, v21, "proof");
ssz_get(&v16, v21, "key");
memset(&v14, 0LL, 16LL);
keccak(v16, v17, v23);
if ( !(unsigned int)patricia_verify(
(unsigned int)v22,
32,
(unsigned int)v23,
(unsigned int)&v14,
v19,
v12,
v18,
v19,
v20) )
{
c4_state_add_error(v27 + 112, "invalid storage proof!");
*(_BYTE *)(v27 + 104) = 0;
return 0;
}
if ( (unsigned int)memcmp(v22, v26, 32LL) )
{
c4_state_add_error(v27 + 112, "invalid storage root!");
*(_BYTE *)(v27 + 104) = 0;
return 0;
}
if ( v29 && v28 >= 32 * (i + 1) && (unsigned int)rlp_decode(&v14, 0LL) == 1 )
memcpy(32 * (i + 1) + v29 - v14, v15, v14);
}
return 1;
}
}
|
verify_storage:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x100
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0xe0],RAX
MOV dword ptr [RBP + -0x18],EDX
MOV qword ptr [RBP + -0x10],RCX
MOV qword ptr [RBP + -0x20],RDI
MOV qword ptr [RBP + -0x28],RSI
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00112fbc
MOV RDI,qword ptr [RBP + -0x10]
XOR ESI,ESI
MOV EDX,0x20
CALL 0x00105110
LAB_00112fbc:
MOV RAX,qword ptr [RBP + -0xe0]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RCX
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x0011b380
MOV dword ptr [RBP + -0x2c],EAX
CMP dword ptr [RBP + -0x2c],0x0
JZ 0x0011302b
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [0x0016f208]
MOV EDX,0x20
CALL 0x00105310
CMP EAX,0x0
JNZ 0x0011302b
JMP 0x00113006
LAB_00113006:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x70
LEA RSI,[0x153818]
CALL 0x00122510
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x68],0x0
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0011321a
LAB_0011302b:
MOV dword ptr [RBP + -0x30],0x0
LAB_00113032:
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x2c]
JGE 0x00113216
LEA RDI,[RBP + -0x50]
XOR ESI,ESI
MOV EDX,0x20
CALL 0x00105110
LEA RDI,[RBP + -0x70]
XOR ESI,ESI
MOV EDX,0x20
CALL 0x00105110
MOV RAX,qword ptr [RBP + -0xe0]
MOV ESI,dword ptr [RBP + -0x30]
LEA RDI,[RBP + -0x88]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RCX
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x0011b0d0
LEA RDI,[RBP + -0xa0]
LEA RSI,[RBP + -0x88]
LEA RDX,[0x154438]
CALL 0x0011c760
LEA RDI,[RBP + -0xb8]
LEA RSI,[RBP + -0x88]
LEA RDX,[0x1530ee]
CALL 0x0011c760
LEA RDI,[RBP + -0xc8]
XOR ESI,ESI
MOV EDX,0x10
CALL 0x00105110
LEA RDX,[RBP + -0x50]
MOV EDI,dword ptr [RBP + -0xb8]
MOV RSI,qword ptr [RBP + -0xb0]
CALL 0x0011f4e0
LEA RDI,[RBP + -0x70]
MOV dword ptr [RBP + -0xd8],0x20
LEA RAX,[RBP + -0x50]
MOV qword ptr [RBP + -0xd0],RAX
MOV ESI,dword ptr [RBP + -0xd8]
MOV RDX,qword ptr [RBP + -0xd0]
LEA RAX,[RBP + -0xa0]
LEA RCX,[RBP + -0xc8]
MOV R8,qword ptr [RAX]
MOV qword ptr [RSP],R8
MOV R8,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],R8
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x001155e0
CMP EAX,0x0
JNZ 0x00113168
JMP 0x00113143
LAB_00113143:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x70
LEA RSI,[0x1536e1]
CALL 0x00122510
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x68],0x0
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0011321a
LAB_00113168:
LEA RDI,[RBP + -0x70]
MOV RSI,qword ptr [RBP + -0x28]
MOV EDX,0x20
CALL 0x00105310
CMP EAX,0x0
JZ 0x001131a3
JMP 0x00113181
LAB_00113181:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x70
LEA RSI,[0x153861]
CALL 0x00122510
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x68],0x0
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0011321a
LAB_001131a3:
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00113206
MOV EAX,dword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x30]
ADD ECX,0x1
SHL ECX,0x5
CMP EAX,ECX
JC 0x00113206
LEA RDX,[RBP + -0xc8]
XOR ESI,ESI
MOV RDI,RDX
CALL 0x00115f10
CMP EAX,0x1
JNZ 0x00113206
MOV RDI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x30]
ADD EAX,0x1
SHL EAX,0x5
CDQE
ADD RDI,RAX
MOV EAX,dword ptr [RBP + -0xc8]
MOV ECX,EAX
XOR EAX,EAX
SUB RAX,RCX
ADD RDI,RAX
MOV RSI,qword ptr [RBP + -0xc0]
MOV EAX,dword ptr [RBP + -0xc8]
MOV EDX,EAX
CALL 0x00105060
LAB_00113206:
JMP 0x00113208
LAB_00113208:
MOV EAX,dword ptr [RBP + -0x30]
ADD EAX,0x1
MOV dword ptr [RBP + -0x30],EAX
JMP 0x00113032
LAB_00113216:
MOV byte ptr [RBP + -0x1],0x1
LAB_0011321a:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0x100
POP RBP
RET
|
int1
verify_storage(long param_1,void *param_2,uint param_3,void *param_4,int8 param_5,
int8 param_6)
{
int iVar1;
uint local_d0 [2];
void *local_c8;
int4 local_c0 [2];
int8 local_b8;
int8 local_a8;
int8 local_a0;
int8 local_98;
int1 local_90 [24];
int1 local_78 [32];
int1 local_58 [32];
int local_38;
int local_34;
void *local_30;
long local_28;
uint local_20;
void *local_18;
local_30 = param_2;
local_28 = param_1;
local_20 = param_3;
local_18 = param_4;
if (param_4 != (void *)0x0) {
memset(param_4,0,0x20);
}
local_34 = ssz_len();
if ((local_34 != 0) && (iVar1 = memcmp(local_30,EMPTY_ROOT_HASH,0x20), iVar1 == 0)) {
c4_state_add_error(local_28 + 0x70,
"invalid storage proof because an empty storage hash can not have values!");
*(int1 *)(local_28 + 0x68) = 0;
return 0;
}
local_38 = 0;
while( true ) {
if (local_34 <= local_38) {
return 1;
}
memset(local_58,0,0x20);
memset(local_78,0,0x20);
ssz_at(local_90,local_38);
ssz_get(&local_a8,local_90,"proof");
ssz_get(local_c0,local_90,"key");
memset(local_d0,0,0x10);
keccak(local_c0[0],local_b8,local_58);
iVar1 = patricia_verify(local_78,0x20,local_58,local_d0,local_a0,param_6,local_a8,local_a0,
local_98);
if (iVar1 == 0) break;
iVar1 = memcmp(local_78,local_30,0x20);
if (iVar1 != 0) {
c4_state_add_error(local_28 + 0x70,"invalid storage root!");
*(int1 *)(local_28 + 0x68) = 0;
return 0;
}
if (((local_18 != (void *)0x0) && ((uint)((local_38 + 1) * 0x20) <= local_20)) &&
(iVar1 = rlp_decode(local_d0), iVar1 == 1)) {
memcpy((void *)((long)local_18 + ((long)((local_38 + 1) * 0x20) - (ulong)local_d0[0])),
local_c8,(ulong)local_d0[0]);
}
local_38 = local_38 + 1;
}
c4_state_add_error(local_28 + 0x70,"invalid storage proof!");
*(int1 *)(local_28 + 0x68) = 0;
return 0;
}
|
|
18,432
|
key_cache_insert
|
eloqsql/mysys/mf_keycache.c
|
int key_cache_insert(KEY_CACHE *keycache,
File file, my_off_t filepos, int level,
uchar *buff, uint length)
{
if (keycache->can_be_used)
return keycache->interface_funcs->insert(keycache->keycache_cb,
file, filepos, level,
buff, length);
return 0;
}
|
O0
|
c
|
key_cache_insert:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x49(%rax)
je 0xef0e5
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %r8
movl -0x34(%rbp), %r9d
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0xef0ec
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
key_cache_insert:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov [rbp+var_30], r8
mov [rbp+var_34], r9d
mov rax, [rbp+var_10]
cmp byte ptr [rax+49h], 0
jz short loc_EF0E5
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov rax, [rax+20h]
mov rcx, [rbp+var_10]
mov rdi, [rcx+8]
mov esi, [rbp+var_14]
mov rdx, [rbp+var_20]
mov ecx, [rbp+var_24]
mov r8, [rbp+var_30]
mov r9d, [rbp+var_34]
call rax
mov [rbp+var_4], eax
jmp short loc_EF0EC
loc_EF0E5:
mov [rbp+var_4], 0
loc_EF0EC:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
|
long long key_cache_insert(
long long a1,
unsigned int a2,
long long a3,
unsigned int a4,
long long a5,
unsigned int a6)
{
if ( *(_BYTE *)(a1 + 73) )
return (unsigned int)(*(long long ( **)(_QWORD, _QWORD, long long, _QWORD, long long, _QWORD))(*(_QWORD *)(a1 + 16) + 32LL))(
*(_QWORD *)(a1 + 8),
a2,
a3,
a4,
a5,
a6);
else
return 0;
}
|
key_cache_insert:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV qword ptr [RBP + -0x30],R8
MOV dword ptr [RBP + -0x34],R9D
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX + 0x49],0x0
JZ 0x001ef0e5
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RCX + 0x8]
MOV ESI,dword ptr [RBP + -0x14]
MOV RDX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x24]
MOV R8,qword ptr [RBP + -0x30]
MOV R9D,dword ptr [RBP + -0x34]
CALL RAX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001ef0ec
LAB_001ef0e5:
MOV dword ptr [RBP + -0x4],0x0
LAB_001ef0ec:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
int4
key_cache_insert(long param_1,int4 param_2,int8 param_3,int4 param_4,
int8 param_5,int4 param_6)
{
int4 local_c;
if (*(char *)(param_1 + 0x49) == '\0') {
local_c = 0;
}
else {
local_c = (**(code **)(*(long *)(param_1 + 0x10) + 0x20))
(*(int8 *)(param_1 + 8),param_2,param_3,param_4,param_5,param_6);
}
return local_c;
}
|
|
18,433
|
my_read_charset_file
|
eloqsql/mysys/charset.c
|
static my_bool
my_read_charset_file(MY_CHARSET_LOADER *loader,
const char *filename,
myf myflags)
{
uchar *buf;
int fd;
size_t len, tmp_len;
MY_STAT stat_info;
if (!my_stat(filename, &stat_info, MYF(myflags)) ||
((len= (uint)stat_info.st_size) > MY_MAX_ALLOWED_BUF) ||
!(buf= (uchar*) my_malloc(key_memory_charset_loader,len,myflags)))
return TRUE;
if ((fd= mysql_file_open(key_file_charset, filename, O_RDONLY, myflags)) < 0)
goto error;
tmp_len= mysql_file_read(fd, buf, len, myflags);
mysql_file_close(fd, myflags);
if (tmp_len != len)
goto error;
if (my_parse_charset_xml(loader, (char *) buf, len))
{
my_printf_error(EE_UNKNOWN_CHARSET, "Error while parsing '%s': %s\n",
MYF(0), filename, loader->error);
goto error;
}
my_free(buf);
return FALSE;
error:
my_free(buf);
return TRUE;
}
|
O3
|
c
|
my_read_charset_file:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x120(%rbp), %rsi
movq %r14, %rdi
callq 0xbf003
testq %rax, %rax
je 0xae4e0
movl -0xf0(%rbp), %r13d
cmpq $0x100000, %r13 # imm = 0x100000
ja 0xae4e0
leaq 0xb82c4c(%rip), %rax # 0xc31014
movl (%rax), %edi
movq %r13, %rsi
movq %r12, %rdx
callq 0xbf321
testq %rax, %rax
je 0xae4e0
movq %rax, %r15
movq %rbx, -0x38(%rbp)
leaq 0xb822c4(%rip), %rax # 0xc306b0
movl (%rax), %esi
leaq 0x300623(%rip), %rax # 0x3aea18
movq (%rax), %rax
leaq -0x90(%rbp), %rdi
leaq -0x48(%rbp), %rbx
movl $0x2, %edx
movq %r14, %rcx
movq %rbx, %r8
callq *0x148(%rax)
movq %rax, (%rbx)
testq %rax, %rax
jne 0xae4f2
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0xbf950
movl %eax, %ebx
testl %ebx, %ebx
js 0xae4d8
leaq 0x3005da(%rip), %rax # 0x3aea18
movq (%rax), %rax
leaq -0x90(%rbp), %rdi
movl %ebx, %esi
movl $0x6, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0xae53b
movl %ebx, %edi
movq %r15, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0xbff8c
movq %rax, -0x30(%rbp)
leaq 0x30059f(%rip), %rax # 0x3aea18
movq (%rax), %rax
leaq -0x90(%rbp), %rdi
movl %ebx, %esi
movl $0x4, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0xae5af
movl %ebx, %edi
movq %r12, %rsi
callq 0xbfaf5
cmpq %r13, -0x30(%rbp)
jne 0xae4d8
movq -0x38(%rbp), %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xf0834
testb %al, %al
je 0xae4d8
leaq 0x50f1e(%rip), %rsi # 0xff3e1
movl $0x16, %edi
xorl %edx, %edx
movq %r14, %rcx
movq -0x38(%rbp), %r8
xorl %eax, %eax
callq 0xbae95
movq %r15, %rdi
callq 0xbf54e
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x30051f(%rip), %rcx # 0x3aea18
movq (%rcx), %rcx
leaq 0x50ea5(%rip), %rsi # 0xff3a8
movq %rax, %rdi
movl $0x223, %edx # imm = 0x223
callq *0x1f0(%rcx)
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0xbf950
movl %eax, %ebx
leaq 0x3004f1(%rip), %rax # 0x3aea18
movq (%rax), %rax
movq -0x48(%rbp), %rdi
movl %ebx, %esi
callq *0x200(%rax)
jmp 0xae42f
movq %rax, %rcx
leaq 0x3004d3(%rip), %rax # 0x3aea18
movq (%rax), %rax
leaq 0x50e59(%rip), %rdx # 0xff3a8
movq %rcx, -0x40(%rbp)
movq %rcx, %rdi
movq %r13, %rsi
movl $0x225, %ecx # imm = 0x225
callq *0x210(%rax)
movl %ebx, %edi
movq %r15, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0xbff8c
xorl %esi, %esi
testq %rax, %rax
movl $0x0, %ecx
cmoveq %r13, %rcx
cmpq $-0x1, %rax
movq %rax, -0x30(%rbp)
cmovneq %rax, %rsi
testb $0x6, %r12b
cmovneq %rcx, %rsi
leaq 0x30047b(%rip), %rax # 0x3aea18
movq (%rax), %rax
movq -0x40(%rbp), %rdi
callq *0x218(%rax)
jmp 0xae472
movq %rax, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x3060e
jmp 0xae4a3
|
my_read_charset_file:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0F8h
mov r12, rdx
mov r14, rsi
mov rbx, rdi
lea rsi, [rbp+var_120]
mov rdi, r14
call my_stat
test rax, rax
jz loc_AE4E0
mov r13d, [rbp+var_F0]
cmp r13, 100000h
ja loc_AE4E0
lea rax, key_memory_charset_loader
mov edi, [rax]
mov rsi, r13
mov rdx, r12
call my_malloc
test rax, rax
jz loc_AE4E0
mov r15, rax
mov [rbp+var_38], rbx
lea rax, key_file_charset
mov esi, [rax]
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_90]
lea rbx, [rbp+var_48]
mov edx, 2
mov rcx, r14
mov r8, rbx
call qword ptr [rax+148h]
mov [rbx], rax
test rax, rax
jnz loc_AE4F2
mov rdi, r14
xor esi, esi
mov rdx, r12
call my_open
mov ebx, eax
loc_AE42F:
test ebx, ebx
js loc_AE4D8
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_90]
mov esi, ebx
mov edx, 6
call qword ptr [rax+158h]
test rax, rax
jnz loc_AE53B
mov edi, ebx
mov rsi, r15
mov rdx, r13
mov rcx, r12
call my_read
mov [rbp+var_30], rax
loc_AE472:
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_90]
mov esi, ebx
mov edx, 4
call qword ptr [rax+158h]
test rax, rax
jnz loc_AE5AF
mov edi, ebx
mov rsi, r12
call my_close
loc_AE4A3:
cmp [rbp+var_30], r13
jnz short loc_AE4D8
mov rdi, [rbp+var_38]
mov rsi, r15
mov rdx, r13
call my_parse_charset_xml
test al, al
jz short loc_AE4D8
lea rsi, aErrorWhilePars; "Error while parsing '%s': %s\n"
mov edi, 16h
xor edx, edx
mov rcx, r14
mov r8, [rbp+var_38]
xor eax, eax
call my_printf_error
loc_AE4D8:
mov rdi, r15
call my_free
loc_AE4E0:
add rsp, 0F8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_AE4F2:
lea rcx, PSI_server
mov rcx, [rcx]
lea rsi, aWorkspaceLlm4b_24; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, rax
mov edx, 223h
call qword ptr [rcx+1F0h]
mov rdi, r14
xor esi, esi
mov rdx, r12
call my_open
mov ebx, eax
lea rax, PSI_server
mov rax, [rax]
mov rdi, [rbp+var_48]
mov esi, ebx
call qword ptr [rax+200h]
jmp loc_AE42F
loc_AE53B:
mov rcx, rax
lea rax, PSI_server
mov rax, [rax]
lea rdx, aWorkspaceLlm4b_24; "/workspace/llm4binary/github2025/eloqsq"...
mov [rbp+var_40], rcx
mov rdi, rcx
mov rsi, r13
mov ecx, 225h
call qword ptr [rax+210h]
mov edi, ebx
mov rsi, r15
mov rdx, r13
mov rcx, r12
call my_read
xor esi, esi
test rax, rax
mov ecx, 0
cmovz rcx, r13
cmp rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_30], rax
cmovnz rsi, rax
test r12b, 6
cmovnz rsi, rcx
lea rax, PSI_server
mov rax, [rax]
mov rdi, [rbp+var_40]
call qword ptr [rax+218h]
jmp loc_AE472
loc_AE5AF:
mov rdi, rax
mov esi, ebx
mov rdx, r12
call my_read_charset_file_cold_1
jmp loc_AE4A3
|
long long my_read_charset_file(long long a1, long long a2, long long a3)
{
int v4; // r14d
long long result; // rax
long long v6; // r13
long long v7; // r15
long long v8; // rax
long long v9; // rbx
long long v10; // rax
long long v11; // rax
int v12; // r9d
long long v13; // rax
long long v14; // rdx
long long v15; // rsi
long long v16; // rcx
char v17[48]; // [rsp+0h] [rbp-120h] BYREF
unsigned int v18; // [rsp+30h] [rbp-F0h]
_BYTE v19[72]; // [rsp+90h] [rbp-90h] BYREF
long long v20; // [rsp+D8h] [rbp-48h] BYREF
long long v21; // [rsp+E0h] [rbp-40h]
long long v22; // [rsp+E8h] [rbp-38h]
long long v23; // [rsp+F0h] [rbp-30h]
v4 = a2;
result = my_stat(a2, v17, a3);
if ( result )
{
v6 = v18;
if ( v18 <= 0x100000uLL )
{
result = my_malloc(key_memory_charset_loader, v18, a3);
if ( result )
{
v7 = result;
v22 = a1;
v8 = ((long long ( *)(_BYTE *, _QWORD, long long, long long, long long *))PSI_server[41])(
v19,
key_file_charset,
2LL,
a2,
&v20);
v20 = v8;
if ( v8 )
{
((void ( *)(long long, const char *, long long))PSI_server[62])(
v8,
"/workspace/llm4binary/github2025/eloqsql/mysys/charset.c",
547LL);
v9 = (unsigned int)my_open(a2, 0LL, a3);
((void ( *)(long long, long long))PSI_server[64])(v20, v9);
}
else
{
LODWORD(v9) = my_open(a2, 0LL, a3);
}
if ( (int)v9 >= 0 )
{
v10 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v19, (unsigned int)v9, 6LL);
if ( v10 )
{
v21 = v10;
((void ( *)(long long, long long, const char *, long long))PSI_server[66])(
v10,
v6,
"/workspace/llm4binary/github2025/eloqsql/mysys/charset.c",
549LL);
v13 = my_read((unsigned int)v9, v7, v6, a3);
v15 = 0LL;
v16 = 0LL;
if ( !v13 )
v16 = v6;
v23 = v13;
if ( v13 != -1 )
v15 = v13;
if ( (a3 & 6) != 0 )
v15 = v16;
((void ( *)(long long, long long, long long, long long))PSI_server[67])(v21, v15, v14, v16);
}
else
{
v23 = my_read((unsigned int)v9, v7, v6, a3);
}
v11 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v19, (unsigned int)v9, 4LL);
if ( v11 )
my_read_charset_file_cold_1(v11, v9, a3);
else
my_close((unsigned int)v9, a3);
if ( v23 == v6 )
{
if ( (unsigned __int8)my_parse_charset_xml(v22, v7, v6) )
my_printf_error(22, (unsigned int)"Error while parsing '%s': %s\n", 0, v4, v22, v12);
}
}
return my_free(v7);
}
}
}
return result;
}
|
my_read_charset_file:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xf8
MOV R12,RDX
MOV R14,RSI
MOV RBX,RDI
LEA RSI,[RBP + -0x120]
MOV RDI,R14
CALL 0x001bf003
TEST RAX,RAX
JZ 0x001ae4e0
MOV R13D,dword ptr [RBP + -0xf0]
CMP R13,0x100000
JA 0x001ae4e0
LEA RAX,[0xd31014]
MOV EDI,dword ptr [RAX]
MOV RSI,R13
MOV RDX,R12
CALL 0x001bf321
TEST RAX,RAX
JZ 0x001ae4e0
MOV R15,RAX
MOV qword ptr [RBP + -0x38],RBX
LEA RAX,[0xd306b0]
MOV ESI,dword ptr [RAX]
LEA RAX,[0x4aea18]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x90]
LEA RBX,[RBP + -0x48]
MOV EDX,0x2
MOV RCX,R14
MOV R8,RBX
CALL qword ptr [RAX + 0x148]
MOV qword ptr [RBX],RAX
TEST RAX,RAX
JNZ 0x001ae4f2
MOV RDI,R14
XOR ESI,ESI
MOV RDX,R12
CALL 0x001bf950
MOV EBX,EAX
LAB_001ae42f:
TEST EBX,EBX
JS 0x001ae4d8
LEA RAX,[0x4aea18]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x90]
MOV ESI,EBX
MOV EDX,0x6
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x001ae53b
MOV EDI,EBX
MOV RSI,R15
MOV RDX,R13
MOV RCX,R12
CALL 0x001bff8c
MOV qword ptr [RBP + -0x30],RAX
LAB_001ae472:
LEA RAX,[0x4aea18]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x90]
MOV ESI,EBX
MOV EDX,0x4
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x001ae5af
MOV EDI,EBX
MOV RSI,R12
CALL 0x001bfaf5
LAB_001ae4a3:
CMP qword ptr [RBP + -0x30],R13
JNZ 0x001ae4d8
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,R15
MOV RDX,R13
CALL 0x001f0834
TEST AL,AL
JZ 0x001ae4d8
LEA RSI,[0x1ff3e1]
MOV EDI,0x16
XOR EDX,EDX
MOV RCX,R14
MOV R8,qword ptr [RBP + -0x38]
XOR EAX,EAX
CALL 0x001bae95
LAB_001ae4d8:
MOV RDI,R15
CALL 0x001bf54e
LAB_001ae4e0:
ADD RSP,0xf8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001ae4f2:
LEA RCX,[0x4aea18]
MOV RCX,qword ptr [RCX]
LEA RSI,[0x1ff3a8]
MOV RDI,RAX
MOV EDX,0x223
CALL qword ptr [RCX + 0x1f0]
MOV RDI,R14
XOR ESI,ESI
MOV RDX,R12
CALL 0x001bf950
MOV EBX,EAX
LEA RAX,[0x4aea18]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RBP + -0x48]
MOV ESI,EBX
CALL qword ptr [RAX + 0x200]
JMP 0x001ae42f
LAB_001ae53b:
MOV RCX,RAX
LEA RAX,[0x4aea18]
MOV RAX,qword ptr [RAX]
LEA RDX,[0x1ff3a8]
MOV qword ptr [RBP + -0x40],RCX
MOV RDI,RCX
MOV RSI,R13
MOV ECX,0x225
CALL qword ptr [RAX + 0x210]
MOV EDI,EBX
MOV RSI,R15
MOV RDX,R13
MOV RCX,R12
CALL 0x001bff8c
XOR ESI,ESI
TEST RAX,RAX
MOV ECX,0x0
CMOVZ RCX,R13
CMP RAX,-0x1
MOV qword ptr [RBP + -0x30],RAX
CMOVNZ RSI,RAX
TEST R12B,0x6
CMOVNZ RSI,RCX
LEA RAX,[0x4aea18]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RBP + -0x40]
CALL qword ptr [RAX + 0x218]
JMP 0x001ae472
LAB_001ae5af:
MOV RDI,RAX
MOV ESI,EBX
MOV RDX,R12
CALL 0x0013060e
JMP 0x001ae4a3
|
void my_read_charset_file(int8 param_1,int8 param_2,ulong param_3)
{
char cVar1;
int iVar2;
long lVar3;
long lVar4;
ulong uVar5;
ulong uVar6;
ulong uVar7;
int1 local_128 [48];
uint local_f8;
int1 local_98 [72];
long local_50;
long local_48;
int8 local_40;
ulong local_38;
lVar3 = my_stat(param_2,local_128);
if ((lVar3 != 0) && (uVar7 = (ulong)local_f8, uVar7 < 0x100001)) {
lVar3 = my_malloc(key_memory_charset_loader,uVar7,param_3);
if (lVar3 != 0) {
local_40 = param_1;
local_50 = (**(code **)(PSI_server + 0x148))(local_98,key_file_charset,2,param_2,&local_50);
if (local_50 == 0) {
iVar2 = my_open(param_2,0,param_3);
}
else {
(**(code **)(PSI_server + 0x1f0))
(local_50,"/workspace/llm4binary/github2025/eloqsql/mysys/charset.c",0x223);
iVar2 = my_open(param_2,0,param_3);
(**(code **)(PSI_server + 0x200))(local_50,iVar2);
}
if (-1 < iVar2) {
lVar4 = (**(code **)(PSI_server + 0x158))(local_98,iVar2,6);
if (lVar4 == 0) {
local_38 = my_read(iVar2,lVar3,uVar7,param_3);
}
else {
local_48 = lVar4;
(**(code **)(PSI_server + 0x210))
(lVar4,uVar7,"/workspace/llm4binary/github2025/eloqsql/mysys/charset.c",0x225);
local_38 = my_read(iVar2,lVar3,uVar7,param_3);
uVar5 = 0;
if (local_38 == 0) {
uVar5 = uVar7;
}
uVar6 = 0;
if (local_38 != 0xffffffffffffffff) {
uVar6 = local_38;
}
if ((param_3 & 6) != 0) {
uVar6 = uVar5;
}
(**(code **)(PSI_server + 0x218))(local_48,uVar6);
}
lVar4 = (**(code **)(PSI_server + 0x158))(local_98,iVar2,4);
if (lVar4 == 0) {
my_close(iVar2,param_3);
}
else {
my_read_charset_file_cold_1(lVar4,iVar2,param_3);
}
if (local_38 == uVar7) {
cVar1 = my_parse_charset_xml(local_40,lVar3,uVar7);
if (cVar1 != '\0') {
my_printf_error(0x16,"Error while parsing \'%s\': %s\n",0,param_2,local_40);
}
}
}
my_free(lVar3);
}
}
return;
}
|
|
18,434
|
mthd_stmt_fetch_to_bind
|
eloqsql/libmariadb/libmariadb/mariadb_stmt.c
|
int mthd_stmt_fetch_to_bind(MYSQL_STMT *stmt, unsigned char *row)
{
uint i;
size_t truncations= 0;
unsigned char *null_ptr, bit_offset= 4;
row++; /* skip status byte */
null_ptr= row;
row+= (stmt->field_count + 9) / 8;
for (i=0; i < stmt->field_count; i++)
{
/* save row position for fetching values in pieces */
if (*null_ptr & bit_offset)
{
if (stmt->result_callback)
stmt->result_callback(stmt->user_data, i, NULL);
else
{
if (!stmt->bind[i].is_null)
stmt->bind[i].is_null= &stmt->bind[i].is_null_value;
*stmt->bind[i].is_null= 1;
stmt->bind[i].u.row_ptr= NULL;
}
} else
{
stmt->bind[i].u.row_ptr= row;
if (!stmt->bind_result_done ||
stmt->bind[i].flags & MADB_BIND_DUMMY)
{
unsigned long length;
if (stmt->result_callback)
stmt->result_callback(stmt->user_data, i, &row);
else {
if (mysql_ps_fetch_functions[stmt->fields[i].type].pack_len >= 0)
length= mysql_ps_fetch_functions[stmt->fields[i].type].pack_len;
else
length= net_field_length(&row);
row+= length;
if (!stmt->bind[i].length)
stmt->bind[i].length= &stmt->bind[i].length_value;
*stmt->bind[i].length= stmt->bind[i].length_value= length;
}
}
else
{
if (!stmt->bind[i].length)
stmt->bind[i].length= &stmt->bind[i].length_value;
if (!stmt->bind[i].is_null)
stmt->bind[i].is_null= &stmt->bind[i].is_null_value;
*stmt->bind[i].is_null= 0;
mysql_ps_fetch_functions[stmt->fields[i].type].func(&stmt->bind[i], &stmt->fields[i], &row);
if (stmt->mysql->options.report_data_truncation)
truncations+= *stmt->bind[i].error;
}
}
if (!((bit_offset <<=1) & 255)) {
bit_offset= 1; /* To next byte */
null_ptr++;
}
}
return((truncations) ? MYSQL_DATA_TRUNCATED : 0);
}
|
O3
|
c
|
mthd_stmt_fetch_to_bind:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl 0x60(%rdi), %eax
leal 0x9(%rax), %ecx
shrl $0x3, %ecx
addq %rsi, %rcx
incq %rcx
movq %rcx, -0x38(%rbp)
testl %eax, %eax
je 0x1ebd7
movq %rsi, %rbx
incq %rbx
movl $0x4, %r14d
movl $0x50, %r13d
xorl %r15d, %r15d
xorl %r12d, %r12d
movq $0x0, -0x40(%rbp)
movq %rdi, -0x30(%rbp)
movzbl (%rbx), %eax
testl %eax, %r14d
je 0x1ea27
movq 0x388(%rdi), %rax
testq %rax, %rax
je 0x1eb03
movq -0x30(%rbp), %rcx
movq 0x380(%rcx), %rdi
movl %r12d, %esi
xorl %edx, %edx
jmp 0x1eaf8
movq -0x38(%rbp), %rcx
movq 0x78(%rdi), %rax
movq %rcx, -0x30(%rax,%r13)
cmpb $0x0, 0xe8(%rdi)
je 0x1eada
movq 0x78(%rdi), %rax
testb $0x1, 0x8(%rax,%r13)
jne 0x1eada
cmpq $0x0, -0x50(%rax,%r13)
jne 0x1ea66
leaq (%rax,%r13), %rcx
movq %rcx, -0x50(%rax,%r13)
movq 0x78(%rdi), %rax
cmpq $0x0, -0x48(%rax,%r13)
jne 0x1ea7d
addq %r13, %rax
addq $0x17, %rax
movq %rax, -0x5f(%rax)
movq 0x78(%rdi), %rax
movq -0x48(%rax,%r13), %rax
movb $0x0, (%rax)
movq 0x58(%rdi), %rsi
movq 0x78(%rdi), %rax
movl 0x70(%rsi,%r15), %ecx
addq %r15, %rsi
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%r13), %rdi
addq $-0x50, %rdi
leaq -0x38(%rbp), %rdx
leaq 0x2a554(%rip), %rax # 0x49000
callq *(%rax,%rcx,8)
movq -0x30(%rbp), %rdi
movq 0x38(%rdi), %rax
cmpb $0x0, 0x451(%rax)
je 0x1eb94
movq 0x78(%rdi), %rax
movq -0x38(%rax,%r13), %rax
movsbq (%rax), %rax
addq %rax, -0x40(%rbp)
jmp 0x1eb94
movq 0x388(%rdi), %rax
testq %rax, %rax
je 0x1eb35
movq -0x30(%rbp), %rcx
movq 0x380(%rcx), %rdi
movl %r12d, %esi
leaq -0x38(%rbp), %rdx
callq *%rax
movq -0x30(%rbp), %rdi
jmp 0x1eb94
movq 0x78(%rdi), %rax
cmpq $0x0, -0x48(%rax,%r13)
jne 0x1eb1e
addq %r13, %rax
addq $0x17, %rax
movq %rax, -0x5f(%rax)
movq 0x78(%rdi), %rax
movq -0x48(%rax,%r13), %rax
movb $0x1, (%rax)
movq 0x78(%rdi), %rax
movq $0x0, -0x30(%rax,%r13)
jmp 0x1eb94
movq 0x58(%rdi), %rax
movl 0x70(%rax,%r15), %eax
leaq (%rax,%rax,2), %rax
leaq 0x2a4b7(%rip), %rdx # 0x49000
movslq 0x8(%rdx,%rax,8), %rax
testq %rax, %rax
jns 0x1eb64
leaq -0x38(%rbp), %rdi
callq 0x15ac5
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rcx
addq %rax, %rcx
movq %rcx, -0x38(%rbp)
movq 0x78(%rdi), %rcx
cmpq $0x0, -0x50(%rcx,%r13)
jne 0x1eb84
leaq (%rcx,%r13), %rdx
movq %rdx, -0x50(%rcx,%r13)
movq 0x78(%rdi), %rcx
movq %rax, (%rcx,%r13)
movq 0x78(%rdi), %rcx
movq -0x50(%rcx,%r13), %rcx
movq %rax, (%rcx)
movzbl %r14b, %eax
leal (%rax,%rax), %r14d
xorl %ecx, %ecx
testb $0x7f, %al
sete %cl
movl $0x1, %eax
cmovel %eax, %r14d
addq %rcx, %rbx
incq %r12
movl 0x60(%rdi), %eax
addq $0x70, %r13
subq $-0x80, %r15
cmpq %rax, %r12
jb 0x1e9fa
xorl %ecx, %ecx
cmpq $0x0, -0x40(%rbp)
movl $0x65, %eax
cmovel %ecx, %eax
jmp 0x1ebd9
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
mthd_stmt_fetch_to_bind:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov eax, [rdi+60h]
lea ecx, [rax+9]
shr ecx, 3
add rcx, rsi
inc rcx
mov [rbp+var_38], rcx
test eax, eax
jz loc_1EBD7
mov rbx, rsi
inc rbx
mov r14d, 4
mov r13d, 50h ; 'P'
xor r15d, r15d
xor r12d, r12d
mov [rbp+var_40], 0
mov [rbp+var_30], rdi
loc_1E9FA:
movzx eax, byte ptr [rbx]
test r14d, eax
jz short loc_1EA27
mov rax, [rdi+388h]
test rax, rax
jz loc_1EB03
mov rcx, [rbp+var_30]
mov rdi, [rcx+380h]
mov esi, r12d
xor edx, edx
jmp loc_1EAF8
loc_1EA27:
mov rcx, [rbp+var_38]
mov rax, [rdi+78h]
mov [rax+r13-30h], rcx
cmp byte ptr [rdi+0E8h], 0
jz loc_1EADA
mov rax, [rdi+78h]
test byte ptr [rax+r13+8], 1
jnz loc_1EADA
cmp qword ptr [rax+r13-50h], 0
jnz short loc_1EA66
lea rcx, [rax+r13]
mov [rax+r13-50h], rcx
mov rax, [rdi+78h]
loc_1EA66:
cmp qword ptr [rax+r13-48h], 0
jnz short loc_1EA7D
add rax, r13
add rax, 17h
mov [rax-5Fh], rax
mov rax, [rdi+78h]
loc_1EA7D:
mov rax, [rax+r13-48h]
mov byte ptr [rax], 0
mov rsi, [rdi+58h]
mov rax, [rdi+78h]
mov ecx, [rsi+r15+70h]
add rsi, r15
lea rcx, [rcx+rcx*2]
lea rdi, [rax+r13]
add rdi, 0FFFFFFFFFFFFFFB0h
lea rdx, [rbp+var_38]
lea rax, mysql_ps_fetch_functions
call qword ptr [rax+rcx*8]
mov rdi, [rbp+var_30]
mov rax, [rdi+38h]
cmp byte ptr [rax+451h], 0
jz loc_1EB94
mov rax, [rdi+78h]
mov rax, [rax+r13-38h]
movsx rax, byte ptr [rax]
add [rbp+var_40], rax
jmp loc_1EB94
loc_1EADA:
mov rax, [rdi+388h]
test rax, rax
jz short loc_1EB35
mov rcx, [rbp+var_30]
mov rdi, [rcx+380h]
mov esi, r12d
lea rdx, [rbp+var_38]
loc_1EAF8:
call rax
mov rdi, [rbp+var_30]
jmp loc_1EB94
loc_1EB03:
mov rax, [rdi+78h]
cmp qword ptr [rax+r13-48h], 0
jnz short loc_1EB1E
add rax, r13
add rax, 17h
mov [rax-5Fh], rax
mov rax, [rdi+78h]
loc_1EB1E:
mov rax, [rax+r13-48h]
mov byte ptr [rax], 1
mov rax, [rdi+78h]
mov qword ptr [rax+r13-30h], 0
jmp short loc_1EB94
loc_1EB35:
mov rax, [rdi+58h]
mov eax, [rax+r15+70h]
lea rax, [rax+rax*2]
lea rdx, mysql_ps_fetch_functions
movsxd rax, dword ptr [rdx+rax*8+8]
test rax, rax
jns short loc_1EB64
lea rdi, [rbp+var_38]
call net_field_length
mov rdi, [rbp+var_30]
mov rcx, [rbp+var_38]
loc_1EB64:
add rcx, rax
mov [rbp+var_38], rcx
mov rcx, [rdi+78h]
cmp qword ptr [rcx+r13-50h], 0
jnz short loc_1EB84
lea rdx, [rcx+r13]
mov [rcx+r13-50h], rdx
mov rcx, [rdi+78h]
loc_1EB84:
mov [rcx+r13], rax
mov rcx, [rdi+78h]
mov rcx, [rcx+r13-50h]
mov [rcx], rax
loc_1EB94:
movzx eax, r14b
lea r14d, [rax+rax]
xor ecx, ecx
test al, 7Fh
setz cl
mov eax, 1
cmovz r14d, eax
add rbx, rcx
inc r12
mov eax, [rdi+60h]
add r13, 70h ; 'p'
sub r15, 0FFFFFFFFFFFFFF80h
cmp r12, rax
jb loc_1E9FA
xor ecx, ecx
cmp [rbp+var_40], 0
mov eax, 65h ; 'e'
cmovz eax, ecx
jmp short loc_1EBD9
loc_1EBD7:
xor eax, eax
loc_1EBD9:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long mthd_stmt_fetch_to_bind(_QWORD *a1, long long a2)
{
int v2; // eax
_BYTE *v3; // rbx
char v4; // r14
long long v5; // r13
long long v6; // r15
unsigned long long v7; // r12
void ( *v8)(long long, long long, unsigned __int8 **); // rax
long long v9; // rdi
long long v10; // rsi
unsigned __int8 **v11; // rdx
unsigned __int8 *v12; // rcx
long long v13; // rax
long long v14; // rax
signed long long v15; // rax
long long v16; // rcx
char v17; // al
long long result; // rax
long long v19; // [rsp+0h] [rbp-40h]
unsigned __int8 *v20; // [rsp+8h] [rbp-38h] BYREF
_QWORD *v21; // [rsp+10h] [rbp-30h]
v2 = *((_DWORD *)a1 + 24);
v20 = (unsigned __int8 *)(a2 + ((unsigned int)(v2 + 9) >> 3) + 1);
if ( !v2 )
return 0LL;
v3 = (_BYTE *)(a2 + 1);
v4 = 4;
v5 = 80LL;
v6 = 0LL;
v7 = 0LL;
v19 = 0LL;
v21 = a1;
do
{
if ( (*v3 & (unsigned __int8)v4) != 0 )
{
v8 = (void ( *)(long long, long long, unsigned __int8 **))a1[113];
if ( v8 )
{
v9 = v21[112];
v10 = (unsigned int)v7;
v11 = 0LL;
LABEL_16:
v8(v9, v10, v11);
a1 = v21;
goto LABEL_25;
}
v14 = a1[15];
if ( !*(_QWORD *)(v14 + v5 - 72) )
{
*(_QWORD *)(v5 + v14 - 72) = v5 + v14 + 23;
v14 = a1[15];
}
**(_BYTE **)(v14 + v5 - 72) = 1;
*(_QWORD *)(a1[15] + v5 - 48) = 0LL;
}
else
{
v12 = v20;
*(_QWORD *)(a1[15] + v5 - 48) = v20;
if ( !*((_BYTE *)a1 + 232) || (v13 = a1[15], (*(_BYTE *)(v13 + v5 + 8) & 1) != 0) )
{
v8 = (void ( *)(long long, long long, unsigned __int8 **))a1[113];
if ( v8 )
{
v9 = v21[112];
v10 = (unsigned int)v7;
v11 = &v20;
goto LABEL_16;
}
v15 = *((int *)&mysql_ps_fetch_functions + 6 * *(unsigned int *)(a1[11] + v6 + 112) + 2);
if ( v15 < 0 )
{
v15 = net_field_length(&v20);
a1 = v21;
v12 = v20;
}
v20 = &v12[v15];
v16 = a1[15];
if ( !*(_QWORD *)(v16 + v5 - 80) )
{
*(_QWORD *)(v16 + v5 - 80) = v16 + v5;
v16 = a1[15];
}
*(_QWORD *)(v16 + v5) = v15;
**(_QWORD **)(a1[15] + v5 - 80) = v15;
}
else
{
if ( !*(_QWORD *)(v13 + v5 - 80) )
{
*(_QWORD *)(v13 + v5 - 80) = v13 + v5;
v13 = a1[15];
}
if ( !*(_QWORD *)(v13 + v5 - 72) )
{
*(_QWORD *)(v5 + v13 - 72) = v5 + v13 + 23;
v13 = a1[15];
}
**(_BYTE **)(v13 + v5 - 72) = 0;
(*((void ( **)(long long, long long, unsigned __int8 **))&mysql_ps_fetch_functions
+ 3 * *(unsigned int *)(a1[11] + v6 + 112)))(
a1[15] + v5 - 80,
v6 + a1[11],
&v20);
a1 = v21;
if ( *(_BYTE *)(v21[7] + 1105LL) )
v19 += **(char **)(v21[15] + v5 - 56);
}
}
LABEL_25:
v17 = v4;
v4 *= 2;
if ( (v17 & 0x7F) == 0 )
v4 = 1;
v3 += (v17 & 0x7F) == 0;
++v7;
v5 += 112LL;
v6 += 128LL;
}
while ( v7 < *((unsigned int *)a1 + 24) );
result = 101LL;
if ( !v19 )
return 0LL;
return result;
}
|
mthd_stmt_fetch_to_bind:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV EAX,dword ptr [RDI + 0x60]
LEA ECX,[RAX + 0x9]
SHR ECX,0x3
ADD RCX,RSI
INC RCX
MOV qword ptr [RBP + -0x38],RCX
TEST EAX,EAX
JZ 0x0011ebd7
MOV RBX,RSI
INC RBX
MOV R14D,0x4
MOV R13D,0x50
XOR R15D,R15D
XOR R12D,R12D
MOV qword ptr [RBP + -0x40],0x0
MOV qword ptr [RBP + -0x30],RDI
LAB_0011e9fa:
MOVZX EAX,byte ptr [RBX]
TEST R14D,EAX
JZ 0x0011ea27
MOV RAX,qword ptr [RDI + 0x388]
TEST RAX,RAX
JZ 0x0011eb03
MOV RCX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RCX + 0x380]
MOV ESI,R12D
XOR EDX,EDX
JMP 0x0011eaf8
LAB_0011ea27:
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RDI + 0x78]
MOV qword ptr [RAX + R13*0x1 + -0x30],RCX
CMP byte ptr [RDI + 0xe8],0x0
JZ 0x0011eada
MOV RAX,qword ptr [RDI + 0x78]
TEST byte ptr [RAX + R13*0x1 + 0x8],0x1
JNZ 0x0011eada
CMP qword ptr [RAX + R13*0x1 + -0x50],0x0
JNZ 0x0011ea66
LEA RCX,[RAX + R13*0x1]
MOV qword ptr [RAX + R13*0x1 + -0x50],RCX
MOV RAX,qword ptr [RDI + 0x78]
LAB_0011ea66:
CMP qword ptr [RAX + R13*0x1 + -0x48],0x0
JNZ 0x0011ea7d
ADD RAX,R13
ADD RAX,0x17
MOV qword ptr [RAX + -0x5f],RAX
MOV RAX,qword ptr [RDI + 0x78]
LAB_0011ea7d:
MOV RAX,qword ptr [RAX + R13*0x1 + -0x48]
MOV byte ptr [RAX],0x0
MOV RSI,qword ptr [RDI + 0x58]
MOV RAX,qword ptr [RDI + 0x78]
MOV ECX,dword ptr [RSI + R15*0x1 + 0x70]
ADD RSI,R15
LEA RCX,[RCX + RCX*0x2]
LEA RDI,[RAX + R13*0x1]
ADD RDI,-0x50
LEA RDX,[RBP + -0x38]
LEA RAX,[0x149000]
CALL qword ptr [RAX + RCX*0x8]
MOV RDI,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RDI + 0x38]
CMP byte ptr [RAX + 0x451],0x0
JZ 0x0011eb94
MOV RAX,qword ptr [RDI + 0x78]
MOV RAX,qword ptr [RAX + R13*0x1 + -0x38]
MOVSX RAX,byte ptr [RAX]
ADD qword ptr [RBP + -0x40],RAX
JMP 0x0011eb94
LAB_0011eada:
MOV RAX,qword ptr [RDI + 0x388]
TEST RAX,RAX
JZ 0x0011eb35
MOV RCX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RCX + 0x380]
MOV ESI,R12D
LEA RDX,[RBP + -0x38]
LAB_0011eaf8:
CALL RAX
MOV RDI,qword ptr [RBP + -0x30]
JMP 0x0011eb94
LAB_0011eb03:
MOV RAX,qword ptr [RDI + 0x78]
CMP qword ptr [RAX + R13*0x1 + -0x48],0x0
JNZ 0x0011eb1e
ADD RAX,R13
ADD RAX,0x17
MOV qword ptr [RAX + -0x5f],RAX
MOV RAX,qword ptr [RDI + 0x78]
LAB_0011eb1e:
MOV RAX,qword ptr [RAX + R13*0x1 + -0x48]
MOV byte ptr [RAX],0x1
MOV RAX,qword ptr [RDI + 0x78]
MOV qword ptr [RAX + R13*0x1 + -0x30],0x0
JMP 0x0011eb94
LAB_0011eb35:
MOV RAX,qword ptr [RDI + 0x58]
MOV EAX,dword ptr [RAX + R15*0x1 + 0x70]
LEA RAX,[RAX + RAX*0x2]
LEA RDX,[0x149000]
MOVSXD RAX,dword ptr [RDX + RAX*0x8 + 0x8]
TEST RAX,RAX
JNS 0x0011eb64
LEA RDI,[RBP + -0x38]
CALL 0x00115ac5
MOV RDI,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x38]
LAB_0011eb64:
ADD RCX,RAX
MOV qword ptr [RBP + -0x38],RCX
MOV RCX,qword ptr [RDI + 0x78]
CMP qword ptr [RCX + R13*0x1 + -0x50],0x0
JNZ 0x0011eb84
LEA RDX,[RCX + R13*0x1]
MOV qword ptr [RCX + R13*0x1 + -0x50],RDX
MOV RCX,qword ptr [RDI + 0x78]
LAB_0011eb84:
MOV qword ptr [RCX + R13*0x1],RAX
MOV RCX,qword ptr [RDI + 0x78]
MOV RCX,qword ptr [RCX + R13*0x1 + -0x50]
MOV qword ptr [RCX],RAX
LAB_0011eb94:
MOVZX EAX,R14B
LEA R14D,[RAX + RAX*0x1]
XOR ECX,ECX
TEST AL,0x7f
SETZ CL
MOV EAX,0x1
CMOVZ R14D,EAX
ADD RBX,RCX
INC R12
MOV EAX,dword ptr [RDI + 0x60]
ADD R13,0x70
SUB R15,-0x80
CMP R12,RAX
JC 0x0011e9fa
XOR ECX,ECX
CMP qword ptr [RBP + -0x40],0x0
MOV EAX,0x65
CMOVZ EAX,ECX
JMP 0x0011ebd9
LAB_0011ebd7:
XOR EAX,EAX
LAB_0011ebd9:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 mthd_stmt_fetch_to_bind(long param_1,long param_2)
{
code *pcVar1;
long lVar2;
int8 uVar3;
long lVar4;
long *plVar5;
byte *pbVar6;
ulong uVar7;
long lVar8;
byte bVar9;
long lVar10;
bool bVar11;
long local_48;
long local_40;
long local_38;
local_40 = (ulong)(*(int *)(param_1 + 0x60) + 9U >> 3) + param_2 + 1;
if (*(int *)(param_1 + 0x60) == 0) {
uVar3 = 0;
}
else {
pbVar6 = (byte *)(param_2 + 1);
bVar9 = 4;
lVar8 = 0x50;
lVar10 = 0;
uVar7 = 0;
local_48 = 0;
local_38 = param_1;
do {
if ((bVar9 & *pbVar6) == 0) {
*(long *)(*(long *)(param_1 + 0x78) + -0x30 + lVar8) = local_40;
if ((*(char *)(param_1 + 0xe8) == '\0') ||
(lVar2 = *(long *)(param_1 + 0x78), (*(byte *)(lVar2 + 8 + lVar8) & 1) != 0)) {
pcVar1 = *(code **)(param_1 + 0x388);
if (pcVar1 != (code *)0x0) {
uVar3 = *(int8 *)(local_38 + 0x380);
plVar5 = &local_40;
goto LAB_0011eaf8;
}
lVar2 = (long)(int)(&DAT_00149008)
[(ulong)*(uint *)(*(long *)(param_1 + 0x58) + 0x70 + lVar10) * 6];
if (lVar2 < 0) {
lVar2 = net_field_length(&local_40);
param_1 = local_38;
}
local_40 = local_40 + lVar2;
lVar4 = *(long *)(param_1 + 0x78);
if (*(long *)(lVar4 + -0x50 + lVar8) == 0) {
*(long *)(lVar4 + -0x50 + lVar8) = lVar4 + lVar8;
lVar4 = *(long *)(param_1 + 0x78);
}
*(long *)(lVar4 + lVar8) = lVar2;
**(long **)(*(long *)(param_1 + 0x78) + -0x50 + lVar8) = lVar2;
}
else {
if (*(long *)(lVar2 + -0x50 + lVar8) == 0) {
*(long *)(lVar2 + -0x50 + lVar8) = lVar2 + lVar8;
lVar2 = *(long *)(param_1 + 0x78);
}
if (*(long *)(lVar2 + -0x48 + lVar8) == 0) {
*(long *)(lVar2 + lVar8 + -0x48) = lVar2 + lVar8 + 0x17;
lVar2 = *(long *)(param_1 + 0x78);
}
**(int1 **)(lVar2 + -0x48 + lVar8) = 0;
(*(code *)(&mysql_ps_fetch_functions)
[(ulong)*(uint *)(*(long *)(param_1 + 0x58) + 0x70 + lVar10) * 3])
(*(long *)(param_1 + 0x78) + lVar8 + -0x50,*(long *)(param_1 + 0x58) + lVar10,
&local_40);
param_1 = local_38;
if (*(char *)(*(long *)(local_38 + 0x38) + 0x451) != '\0') {
local_48 = local_48 + **(char **)(*(long *)(local_38 + 0x78) + -0x38 + lVar8);
}
}
}
else {
pcVar1 = *(code **)(param_1 + 0x388);
if (pcVar1 == (code *)0x0) {
lVar2 = *(long *)(param_1 + 0x78);
if (*(long *)(lVar2 + -0x48 + lVar8) == 0) {
*(long *)(lVar2 + lVar8 + -0x48) = lVar2 + lVar8 + 0x17;
lVar2 = *(long *)(param_1 + 0x78);
}
**(int1 **)(lVar2 + -0x48 + lVar8) = 1;
*(int8 *)(*(long *)(param_1 + 0x78) + -0x30 + lVar8) = 0;
}
else {
uVar3 = *(int8 *)(local_38 + 0x380);
plVar5 = (long *)0x0;
LAB_0011eaf8:
(*pcVar1)(uVar3,uVar7 & 0xffffffff,plVar5);
param_1 = local_38;
}
}
bVar11 = (bVar9 & 0x7f) == 0;
bVar9 = bVar9 * '\x02';
if (bVar11) {
bVar9 = 1;
}
pbVar6 = pbVar6 + bVar11;
uVar7 = uVar7 + 1;
lVar8 = lVar8 + 0x70;
lVar10 = lVar10 + 0x80;
} while (uVar7 < *(uint *)(param_1 + 0x60));
uVar3 = 0x65;
if (local_48 == 0) {
uVar3 = 0;
}
}
return uVar3;
}
|
|
18,435
|
keys_free
|
eloqsql/storage/maria/ma_write.c
|
static int keys_free(void* key_arg, TREE_FREE mode, void *param_arg)
{
/*
Probably I can use info->lastkey here, but I'm not sure,
and to be safe I'd better use local lastkey.
*/
bulk_insert_param *param= (bulk_insert_param*)param_arg;
MARIA_SHARE *share= param->info->s;
uchar lastkey[MARIA_MAX_KEY_BUFF], *key= (uchar*)key_arg;
uint keylen;
MARIA_KEYDEF *keyinfo= share->keyinfo + param->keynr;
MARIA_KEY tmp_key;
switch (mode) {
case free_init:
if (share->lock_key_trees)
{
mysql_rwlock_wrlock(&keyinfo->root_lock);
keyinfo->version++;
}
return 0;
case free_free:
/* Note: keylen doesn't contain transid lengths */
keylen= _ma_keylength(keyinfo, key);
tmp_key.data= lastkey;
tmp_key.keyinfo= keyinfo;
tmp_key.data_length= keylen - share->rec_reflength;
tmp_key.ref_length= param->info->bulk_insert_ref_length;
tmp_key.flag= (param->info->bulk_insert_ref_length ==
share->rec_reflength ? 0 : SEARCH_USER_KEY_HAS_TRANSID);
/*
We have to copy key as ma_ck_write_btree may need the buffer for
copying middle key up if tree is growing
*/
memcpy(lastkey, key, tmp_key.data_length + tmp_key.ref_length);
_ma_ck_write_btree(param->info, &tmp_key);
return 0;
case free_end:
if (share->lock_key_trees)
mysql_rwlock_unlock(&keyinfo->root_lock);
return 0;
}
return 0;
}
|
O3
|
c
|
keys_free:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa08, %rsp # imm = 0xA08
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq (%rdx), %rax
movq (%rax), %r13
movl 0x8(%rdx), %eax
imulq $0x118, %rax, %rbx # imm = 0x118
addq 0x570(%r13), %rbx
cmpl $0x2, %esi
je 0x58bb6
cmpl $0x1, %esi
je 0x58b46
testl %esi, %esi
jne 0x58bd8
cmpb $0x0, 0x7e3(%r13)
je 0x58bd8
leaq 0x8(%rbx), %rdi
cmpq $0x0, 0x98(%rbx)
jne 0x58c0d
callq 0xa8d21
incl 0xb8(%rbx)
jmp 0x58bd8
movq %rdx, %r15
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6f7b4
leaq -0xa10(%rbp), %rdi
leaq -0xa30(%rbp), %r12
movq %rdi, (%r12)
movq %rbx, 0x8(%r12)
movl 0x740(%r13), %ecx
subl %ecx, %eax
movl %eax, 0x10(%r12)
movq (%r15), %rbx
movl 0x640(%rbx), %edx
xorl %esi, %esi
cmpl %ecx, %edx
setne %sil
movl %edx, 0x14(%r12)
shll $0x13, %esi
movl %esi, 0x18(%r12)
addl %eax, %edx
movl $0x9d3, %ecx # imm = 0x9D3
movq %r14, %rsi
callq 0x2a400
movq %rbx, %rdi
movq %r12, %rsi
callq 0x56626
jmp 0x58bd8
cmpb $0x0, 0x7e3(%r13)
je 0x58bd8
movq 0x98(%rbx), %rdi
addq $0x8, %rbx
testq %rdi, %rdi
jne 0x58bfb
movq %rbx, %rdi
callq 0xa8dc2
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x58c23
xorl %eax, %eax
addq $0xa08, %rsp # imm = 0xA08
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3337c6(%rip), %rax # 0x38c3c8
movq (%rax), %rax
callq *0x168(%rax)
jmp 0x58bd0
leaq 0x85616(%rip), %rsi # 0xde22a
movl $0x6af, %edx # imm = 0x6AF
callq 0x308b1
jmp 0x58b3b
callq 0x2a240
|
keys_free:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0A08h
mov rax, fs:28h
mov [rbp+var_30], rax
mov rax, [rdx]
mov r13, [rax]
mov eax, [rdx+8]
imul rbx, rax, 118h
add rbx, [r13+570h]
cmp esi, 2
jz loc_58BB6
cmp esi, 1
jz short loc_58B46
test esi, esi
jnz loc_58BD8
cmp byte ptr [r13+7E3h], 0
jz loc_58BD8
lea rdi, [rbx+8]
cmp qword ptr [rbx+98h], 0
jnz loc_58C0D
call my_rw_wrlock
loc_58B3B:
inc dword ptr [rbx+0B8h]
jmp loc_58BD8
loc_58B46:
mov r15, rdx
mov r14, rdi
mov rdi, rbx
mov rsi, r14
call _ma_keylength
lea rdi, [rbp+var_A10]
lea r12, [rbp+var_A30]
mov [r12], rdi
mov [r12+8], rbx
mov ecx, [r13+740h]
sub eax, ecx
mov [r12+10h], eax
mov rbx, [r15]
mov edx, [rbx+640h]
xor esi, esi
cmp edx, ecx
setnz sil
mov [r12+14h], edx
shl esi, 13h
mov [r12+18h], esi
add edx, eax
mov ecx, 9D3h
mov rsi, r14
call ___memcpy_chk
mov rdi, rbx
mov rsi, r12
call _ma_ck_write_btree
jmp short loc_58BD8
loc_58BB6:
cmp byte ptr [r13+7E3h], 0
jz short loc_58BD8
mov rdi, [rbx+98h]
add rbx, 8
test rdi, rdi
jnz short loc_58BFB
loc_58BD0:
mov rdi, rbx
call my_rw_unlock
loc_58BD8:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_58C23
xor eax, eax
add rsp, 0A08h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_58BFB:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+168h]
jmp short loc_58BD0
loc_58C0D:
lea rsi, aWorkspaceLlm4b_32; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 6AFh
call psi_rwlock_wrlock
jmp loc_58B3B
loc_58C23:
call ___stack_chk_fail
|
long long keys_free(long long a1, int a2, unsigned int *a3)
{
long long v3; // r13
long long v4; // rax
long long v5; // rbx
long long v6; // rdi
int v8; // eax
int v9; // ecx
long long *v10; // rbx
long long v11; // rdi
long long v12; // rbx
__int128 v14; // [rsp+0h] [rbp-A30h] BYREF
int v15; // [rsp+10h] [rbp-A20h]
int v16; // [rsp+14h] [rbp-A1Ch]
int v17; // [rsp+18h] [rbp-A18h]
_BYTE v18[2528]; // [rsp+20h] [rbp-A10h] BYREF
unsigned long long v19; // [rsp+A00h] [rbp-30h]
v19 = __readfsqword(0x28u);
v3 = **(_QWORD **)a3;
v4 = a3[2];
v5 = *(_QWORD *)(v3 + 1392) + 280 * v4;
if ( a2 == 2 )
{
if ( *(_BYTE *)(v3 + 2019) )
{
v11 = *(_QWORD *)(v5 + 152);
v12 = v5 + 8;
if ( v11 )
PSI_server[45]();
my_rw_unlock(v12);
}
}
else if ( a2 == 1 )
{
v8 = ma_keylength(*(_QWORD *)(v3 + 1392) + 280 * v4, a1);
*(_QWORD *)&v14 = v18;
*((_QWORD *)&v14 + 1) = v5;
v9 = *(_DWORD *)(v3 + 1856);
v15 = v8 - v9;
v10 = *(long long **)a3;
v16 = *(_DWORD *)(*(_QWORD *)a3 + 1600LL);
v17 = (v16 != v9) << 19;
__memcpy_chk(v18, a1, (unsigned int)(v8 - v9 + v16), 2515LL);
ma_ck_write_btree((long long)v10, &v14);
}
else if ( !a2 && *(_BYTE *)(v3 + 2019) )
{
v6 = v5 + 8;
if ( *(_QWORD *)(v5 + 152) )
psi_rwlock_wrlock(v6, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_write.c", 0x6AFu);
else
my_rw_wrlock(v6);
++*(_DWORD *)(v5 + 184);
}
return 0LL;
}
|
keys_free:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xa08
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RDX]
MOV R13,qword ptr [RAX]
MOV EAX,dword ptr [RDX + 0x8]
IMUL RBX,RAX,0x118
ADD RBX,qword ptr [R13 + 0x570]
CMP ESI,0x2
JZ 0x00158bb6
CMP ESI,0x1
JZ 0x00158b46
TEST ESI,ESI
JNZ 0x00158bd8
CMP byte ptr [R13 + 0x7e3],0x0
JZ 0x00158bd8
LEA RDI,[RBX + 0x8]
CMP qword ptr [RBX + 0x98],0x0
JNZ 0x00158c0d
CALL 0x001a8d21
LAB_00158b3b:
INC dword ptr [RBX + 0xb8]
JMP 0x00158bd8
LAB_00158b46:
MOV R15,RDX
MOV R14,RDI
MOV RDI,RBX
MOV RSI,R14
CALL 0x0016f7b4
LEA RDI,[RBP + -0xa10]
LEA R12,[RBP + -0xa30]
MOV qword ptr [R12],RDI
MOV qword ptr [R12 + 0x8],RBX
MOV ECX,dword ptr [R13 + 0x740]
SUB EAX,ECX
MOV dword ptr [R12 + 0x10],EAX
MOV RBX,qword ptr [R15]
MOV EDX,dword ptr [RBX + 0x640]
XOR ESI,ESI
CMP EDX,ECX
SETNZ SIL
MOV dword ptr [R12 + 0x14],EDX
SHL ESI,0x13
MOV dword ptr [R12 + 0x18],ESI
ADD EDX,EAX
MOV ECX,0x9d3
MOV RSI,R14
CALL 0x0012a400
MOV RDI,RBX
MOV RSI,R12
CALL 0x00156626
JMP 0x00158bd8
LAB_00158bb6:
CMP byte ptr [R13 + 0x7e3],0x0
JZ 0x00158bd8
MOV RDI,qword ptr [RBX + 0x98]
ADD RBX,0x8
TEST RDI,RDI
JNZ 0x00158bfb
LAB_00158bd0:
MOV RDI,RBX
CALL 0x001a8dc2
LAB_00158bd8:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00158c23
XOR EAX,EAX
ADD RSP,0xa08
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00158bfb:
LEA RAX,[0x48c3c8]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x168]
JMP 0x00158bd0
LAB_00158c0d:
LEA RSI,[0x1de22a]
MOV EDX,0x6af
CALL 0x001308b1
JMP 0x00158b3b
LAB_00158c23:
CALL 0x0012a240
|
int8 keys_free(int8 param_1,int param_2,long *param_3)
{
long lVar1;
long lVar2;
long lVar3;
long in_FS_OFFSET;
int1 *local_a38;
long local_a30;
int local_a28;
int local_a24;
int local_a20;
int1 local_a18 [2528];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
lVar1 = *(long *)*param_3;
lVar3 = (ulong)*(uint *)(param_3 + 1) * 0x118 + *(long *)(lVar1 + 0x570);
if (param_2 == 2) {
if (*(char *)(lVar1 + 0x7e3) != '\0') {
if (*(long *)(lVar3 + 0x98) != 0) {
(**(code **)(PSI_server + 0x168))();
}
my_rw_unlock(lVar3 + 8);
}
}
else if (param_2 == 1) {
local_a28 = _ma_keylength(lVar3,param_1);
local_a38 = local_a18;
local_a28 = local_a28 - *(int *)(lVar1 + 0x740);
lVar2 = *param_3;
local_a24 = *(int *)(lVar2 + 0x640);
local_a20 = (uint)(local_a24 != *(int *)(lVar1 + 0x740)) << 0x13;
local_a30 = lVar3;
__memcpy_chk(local_a38,param_1,local_a24 + local_a28,0x9d3);
_ma_ck_write_btree(lVar2,&local_a38);
}
else if ((param_2 == 0) && (*(char *)(lVar1 + 0x7e3) != '\0')) {
if (*(long *)(lVar3 + 0x98) == 0) {
my_rw_wrlock();
}
else {
psi_rwlock_wrlock(lVar3 + 8,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_write.c",0x6af);
}
*(int *)(lVar3 + 0xb8) = *(int *)(lVar3 + 0xb8) + 1;
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return 0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
18,436
|
aimrt::logger::LoggerRef::GetLogLevel() const
|
aimrt_mujoco_sim/_deps/aimrt-src/src/interface/aimrt_core_plugin_interface/../aimrt_module_cpp_interface/logger/logger.h
|
uint32_t GetLogLevel() const {
AIMRT_ASSERT(base_ptr_, "Reference is null.");
return static_cast<uint32_t>(base_ptr_->get_log_level(base_ptr_->impl));
}
|
O3
|
c
|
aimrt::logger::LoggerRef::GetLogLevel() const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0x23b8e
movq 0x10(%rax), %rdi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmpq *(%rax)
movl $0x28, %edi
callq 0x1e7e0
movq %rax, %rbx
leaq 0x5fc67(%rip), %rsi # 0x83809
movq %rsp, %rdi
leaq 0x20(%rsp), %r8
movl $0x12, %edx
xorl %ecx, %ecx
callq 0x25059
leaq 0x8a893(%rip), %rax # 0xae450
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x18, %rax
movq %rax, 0x8(%rbx)
leaq 0x10(%rsp), %r15
movq -0x10(%r15), %rcx
cmpq %r15, %rcx
jne 0x23be2
movups (%r15), %xmm0
movups %xmm0, (%rax)
jmp 0x23bef
movq %rcx, 0x8(%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rbx)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rbx)
movq %r15, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
leaq 0x8a76f(%rip), %rsi # 0xae380
leaq 0x11c(%rip), %rdx # 0x23d34
movq %rbx, %rdi
callq 0x1fec0
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x23c46
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1f250
jmp 0x23c46
movq %rax, %r14
movq %rbx, %rdi
callq 0x1ebc0
movq %r14, %rdi
callq 0x1ffd0
|
_ZNK5aimrt6logger9LoggerRef11GetLogLevelEv:
push r15
push r14
push rbx
sub rsp, 30h
mov rax, [rdi]
test rax, rax
jz short loc_23B8E
mov rdi, [rax+10h]
add rsp, 30h
pop rbx
pop r14
pop r15
jmp qword ptr [rax]
loc_23B8E:
mov edi, 28h ; '('; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aReferenceIsNul; "Reference is null."
mov rdi, rsp; int
lea r8, [rsp+48h+var_28]; int
mov edx, 12h; int
xor ecx, ecx; int
call _ZN3fmt3v107vformatB5cxx11ENS0_17basic_string_viewIcEENS0_17basic_format_argsINS0_20basic_format_contextINS0_8appenderEcEEEE; fmt::v10::vformat(fmt::v10::basic_string_view<char>,fmt::v10::basic_format_args<fmt::v10::basic_format_context<fmt::v10::appender,char>>)
lea rax, off_AE450
mov [rbx], rax
mov rax, rbx
add rax, 18h
mov [rbx+8], rax
lea r15, [rsp+48h+var_38]
mov rcx, [r15-10h]
cmp rcx, r15
jnz short loc_23BE2
movups xmm0, xmmword ptr [r15]
movups xmmword ptr [rax], xmm0
jmp short loc_23BEF
loc_23BE2:
mov [rbx+8], rcx
mov rax, [rsp+48h+var_38]
mov [rbx+18h], rax
loc_23BEF:
mov rax, [rsp+48h+var_40]
mov [rbx+10h], rax
mov [rsp+48h+var_48], r15
mov [rsp+48h+var_40], 0
mov byte ptr [rsp+48h+var_38], 0
lea rsi, _ZTIN5aimrt6common4util14AimRTExceptionE; lptinfo
lea rdx, _ZN5aimrt6common4util14AimRTExceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rdi, [rsp+48h+var_48]; void *
cmp rdi, r15
jz short loc_23C46
mov rsi, [rsp+48h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_23C46
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
loc_23C46:
mov rdi, r14
call __Unwind_Resume
|
long long aimrt::logger::LoggerRef::GetLogLevel(aimrt::logger::LoggerRef *this)
{
char *exception; // rbx
int v3; // r9d
void *v4; // [rsp+0h] [rbp-48h] BYREF
long long v5; // [rsp+8h] [rbp-40h]
__int128 v6; // [rsp+10h] [rbp-38h] BYREF
int v7; // [rsp+20h] [rbp-28h] BYREF
if ( !*(_QWORD *)this )
{
exception = (char *)__cxa_allocate_exception(0x28uLL);
fmt::v10::vformat[abi:cxx11]((int)&v4, (int)"Reference is null.", 18, 0, (int)&v7, v3, v4, v5, v6);
*(_QWORD *)exception = off_AE450;
*((_QWORD *)exception + 1) = exception + 24;
if ( v4 == &v6 )
{
*(_OWORD *)(exception + 24) = v6;
}
else
{
*((_QWORD *)exception + 1) = v4;
*((_QWORD *)exception + 3) = v6;
}
*((_QWORD *)exception + 2) = v5;
v4 = &v6;
v5 = 0LL;
LOBYTE(v6) = 0;
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'aimrt::common::util::AimRTException,
aimrt::common::util::AimRTException::~AimRTException);
}
return (**(long long ( ***)(_QWORD))this)(*(_QWORD *)(*(_QWORD *)this + 16LL));
}
|
GetLogLevel:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x00123b8e
MOV RDI,qword ptr [RAX + 0x10]
ADD RSP,0x30
POP RBX
POP R14
POP R15
JMP qword ptr [RAX]
LAB_00123b8e:
MOV EDI,0x28
CALL 0x0011e7e0
MOV RBX,RAX
LAB_00123b9b:
LEA RSI,[0x183809]
MOV RDI,RSP
LEA R8,[RSP + 0x20]
MOV EDX,0x12
XOR ECX,ECX
CALL 0x00125059
LEA RAX,[0x1ae450]
MOV qword ptr [RBX],RAX
MOV RAX,RBX
ADD RAX,0x18
MOV qword ptr [RBX + 0x8],RAX
LEA R15,[RSP + 0x10]
MOV RCX,qword ptr [R15 + -0x10]
CMP RCX,R15
JNZ 0x00123be2
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RAX],XMM0
JMP 0x00123bef
LAB_00123be2:
MOV qword ptr [RBX + 0x8],RCX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RBX + 0x18],RAX
LAB_00123bef:
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RBX + 0x10],RAX
MOV qword ptr [RSP],R15
MOV qword ptr [RSP + 0x8],0x0
MOV byte ptr [RSP + 0x10],0x0
LAB_00123c0a:
LEA RSI,[0x1ae380]
LEA RDX,[0x123d34]
MOV RDI,RBX
CALL 0x0011fec0
|
/* aimrt::logger::LoggerRef::GetLogLevel() const */
void __thiscall aimrt::logger::LoggerRef::GetLogLevel(LoggerRef *this)
{
int8 *puVar1;
uint *local_48;
int8 local_40;
uint local_38;
int4 uStack_34;
int4 uStack_30;
int4 uStack_2c;
int1 local_28 [16];
puVar1 = *(int8 **)this;
if (puVar1 != (int8 *)0x0) {
/* WARNING: Could not recover jumptable at 0x00123b8c. Too many branches */
/* WARNING: Treating indirect jump as call */
(*(code *)*puVar1)(puVar1[2]);
return;
}
puVar1 = (int8 *)__cxa_allocate_exception(0x28);
/* try { // try from 00123b9b to 00123bb5 has its CatchHandler @ 00123c3b */
fmt::v10::vformat_abi_cxx11_(&local_48,"Reference is null.",0x12,0,local_28);
*puVar1 = &PTR__AimRTException_001ae450;
puVar1[1] = puVar1 + 3;
if (local_48 == &local_38) {
*(uint *)(puVar1 + 3) = local_38;
*(int4 *)((long)puVar1 + 0x1c) = uStack_34;
*(int4 *)(puVar1 + 4) = uStack_30;
*(int4 *)((long)puVar1 + 0x24) = uStack_2c;
}
else {
puVar1[1] = local_48;
puVar1[3] = CONCAT44(uStack_34,local_38);
}
puVar1[2] = local_40;
local_40 = 0;
local_38 = local_38 & 0xffffff00;
local_48 = &local_38;
/* try { // try from 00123c0a to 00123c1f has its CatchHandler @ 00123c20 */
/* WARNING: Subroutine does not return */
__cxa_throw(puVar1,&common::util::AimRTException::typeinfo,
common::util::AimRTException::~AimRTException);
}
|
|
18,437
|
parse_cpu_mask(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool (&) [512])
|
monkey531[P]llama/common/common.cpp
|
bool parse_cpu_mask(const std::string & mask, bool (&boolmask)[GGML_MAX_N_THREADS]) {
// Discard potential 0x prefix
size_t start_i = 0;
if (mask.length() >= 2 && mask.substr(0, 2) == "0x") {
start_i = 2;
}
size_t num_digits = mask.length() - start_i;
if (num_digits > 128) num_digits = 128;
size_t end_i = num_digits + start_i;
for (size_t i = start_i, n = (num_digits*4 - 1); i < end_i; i++, n-=4) {
char c = mask.at(i);
int8_t id = c;
if ((c >= '0' && c <= '9')) {
id -= '0';
} else if (c >= 'a' && c <= 'f') {
id -= 'a' - 10;
} else if (c >= 'A' && c <= 'F') {
id -= 'A' - 10;
} else {
LOG_ERR("Invalid hex character '%c' at position %d\n", c, int32_t(i));
return false;
}
boolmask[ n ] = boolmask[ n ] || ((id & 8) != 0);
boolmask[n - 1] = boolmask[n - 1] || ((id & 4) != 0);
boolmask[n - 2] = boolmask[n - 2] || ((id & 2) != 0);
boolmask[n - 3] = boolmask[n - 3] || ((id & 1) != 0);
}
return true;
}
|
O1
|
cpp
|
parse_cpu_mask(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool (&) [512]):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %r12
cmpq $0x2, %r12
jb 0x720ec
movq %rsp, %rbx
movl $0x2, %ecx
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x1b920
leaq 0x82351(%rip), %rsi # 0xf442a
movq %rbx, %rdi
callq 0x1b230
xorl %ebx, %ebx
testl %eax, %eax
sete %bl
addl %ebx, %ebx
jmp 0x720ee
xorl %ebx, %ebx
cmpq $0x2, %r12
jb 0x7210f
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7210f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1b8d0
movq 0x8(%r15), %rdx
movq %rdx, %rax
subq %rbx, %rax
movl $0x80, %ecx
cmpq %rcx, %rax
cmovaeq %rcx, %rax
cmpq %rbx, %rdx
sete %bpl
je 0x721ce
movq (%r15), %rcx
leaq (%r14,%rax,4), %rsi
addq $-0x4, %rsi
addq %rbx, %rax
movdqa 0x7f6f8(%rip), %xmm0 # 0xf1840
movdqa 0x7f700(%rip), %xmm1 # 0xf1850
cmpq %rbx, %rdx
jbe 0x72210
movsbl (%rcx,%rbx), %r14d
leal -0x30(%r14), %edi
cmpb $0xa, %dil
jb 0x72189
leal -0x61(%r14), %edi
cmpb $0x5, %dil
ja 0x72178
addb $-0x57, %r14b
jmp 0x72186
leal -0x41(%r14), %edi
cmpb $0x5, %dil
ja 0x721e1
addb $-0x37, %r14b
movl %r14d, %edi
movzbl %dil, %edi
movd (%rsi), %xmm2
punpcklbw %xmm2, %xmm2 # xmm2 = xmm2[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
punpcklwd %xmm2, %xmm2 # xmm2 = xmm2[0,0,1,1,2,2,3,3]
movd %edi, %xmm3
pshufd $0x0, %xmm3, %xmm3 # xmm3 = xmm3[0,0,0,0]
pand %xmm0, %xmm3
pcmpeqd %xmm0, %xmm3
por %xmm2, %xmm3
pand %xmm1, %xmm3
packuswb %xmm3, %xmm3
packuswb %xmm3, %xmm3
movd %xmm3, (%rsi)
incq %rbx
addq $-0x4, %rsi
cmpq %rax, %rbx
setae %bpl
jb 0x72150
andb $0x1, %bpl
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbe240(%rip), %rax # 0x130428
cmpl $0x0, (%rax)
js 0x721ce
callq 0xcd6bb
leaq 0x7f9c9(%rip), %rdx # 0xf1bc2
movq %rax, %rdi
movl $0x4, %esi
movl %r14d, %ecx
movl %ebx, %r8d
xorl %eax, %eax
callq 0xcd756
jmp 0x721ce
leaq 0x8279f(%rip), %rdi # 0xf49b6
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1bd40
|
_Z14parse_cpu_maskRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA512_b:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 20h
mov r14, rsi
mov r15, rdi
mov r12, [rdi+8]
cmp r12, 2
jb short loc_720EC
mov rbx, rsp
mov ecx, 2
mov rdi, rbx
mov rsi, r15
xor edx, edx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
lea rsi, aIncompleteUtf8+24h; "0x"
mov rdi, rbx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
xor ebx, ebx
test eax, eax
setz bl
add ebx, ebx
jmp short loc_720EE
loc_720EC:
xor ebx, ebx
loc_720EE:
cmp r12, 2
jb short loc_7210F
lea rax, [rsp+48h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_7210F
mov rsi, [rsp+48h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7210F:
mov rdx, [r15+8]
mov rax, rdx
sub rax, rbx
mov ecx, 80h
cmp rax, rcx
cmovnb rax, rcx
cmp rdx, rbx
setz bpl
jz loc_721CE
mov rcx, [r15]
lea rsi, [r14+rax*4]
add rsi, 0FFFFFFFFFFFFFFFCh
add rax, rbx
movdqa xmm0, cs:xmmword_F1840
movdqa xmm1, cs:xmmword_F1850
loc_72150:
cmp rdx, rbx
jbe loc_72210
movsx r14d, byte ptr [rcx+rbx]
lea edi, [r14-30h]
cmp dil, 0Ah
jb short loc_72189
lea edi, [r14-61h]
cmp dil, 5
ja short loc_72178
add r14b, 0A9h
jmp short loc_72186
loc_72178:
lea edi, [r14-41h]
cmp dil, 5
ja short loc_721E1
add r14b, 0C9h
loc_72186:
mov edi, r14d
loc_72189:
movzx edi, dil
movd xmm2, dword ptr [rsi]
punpcklbw xmm2, xmm2
punpcklwd xmm2, xmm2
movd xmm3, edi
pshufd xmm3, xmm3, 0
pand xmm3, xmm0
pcmpeqd xmm3, xmm0
por xmm3, xmm2
pand xmm3, xmm1
packuswb xmm3, xmm3
packuswb xmm3, xmm3
movd dword ptr [rsi], xmm3
inc rbx
add rsi, 0FFFFFFFFFFFFFFFCh
cmp rbx, rax
setnb bpl
jb short loc_72150
loc_721CE:
and bpl, 1
mov eax, ebp
add rsp, 20h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_721E1:
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js short loc_721CE
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aInvalidHexChar; "Invalid hex character '%c' at position "...
mov rdi, rax
mov esi, 4
mov ecx, r14d
mov r8d, ebx
xor eax, eax
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
jmp short loc_721CE
loc_72210:
lea rdi, aBasicStringAtN; "basic_string::at: __n (which is %zu) >="...
mov rsi, rbx
xor eax, eax
call __ZSt24__throw_out_of_range_fmtPKcz; std::__throw_out_of_range_fmt(char const*,...)
|
long long parse_cpu_mask(long long *a1, long long a2)
{
unsigned int v2; // ebp
unsigned long long v3; // r12
unsigned long long v4; // rbx
unsigned long long v5; // rdx
long long v6; // rax
long long v7; // rcx
unsigned int *v8; // rsi
unsigned long long v9; // rax
__m128i si128; // xmm0
__m128i v11; // xmm1
int v12; // r14d
unsigned __int8 v13; // di
unsigned __int8 v14; // r14
__m128i v15; // xmm2
__m128i v16; // xmm2
__m128i v17; // xmm3
__m128i v18; // xmm3
int v20; // eax
int v21; // r9d
void *v22[2]; // [rsp+0h] [rbp-48h] BYREF
long long v23; // [rsp+10h] [rbp-38h] BYREF
v3 = a1[1];
if ( v3 < 2 )
{
v4 = 0LL;
}
else
{
std::string::substr(v22, a1, 0LL, 2LL);
v4 = 2 * (unsigned int)((unsigned int)std::string::compare(v22, "0x") == 0);
}
if ( v3 >= 2 && v22[0] != &v23 )
operator delete(v22[0], v23 + 1);
v5 = a1[1];
v6 = v5 - v4;
if ( v5 - v4 >= 0x80 )
v6 = 128LL;
LOBYTE(v2) = v5 == v4;
if ( v5 != v4 )
{
v7 = *a1;
v8 = (unsigned int *)(a2 + 4 * v6 - 4);
v9 = v4 + v6;
si128 = _mm_load_si128((const __m128i *)&xmmword_F1840);
v11 = _mm_load_si128((const __m128i *)&xmmword_F1850);
do
{
if ( v5 <= v4 )
std::__throw_out_of_range_fmt("basic_string::at: __n (which is %zu) >= this->size() (which is %zu)", v4, v5);
v12 = *(char *)(v7 + v4);
v13 = *(_BYTE *)(v7 + v4) - 48;
if ( v13 >= 0xAu )
{
if ( (unsigned __int8)(v12 - 97) > 5u )
{
if ( (unsigned __int8)(v12 - 65) > 5u )
{
if ( common_log_verbosity_thold >= 0 )
{
v20 = common_log_main();
common_log_add(v20, 4, (unsigned int)"Invalid hex character '%c' at position %d\n", v12, v4, v21);
}
break;
}
v14 = v12 - 55;
}
else
{
v14 = v12 - 87;
}
v13 = v14;
}
v15 = _mm_cvtsi32_si128(*v8);
v16 = _mm_unpacklo_epi8(v15, v15);
v17 = _mm_and_si128(
_mm_or_si128(
_mm_cmpeq_epi32(_mm_and_si128(_mm_shuffle_epi32(_mm_cvtsi32_si128(v13), 0), si128), si128),
_mm_unpacklo_epi16(v16, v16)),
v11);
v18 = _mm_packus_epi16(v17, v17);
*v8 = _mm_cvtsi128_si32(_mm_packus_epi16(v18, v18));
++v4;
--v8;
LOBYTE(v2) = v4 >= v9;
}
while ( v4 < v9 );
}
LOBYTE(v2) = v2 & 1;
return v2;
}
|
parse_cpu_mask:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV R14,RSI
MOV R15,RDI
MOV R12,qword ptr [RDI + 0x8]
CMP R12,0x2
JC 0x001720ec
MOV RBX,RSP
MOV ECX,0x2
MOV RDI,RBX
MOV RSI,R15
XOR EDX,EDX
CALL 0x0011b920
LEA RSI,[0x1f442a]
MOV RDI,RBX
CALL 0x0011b230
XOR EBX,EBX
TEST EAX,EAX
SETZ BL
ADD EBX,EBX
JMP 0x001720ee
LAB_001720ec:
XOR EBX,EBX
LAB_001720ee:
CMP R12,0x2
JC 0x0017210f
LEA RAX,[RSP + 0x10]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0017210f
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x0011b8d0
LAB_0017210f:
MOV RDX,qword ptr [R15 + 0x8]
MOV RAX,RDX
SUB RAX,RBX
MOV ECX,0x80
CMP RAX,RCX
CMOVNC RAX,RCX
CMP RDX,RBX
SETZ BPL
JZ 0x001721ce
MOV RCX,qword ptr [R15]
LEA RSI,[R14 + RAX*0x4]
ADD RSI,-0x4
ADD RAX,RBX
MOVDQA XMM0,xmmword ptr [0x001f1840]
MOVDQA XMM1,xmmword ptr [0x001f1850]
LAB_00172150:
CMP RDX,RBX
JBE 0x00172210
MOVSX R14D,byte ptr [RCX + RBX*0x1]
LEA EDI,[R14 + -0x30]
CMP DIL,0xa
JC 0x00172189
LEA EDI,[R14 + -0x61]
CMP DIL,0x5
JA 0x00172178
ADD R14B,0xa9
JMP 0x00172186
LAB_00172178:
LEA EDI,[R14 + -0x41]
CMP DIL,0x5
JA 0x001721e1
ADD R14B,0xc9
LAB_00172186:
MOV EDI,R14D
LAB_00172189:
MOVZX EDI,DIL
MOVD XMM2,dword ptr [RSI]
PUNPCKLBW XMM2,XMM2
PUNPCKLWD XMM2,XMM2
MOVD XMM3,EDI
PSHUFD XMM3,XMM3,0x0
PAND XMM3,XMM0
PCMPEQD XMM3,XMM0
POR XMM3,XMM2
PAND XMM3,XMM1
PACKUSWB XMM3,XMM3
PACKUSWB XMM3,XMM3
MOVD dword ptr [RSI],XMM3
INC RBX
ADD RSI,-0x4
CMP RBX,RAX
SETNC BPL
JC 0x00172150
LAB_001721ce:
AND BPL,0x1
MOV EAX,EBP
ADD RSP,0x20
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001721e1:
LEA RAX,[0x230428]
CMP dword ptr [RAX],0x0
JS 0x001721ce
CALL 0x001cd6bb
LEA RDX,[0x1f1bc2]
MOV RDI,RAX
MOV ESI,0x4
MOV ECX,R14D
MOV R8D,EBX
XOR EAX,EAX
CALL 0x001cd756
JMP 0x001721ce
LAB_00172210:
LEA RDI,[0x1f49b6]
MOV RSI,RBX
XOR EAX,EAX
CALL 0x0011bd40
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* parse_cpu_mask(std::__cxx11::string const&, bool (&) [512]) */
ulong parse_cpu_mask(string *param_1,bool *param_2)
{
char cVar1;
ulong uVar2;
long lVar3;
char cVar4;
short sVar7;
short sVar8;
short sVar9;
ulong uVar10;
int1 auVar11 [16];
int1 auVar12 [16];
int iVar13;
ulong uVar14;
int8 uVar15;
ulong uVar16;
int8 unaff_RBP;
bool *pbVar17;
byte bVar18;
bool bVar19;
bool bVar20;
int1 uVar24;
int1 auVar21 [16];
short sVar26;
int1 auVar29 [16];
int1 auVar30 [16];
int1 auVar31 [16];
long *local_48 [2];
long local_38 [2];
char cVar5;
char cVar6;
int1 auVar22 [16];
int1 auVar23 [16];
int2 uVar25;
int4 uVar27;
int6 uVar28;
if (*(ulong *)(param_1 + 8) < 2) {
uVar16 = 0;
}
else {
std::__cxx11::string::substr((ulong)local_48,(ulong)param_1);
iVar13 = std::__cxx11::string::compare((char *)local_48);
uVar16 = (ulong)((uint)(iVar13 == 0) * 2);
if (local_48[0] != local_38) {
operator_delete(local_48[0],local_38[0] + 1);
}
}
auVar12 = _DAT_001f1850;
auVar11 = _DAT_001f1840;
uVar2 = *(ulong *)(param_1 + 8);
uVar14 = uVar2 - uVar16;
if (0x7f < uVar14) {
uVar14 = 0x80;
}
bVar20 = uVar2 == uVar16;
if (!bVar20) {
lVar3 = *(long *)param_1;
pbVar17 = param_2 + uVar14 * 4;
uVar14 = uVar14 + uVar16;
do {
pbVar17 = pbVar17 + -4;
if (uVar2 <= uVar16) {
uVar16 = std::__throw_out_of_range_fmt
("basic_string::at: __n (which is %zu) >= this->size() (which is %zu)",
uVar16);
llama_log_set(common_init()::$_0::__invoke,0);
if (-1 < common_log_verbosity_thold) {
uVar15 = common_log_main();
common_log_add(uVar15,2,"build: %d (%s) with %s for %s%s\n",LLAMA_BUILD_NUMBER,
LLAMA_COMMIT,LLAMA_COMPILER,LLAMA_BUILD_TARGET,"");
}
return uVar16;
}
cVar1 = *(char *)(lVar3 + uVar16);
bVar18 = cVar1 - 0x30;
if (9 < bVar18) {
if ((byte)(cVar1 + 0x9fU) < 6) {
bVar18 = cVar1 + 0xa9;
}
else {
if (5 < (byte)(cVar1 + 0xbfU)) {
if (-1 < common_log_verbosity_thold) {
uVar15 = common_log_main();
common_log_add(uVar15,4,"Invalid hex character \'%c\' at position %d\n",(int)cVar1,
uVar16 & 0xffffffff);
}
break;
}
bVar18 = cVar1 - 0x37;
}
}
uVar27 = *(int4 *)pbVar17;
uVar24 = (int1)((uint)uVar27 >> 0x18);
uVar25 = CONCAT11(uVar24,uVar24);
uVar24 = (int1)((uint)uVar27 >> 0x10);
uVar15 = CONCAT35(CONCAT21(uVar25,uVar24),CONCAT14(uVar24,uVar27));
uVar24 = (int1)((uint)uVar27 >> 8);
uVar28 = CONCAT51(CONCAT41((int)((ulong)uVar15 >> 0x20),uVar24),uVar24);
auVar31._0_2_ = CONCAT11((char)uVar27,(char)uVar27);
uVar10 = CONCAT62(uVar28,auVar31._0_2_);
auVar23._8_4_ = 0;
auVar23._0_8_ = uVar10;
auVar23._12_2_ = uVar25;
auVar23._14_2_ = uVar25;
uVar25 = (int2)((ulong)uVar15 >> 0x20);
auVar22._12_4_ = auVar23._12_4_;
auVar22._8_2_ = 0;
auVar22._0_8_ = uVar10;
auVar22._10_2_ = uVar25;
auVar21._10_6_ = auVar22._10_6_;
auVar21._8_2_ = uVar25;
auVar21._0_8_ = uVar10;
uVar25 = (int2)uVar28;
auVar31._8_8_ = auVar21._8_8_;
auVar31._6_2_ = uVar25;
auVar31._4_2_ = uVar25;
auVar31._2_2_ = auVar31._0_2_;
auVar29._1_3_ = 0;
auVar29[0] = bVar18;
auVar29[4] = bVar18;
auVar29._5_3_ = 0;
auVar29[8] = bVar18;
auVar29._9_3_ = 0;
auVar29[0xc] = bVar18;
auVar29._13_3_ = 0;
auVar29 = auVar29 & auVar11;
auVar30._0_4_ = -(uint)(auVar29._0_4_ == auVar11._0_4_);
auVar30._4_4_ = -(uint)(auVar29._4_4_ == auVar11._4_4_);
auVar30._8_4_ = -(uint)(auVar29._8_4_ == auVar11._8_4_);
auVar30._12_4_ = -(uint)(auVar29._12_4_ == auVar11._12_4_);
auVar31 = (auVar30 | auVar31) & auVar12;
sVar7 = auVar31._0_2_;
cVar1 = (0 < sVar7) * (sVar7 < 0x100) * auVar31[0] - (0xff < sVar7);
sVar7 = auVar31._2_2_;
sVar26 = CONCAT11((0 < sVar7) * (sVar7 < 0x100) * auVar31[2] - (0xff < sVar7),cVar1);
sVar7 = auVar31._4_2_;
cVar4 = (0 < sVar7) * (sVar7 < 0x100) * auVar31[4] - (0xff < sVar7);
sVar7 = auVar31._6_2_;
uVar27 = CONCAT13((0 < sVar7) * (sVar7 < 0x100) * auVar31[6] - (0xff < sVar7),
CONCAT12(cVar4,sVar26));
sVar7 = auVar31._8_2_;
cVar5 = (0 < sVar7) * (sVar7 < 0x100) * auVar31[8] - (0xff < sVar7);
sVar7 = auVar31._10_2_;
uVar28 = CONCAT15((0 < sVar7) * (sVar7 < 0x100) * auVar31[10] - (0xff < sVar7),
CONCAT14(cVar5,uVar27));
sVar7 = auVar31._12_2_;
cVar6 = (0 < sVar7) * (sVar7 < 0x100) * auVar31[0xc] - (0xff < sVar7);
sVar9 = auVar31._14_2_;
sVar7 = (short)((uint)uVar27 >> 0x10);
sVar8 = (short)((uint6)uVar28 >> 0x20);
sVar9 = (short)(CONCAT17((0 < sVar9) * (sVar9 < 0x100) * auVar31[0xe] - (0xff < sVar9),
CONCAT16(cVar6,uVar28)) >> 0x30);
*(uint *)pbVar17 =
CONCAT13((0 < sVar9) * (sVar9 < 0x100) * cVar6 - (0xff < sVar9),
CONCAT12((0 < sVar8) * (sVar8 < 0x100) * cVar5 - (0xff < sVar8),
CONCAT11((0 < sVar7) * (sVar7 < 0x100) * cVar4 - (0xff < sVar7),
(0 < sVar26) * (sVar26 < 0x100) * cVar1 - (0xff < sVar26))));
uVar16 = uVar16 + 1;
bVar19 = uVar16 < uVar14;
bVar20 = !bVar19;
} while (bVar19);
}
return CONCAT71((int7)((ulong)unaff_RBP >> 8),bVar20) & 0xffffffff;
}
|
|
18,438
|
js_iterator_wrap_finalizer
|
bluesky950520[P]quickjs/quickjs.c
|
static void js_iterator_wrap_finalizer(JSRuntime *rt, JSValue val)
{
JSObject *p = JS_VALUE_GET_OBJ(val);
JSIteratorWrapData *it = p->u.iterator_wrap_data;
if (it) {
JS_FreeValueRT(rt, it->wrapped_iter);
JS_FreeValueRT(rt, it->wrapped_next);
js_free_rt(rt, it);
}
}
|
O0
|
c
|
js_iterator_wrap_finalizer:
subq $0x28, %rsp
movq %rsi, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq %rdi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x5a9ca
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x22a50
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
callq 0x22a50
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0x206a0
addq $0x28, %rsp
retq
nop
|
js_iterator_wrap_finalizer:
sub rsp, 28h
mov [rsp+28h+var_10], rsi
mov [rsp+28h+var_8], rdx
mov [rsp+28h+var_18], rdi
mov rax, [rsp+28h+var_10]
mov [rsp+28h+var_20], rax
mov rax, [rsp+28h+var_20]
mov rax, [rax+30h]
mov [rsp+28h+var_28], rax
cmp [rsp+28h+var_28], 0
jz short loc_5A9CA
mov rdi, [rsp+28h+var_18]
mov rax, [rsp+28h+var_28]
mov rsi, [rax]
mov rdx, [rax+8]
call JS_FreeValueRT
mov rdi, [rsp+28h+var_18]
mov rax, [rsp+28h+var_28]
mov rsi, [rax+10h]
mov rdx, [rax+18h]
call JS_FreeValueRT
mov rdi, [rsp+28h+var_18]
mov rsi, [rsp+28h+var_28]
call js_free_rt
loc_5A9CA:
add rsp, 28h
retn
|
void js_iterator_wrap_finalizer(long long a1, long long a2)
{
long long v2; // [rsp+0h] [rbp-28h]
v2 = *(_QWORD *)(a2 + 48);
if ( v2 )
{
JS_FreeValueRT(a1, *(_DWORD **)v2, *(_QWORD *)(v2 + 8));
JS_FreeValueRT(a1, *(_DWORD **)(v2 + 16), *(_QWORD *)(v2 + 24));
js_free_rt(a1, v2);
}
}
|
js_iterator_wrap_finalizer:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RSI
MOV qword ptr [RSP + 0x20],RDX
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RSP],RAX
CMP qword ptr [RSP],0x0
JZ 0x0015a9ca
MOV RDI,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x00122a50
MOV RDI,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP]
MOV RSI,qword ptr [RAX + 0x10]
MOV RDX,qword ptr [RAX + 0x18]
CALL 0x00122a50
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP]
CALL 0x001206a0
LAB_0015a9ca:
ADD RSP,0x28
RET
|
void js_iterator_wrap_finalizer(int8 param_1,long param_2)
{
int8 *puVar1;
puVar1 = *(int8 **)(param_2 + 0x30);
if (puVar1 != (int8 *)0x0) {
JS_FreeValueRT(param_1,*puVar1,puVar1[1]);
JS_FreeValueRT(param_1,puVar1[2],puVar1[3]);
js_free_rt(param_1,puVar1);
}
return;
}
|
|
18,439
|
js_iterator_wrap_finalizer
|
bluesky950520[P]quickjs/quickjs.c
|
static void js_iterator_wrap_finalizer(JSRuntime *rt, JSValue val)
{
JSObject *p = JS_VALUE_GET_OBJ(val);
JSIteratorWrapData *it = p->u.iterator_wrap_data;
if (it) {
JS_FreeValueRT(rt, it->wrapped_iter);
JS_FreeValueRT(rt, it->wrapped_next);
js_free_rt(rt, it);
}
}
|
O1
|
c
|
js_iterator_wrap_finalizer:
pushq %r14
pushq %rbx
pushq %rax
movq 0x30(%rsi), %rbx
testq %rbx, %rbx
je 0x3a4ef
movq %rdi, %r14
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x1ccb2
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
movq %r14, %rdi
callq 0x1ccb2
decq 0x28(%r14)
movq %rbx, %rdi
callq *0x20(%r14)
movq 0x10(%r14), %rcx
movq 0x30(%r14), %rdx
subq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x30(%r14)
movq 0x40(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
js_iterator_wrap_finalizer:
push r14
push rbx
push rax
mov rbx, [rsi+30h]
test rbx, rbx
jz short loc_3A4EF
mov r14, rdi
mov rsi, [rbx]
mov rdx, [rbx+8]
call JS_FreeValueRT
mov rsi, [rbx+10h]
mov rdx, [rbx+18h]
mov rdi, r14
call JS_FreeValueRT
dec qword ptr [r14+28h]
mov rdi, rbx
call qword ptr [r14+20h]
mov rcx, [r14+10h]
mov rdx, [r14+30h]
sub rdx, rax
add rdx, 0FFFFFFFFFFFFFFF8h
mov [r14+30h], rdx
mov rdi, [r14+40h]
mov rsi, rbx
add rsp, 8
pop rbx
pop r14
jmp rcx
loc_3A4EF:
add rsp, 8
pop rbx
pop r14
retn
|
long long js_iterator_wrap_finalizer(long long a1, long long a2)
{
long long v2; // rbx
long long v3; // rax
long long ( *v4)(_QWORD, long long); // rcx
long long result; // rax
v2 = *(_QWORD *)(a2 + 48);
if ( v2 )
{
JS_FreeValueRT(a1, *(_DWORD **)v2, *(_QWORD *)(v2 + 8));
JS_FreeValueRT(a1, *(_DWORD **)(v2 + 16), *(_QWORD *)(v2 + 24));
--*(_QWORD *)(a1 + 40);
v3 = (*(long long ( **)(long long))(a1 + 32))(v2);
v4 = *(long long ( **)(_QWORD, long long))(a1 + 16);
*(_QWORD *)(a1 + 48) = *(_QWORD *)(a1 + 48) - v3 - 8;
return v4(*(_QWORD *)(a1 + 64), v2);
}
return result;
}
|
js_iterator_wrap_finalizer:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,qword ptr [RSI + 0x30]
TEST RBX,RBX
JZ 0x0013a4ef
MOV R14,RDI
MOV RSI,qword ptr [RBX]
MOV RDX,qword ptr [RBX + 0x8]
CALL 0x0011ccb2
MOV RSI,qword ptr [RBX + 0x10]
MOV RDX,qword ptr [RBX + 0x18]
MOV RDI,R14
CALL 0x0011ccb2
DEC qword ptr [R14 + 0x28]
MOV RDI,RBX
CALL qword ptr [R14 + 0x20]
MOV RCX,qword ptr [R14 + 0x10]
MOV RDX,qword ptr [R14 + 0x30]
SUB RDX,RAX
ADD RDX,-0x8
MOV qword ptr [R14 + 0x30],RDX
MOV RDI,qword ptr [R14 + 0x40]
MOV RSI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP RCX
LAB_0013a4ef:
ADD RSP,0x8
POP RBX
POP R14
RET
|
void js_iterator_wrap_finalizer(long param_1,long param_2)
{
int8 *puVar1;
long lVar2;
puVar1 = *(int8 **)(param_2 + 0x30);
if (puVar1 != (int8 *)0x0) {
JS_FreeValueRT(param_1,*puVar1,puVar1[1]);
JS_FreeValueRT(param_1,puVar1[2],puVar1[3]);
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + -1;
lVar2 = (**(code **)(param_1 + 0x20))(puVar1);
lVar2 = (*(long *)(param_1 + 0x30) - lVar2) + -8;
*(long *)(param_1 + 0x30) = lVar2;
/* WARNING: Could not recover jumptable at 0x0013a4ed. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(param_1 + 0x10))
(*(int8 *)(param_1 + 0x40),puVar1,lVar2,*(code **)(param_1 + 0x10));
return;
}
return;
}
|
|
18,440
|
js_iterator_wrap_finalizer
|
bluesky950520[P]quickjs/quickjs.c
|
static void js_iterator_wrap_finalizer(JSRuntime *rt, JSValue val)
{
JSObject *p = JS_VALUE_GET_OBJ(val);
JSIteratorWrapData *it = p->u.iterator_wrap_data;
if (it) {
JS_FreeValueRT(rt, it->wrapped_iter);
JS_FreeValueRT(rt, it->wrapped_next);
js_free_rt(rt, it);
}
}
|
O3
|
c
|
js_iterator_wrap_finalizer:
pushq %r14
pushq %rbx
pushq %rax
movq 0x30(%rsi), %rbx
testq %rbx, %rbx
je 0x3bab9
movq %rdi, %r14
movq 0x8(%rbx), %rdx
cmpl $-0x9, %edx
jb 0x3ba6a
movq (%rbx), %rsi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jg 0x3ba6a
movq %r14, %rdi
callq 0x20d90
movq 0x18(%rbx), %rdx
cmpl $-0x9, %edx
jb 0x3ba8b
movq 0x10(%rbx), %rsi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jg 0x3ba8b
movq %r14, %rdi
callq 0x20d90
decq 0x28(%r14)
movq %rbx, %rdi
callq *0x20(%r14)
movq 0x10(%r14), %rcx
movq 0x30(%r14), %rdx
subq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x30(%r14)
movq 0x40(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
js_iterator_wrap_finalizer:
push r14
push rbx
push rax
mov rbx, [rsi+30h]
test rbx, rbx
jz short loc_3BAB9
mov r14, rdi
mov rdx, [rbx+8]
cmp edx, 0FFFFFFF7h
jb short loc_3BA6A
mov rsi, [rbx]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jg short loc_3BA6A
mov rdi, r14
call js_free_value_rt
loc_3BA6A:
mov rdx, [rbx+18h]
cmp edx, 0FFFFFFF7h
jb short loc_3BA8B
mov rsi, [rbx+10h]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jg short loc_3BA8B
mov rdi, r14
call js_free_value_rt
loc_3BA8B:
dec qword ptr [r14+28h]
mov rdi, rbx
call qword ptr [r14+20h]
mov rcx, [r14+10h]
mov rdx, [r14+30h]
sub rdx, rax
add rdx, 0FFFFFFFFFFFFFFF8h
mov [r14+30h], rdx
mov rdi, [r14+40h]
mov rsi, rbx
add rsp, 8
pop rbx
pop r14
jmp rcx
loc_3BAB9:
add rsp, 8
pop rbx
pop r14
retn
|
long long js_iterator_wrap_finalizer(long long a1, long long a2, long long a3, long long a4, long long a5, long long a6)
{
long long v6; // rbx
long long v7; // rdx
int *v8; // rsi
int v9; // eax
long long v10; // rcx
long long v11; // rdx
_QWORD *v12; // rsi
int v13; // eax
long long v14; // rcx
long long v15; // rax
long long ( *v16)(_QWORD, long long); // rcx
long long result; // rax
v6 = *(_QWORD *)(a2 + 48);
if ( v6 )
{
v7 = *(_QWORD *)(v6 + 8);
if ( (unsigned int)v7 >= 0xFFFFFFF7 )
{
v8 = *(int **)v6;
v9 = **(_DWORD **)v6;
v10 = (unsigned int)(v9 - 1);
**(_DWORD **)v6 = v10;
if ( v9 <= 1 )
js_free_value_rt(a1, v8, v7, v10, a5, a6);
}
v11 = *(_QWORD *)(v6 + 24);
if ( (unsigned int)v11 >= 0xFFFFFFF7 )
{
v12 = *(_QWORD **)(v6 + 16);
v13 = *(_DWORD *)v12;
v14 = (unsigned int)(*(_DWORD *)v12 - 1);
*(_DWORD *)v12 = v14;
if ( v13 <= 1 )
js_free_value_rt(a1, v12, v11, v14, a5, a6);
}
--*(_QWORD *)(a1 + 40);
v15 = (*(long long ( **)(long long))(a1 + 32))(v6);
v16 = *(long long ( **)(_QWORD, long long))(a1 + 16);
*(_QWORD *)(a1 + 48) = *(_QWORD *)(a1 + 48) - v15 - 8;
return v16(*(_QWORD *)(a1 + 64), v6);
}
return result;
}
|
js_iterator_wrap_finalizer:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,qword ptr [RSI + 0x30]
TEST RBX,RBX
JZ 0x0013bab9
MOV R14,RDI
MOV RDX,qword ptr [RBX + 0x8]
CMP EDX,-0x9
JC 0x0013ba6a
MOV RSI,qword ptr [RBX]
MOV EAX,dword ptr [RSI]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSI],ECX
CMP EAX,0x1
JG 0x0013ba6a
MOV RDI,R14
CALL 0x00120d90
LAB_0013ba6a:
MOV RDX,qword ptr [RBX + 0x18]
CMP EDX,-0x9
JC 0x0013ba8b
MOV RSI,qword ptr [RBX + 0x10]
MOV EAX,dword ptr [RSI]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSI],ECX
CMP EAX,0x1
JG 0x0013ba8b
MOV RDI,R14
CALL 0x00120d90
LAB_0013ba8b:
DEC qword ptr [R14 + 0x28]
MOV RDI,RBX
CALL qword ptr [R14 + 0x20]
MOV RCX,qword ptr [R14 + 0x10]
MOV RDX,qword ptr [R14 + 0x30]
SUB RDX,RAX
ADD RDX,-0x8
MOV qword ptr [R14 + 0x30],RDX
MOV RDI,qword ptr [R14 + 0x40]
MOV RSI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP RCX
LAB_0013bab9:
ADD RSP,0x8
POP RBX
POP R14
RET
|
void js_iterator_wrap_finalizer(long param_1,long param_2)
{
int iVar1;
int8 *puVar2;
long lVar3;
puVar2 = *(int8 **)(param_2 + 0x30);
if (puVar2 != (int8 *)0x0) {
if (0xfffffff6 < (uint)puVar2[1]) {
iVar1 = *(int *)*puVar2;
*(int *)*puVar2 = iVar1 + -1;
if (iVar1 < 2) {
js_free_value_rt(param_1);
}
}
if (0xfffffff6 < (uint)puVar2[3]) {
iVar1 = *(int *)puVar2[2];
*(int *)puVar2[2] = iVar1 + -1;
if (iVar1 < 2) {
js_free_value_rt(param_1);
}
}
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + -1;
lVar3 = (**(code **)(param_1 + 0x20))(puVar2);
lVar3 = (*(long *)(param_1 + 0x30) - lVar3) + -8;
*(long *)(param_1 + 0x30) = lVar3;
/* WARNING: Could not recover jumptable at 0x0013bab7. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(param_1 + 0x10))
(*(int8 *)(param_1 + 0x40),puVar2,lVar3,*(code **)(param_1 + 0x10));
return;
}
return;
}
|
|
18,441
|
testing::Test::IsSkipped()
|
giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/src/gtest.cc
|
bool Test::IsSkipped() {
return internal::GetUnitTestImpl()->current_test_result()->Skipped();
}
|
O1
|
cpp
|
testing::Test::IsSkipped():
pushq %rax
callq 0x19012
movq 0x38adf(%rip), %rax # 0x597b0
movq 0x1e0(%rax), %rdi
testq %rdi, %rdi
je 0x20ce6
addq $0x90, %rdi
jmp 0x20d04
movq 0x1d8(%rax), %rdi
testq %rdi, %rdi
je 0x20cfb
addq $0x88, %rdi
jmp 0x20d04
addq $0x1e8, %rax # imm = 0x1E8
movq %rax, %rdi
popq %rax
jmp 0x202de
|
_ZN7testing4Test9IsSkippedEv:
push rax
call _ZN7testing8UnitTest11GetInstanceEv; testing::UnitTest::GetInstance(void)
mov rax, cs:qword_597B0
mov rdi, [rax+1E0h]
test rdi, rdi
jz short loc_20CE6
add rdi, 90h
jmp short loc_20D04
loc_20CE6:
mov rdi, [rax+1D8h]
test rdi, rdi
jz short loc_20CFB
add rdi, 88h
jmp short loc_20D04
loc_20CFB:
add rax, 1E8h
mov rdi, rax; this
loc_20D04:
pop rax
jmp _ZNK7testing10TestResult7SkippedEv; testing::TestResult::Skipped(void)
|
char testing::Test::IsSkipped(testing::Test *this)
{
long long v1; // rdi
long long v3; // rdi
testing::UnitTest::GetInstance(this);
v1 = *((_QWORD *)qword_597B0 + 60);
if ( v1 )
return testing::TestResult::Skipped((testing::TestResult *)(v1 + 144));
v3 = *((_QWORD *)qword_597B0 + 59);
if ( v3 )
return testing::TestResult::Skipped((testing::TestResult *)(v3 + 136));
else
return testing::TestResult::Skipped((testing::internal::UnitTestImpl *)((char *)qword_597B0 + 488));
}
|
IsSkipped:
PUSH RAX
CALL 0x00119012
MOV RAX,qword ptr [0x001597b0]
MOV RDI,qword ptr [RAX + 0x1e0]
TEST RDI,RDI
JZ 0x00120ce6
ADD RDI,0x90
JMP 0x00120d04
LAB_00120ce6:
MOV RDI,qword ptr [RAX + 0x1d8]
TEST RDI,RDI
JZ 0x00120cfb
ADD RDI,0x88
JMP 0x00120d04
LAB_00120cfb:
ADD RAX,0x1e8
MOV RDI,RAX
LAB_00120d04:
POP RAX
JMP 0x001202de
|
/* testing::Test::IsSkipped() */
void testing::Test::IsSkipped(void)
{
TestResult *this;
UnitTest::GetInstance();
if (*(long *)(UnitTest::GetInstance()::instance._64_8_ + 0x1e0) == 0) {
if (*(long *)(UnitTest::GetInstance()::instance._64_8_ + 0x1d8) == 0) {
this = (TestResult *)(UnitTest::GetInstance()::instance._64_8_ + 0x1e8);
}
else {
this = (TestResult *)(*(long *)(UnitTest::GetInstance()::instance._64_8_ + 0x1d8) + 0x88);
}
}
else {
this = (TestResult *)(*(long *)(UnitTest::GetInstance()::instance._64_8_ + 0x1e0) + 0x90);
}
TestResult::Skipped(this);
return;
}
|
|
18,442
|
coro::thread_pool::schedule_impl(std::__n4861::coroutine_handle<void>)
|
AlayaLite/build_O3/_deps/libcoro-src/src/thread_pool.cpp
|
auto thread_pool::schedule_impl(std::coroutine_handle<> handle) noexcept -> void
{
if (handle == nullptr || handle.done())
{
return;
}
{
std::scoped_lock lk{m_wait_mutex};
m_queue.emplace_back(handle);
m_wait_cv.notify_one();
}
}
|
O3
|
cpp
|
coro::thread_pool::schedule_impl(std::__n4861::coroutine_handle<void>):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
testq %rsi, %rsi
je 0x55e4
cmpq $0x0, (%rsi)
je 0x55e4
movq %rdi, %rbx
leaq 0x68(%rdi), %r14
movq %r14, %rdi
callq 0x33a0
testl %eax, %eax
jne 0x55ec
leaq 0xd0(%rbx), %rdi
movq %rsp, %rsi
callq 0x5fe6
addq $0x90, %rbx
movq %rbx, %rdi
callq 0x6034
movq %r14, %rdi
callq 0x3210
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %eax, %edi
callq 0x31c0
movq %rax, %rdi
callq 0x466e
nop
|
_ZN4coro11thread_pool13schedule_implENSt7__n486116coroutine_handleIvEE:
push r14
push rbx
push rax
mov [rsp+18h+var_18], rsi
test rsi, rsi
jz short loc_55E4
cmp qword ptr [rsi], 0
jz short loc_55E4
mov rbx, rdi
lea r14, [rdi+68h]
mov rdi, r14
call _pthread_mutex_lock
test eax, eax
jnz short loc_55EC
lea rdi, [rbx+0D0h]
mov rsi, rsp
call _ZNSt5dequeINSt7__n486116coroutine_handleIvEESaIS2_EE12emplace_backIJRS2_EEES6_DpOT_; std::deque<std::__n4861::coroutine_handle<void>>::emplace_back<std::__n4861::coroutine_handle<void>&>(std::__n4861::coroutine_handle<void>&)
add rbx, 90h
mov rdi, rbx; this
call _ZNSt3_V222condition_variable_any10notify_oneEv; std::_V2::condition_variable_any::notify_one(void)
mov rdi, r14
call _pthread_mutex_unlock
loc_55E4:
add rsp, 8
pop rbx
pop r14
retn
loc_55EC:
mov edi, eax; int
call __ZSt20__throw_system_errori; std::__throw_system_error(int)
mov rdi, rax
call __clang_call_terminate
|
void coro::thread_pool::schedule_impl(long long a1, _QWORD *a2)
{
int v2; // eax
_QWORD *v3; // [rsp+0h] [rbp-18h] BYREF
v3 = a2;
if ( a2 && *a2 )
{
v2 = pthread_mutex_lock(a1 + 104);
if ( v2 )
std::__throw_system_error(v2);
std::deque<std::__n4861::coroutine_handle<void>>::emplace_back<std::__n4861::coroutine_handle<void>&>(a1 + 208, &v3);
std::_V2::condition_variable_any::notify_one((std::_V2::condition_variable_any *)(a1 + 144));
pthread_mutex_unlock(a1 + 104);
}
}
|
schedule_impl:
PUSH R14
PUSH RBX
PUSH RAX
MOV qword ptr [RSP],RSI
TEST RSI,RSI
JZ 0x001055e4
CMP qword ptr [RSI],0x0
JZ 0x001055e4
MOV RBX,RDI
LEA R14,[RDI + 0x68]
MOV RDI,R14
CALL 0x001033a0
TEST EAX,EAX
JNZ 0x001055ec
LEA RDI,[RBX + 0xd0]
LAB_001055c5:
MOV RSI,RSP
CALL 0x00105fe6
ADD RBX,0x90
MOV RDI,RBX
CALL 0x00106034
MOV RDI,R14
CALL 0x00103210
LAB_001055e4:
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_001055ec:
MOV EDI,EAX
CALL 0x001031c0
LAB_001055f3:
MOV RDI,RAX
CALL 0x0010466e
|
/* coro::thread_pool::schedule_impl(std::__n4861::coroutine_handle<void>) */
void __thiscall coro::thread_pool::schedule_impl(thread_pool *this,long *param_2)
{
int iVar1;
int8 uVar2;
long *local_18;
if ((param_2 != (long *)0x0) && (*param_2 != 0)) {
local_18 = param_2;
iVar1 = pthread_mutex_lock((pthread_mutex_t *)(this + 0x68));
if (iVar1 != 0) {
uVar2 = std::__throw_system_error(iVar1);
/* catch(type#1 @ 00000000) { ... } // from try @ 001055c5 with catch @ 001055f3
*/
/* WARNING: Subroutine does not return */
__clang_call_terminate(uVar2);
}
/* try { // try from 001055c5 to 001055f2 has its CatchHandler @ 001055f3 */
std::
deque<std::__n4861::coroutine_handle<void>,std::allocator<std::__n4861::coroutine_handle<void>>>
::emplace_back<std::__n4861::coroutine_handle<void>&>
((deque<std::__n4861::coroutine_handle<void>,std::allocator<std::__n4861::coroutine_handle<void>>>
*)(this + 0xd0),(coroutine_handle *)&local_18);
std::_V2::condition_variable_any::notify_one((condition_variable_any *)(this + 0x90));
pthread_mutex_unlock((pthread_mutex_t *)(this + 0x68));
}
return;
}
|
|
18,443
|
LefDefParser::lefiPin::addAntennaPartialMetalArea(double, char const*)
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiMacro.cpp
|
void
lefiPin::addAntennaPartialMetalArea(double val,
const char *layer)
{
int len;
if (numAntennaPartialMetalArea_ == antennaPartialMetalAreaAllocated_) {
int i;
int max;
int lim = numAntennaPartialMetalArea_;
double *nd;
char **nl;
if (antennaPartialMetalAreaAllocated_ == 0)
max = antennaPartialMetalAreaAllocated_ = 2;
else
max = antennaPartialMetalAreaAllocated_ *= 2;
nd = (double*) lefMalloc(sizeof(double) * max);
nl = (char**) lefMalloc(sizeof(double) * max);
for (i = 0; i < lim; i++) {
nl[i] = antennaPartialMetalAreaLayer_[i];
nd[i] = antennaPartialMetalArea_[i];
}
lefFree((char*) (antennaPartialMetalAreaLayer_));
lefFree((char*) (antennaPartialMetalArea_));
antennaPartialMetalAreaLayer_ = nl;
antennaPartialMetalArea_ = nd;
}
antennaPartialMetalArea_[numAntennaPartialMetalArea_] = val;
if (layer) { // layer can be null, since it is optional
len = strlen(layer) + 1;
antennaPartialMetalAreaLayer_[numAntennaPartialMetalArea_] =
(char*) lefMalloc(len);
strcpy(antennaPartialMetalAreaLayer_[numAntennaPartialMetalArea_],
layer);
} else
antennaPartialMetalAreaLayer_[numAntennaPartialMetalArea_] = NULL;
numAntennaPartialMetalArea_ += 1;
}
|
O3
|
cpp
|
LefDefParser::lefiPin::addAntennaPartialMetalArea(double, char const*):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x1c8(%rdi), %r13d
cmpl 0x1cc(%rdi), %r13d
jne 0x368ec
movsd %xmm0, 0x8(%rsp)
leal (,%r13,2), %eax
testl %r13d, %r13d
movl $0x2, %ecx
cmovnel %eax, %ecx
movl %ecx, 0x1cc(%rbx)
movslq %ecx, %r12
shlq $0x3, %r12
movq %r12, %rdi
callq 0x30c15
movq %rax, %r15
movq %r12, %rdi
callq 0x30c15
movq %rax, %r12
testl %r13d, %r13d
jle 0x368b7
xorl %eax, %eax
movq 0x1d8(%rbx), %rcx
movq (%rcx,%rax,8), %rcx
movq %rcx, (%r12,%rax,8)
movq 0x1d0(%rbx), %rcx
movsd (%rcx,%rax,8), %xmm0
movsd %xmm0, (%r15,%rax,8)
incq %rax
cmpq %rax, %r13
jne 0x3688e
movq 0x1d8(%rbx), %rdi
callq 0x322d0
movq 0x1d0(%rbx), %rdi
callq 0x322d0
movq %r12, 0x1d8(%rbx)
movq %r15, 0x1d0(%rbx)
movl 0x1c8(%rbx), %r13d
movsd 0x8(%rsp), %xmm0
jmp 0x368f3
movq 0x1d0(%rbx), %r15
movslq %r13d, %rax
movsd %xmm0, (%r15,%rax,8)
testq %r14, %r14
je 0x36941
movq %r14, %rdi
callq 0x20e0
incl %eax
movslq %eax, %rdi
callq 0x30c15
movq 0x1d8(%rbx), %rcx
movslq 0x1c8(%rbx), %rdx
movq %rax, (%rcx,%rdx,8)
movq 0x1d8(%rbx), %rax
movq (%rax,%rdx,8), %rdi
movq %r14, %rsi
callq 0x21d0
movl 0x1c8(%rbx), %r13d
jmp 0x36950
movq 0x1d8(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incl %r13d
movl %r13d, 0x1c8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
_ZN12LefDefParser7lefiPin26addAntennaPartialMetalAreaEdPKc:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov r14, rsi
mov rbx, rdi
mov r13d, [rdi+1C8h]
cmp r13d, [rdi+1CCh]
jnz loc_368EC
movsd [rsp+38h+var_30], xmm0
lea eax, ds:0[r13*2]
test r13d, r13d
mov ecx, 2
cmovnz ecx, eax
mov [rbx+1CCh], ecx
movsxd r12, ecx
shl r12, 3
mov rdi, r12; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov r15, rax
mov rdi, r12; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov r12, rax
test r13d, r13d
jle short loc_368B7
xor eax, eax
loc_3688E:
mov rcx, [rbx+1D8h]
mov rcx, [rcx+rax*8]
mov [r12+rax*8], rcx
mov rcx, [rbx+1D0h]
movsd xmm0, qword ptr [rcx+rax*8]
movsd qword ptr [r15+rax*8], xmm0
inc rax
cmp r13, rax
jnz short loc_3688E
loc_368B7:
mov rdi, [rbx+1D8h]; this
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
mov rdi, [rbx+1D0h]; this
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
mov [rbx+1D8h], r12
mov [rbx+1D0h], r15
mov r13d, [rbx+1C8h]
movsd xmm0, [rsp+38h+var_30]
jmp short loc_368F3
loc_368EC:
mov r15, [rbx+1D0h]
loc_368F3:
movsxd rax, r13d
movsd qword ptr [r15+rax*8], xmm0
test r14, r14
jz short loc_36941
mov rdi, r14
call _strlen
inc eax
movsxd rdi, eax; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov rcx, [rbx+1D8h]
movsxd rdx, dword ptr [rbx+1C8h]
mov [rcx+rdx*8], rax
mov rax, [rbx+1D8h]
mov rdi, [rax+rdx*8]
mov rsi, r14
call _strcpy
mov r13d, [rbx+1C8h]
jmp short loc_36950
loc_36941:
mov rcx, [rbx+1D8h]
mov qword ptr [rcx+rax*8], 0
loc_36950:
inc r13d
mov [rbx+1C8h], r13d
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
|
long long LefDefParser::lefiPin::addAntennaPartialMetalArea(LefDefParser::lefiPin *this, double a2, char *a3)
{
long long v3; // r13
int v4; // ecx
LefDefParser *v5; // r12
long long v6; // r15
long long v7; // r12
long long i; // rax
long long result; // rax
int v10; // eax
long long v11; // rax
long long v12; // rdx
v3 = *((unsigned int *)this + 114);
if ( (_DWORD)v3 == *((_DWORD *)this + 115) )
{
v4 = 2;
if ( (_DWORD)v3 )
v4 = 2 * v3;
*((_DWORD *)this + 115) = v4;
v5 = (LefDefParser *)(8LL * v4);
v6 = LefDefParser::lefMalloc(v5);
v7 = LefDefParser::lefMalloc(v5);
if ( (int)v3 > 0 )
{
for ( i = 0LL; i != v3; ++i )
{
*(_QWORD *)(v7 + 8 * i) = *(_QWORD *)(*((_QWORD *)this + 59) + 8 * i);
*(_QWORD *)(v6 + 8 * i) = *(_QWORD *)(*((_QWORD *)this + 58) + 8 * i);
}
}
LefDefParser::lefFree(*((LefDefParser **)this + 59), a3);
LefDefParser::lefFree(*((LefDefParser **)this + 58), a3);
*((_QWORD *)this + 59) = v7;
*((_QWORD *)this + 58) = v6;
LODWORD(v3) = *((_DWORD *)this + 114);
}
else
{
v6 = *((_QWORD *)this + 58);
}
result = (int)v3;
*(double *)(v6 + 8LL * (int)v3) = a2;
if ( a3 )
{
v10 = strlen(a3);
v11 = LefDefParser::lefMalloc((LefDefParser *)(v10 + 1));
v12 = *((int *)this + 114);
*(_QWORD *)(*((_QWORD *)this + 59) + 8 * v12) = v11;
result = strcpy(*(_QWORD *)(*((_QWORD *)this + 59) + 8 * v12), a3);
LODWORD(v3) = *((_DWORD *)this + 114);
}
else
{
*(_QWORD *)(*((_QWORD *)this + 59) + 8LL * (int)v3) = 0LL;
}
*((_DWORD *)this + 114) = v3 + 1;
return result;
}
|
addAntennaPartialMetalArea:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R14,RSI
MOV RBX,RDI
MOV R13D,dword ptr [RDI + 0x1c8]
CMP R13D,dword ptr [RDI + 0x1cc]
JNZ 0x001368ec
MOVSD qword ptr [RSP + 0x8],XMM0
LEA EAX,[R13*0x2]
TEST R13D,R13D
MOV ECX,0x2
CMOVNZ ECX,EAX
MOV dword ptr [RBX + 0x1cc],ECX
MOVSXD R12,ECX
SHL R12,0x3
MOV RDI,R12
CALL 0x00130c15
MOV R15,RAX
MOV RDI,R12
CALL 0x00130c15
MOV R12,RAX
TEST R13D,R13D
JLE 0x001368b7
XOR EAX,EAX
LAB_0013688e:
MOV RCX,qword ptr [RBX + 0x1d8]
MOV RCX,qword ptr [RCX + RAX*0x8]
MOV qword ptr [R12 + RAX*0x8],RCX
MOV RCX,qword ptr [RBX + 0x1d0]
MOVSD XMM0,qword ptr [RCX + RAX*0x8]
MOVSD qword ptr [R15 + RAX*0x8],XMM0
INC RAX
CMP R13,RAX
JNZ 0x0013688e
LAB_001368b7:
MOV RDI,qword ptr [RBX + 0x1d8]
CALL 0x001322d0
MOV RDI,qword ptr [RBX + 0x1d0]
CALL 0x001322d0
MOV qword ptr [RBX + 0x1d8],R12
MOV qword ptr [RBX + 0x1d0],R15
MOV R13D,dword ptr [RBX + 0x1c8]
MOVSD XMM0,qword ptr [RSP + 0x8]
JMP 0x001368f3
LAB_001368ec:
MOV R15,qword ptr [RBX + 0x1d0]
LAB_001368f3:
MOVSXD RAX,R13D
MOVSD qword ptr [R15 + RAX*0x8],XMM0
TEST R14,R14
JZ 0x00136941
MOV RDI,R14
CALL 0x001020e0
INC EAX
MOVSXD RDI,EAX
CALL 0x00130c15
MOV RCX,qword ptr [RBX + 0x1d8]
MOVSXD RDX,dword ptr [RBX + 0x1c8]
MOV qword ptr [RCX + RDX*0x8],RAX
MOV RAX,qword ptr [RBX + 0x1d8]
MOV RDI,qword ptr [RAX + RDX*0x8]
MOV RSI,R14
CALL 0x001021d0
MOV R13D,dword ptr [RBX + 0x1c8]
JMP 0x00136950
LAB_00136941:
MOV RCX,qword ptr [RBX + 0x1d8]
MOV qword ptr [RCX + RAX*0x8],0x0
LAB_00136950:
INC R13D
MOV dword ptr [RBX + 0x1c8],R13D
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* LefDefParser::lefiPin::addAntennaPartialMetalArea(double, char const*) */
void __thiscall
LefDefParser::lefiPin::addAntennaPartialMetalArea(lefiPin *this,double param_1,char *param_2)
{
long lVar1;
long lVar2;
ulong uVar3;
size_t sVar4;
int8 uVar5;
int iVar6;
char *pcVar7;
uint uVar8;
uVar8 = *(uint *)(this + 0x1c8);
pcVar7 = param_2;
if (uVar8 == *(uint *)(this + 0x1cc)) {
iVar6 = 2;
if (uVar8 != 0) {
iVar6 = uVar8 * 2;
}
*(int *)(this + 0x1cc) = iVar6;
lVar1 = lefMalloc((LefDefParser *)((long)iVar6 << 3),(ulong)param_2);
lVar2 = lefMalloc((LefDefParser *)((long)iVar6 << 3),(ulong)pcVar7);
if (0 < (int)uVar8) {
uVar3 = 0;
do {
*(int8 *)(lVar2 + uVar3 * 8) = *(int8 *)(*(long *)(this + 0x1d8) + uVar3 * 8);
*(int8 *)(lVar1 + uVar3 * 8) = *(int8 *)(*(long *)(this + 0x1d0) + uVar3 * 8);
uVar3 = uVar3 + 1;
} while (uVar8 != uVar3);
}
lefFree(*(void **)(this + 0x1d8));
lefFree(*(void **)(this + 0x1d0));
*(long *)(this + 0x1d8) = lVar2;
*(long *)(this + 0x1d0) = lVar1;
uVar8 = *(uint *)(this + 0x1c8);
}
else {
lVar1 = *(long *)(this + 0x1d0);
}
*(double *)(lVar1 + (long)(int)uVar8 * 8) = param_1;
if (param_2 == (char *)0x0) {
*(int8 *)(*(long *)(this + 0x1d8) + (long)(int)uVar8 * 8) = 0;
}
else {
sVar4 = strlen(param_2);
uVar5 = lefMalloc((LefDefParser *)(long)((int)sVar4 + 1),(ulong)pcVar7);
iVar6 = *(int *)(this + 0x1c8);
*(int8 *)(*(long *)(this + 0x1d8) + (long)iVar6 * 8) = uVar5;
strcpy(*(char **)(*(long *)(this + 0x1d8) + (long)iVar6 * 8),param_2);
uVar8 = *(uint *)(this + 0x1c8);
}
*(uint *)(this + 0x1c8) = uVar8 + 1;
return;
}
|
|
18,444
|
rawsock_prepare
|
xtate/src/rawsock/rawsock.c
|
void rawsock_prepare(void) {
/* load pcap as stub dynamically */
if (pcap_init() != 0)
LOG(LEVEL_ERROR, "(libpcap) failed to load\n");
#ifndef _WIN32
PFRING_init();
#endif
return;
}
|
O3
|
c
|
rawsock_prepare:
pushq %rax
callq 0x42be9
testl %eax, %eax
je 0x36471
leaq 0x35c8f(%rip), %rsi # 0x6c0f4
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x536da
popq %rax
jmp 0x43948
|
rawsock_prepare:
push rax
call pcap_init
test eax, eax
jz short loc_36471
lea rsi, aLibpcapFailedT; "(libpcap) failed to load\n"
mov edi, 0FFFFFFFFh
xor eax, eax
call LOG
loc_36471:
pop rax
jmp PFRING_init
|
long long rawsock_prepare()
{
int v0; // edx
int v1; // ecx
int v2; // r8d
int v3; // r9d
if ( (unsigned int)pcap_init() )
LOG(-1, (unsigned int)"(libpcap) failed to load\n", v0, v1, v2, v3);
return PFRING_init();
}
|
rawsock_prepare:
PUSH RAX
CALL 0x00142be9
TEST EAX,EAX
JZ 0x00136471
LEA RSI,[0x16c0f4]
MOV EDI,0xffffffff
XOR EAX,EAX
CALL 0x001536da
LAB_00136471:
POP RAX
JMP 0x00143948
|
void rawsock_prepare(void)
{
int iVar1;
iVar1 = pcap_init();
if (iVar1 != 0) {
LOG(0xffffffff,"(libpcap) failed to load\n");
}
PFRING_init();
return;
}
|
|
18,445
|
ftxui::ButtonOption::Animated(ftxui::Color, ftxui::Color, ftxui::Color, ftxui::Color)
|
Andrewchistyakov[P]flashcards_lyc/build_O0/_deps/ftxui-src/src/ftxui/component/component_options.cpp
|
ButtonOption ButtonOption::Animated(Color background,
Color foreground,
Color background_active,
Color foreground_active) {
ButtonOption option;
option.transform = [](const EntryState& s) {
auto element = text(s.label) | borderEmpty;
if (s.focused) {
element |= bold;
}
return element;
};
option.animated_colors.foreground.Set(foreground, foreground_active);
option.animated_colors.background.Set(background, background_active);
return option;
}
|
O0
|
cpp
|
ftxui::ButtonOption::Animated(ftxui::Color, ftxui::Color, ftxui::Color, ftxui::Color):
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x7a9a0
movq -0xb8(%rbp), %rdi
addq $0x48, %rdi
leaq -0x1a(%rbp), %rsi
callq 0x75740
movq -0xb8(%rbp), %rdi
addq $0x98, %rdi
movq %rdi, -0xb0(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movl $0xfa, -0x34(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x7aa80
jmp 0x754f1
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7aaa0
jmp 0x75500
leaq 0x7939(%rip), %rsi # 0x7ce40
leaq -0x68(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x7aae0
movq -0xb0(%rbp), %rdi
movq -0xd0(%rbp), %rcx
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
movss -0x28(%rbp), %xmm0
callq 0x74d30
movq -0xd0(%rbp), %rdi
callq 0x7a760
movq -0xb8(%rbp), %rax
addq $0x68, %rax
movq %rax, -0xc8(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x6c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x70(%rbp)
movl $0xfa, -0x84(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x84(%rbp), %rsi
callq 0x7aa80
jmp 0x7557b
leaq -0x74(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x7aaa0
jmp 0x7558a
leaq -0xa8(%rbp), %rdi
leaq 0x78a8(%rip), %rsi # 0x7ce40
callq 0x7aae0
movq -0xc8(%rbp), %rdi
movl -0x6c(%rbp), %esi
movl -0x70(%rbp), %edx
movss -0x74(%rbp), %xmm0
leaq -0xa8(%rbp), %rcx
callq 0x74d30
leaq -0xa8(%rbp), %rdi
callq 0x7a760
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x755f9
jmp 0x755ed
movq -0xb8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x7aa30
jmp 0x75609
movq -0xb8(%rbp), %rdi
callq 0x7aa30
movq -0xc0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xda90
nopw %cs:(%rax,%rax)
|
_ZN5ftxui12ButtonOption8AnimatedENS_5ColorES1_S1_S1_:
push rbp
mov rbp, rsp
sub rsp, 0D0h
mov [rbp+var_B8], rdi
mov rax, rdi
mov [rbp+var_C0], rax
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_10], edx
mov [rbp+var_14], ecx
mov [rbp+var_18], r8d
mov [rbp+var_19], 0
call _ZN5ftxui12ButtonOptionC2Ev; ftxui::ButtonOption::ButtonOption(void)
mov rdi, [rbp+var_B8]
add rdi, 48h ; 'H'
lea rsi, [rbp+var_1A]
call _ZNSt8functionIFSt10shared_ptrIN5ftxui4NodeEERKNS1_10EntryStateEEEaSIZNS1_12ButtonOption8AnimatedENS1_5ColorESB_SB_SB_E3$_0EENSt9enable_ifIXsrNS8_9_CallableIT_NSD_IXntsr7is_sameINSt9remove_cvINSt16remove_referenceISF_E4typeEE4typeES8_EE5valueESt5decayISF_EE4type4typeESt15__invoke_resultIRSQ_JS6_EEEE5valueERS8_E4typeEOSF_
mov rdi, [rbp+var_B8]
add rdi, 98h
mov [rbp+var_B0], rdi
mov eax, [rbp+var_10]
mov [rbp+var_20], eax
mov eax, [rbp+var_18]
mov [rbp+var_24], eax
mov [rbp+var_34], 0FAh
lea rdi, [rbp+var_30]
lea rsi, [rbp+var_34]
call _ZNSt6chrono8durationIlSt5ratioILl1ELl1000EEEC2IivEERKT_; std::chrono::duration<long,std::ratio<1l,1000l>>::duration<int,void>(int const&)
jmp short $+2
loc_754F1:
lea rdi, [rbp+var_28]
lea rsi, [rbp+var_30]
call _ZNSt6chrono8durationIfSt5ratioILl1ELl1EEEC2IlS1_ILl1ELl1000EEvEERKNS0_IT_T0_EE; std::chrono::duration<float,std::ratio<1l,1l>>::duration<long,std::ratio<1l,1000l>,void>(std::chrono::duration<long,std::ratio<1l,1000l>> const&)
jmp short $+2
loc_75500:
lea rsi, _ZN5ftxui9animation6easing14QuadraticInOutEf; ftxui::animation::easing::QuadraticInOut(float)
lea rdi, [rbp+var_68]
mov [rbp+var_D0], rdi
call _ZNSt8functionIFffEEC2IRS0_vEEOT_; std::function<float ()(float)>::function<float (&)(float),void>(float (&)(float) &&)
mov rdi, [rbp+var_B0]
mov rcx, [rbp+var_D0]
mov esi, [rbp+var_20]
mov edx, [rbp+var_24]
movss xmm0, [rbp+var_28]
call _ZN5ftxui19AnimatedColorOption3SetENS_5ColorES1_NSt6chrono8durationIfSt5ratioILl1ELl1EEEESt8functionIFffEE; ftxui::AnimatedColorOption::Set(ftxui::Color,ftxui::Color,std::chrono::duration<float,std::ratio<1l,1l>>,std::function<float ()(float)>)
mov rdi, [rbp+var_D0]
call _ZNSt8functionIFffEED2Ev; std::function<float ()(float)>::~function()
mov rax, [rbp+var_B8]
add rax, 68h ; 'h'
mov [rbp+var_C8], rax
mov eax, [rbp+var_C]
mov [rbp+var_6C], eax
mov eax, [rbp+var_14]
mov [rbp+var_70], eax
mov [rbp+var_84], 0FAh
lea rdi, [rbp+var_80]
lea rsi, [rbp+var_84]
call _ZNSt6chrono8durationIlSt5ratioILl1ELl1000EEEC2IivEERKT_; std::chrono::duration<long,std::ratio<1l,1000l>>::duration<int,void>(int const&)
jmp short $+2
loc_7557B:
lea rdi, [rbp+var_74]
lea rsi, [rbp+var_80]
call _ZNSt6chrono8durationIfSt5ratioILl1ELl1EEEC2IlS1_ILl1ELl1000EEvEERKNS0_IT_T0_EE; std::chrono::duration<float,std::ratio<1l,1l>>::duration<long,std::ratio<1l,1000l>,void>(std::chrono::duration<long,std::ratio<1l,1000l>> const&)
jmp short $+2
loc_7558A:
lea rdi, [rbp+var_A8]
lea rsi, _ZN5ftxui9animation6easing14QuadraticInOutEf; ftxui::animation::easing::QuadraticInOut(float)
call _ZNSt8functionIFffEEC2IRS0_vEEOT_; std::function<float ()(float)>::function<float (&)(float),void>(float (&)(float) &&)
mov rdi, [rbp+var_C8]
mov esi, [rbp+var_6C]
mov edx, [rbp+var_70]
movss xmm0, [rbp+var_74]
lea rcx, [rbp+var_A8]
call _ZN5ftxui19AnimatedColorOption3SetENS_5ColorES1_NSt6chrono8durationIfSt5ratioILl1ELl1EEEESt8functionIFffEE; ftxui::AnimatedColorOption::Set(ftxui::Color,ftxui::Color,std::chrono::duration<float,std::ratio<1l,1l>>,std::function<float ()(float)>)
lea rdi, [rbp+var_A8]
call _ZNSt8functionIFffEED2Ev; std::function<float ()(float)>::~function()
mov [rbp+var_19], 1
test [rbp+var_19], 1
jnz short loc_755F9
jmp short loc_755ED
mov rdi, [rbp+var_B8]; this
mov rcx, rax
mov eax, edx
mov [rbp+var_40], rcx
mov [rbp+var_44], eax
call _ZN5ftxui12ButtonOptionD2Ev; ftxui::ButtonOption::~ButtonOption()
jmp short loc_75609
loc_755ED:
mov rdi, [rbp+var_B8]; this
call _ZN5ftxui12ButtonOptionD2Ev; ftxui::ButtonOption::~ButtonOption()
loc_755F9:
mov rax, [rbp+var_C0]
add rsp, 0D0h
pop rbp
retn
loc_75609:
mov rdi, [rbp+var_40]
call __Unwind_Resume
|
ftxui::ButtonOption * ftxui::ButtonOption::Animated(ftxui::ButtonOption *a1, int a2, int a3, int a4, int a5)
{
_BYTE v6[36]; // [rsp+28h] [rbp-A8h] BYREF
int v7; // [rsp+4Ch] [rbp-84h] BYREF
_BYTE v8[12]; // [rsp+50h] [rbp-80h] BYREF
float v9; // [rsp+5Ch] [rbp-74h] BYREF
int v10; // [rsp+60h] [rbp-70h]
int v11; // [rsp+64h] [rbp-6Ch]
_BYTE v12[36]; // [rsp+68h] [rbp-68h] BYREF
int v13; // [rsp+9Ch] [rbp-34h] BYREF
_BYTE v14[8]; // [rsp+A0h] [rbp-30h] BYREF
float v15; // [rsp+A8h] [rbp-28h] BYREF
int v16; // [rsp+ACh] [rbp-24h]
int v17; // [rsp+B0h] [rbp-20h]
_BYTE v18[2]; // [rsp+B6h] [rbp-1Ah] BYREF
int v19; // [rsp+B8h] [rbp-18h]
int v20; // [rsp+BCh] [rbp-14h]
int v21; // [rsp+C0h] [rbp-10h]
int v22; // [rsp+C4h] [rbp-Ch]
ftxui::ButtonOption *v23; // [rsp+C8h] [rbp-8h]
v23 = a1;
v22 = a2;
v21 = a3;
v20 = a4;
v19 = a5;
v18[1] = 0;
ftxui::ButtonOption::ButtonOption(a1);
std::function<std::shared_ptr<ftxui::Node> ()(ftxui::EntryState const&)>::operator=<ftxui::ButtonOption::Animated(ftxui::Color,ftxui::Color,ftxui::Color,ftxui::Color)::$_0>(
(char *)a1 + 72,
v18);
v17 = v21;
v16 = v19;
v13 = 250;
std::chrono::duration<long,std::ratio<1l,1000l>>::duration<int,void>(v14, &v13);
std::chrono::duration<float,std::ratio<1l,1l>>::duration<long,std::ratio<1l,1000l>,void>(&v15, v14);
std::function<float ()(float)>::function<float (&)(float),void>(v12, ftxui::animation::easing::QuadraticInOut);
ftxui::AnimatedColorOption::Set((long long)a1 + 152, v17, v16, v15);
std::function<float ()(float)>::~function(v12);
v11 = v22;
v10 = v20;
v7 = 250;
std::chrono::duration<long,std::ratio<1l,1000l>>::duration<int,void>(v8, &v7);
std::chrono::duration<float,std::ratio<1l,1l>>::duration<long,std::ratio<1l,1000l>,void>(&v9, v8);
std::function<float ()(float)>::function<float (&)(float),void>(v6, ftxui::animation::easing::QuadraticInOut);
ftxui::AnimatedColorOption::Set((long long)a1 + 104, v11, v10, v9);
std::function<float ()(float)>::~function(v6);
return a1;
}
|
Animated:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
MOV qword ptr [RBP + -0xb8],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0xc0],RAX
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [RBP + -0x10],EDX
MOV dword ptr [RBP + -0x14],ECX
MOV dword ptr [RBP + -0x18],R8D
MOV byte ptr [RBP + -0x19],0x0
CALL 0x0017a9a0
MOV RDI,qword ptr [RBP + -0xb8]
ADD RDI,0x48
LEA RSI,[RBP + -0x1a]
CALL 0x00175740
MOV RDI,qword ptr [RBP + -0xb8]
ADD RDI,0x98
MOV qword ptr [RBP + -0xb0],RDI
MOV EAX,dword ptr [RBP + -0x10]
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x24],EAX
MOV dword ptr [RBP + -0x34],0xfa
LAB_001754e2:
LEA RDI,[RBP + -0x30]
LEA RSI,[RBP + -0x34]
CALL 0x0017aa80
JMP 0x001754f1
LAB_001754f1:
LEA RDI,[RBP + -0x28]
LEA RSI,[RBP + -0x30]
CALL 0x0017aaa0
JMP 0x00175500
LAB_00175500:
LEA RSI,[0x17ce40]
LEA RDI,[RBP + -0x68]
MOV qword ptr [RBP + -0xd0],RDI
CALL 0x0017aae0
MOV RDI,qword ptr [RBP + -0xb0]
MOV RCX,qword ptr [RBP + -0xd0]
MOV ESI,dword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x24]
MOVSS XMM0,dword ptr [RBP + -0x28]
CALL 0x00174d30
MOV RDI,qword ptr [RBP + -0xd0]
CALL 0x0017a760
MOV RAX,qword ptr [RBP + -0xb8]
ADD RAX,0x68
MOV qword ptr [RBP + -0xc8],RAX
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x6c],EAX
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x70],EAX
MOV dword ptr [RBP + -0x84],0xfa
LEA RDI,[RBP + -0x80]
LEA RSI,[RBP + -0x84]
CALL 0x0017aa80
JMP 0x0017557b
LAB_0017557b:
LEA RDI,[RBP + -0x74]
LEA RSI,[RBP + -0x80]
CALL 0x0017aaa0
LAB_00175588:
JMP 0x0017558a
LAB_0017558a:
LEA RDI,[RBP + -0xa8]
LEA RSI,[0x17ce40]
CALL 0x0017aae0
MOV RDI,qword ptr [RBP + -0xc8]
MOV ESI,dword ptr [RBP + -0x6c]
MOV EDX,dword ptr [RBP + -0x70]
MOVSS XMM0,dword ptr [RBP + -0x74]
LEA RCX,[RBP + -0xa8]
CALL 0x00174d30
LEA RDI,[RBP + -0xa8]
CALL 0x0017a760
MOV byte ptr [RBP + -0x19],0x1
TEST byte ptr [RBP + -0x19],0x1
JNZ 0x001755f9
JMP 0x001755ed
LAB_001755ed:
MOV RDI,qword ptr [RBP + -0xb8]
CALL 0x0017aa30
LAB_001755f9:
MOV RAX,qword ptr [RBP + -0xc0]
ADD RSP,0xd0
POP RBP
RET
|
/* WARNING: Removing unreachable block (ram,0x001755d1) */
/* ftxui::ButtonOption::Animated(ftxui::Color, ftxui::Color, ftxui::Color, ftxui::Color) */
ButtonOption * __thiscall
ftxui::ButtonOption::Animated
(ButtonOption *this,int4 param_2,int4 param_3,int4 param_4,
int4 param_5)
{
function<float(float)> local_b0 [36];
int local_8c;
duration<long,std::ratio<1l,1000l>> local_88 [12];
int8 local_7c;
int4 local_74;
function<float(float)> local_70 [52];
int local_3c;
duration<long,std::ratio<1l,1000l>> local_38 [8];
int8 local_30;
int4 local_28;
__0 local_22;
int1 local_21;
int4 local_20;
int4 local_1c;
int4 local_18;
int4 local_14;
ButtonOption *local_10;
local_21 = 0;
local_20 = param_5;
local_1c = param_4;
local_18 = param_3;
local_14 = param_2;
local_10 = this;
ButtonOption(this);
std::function<std::shared_ptr<ftxui::Node>(ftxui::EntryState_const&)>::operator=
((function<std::shared_ptr<ftxui::Node>(ftxui::EntryState_const&)> *)(this + 0x48),
&local_22);
local_28 = local_18;
local_30._4_4_ = local_20;
local_3c = 0xfa;
/* try { // try from 001754e2 to 00175587 has its CatchHandler @ 001755d3 */
std::chrono::duration<long,std::ratio<1l,1000l>>::duration<int,void>(local_38,&local_3c);
std::chrono::duration<float,std::ratio<1l,1l>>::duration<long,std::ratio<1l,1000l>,void>
((duration<float,std::ratio<1l,1l>> *)&local_30,(duration *)local_38);
std::function<float(float)>::function<float(&)(float),void>
(local_70,animation::easing::QuadraticInOut);
AnimatedColorOption::Set
((AnimatedColorOption *)local_30,this + 0x98,local_28,local_30._4_4_,local_70);
std::function<float(float)>::~function(local_70);
local_74 = local_14;
local_7c._4_4_ = local_1c;
local_8c = 0xfa;
std::chrono::duration<long,std::ratio<1l,1000l>>::duration<int,void>(local_88,&local_8c);
std::chrono::duration<float,std::ratio<1l,1l>>::duration<long,std::ratio<1l,1000l>,void>
((duration<float,std::ratio<1l,1l>> *)&local_7c,(duration *)local_88);
std::function<float(float)>::function<float(&)(float),void>
(local_b0,animation::easing::QuadraticInOut);
AnimatedColorOption::Set
((AnimatedColorOption *)local_7c,this + 0x68,local_74,local_7c._4_4_,local_b0);
std::function<float(float)>::~function(local_b0);
return this;
}
|
|
18,446
|
ma_read_key_record
|
eloqsql/storage/maria/ma_key.c
|
int _ma_read_key_record(MARIA_HA *info, uchar *buf, MARIA_RECORD_POS filepos)
{
fast_ma_writeinfo(info);
if (filepos != HA_OFFSET_ERROR)
{
if (info->lastinx >= 0)
{ /* Read only key */
if (_ma_put_key_in_record(info, (uint)info->lastinx, TRUE, buf))
{
_ma_set_fatal_error(info, HA_ERR_CRASHED);
return -1;
}
info->update|= HA_STATE_AKTIV; /* We should find a record */
return 0;
}
my_errno=HA_ERR_WRONG_INDEX;
}
return(-1); /* Wrong data to read */
}
|
O3
|
c
|
ma_read_key_record:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rax
cmpl $0x0, 0x7b8(%rax)
jne 0x373f6
movq %r14, %rdi
xorl %esi, %esi
callq 0x37de6
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
cmpq $-0x1, %r12
je 0x37446
movl 0x62c(%r14), %esi
testl %esi, %esi
js 0x3742f
movq %r14, %rdi
movl $0x1, %edx
movq %r15, %rcx
callq 0x37451
testl %eax, %eax
je 0x3743c
movq %r14, %rdi
movl $0x7e, %esi
callq 0x36a4c
jmp 0x37446
callq 0xa1b22
movl $0x7c, (%rax)
jmp 0x37446
orb $0x2, 0x624(%r14)
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
_ma_read_key_record:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r12, rdx
mov r15, rsi
mov r14, rdi
mov rax, [rdi]
cmp dword ptr [rax+7B8h], 0
jnz short loc_373F6
mov rdi, r14
xor esi, esi
call _ma_writeinfo
loc_373F6:
mov ebx, 0FFFFFFFFh
cmp r12, 0FFFFFFFFFFFFFFFFh
jz short loc_37446
mov esi, [r14+62Ch]
test esi, esi
js short loc_3742F
mov rdi, r14
mov edx, 1
mov rcx, r15
call _ma_put_key_in_record
test eax, eax
jz short loc_3743C
mov rdi, r14
mov esi, 7Eh ; '~'
call _ma_set_fatal_error
jmp short loc_37446
loc_3742F:
call _my_thread_var
mov dword ptr [rax], 7Ch ; '|'
jmp short loc_37446
loc_3743C:
or byte ptr [r14+624h], 2
xor ebx, ebx
loc_37446:
mov eax, ebx
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long ma_read_key_record(unsigned int *a1, long long a2, long long a3, long long a4, long long a5)
{
unsigned int v7; // ebx
long long v8; // rsi
long long v9; // rdx
long long v10; // rcx
long long v11; // r8
int v12; // r9d
if ( !*(_DWORD *)(*(_QWORD *)a1 + 1976LL) )
ma_writeinfo(a1, 0LL);
v7 = -1;
if ( a3 != -1 )
{
v8 = a1[395];
if ( (int)v8 < 0 )
{
*(_DWORD *)my_thread_var(a1, v8, a3, a4, a5) = 124;
}
else if ( (unsigned int)ma_put_key_in_record(a1, v8, 1LL, a2) )
{
ma_set_fatal_error(a1, 126LL, v9, v10, v11, v12);
}
else
{
*((_BYTE *)a1 + 1572) |= 2u;
return 0;
}
}
return v7;
}
|
_ma_read_key_record:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R12,RDX
MOV R15,RSI
MOV R14,RDI
MOV RAX,qword ptr [RDI]
CMP dword ptr [RAX + 0x7b8],0x0
JNZ 0x001373f6
MOV RDI,R14
XOR ESI,ESI
CALL 0x00137de6
LAB_001373f6:
MOV EBX,0xffffffff
CMP R12,-0x1
JZ 0x00137446
MOV ESI,dword ptr [R14 + 0x62c]
TEST ESI,ESI
JS 0x0013742f
MOV RDI,R14
MOV EDX,0x1
MOV RCX,R15
CALL 0x00137451
TEST EAX,EAX
JZ 0x0013743c
MOV RDI,R14
MOV ESI,0x7e
CALL 0x00136a4c
JMP 0x00137446
LAB_0013742f:
CALL 0x001a1b22
MOV dword ptr [RAX],0x7c
JMP 0x00137446
LAB_0013743c:
OR byte ptr [R14 + 0x624],0x2
XOR EBX,EBX
LAB_00137446:
MOV EAX,EBX
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int8 _ma_read_key_record(long *param_1,int8 param_2,long param_3)
{
int iVar1;
int4 *puVar2;
int8 uVar3;
if (*(int *)(*param_1 + 0x7b8) == 0) {
_ma_writeinfo(param_1,0);
}
uVar3 = 0xffffffff;
if (param_3 != -1) {
if (*(int *)((long)param_1 + 0x62c) < 0) {
puVar2 = (int4 *)_my_thread_var();
*puVar2 = 0x7c;
}
else {
iVar1 = _ma_put_key_in_record(param_1,*(int *)((long)param_1 + 0x62c),1,param_2);
if (iVar1 == 0) {
*(byte *)((long)param_1 + 0x624) = *(byte *)((long)param_1 + 0x624) | 2;
uVar3 = 0;
}
else {
_ma_set_fatal_error(param_1,0x7e);
}
}
}
return uVar3;
}
|
|
18,447
|
bool nlohmann::json_abi_v3_11_3::operator==<unsigned long, 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&, unsigned long)
|
monkey531[P]llama/common/json.hpp
|
bool operator==(const_reference lhs, ScalarType rhs) noexcept
{
return lhs == basic_json(rhs);
}
|
O1
|
cpp
|
bool nlohmann::json_abi_v3_11_3::operator==<unsigned long, 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&, unsigned long):
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq %r14, %rdi
callq 0x61eb8
movq %r14, %rdi
movl $0x1, %esi
callq 0x59822
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8f215
movl %eax, %ebx
movq %r14, %rdi
xorl %esi, %esi
callq 0x59822
movq %r14, %rdi
callq 0x5f00e
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
|
_ZN8nlohmann16json_abi_v3_11_3eqImTnNSt9enable_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_tE6EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_17number_unsigned_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)6>::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>::number_unsigned_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_3eqERKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEESF_; nlohmann::json_abi_v3_11_3::operator==(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
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_3eqImTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES3_(
unsigned __int8 *a1,
long long a2)
{
unsigned int v2; // ebx
_OWORD v4[2]; // [rsp+0h] [rbp-28h] BYREF
v4[0] = 0LL;
nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)6>::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 *)v4,
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 *)v4);
v2 = nlohmann::json_abi_v3_11_3::operator==(a1, (unsigned __int8 *)v4, (__m128d)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 *)v4);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v4);
return v2;
}
|
_ZN8nlohmann16json_abi_v3_11_3eqImTnNSt9enable_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 0x00161eb8
MOV RDI,R14
MOV ESI,0x1
CALL 0x00159822
MOV RDI,RBX
MOV RSI,R14
CALL 0x0018f215
MOV EBX,EAX
MOV RDI,R14
XOR ESI,ESI
CALL 0x00159822
MOV RDI,R14
CALL 0x0015f00e
MOV EAX,EBX
ADD RSP,0x18
POP RBX
POP R14
RET
|
int4
_ZN8nlohmann16json_abi_v3_11_3eqImTnNSt9enable_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)6>::
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;
}
|
|
18,448
|
nglog::ErrnoLogMessage::ErrnoLogMessage(char const*, int, nglog::LogSeverity, long, void (nglog::LogMessage::*)())
|
ng-log[P]ng-log/src/logging.cc
|
ErrnoLogMessage::ErrnoLogMessage(const char* file, int line,
LogSeverity severity, int64 ctr,
void (LogMessage::*send_method)())
: LogMessage(file, line, severity, ctr, send_method) {}
|
O3
|
cpp
|
nglog::ErrnoLogMessage::ErrnoLogMessage(char const*, int, nglog::LogSeverity, long, void (nglog::LogMessage::*)()):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, (%rsp)
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
movq 0x40(%rsp), %r13
movq 0x48(%rsp), %rbx
movq $0x0, (%rdi)
addq $0x10, %rdi
callq 0x1db42
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movq %r13, %r8
movq %rbx, %r9
callq 0x192ba
movq 0x8(%r12), %rax
movq (%rsp), %rcx
movq %rcx, 0x7580(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
_ZN5nglog15ErrnoLogMessageC2EPKciNS_11LogSeverityElMNS_10LogMessageEFvvE:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov [rsp+38h+var_38], r8
mov ebp, ecx
mov r14d, edx
mov r15, rsi
mov r12, rdi
mov r13, [rsp+38h+arg_0]
mov rbx, [rsp+38h+arg_8]
mov qword ptr [rdi], 0
add rdi, 10h; this
call _ZN5nglog14LogMessageTimeC2Ev; nglog::LogMessageTime::LogMessageTime(void)
mov rdi, r12
mov rsi, r15
mov edx, r14d
mov ecx, ebp
mov r8, r13
mov r9, rbx
call _ZN5nglog10LogMessage4InitEPKciNS_11LogSeverityEMS0_FvvE; nglog::LogMessage::Init(char const*,int,nglog::LogSeverity,void (nglog::LogMessage::*)(void))
mov rax, [r12+8]
mov rcx, [rsp+38h+var_38]
mov [rax+7580h], rcx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long nglog::ErrnoLogMessage::ErrnoLogMessage(
_QWORD *a1,
nglog::tools *a2,
int a3,
int a4,
long long a5,
long long a6,
long long a7,
long long a8)
{
long long result; // rax
*a1 = 0LL;
nglog::LogMessageTime::LogMessageTime((nglog::LogMessageTime *)(a1 + 2));
nglog::LogMessage::Init((long long)a1, a2, a3, a4, a7, a8);
result = a1[1];
*(_QWORD *)(result + 30080) = a5;
return result;
}
|
ErrnoLogMessage:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV qword ptr [RSP],R8
MOV EBP,ECX
MOV R14D,EDX
MOV R15,RSI
MOV R12,RDI
MOV R13,qword ptr [RSP + 0x40]
MOV RBX,qword ptr [RSP + 0x48]
MOV qword ptr [RDI],0x0
ADD RDI,0x10
CALL 0x0011db42
MOV RDI,R12
MOV RSI,R15
MOV EDX,R14D
MOV ECX,EBP
MOV R8,R13
MOV R9,RBX
CALL 0x001192ba
MOV RAX,qword ptr [R12 + 0x8]
MOV RCX,qword ptr [RSP]
MOV qword ptr [RAX + 0x7580],RCX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nglog::ErrnoLogMessage::ErrnoLogMessage(char const*, int, nglog::LogSeverity, long, void
(nglog::LogMessage::*)()) */
void __thiscall
nglog::ErrnoLogMessage::ErrnoLogMessage
(ErrnoLogMessage *this,int8 param_1,int4 param_2,int4 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8)
{
*(int8 *)this = 0;
LogMessageTime::LogMessageTime((LogMessageTime *)(this + 0x10));
LogMessage::Init(this,param_1,param_2,param_4,param_7,param_8);
*(int8 *)(*(long *)(this + 8) + 0x7580) = param_5;
return;
}
|
|
18,449
|
alaya::HNSWImpl<alaya::RawSpace<float, float, unsigned int, alaya::SequentialStorage<float, unsigned int>>, float, float, unsigned int>::get_neighbors_by_heuristic2(std::priority_queue<std::pair<float, unsigned int>, std::vector<std::pair<float, unsigned int>, std::allocator<std::pair<float, unsigned int>>>, alaya::HNSWImpl<alaya::RawSpace<float, float, unsigned int, alaya::SequentialStorage<float, unsigned int>>, float, float, unsigned int>::CompareByFirst>&, unsigned long)
|
AlayaLite/include/index/graph/hnsw/hnswlib.hpp
|
void get_neighbors_by_heuristic2(
std::priority_queue<std::pair<DistanceType, InternalID>,
std::vector<std::pair<DistanceType, InternalID>>, CompareByFirst>
&top_candidates,
const size_t m) {
// If the number of top candidates is less than m, no filtering is necessary.
if (top_candidates.size() < m) {
return;
}
// Create a temporary priority queue to hold the closest candidates.
std::priority_queue<std::pair<DistanceType, InternalID>> queue_closest;
// Vector to store the selected neighbors.
std::vector<std::pair<DistanceType, InternalID>> return_list;
// Transfer all top candidates to the queue_closest, negating the distances for max-heap
// behavior.
while (top_candidates.size() > 0) {
queue_closest.emplace(-top_candidates.top().first, top_candidates.top().second);
top_candidates.pop();
}
// Iterate through the closest candidates to filter and select the best ones.
while (queue_closest.size()) {
// If we have already selected m neighbors, exit the loop.
if (return_list.size() >= m) {
break;
}
// Get the current candidate from the queue.
std::pair<DistanceType, InternalID> current_pair = queue_closest.top();
DistanceType dist_to_query = -current_pair.first; // Get the distance to the query point.
queue_closest.pop(); // Remove the current candidate from the queue.
bool good = true; // Flag to determine if the candidate is suitable.
// Check the current candidate against the already selected neighbors.
for (std::pair<DistanceType, InternalID> second_pair : return_list) {
// Calculate the distance between the current candidate and the existing neighbor.
DistanceType curdist = space_->get_distance(
get_external_label(second_pair.second), // Get data for the existing neighbor.
get_external_label(current_pair.second) // Get data for the current candidate.
); // Additional parameters for the distance function.
// If the current candidate is closer to an existing neighbor, mark it as not good.
if (curdist < dist_to_query) {
good = false; // Current candidate is not suitable.
break; // Exit the loop since we found a closer neighbor.
}
}
// If the candidate is good, add it to the return list.
if (good) {
return_list.push_back(current_pair);
}
}
// Restore the selected neighbors back to the top_candidates priority queue.
for (std::pair<DistanceType, InternalID> current_pair : return_list) {
top_candidates.emplace(-current_pair.first,
current_pair.second); // Negate distance for max-heap behavior.
}
}
|
O0
|
cpp
|
alaya::HNSWImpl<alaya::RawSpace<float, float, unsigned int, alaya::SequentialStorage<float, unsigned int>>, float, float, unsigned int>::get_neighbors_by_heuristic2(std::priority_queue<std::pair<float, unsigned int>, std::vector<std::pair<float, unsigned int>, std::allocator<std::pair<float, unsigned int>>>, alaya::HNSWImpl<alaya::RawSpace<float, float, unsigned int, alaya::SequentialStorage<float, unsigned int>>, float, float, unsigned int>::CompareByFirst>&, unsigned long):
subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq %rdx, 0xe0(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xe8(%rsp), %rdi
callq 0x339a0
cmpq 0xe0(%rsp), %rax
jae 0x35508
jmp 0x35825
leaq 0xc0(%rsp), %rdi
callq 0x35b10
leaq 0xa8(%rsp), %rdi
callq 0x33b20
movq 0xe8(%rsp), %rdi
callq 0x339a0
cmpq $0x0, %rax
jbe 0x355cd
movq 0xe8(%rsp), %rdi
callq 0x33990
movss (%rax), %xmm0
movaps 0x117aef(%rip), %xmm1 # 0x14d040
pxor %xmm1, %xmm0
movss %xmm0, 0xa4(%rsp)
movq 0xe8(%rsp), %rdi
callq 0x33990
movq %rax, %rdx
addq $0x4, %rdx
leaq 0xc0(%rsp), %rdi
leaq 0xa4(%rsp), %rsi
callq 0x35b40
jmp 0x35589
movq 0xe8(%rsp), %rdi
callq 0x339b0
jmp 0x35598
jmp 0x35522
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x35ce0
leaq 0xc0(%rsp), %rdi
callq 0x35d40
jmp 0x3582d
jmp 0x355cf
leaq 0xc0(%rsp), %rdi
callq 0x35ba0
movq %rax, 0x20(%rsp)
jmp 0x355e3
movq 0x20(%rsp), %rax
cmpq $0x0, %rax
je 0x35779
leaq 0xa8(%rsp), %rdi
callq 0x34380
cmpq 0xe0(%rsp), %rax
jb 0x3560e
jmp 0x35779
leaq 0xc0(%rsp), %rdi
callq 0x35bb0
movq %rax, 0x18(%rsp)
jmp 0x35622
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x88(%rsp)
movaps 0x117a07(%rip), %xmm1 # 0x14d040
movss 0x88(%rsp), %xmm0
pxor %xmm1, %xmm0
movss %xmm0, 0x84(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x35bc0
jmp 0x3565e
movb $0x1, 0x83(%rsp)
leaq 0xa8(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rdi
callq 0x33ce0
movq %rax, 0x70(%rsp)
movq 0x78(%rsp), %rdi
callq 0x33d10
movq %rax, 0x68(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x35c10
xorb $-0x1, %al
testb $0x1, %al
jne 0x356ab
jmp 0x35751
leaq 0x70(%rsp), %rdi
callq 0x34790
movq 0x28(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x60(%rsp)
addq $0xe8, %rdi
callq 0x1c550
movq 0x28(%rsp), %rdi
movq %rax, 0x8(%rsp)
movl 0x64(%rsp), %esi
callq 0x2c4f0
movl %eax, 0x14(%rsp)
jmp 0x356e7
movq 0x28(%rsp), %rdi
movl 0x8c(%rsp), %esi
callq 0x2c4f0
movl %eax, 0x4(%rsp)
jmp 0x356fe
movl 0x4(%rsp), %edx
movl 0x14(%rsp), %esi
movq 0x8(%rsp), %rdi
callq 0x31270
movss %xmm0, (%rsp)
jmp 0x35717
movss (%rsp), %xmm0
movss %xmm0, 0x5c(%rsp)
movss 0x5c(%rsp), %xmm1
movss 0x84(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x35740
movb $0x0, 0x83(%rsp)
jmp 0x35751
jmp 0x35742
leaq 0x70(%rsp), %rdi
callq 0x35c50
jmp 0x35691
testb $0x1, 0x83(%rsp)
je 0x35774
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x35c70
jmp 0x35772
jmp 0x35774
jmp 0x355cf
leaq 0xa8(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x33ce0
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x33d10
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x35c10
xorb $-0x1, %al
testb $0x1, %al
jne 0x357bb
jmp 0x3580b
leaq 0x48(%rsp), %rdi
callq 0x34790
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movq 0xe8(%rsp), %rdi
movaps 0x117864(%rip), %xmm1 # 0x14d040
movss 0x38(%rsp), %xmm0
pxor %xmm1, %xmm0
movss %xmm0, 0x34(%rsp)
leaq 0x3c(%rsp), %rdx
leaq 0x34(%rsp), %rsi
callq 0x33910
jmp 0x357fd
jmp 0x357ff
leaq 0x48(%rsp), %rdi
callq 0x35c50
jmp 0x357a4
leaq 0xa8(%rsp), %rdi
callq 0x35ce0
leaq 0xc0(%rsp), %rdi
callq 0x35d40
addq $0xf8, %rsp
retq
movq 0x98(%rsp), %rdi
callq 0x15dd0
nopw (%rax,%rax)
|
_ZN5alaya8HNSWImplINS_8RawSpaceIffjNS_17SequentialStorageIfjEEEEffjE27get_neighbors_by_heuristic2ERSt14priority_queueISt4pairIfjESt6vectorIS8_SaIS8_EENS5_14CompareByFirstEEm:
sub rsp, 0F8h
mov [rsp+0F8h+var_8], rdi
mov [rsp+0F8h+var_10], rsi
mov [rsp+0F8h+var_18], rdx
mov rax, [rsp+0F8h+var_8]
mov [rsp+0F8h+var_D0], rax
mov rdi, [rsp+0F8h+var_10]
call _ZNKSt14priority_queueISt4pairIfjESt6vectorIS1_SaIS1_EEN5alaya8HNSWImplINS5_8RawSpaceIffjNS5_17SequentialStorageIfjEEEEffjE14CompareByFirstEE4sizeEv; std::priority_queue<std::pair<float,uint>,std::vector<std::pair<float,uint>>,alaya::HNSWImpl<alaya::RawSpace<float,float,uint,alaya::SequentialStorage<float,uint>>,float,float,uint>::CompareByFirst>::size(void)
cmp rax, [rsp+0F8h+var_18]
jnb short loc_35508
jmp loc_35825
loc_35508:
lea rdi, [rsp+0F8h+var_38]
call _ZNSt14priority_queueISt4pairIfjESt6vectorIS1_SaIS1_EESt4lessIS1_EEC2IS4_vEEv; std::priority_queue<std::pair<float,uint>>::priority_queue<std::vector<std::pair<float,uint>>,void>(void)
lea rdi, [rsp+0F8h+var_50]
call _ZNSt6vectorISt4pairIfjESaIS1_EEC2Ev; std::vector<std::pair<float,uint>>::vector(void)
loc_35522:
mov rdi, [rsp+0F8h+var_10]
call _ZNKSt14priority_queueISt4pairIfjESt6vectorIS1_SaIS1_EEN5alaya8HNSWImplINS5_8RawSpaceIffjNS5_17SequentialStorageIfjEEEEffjE14CompareByFirstEE4sizeEv; std::priority_queue<std::pair<float,uint>,std::vector<std::pair<float,uint>>,alaya::HNSWImpl<alaya::RawSpace<float,float,uint,alaya::SequentialStorage<float,uint>>,float,float,uint>::CompareByFirst>::size(void)
cmp rax, 0
jbe loc_355CD
mov rdi, [rsp+0F8h+var_10]
call _ZNKSt14priority_queueISt4pairIfjESt6vectorIS1_SaIS1_EEN5alaya8HNSWImplINS5_8RawSpaceIffjNS5_17SequentialStorageIfjEEEEffjE14CompareByFirstEE3topEv; std::priority_queue<std::pair<float,uint>,std::vector<std::pair<float,uint>>,alaya::HNSWImpl<alaya::RawSpace<float,float,uint,alaya::SequentialStorage<float,uint>>,float,float,uint>::CompareByFirst>::top(void)
movss xmm0, dword ptr [rax]
movaps xmm1, cs:xmmword_14D040
pxor xmm0, xmm1
movss [rsp+0F8h+var_54], xmm0
mov rdi, [rsp+0F8h+var_10]
call _ZNKSt14priority_queueISt4pairIfjESt6vectorIS1_SaIS1_EEN5alaya8HNSWImplINS5_8RawSpaceIffjNS5_17SequentialStorageIfjEEEEffjE14CompareByFirstEE3topEv; std::priority_queue<std::pair<float,uint>,std::vector<std::pair<float,uint>>,alaya::HNSWImpl<alaya::RawSpace<float,float,uint,alaya::SequentialStorage<float,uint>>,float,float,uint>::CompareByFirst>::top(void)
mov rdx, rax
add rdx, 4
lea rdi, [rsp+0F8h+var_38]
lea rsi, [rsp+0F8h+var_54]
call _ZNSt14priority_queueISt4pairIfjESt6vectorIS1_SaIS1_EESt4lessIS1_EE7emplaceIJfRKjEEEvDpOT_; std::priority_queue<std::pair<float,uint>>::emplace<float,uint const&>(float,uint const&)
jmp short $+2
loc_35589:
mov rdi, [rsp+0F8h+var_10]
call _ZNSt14priority_queueISt4pairIfjESt6vectorIS1_SaIS1_EEN5alaya8HNSWImplINS5_8RawSpaceIffjNS5_17SequentialStorageIfjEEEEffjE14CompareByFirstEE3popEv; std::priority_queue<std::pair<float,uint>,std::vector<std::pair<float,uint>>,alaya::HNSWImpl<alaya::RawSpace<float,float,uint,alaya::SequentialStorage<float,uint>>,float,float,uint>::CompareByFirst>::pop(void)
jmp short $+2
loc_35598:
jmp short loc_35522
mov rcx, rax
mov eax, edx
mov [rsp+arg_90], rcx
mov [rsp+arg_8C], eax
lea rdi, [rsp+arg_A0]
call _ZNSt6vectorISt4pairIfjESaIS1_EED2Ev; std::vector<std::pair<float,uint>>::~vector()
lea rdi, [rsp+arg_B8]
call _ZNSt14priority_queueISt4pairIfjESt6vectorIS1_SaIS1_EESt4lessIS1_EED2Ev; std::priority_queue<std::pair<float,uint>>::~priority_queue()
jmp loc_3582D
loc_355CD:
jmp short $+2
loc_355CF:
lea rdi, [rsp+0F8h+var_38]
call _ZNKSt14priority_queueISt4pairIfjESt6vectorIS1_SaIS1_EESt4lessIS1_EE4sizeEv; std::priority_queue<std::pair<float,uint>>::size(void)
mov [rsp+0F8h+var_D8], rax
jmp short $+2
loc_355E3:
mov rax, [rsp+0F8h+var_D8]
cmp rax, 0
jz loc_35779
lea rdi, [rsp+0F8h+var_50]
call _ZNKSt6vectorISt4pairIfjESaIS1_EE4sizeEv; std::vector<std::pair<float,uint>>::size(void)
cmp rax, [rsp+0F8h+var_18]
jb short loc_3560E
jmp loc_35779
loc_3560E:
lea rdi, [rsp+0F8h+var_38]
call _ZNKSt14priority_queueISt4pairIfjESt6vectorIS1_SaIS1_EESt4lessIS1_EE3topEv; std::priority_queue<std::pair<float,uint>>::top(void)
mov [rsp+0F8h+var_E0], rax
jmp short $+2
loc_35622:
mov rax, [rsp+0F8h+var_E0]
mov rax, [rax]
mov [rsp+0F8h+var_70], rax
movaps xmm1, cs:xmmword_14D040
movss xmm0, dword ptr [rsp+0F8h+var_70]
pxor xmm0, xmm1
movss [rsp+0F8h+var_74], xmm0
lea rdi, [rsp+0F8h+var_38]
call _ZNSt14priority_queueISt4pairIfjESt6vectorIS1_SaIS1_EESt4lessIS1_EE3popEv; std::priority_queue<std::pair<float,uint>>::pop(void)
jmp short $+2
loc_3565E:
mov [rsp+0F8h+var_75], 1
lea rax, [rsp+0F8h+var_50]
mov [rsp+0F8h+var_80], rax
mov rdi, [rsp+0F8h+var_80]
call _ZNSt6vectorISt4pairIfjESaIS1_EE5beginEv; std::vector<std::pair<float,uint>>::begin(void)
mov [rsp+0F8h+var_88], rax
mov rdi, [rsp+0F8h+var_80]
call _ZNSt6vectorISt4pairIfjESaIS1_EE3endEv; std::vector<std::pair<float,uint>>::end(void)
mov [rsp+0F8h+var_90], rax
loc_35691:
lea rdi, [rsp+0F8h+var_88]
lea rsi, [rsp+0F8h+var_90]
call _ZN9__gnu_cxxeqIPSt4pairIfjESt6vectorIS2_SaIS2_EEEEbRKNS_17__normal_iteratorIT_T0_EESC_QrqXeqcldtfp_4baseEcldtfp0_4baseERSt14convertible_toIbEE
xor al, 0FFh
test al, 1
jnz short loc_356AB
jmp loc_35751
loc_356AB:
lea rdi, [rsp+0F8h+var_88]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIfjESt6vectorIS2_SaIS2_EEEdeEv; __gnu_cxx::__normal_iterator<std::pair<float,uint> *,std::vector<std::pair<float,uint>>>::operator*(void)
mov rdi, [rsp+0F8h+var_D0]
mov rax, [rax]
mov [rsp+0F8h+var_98], rax
add rdi, 0E8h
call _ZNKSt19__shared_ptr_accessIN5alaya8RawSpaceIffjNS0_17SequentialStorageIfjEEEELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<alaya::RawSpace<float,float,uint,alaya::SequentialStorage<float,uint>>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rdi, [rsp+0F8h+var_D0]
mov [rsp+0F8h+var_F0], rax
mov esi, dword ptr [rsp+0F8h+var_98+4]
call _ZNK5alaya8HNSWImplINS_8RawSpaceIffjNS_17SequentialStorageIfjEEEEffjE18get_external_labelEj; alaya::HNSWImpl<alaya::RawSpace<float,float,uint,alaya::SequentialStorage<float,uint>>,float,float,uint>::get_external_label(uint)
mov [rsp+0F8h+var_E4], eax
jmp short $+2
loc_356E7:
mov rdi, [rsp+0F8h+var_D0]
mov esi, dword ptr [rsp+0F8h+var_70+4]
call _ZNK5alaya8HNSWImplINS_8RawSpaceIffjNS_17SequentialStorageIfjEEEEffjE18get_external_labelEj; alaya::HNSWImpl<alaya::RawSpace<float,float,uint,alaya::SequentialStorage<float,uint>>,float,float,uint>::get_external_label(uint)
mov [rsp+0F8h+var_F4], eax
jmp short $+2
loc_356FE:
mov edx, [rsp+0F8h+var_F4]
mov esi, [rsp+0F8h+var_E4]
mov rdi, [rsp+0F8h+var_F0]
call _ZN5alaya8RawSpaceIffjNS_17SequentialStorageIfjEEE12get_distanceEjj; alaya::RawSpace<float,float,uint,alaya::SequentialStorage<float,uint>>::get_distance(uint,uint)
movss [rsp+0F8h+var_F8], xmm0
jmp short $+2
loc_35717:
movss xmm0, [rsp+0F8h+var_F8]
movss [rsp+0F8h+var_9C], xmm0
movss xmm1, [rsp+0F8h+var_9C]
movss xmm0, [rsp+0F8h+var_74]
ucomiss xmm0, xmm1
jbe short loc_35740
mov [rsp+0F8h+var_75], 0
jmp short loc_35751
loc_35740:
jmp short $+2
loc_35742:
lea rdi, [rsp+0F8h+var_88]
call _ZN9__gnu_cxx17__normal_iteratorIPSt4pairIfjESt6vectorIS2_SaIS2_EEEppEv; __gnu_cxx::__normal_iterator<std::pair<float,uint> *,std::vector<std::pair<float,uint>>>::operator++(void)
jmp loc_35691
loc_35751:
test [rsp+0F8h+var_75], 1
jz short loc_35774
lea rdi, [rsp+0F8h+var_50]
lea rsi, [rsp+0F8h+var_70]
call _ZNSt6vectorISt4pairIfjESaIS1_EE9push_backERKS1_; std::vector<std::pair<float,uint>>::push_back(std::pair<float,uint> const&)
jmp short $+2
loc_35772:
jmp short $+2
loc_35774:
jmp loc_355CF
loc_35779:
lea rax, [rsp+0F8h+var_50]
mov [rsp+0F8h+var_A8], rax
mov rdi, [rsp+0F8h+var_A8]
call _ZNSt6vectorISt4pairIfjESaIS1_EE5beginEv; std::vector<std::pair<float,uint>>::begin(void)
mov [rsp+0F8h+var_B0], rax
mov rdi, [rsp+0F8h+var_A8]
call _ZNSt6vectorISt4pairIfjESaIS1_EE3endEv; std::vector<std::pair<float,uint>>::end(void)
mov [rsp+0F8h+var_B8], rax
loc_357A4:
lea rdi, [rsp+0F8h+var_B0]
lea rsi, [rsp+0F8h+var_B8]
call _ZN9__gnu_cxxeqIPSt4pairIfjESt6vectorIS2_SaIS2_EEEEbRKNS_17__normal_iteratorIT_T0_EESC_QrqXeqcldtfp_4baseEcldtfp0_4baseERSt14convertible_toIbEE
xor al, 0FFh
test al, 1
jnz short loc_357BB
jmp short loc_3580B
loc_357BB:
lea rdi, [rsp+0F8h+var_B0]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIfjESt6vectorIS2_SaIS2_EEEdeEv; __gnu_cxx::__normal_iterator<std::pair<float,uint> *,std::vector<std::pair<float,uint>>>::operator*(void)
mov rax, [rax]
mov [rsp+0F8h+var_C0], rax
mov rdi, [rsp+0F8h+var_10]
movaps xmm1, cs:xmmword_14D040
movss xmm0, dword ptr [rsp+0F8h+var_C0]
pxor xmm0, xmm1
movss [rsp+0F8h+var_C4], xmm0
lea rdx, [rsp+0F8h+var_C0+4]
lea rsi, [rsp+0F8h+var_C4]
call _ZNSt14priority_queueISt4pairIfjESt6vectorIS1_SaIS1_EEN5alaya8HNSWImplINS5_8RawSpaceIffjNS5_17SequentialStorageIfjEEEEffjE14CompareByFirstEE7emplaceIJfRjEEEvDpOT_; std::priority_queue<std::pair<float,uint>,std::vector<std::pair<float,uint>>,alaya::HNSWImpl<alaya::RawSpace<float,float,uint,alaya::SequentialStorage<float,uint>>,float,float,uint>::CompareByFirst>::emplace<float,uint &>(float,uint &)
jmp short $+2
loc_357FD:
jmp short $+2
loc_357FF:
lea rdi, [rsp+0F8h+var_B0]
call _ZN9__gnu_cxx17__normal_iteratorIPSt4pairIfjESt6vectorIS2_SaIS2_EEEppEv; __gnu_cxx::__normal_iterator<std::pair<float,uint> *,std::vector<std::pair<float,uint>>>::operator++(void)
jmp short loc_357A4
loc_3580B:
lea rdi, [rsp+0F8h+var_50]
call _ZNSt6vectorISt4pairIfjESaIS1_EED2Ev; std::vector<std::pair<float,uint>>::~vector()
lea rdi, [rsp+0F8h+var_38]
call _ZNSt14priority_queueISt4pairIfjESt6vectorIS1_SaIS1_EESt4lessIS1_EED2Ev; std::priority_queue<std::pair<float,uint>>::~priority_queue()
loc_35825:
add rsp, 0F8h
retn
loc_3582D:
mov rdi, [rsp+arg_90]
call __Unwind_Resume
|
unsigned long long alaya::HNSWImpl<alaya::RawSpace<float,float,unsigned int,alaya::SequentialStorage<float,unsigned int>>,float,float,unsigned int>::get_neighbors_by_heuristic2(
long long a1,
long long a2,
unsigned long long a3)
{
unsigned long long result; // rax
long long v4; // rax
unsigned long long v5; // rax
unsigned __int32 v6; // xmm0_4
unsigned int v7; // [rsp+4h] [rbp-F4h]
long long v8; // [rsp+8h] [rbp-F0h]
unsigned int external_label; // [rsp+14h] [rbp-E4h]
unsigned __int32 v10; // [rsp+34h] [rbp-C4h] BYREF
long long v11; // [rsp+38h] [rbp-C0h] BYREF
long long v12; // [rsp+40h] [rbp-B8h] BYREF
_QWORD v13[2]; // [rsp+48h] [rbp-B0h] BYREF
float v14; // [rsp+5Ch] [rbp-9Ch]
long long v15; // [rsp+60h] [rbp-98h]
long long v16; // [rsp+68h] [rbp-90h] BYREF
long long v17; // [rsp+70h] [rbp-88h] BYREF
_QWORD *v18; // [rsp+78h] [rbp-80h]
char v19; // [rsp+83h] [rbp-75h]
float v20; // [rsp+84h] [rbp-74h]
long long v21; // [rsp+88h] [rbp-70h] BYREF
unsigned __int32 v22; // [rsp+A4h] [rbp-54h] BYREF
_QWORD v23[3]; // [rsp+A8h] [rbp-50h] BYREF
_BYTE v24[32]; // [rsp+C0h] [rbp-38h] BYREF
unsigned long long v25; // [rsp+E0h] [rbp-18h]
long long v26; // [rsp+E8h] [rbp-10h]
long long v27; // [rsp+F0h] [rbp-8h]
v27 = a1;
v26 = a2;
v25 = a3;
result = std::priority_queue<std::pair<float,unsigned int>,std::vector<std::pair<float,unsigned int>>,alaya::HNSWImpl<alaya::RawSpace<float,float,unsigned int,alaya::SequentialStorage<float,unsigned int>>,float,float,unsigned int>::CompareByFirst>::size(a2);
if ( result >= v25 )
{
std::priority_queue<std::pair<float,unsigned int>>::priority_queue<std::vector<std::pair<float,unsigned int>>,void>(v24);
std::vector<std::pair<float,unsigned int>>::vector((long long)v23);
while ( std::priority_queue<std::pair<float,unsigned int>,std::vector<std::pair<float,unsigned int>>,alaya::HNSWImpl<alaya::RawSpace<float,float,unsigned int,alaya::SequentialStorage<float,unsigned int>>,float,float,unsigned int>::CompareByFirst>::size(v26) )
{
v22 = _mm_xor_si128(
(__m128i)*(unsigned int *)std::priority_queue<std::pair<float,unsigned int>,std::vector<std::pair<float,unsigned int>>,alaya::HNSWImpl<alaya::RawSpace<float,float,unsigned int,alaya::SequentialStorage<float,unsigned int>>,float,float,unsigned int>::CompareByFirst>::top(v26),
(__m128i)xmmword_14D040).m128i_u32[0];
v4 = std::priority_queue<std::pair<float,unsigned int>,std::vector<std::pair<float,unsigned int>>,alaya::HNSWImpl<alaya::RawSpace<float,float,unsigned int,alaya::SequentialStorage<float,unsigned int>>,float,float,unsigned int>::CompareByFirst>::top(v26);
std::priority_queue<std::pair<float,unsigned int>>::emplace<float,unsigned int const&>(v24, &v22, v4 + 4);
std::priority_queue<std::pair<float,unsigned int>,std::vector<std::pair<float,unsigned int>>,alaya::HNSWImpl<alaya::RawSpace<float,float,unsigned int,alaya::SequentialStorage<float,unsigned int>>,float,float,unsigned int>::CompareByFirst>::pop(v26);
}
while ( std::priority_queue<std::pair<float,unsigned int>>::size(v24) )
{
v5 = std::vector<std::pair<float,unsigned int>>::size(v23);
if ( v5 >= v25 )
break;
v21 = *(_QWORD *)std::priority_queue<std::pair<float,unsigned int>>::top(v24);
v6 = _mm_xor_si128((__m128i)(unsigned int)v21, (__m128i)xmmword_14D040).m128i_u32[0];
v20 = *(float *)&v6;
std::priority_queue<std::pair<float,unsigned int>>::pop(v24);
v19 = 1;
v18 = v23;
v17 = std::vector<std::pair<float,unsigned int>>::begin((long long)v23);
v16 = std::vector<std::pair<float,unsigned int>>::end((long long)v18);
while ( (__gnu_cxx::operator==<std::pair<float,unsigned int> *,std::vector<std::pair<float,unsigned int>>>(
&v17,
&v16) & 1) == 0 )
{
v15 = *(_QWORD *)__gnu_cxx::__normal_iterator<std::pair<float,unsigned int> *,std::vector<std::pair<float,unsigned int>>>::operator*((long long)&v17);
v8 = std::__shared_ptr_access<alaya::RawSpace<float,float,unsigned int,alaya::SequentialStorage<float,unsigned int>>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(a1 + 232);
external_label = alaya::HNSWImpl<alaya::RawSpace<float,float,unsigned int,alaya::SequentialStorage<float,unsigned int>>,float,float,unsigned int>::get_external_label(
a1,
HIDWORD(v15));
v7 = alaya::HNSWImpl<alaya::RawSpace<float,float,unsigned int,alaya::SequentialStorage<float,unsigned int>>,float,float,unsigned int>::get_external_label(
a1,
HIDWORD(v21));
alaya::RawSpace<float,float,unsigned int,alaya::SequentialStorage<float,unsigned int>>::get_distance(
v8,
external_label,
v7);
v14 = *(float *)&v6;
v6 = LODWORD(v20);
if ( v20 > v14 )
{
v19 = 0;
break;
}
__gnu_cxx::__normal_iterator<std::pair<float,unsigned int> *,std::vector<std::pair<float,unsigned int>>>::operator++(&v17);
}
if ( (v19 & 1) != 0 )
std::vector<std::pair<float,unsigned int>>::push_back(v23, &v21);
}
v13[1] = v23;
v13[0] = std::vector<std::pair<float,unsigned int>>::begin((long long)v23);
v12 = std::vector<std::pair<float,unsigned int>>::end((long long)v23);
while ( (__gnu_cxx::operator==<std::pair<float,unsigned int> *,std::vector<std::pair<float,unsigned int>>>(
v13,
&v12) & 1) == 0 )
{
v11 = *(_QWORD *)__gnu_cxx::__normal_iterator<std::pair<float,unsigned int> *,std::vector<std::pair<float,unsigned int>>>::operator*((long long)v13);
v10 = _mm_xor_si128((__m128i)(unsigned int)v11, (__m128i)xmmword_14D040).m128i_u32[0];
std::priority_queue<std::pair<float,unsigned int>,std::vector<std::pair<float,unsigned int>>,alaya::HNSWImpl<alaya::RawSpace<float,float,unsigned int,alaya::SequentialStorage<float,unsigned int>>,float,float,unsigned int>::CompareByFirst>::emplace<float,unsigned int &>(
v26,
(long long)&v10,
(long long)&v11 + 4);
__gnu_cxx::__normal_iterator<std::pair<float,unsigned int> *,std::vector<std::pair<float,unsigned int>>>::operator++(v13);
}
std::vector<std::pair<float,unsigned int>>::~vector(v23);
return std::priority_queue<std::pair<float,unsigned int>>::~priority_queue(v24);
}
return result;
}
|
get_neighbors_by_heuristic2:
SUB RSP,0xf8
MOV qword ptr [RSP + 0xf0],RDI
MOV qword ptr [RSP + 0xe8],RSI
MOV qword ptr [RSP + 0xe0],RDX
MOV RAX,qword ptr [RSP + 0xf0]
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0xe8]
CALL 0x001339a0
CMP RAX,qword ptr [RSP + 0xe0]
JNC 0x00135508
JMP 0x00135825
LAB_00135508:
LEA RDI,[RSP + 0xc0]
CALL 0x00135b10
LEA RDI,[RSP + 0xa8]
CALL 0x00133b20
LAB_00135522:
MOV RDI,qword ptr [RSP + 0xe8]
CALL 0x001339a0
CMP RAX,0x0
JBE 0x001355cd
MOV RDI,qword ptr [RSP + 0xe8]
CALL 0x00133990
MOVSS XMM0,dword ptr [RAX]
MOVAPS XMM1,xmmword ptr [0x0024d040]
PXOR XMM0,XMM1
MOVSS dword ptr [RSP + 0xa4],XMM0
MOV RDI,qword ptr [RSP + 0xe8]
CALL 0x00133990
MOV RDX,RAX
ADD RDX,0x4
LAB_00135572:
LEA RDI,[RSP + 0xc0]
LEA RSI,[RSP + 0xa4]
CALL 0x00135b40
JMP 0x00135589
LAB_00135589:
MOV RDI,qword ptr [RSP + 0xe8]
CALL 0x001339b0
JMP 0x00135598
LAB_00135598:
JMP 0x00135522
LAB_001355cd:
JMP 0x001355cf
LAB_001355cf:
LEA RDI,[RSP + 0xc0]
CALL 0x00135ba0
MOV qword ptr [RSP + 0x20],RAX
JMP 0x001355e3
LAB_001355e3:
MOV RAX,qword ptr [RSP + 0x20]
CMP RAX,0x0
JZ 0x00135779
LEA RDI,[RSP + 0xa8]
CALL 0x00134380
CMP RAX,qword ptr [RSP + 0xe0]
JC 0x0013560e
JMP 0x00135779
LAB_0013560e:
LEA RDI,[RSP + 0xc0]
CALL 0x00135bb0
MOV qword ptr [RSP + 0x18],RAX
JMP 0x00135622
LAB_00135622:
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0x88],RAX
MOVAPS XMM1,xmmword ptr [0x0024d040]
MOVSS XMM0,dword ptr [RSP + 0x88]
PXOR XMM0,XMM1
MOVSS dword ptr [RSP + 0x84],XMM0
LEA RDI,[RSP + 0xc0]
CALL 0x00135bc0
JMP 0x0013565e
LAB_0013565e:
MOV byte ptr [RSP + 0x83],0x1
LEA RAX,[RSP + 0xa8]
MOV qword ptr [RSP + 0x78],RAX
MOV RDI,qword ptr [RSP + 0x78]
CALL 0x00133ce0
MOV qword ptr [RSP + 0x70],RAX
MOV RDI,qword ptr [RSP + 0x78]
CALL 0x00133d10
MOV qword ptr [RSP + 0x68],RAX
LAB_00135691:
LEA RDI,[RSP + 0x70]
LEA RSI,[RSP + 0x68]
CALL 0x00135c10
XOR AL,0xff
TEST AL,0x1
JNZ 0x001356ab
JMP 0x00135751
LAB_001356ab:
LEA RDI,[RSP + 0x70]
CALL 0x00134790
MOV RDI,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0x60],RAX
ADD RDI,0xe8
CALL 0x0011c550
MOV RDI,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x8],RAX
MOV ESI,dword ptr [RSP + 0x64]
CALL 0x0012c4f0
MOV dword ptr [RSP + 0x14],EAX
JMP 0x001356e7
LAB_001356e7:
MOV RDI,qword ptr [RSP + 0x28]
MOV ESI,dword ptr [RSP + 0x8c]
CALL 0x0012c4f0
MOV dword ptr [RSP + 0x4],EAX
JMP 0x001356fe
LAB_001356fe:
MOV EDX,dword ptr [RSP + 0x4]
MOV ESI,dword ptr [RSP + 0x14]
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x00131270
MOVSS dword ptr [RSP],XMM0
JMP 0x00135717
LAB_00135717:
MOVSS XMM0,dword ptr [RSP]
MOVSS dword ptr [RSP + 0x5c],XMM0
MOVSS XMM1,dword ptr [RSP + 0x5c]
MOVSS XMM0,dword ptr [RSP + 0x84]
UCOMISS XMM0,XMM1
JBE 0x00135740
MOV byte ptr [RSP + 0x83],0x0
JMP 0x00135751
LAB_00135740:
JMP 0x00135742
LAB_00135742:
LEA RDI,[RSP + 0x70]
CALL 0x00135c50
JMP 0x00135691
LAB_00135751:
TEST byte ptr [RSP + 0x83],0x1
JZ 0x00135774
LEA RDI,[RSP + 0xa8]
LEA RSI,[RSP + 0x88]
CALL 0x00135c70
JMP 0x00135772
LAB_00135772:
JMP 0x00135774
LAB_00135774:
JMP 0x001355cf
LAB_00135779:
LEA RAX,[RSP + 0xa8]
MOV qword ptr [RSP + 0x50],RAX
MOV RDI,qword ptr [RSP + 0x50]
CALL 0x00133ce0
MOV qword ptr [RSP + 0x48],RAX
MOV RDI,qword ptr [RSP + 0x50]
CALL 0x00133d10
MOV qword ptr [RSP + 0x40],RAX
LAB_001357a4:
LEA RDI,[RSP + 0x48]
LEA RSI,[RSP + 0x40]
CALL 0x00135c10
XOR AL,0xff
TEST AL,0x1
JNZ 0x001357bb
JMP 0x0013580b
LAB_001357bb:
LEA RDI,[RSP + 0x48]
CALL 0x00134790
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0x38],RAX
MOV RDI,qword ptr [RSP + 0xe8]
MOVAPS XMM1,xmmword ptr [0x0024d040]
MOVSS XMM0,dword ptr [RSP + 0x38]
PXOR XMM0,XMM1
MOVSS dword ptr [RSP + 0x34],XMM0
LEA RDX,[RSP + 0x3c]
LEA RSI,[RSP + 0x34]
CALL 0x00133910
LAB_001357fb:
JMP 0x001357fd
LAB_001357fd:
JMP 0x001357ff
LAB_001357ff:
LEA RDI,[RSP + 0x48]
CALL 0x00135c50
JMP 0x001357a4
LAB_0013580b:
LEA RDI,[RSP + 0xa8]
CALL 0x00135ce0
LEA RDI,[RSP + 0xc0]
CALL 0x00135d40
LAB_00135825:
ADD RSP,0xf8
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* alaya::HNSWImpl<alaya::RawSpace<float, float, unsigned int, alaya::SequentialStorage<float,
unsigned int> >, float, float, unsigned
int>::get_neighbors_by_heuristic2(std::priority_queue<std::pair<float, unsigned int>,
std::vector<std::pair<float, unsigned int>, std::allocator<std::pair<float, unsigned int> > >,
alaya::HNSWImpl<alaya::RawSpace<float, float, unsigned int, alaya::SequentialStorage<float,
unsigned int> >, float, float, unsigned int>::CompareByFirst>&, unsigned long) */
void __thiscall
alaya::
HNSWImpl<alaya::RawSpace<float,float,unsigned_int,alaya::SequentialStorage<float,unsigned_int>>,float,float,unsigned_int>
::get_neighbors_by_heuristic2
(HNSWImpl<alaya::RawSpace<float,float,unsigned_int,alaya::SequentialStorage<float,unsigned_int>>,float,float,unsigned_int>
*this,priority_queue *param_1,ulong param_2)
{
byte bVar1;
uint uVar2;
uint uVar3;
ulong uVar4;
long lVar5;
uint *puVar6;
RawSpace<float,float,unsigned_int,alaya::SequentialStorage<float,unsigned_int>> *this_00;
int8 *puVar7;
float local_c4;
int8 local_c0;
int8 local_b8;
int8 local_b0;
vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>> *local_a8;
float local_9c;
int8 local_98;
int8 local_90;
int8 local_88;
vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>> *local_80;
byte local_75;
float local_74;
int8 local_70;
float local_54;
vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>> local_50 [24];
priority_queue<std::pair<float,unsigned_int>,std::vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>,std::less<std::pair<float,unsigned_int>>>
local_38 [32];
ulong local_18;
priority_queue *local_10;
HNSWImpl<alaya::RawSpace<float,float,unsigned_int,alaya::SequentialStorage<float,unsigned_int>>,float,float,unsigned_int>
*local_8;
local_18 = param_2;
local_10 = param_1;
local_8 = this;
uVar4 = std::
priority_queue<std::pair<float,unsigned_int>,std::vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>,alaya::HNSWImpl<alaya::RawSpace<float,float,unsigned_int,alaya::SequentialStorage<float,unsigned_int>>,float,float,unsigned_int>::CompareByFirst>
::size((priority_queue<std::pair<float,unsigned_int>,std::vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>,alaya::HNSWImpl<alaya::RawSpace<float,float,unsigned_int,alaya::SequentialStorage<float,unsigned_int>>,float,float,unsigned_int>::CompareByFirst>
*)param_1);
if (local_18 <= uVar4) {
std::
priority_queue<std::pair<float,unsigned_int>,std::vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>,std::less<std::pair<float,unsigned_int>>>
::
priority_queue<std::vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>,void>
(local_38);
std::vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>::vector
(local_50);
while (lVar5 = std::
priority_queue<std::pair<float,unsigned_int>,std::vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>,alaya::HNSWImpl<alaya::RawSpace<float,float,unsigned_int,alaya::SequentialStorage<float,unsigned_int>>,float,float,unsigned_int>::CompareByFirst>
::size((priority_queue<std::pair<float,unsigned_int>,std::vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>,alaya::HNSWImpl<alaya::RawSpace<float,float,unsigned_int,alaya::SequentialStorage<float,unsigned_int>>,float,float,unsigned_int>::CompareByFirst>
*)local_10), lVar5 != 0) {
puVar6 = (uint *)std::
priority_queue<std::pair<float,unsigned_int>,std::vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>,alaya::HNSWImpl<alaya::RawSpace<float,float,unsigned_int,alaya::SequentialStorage<float,unsigned_int>>,float,float,unsigned_int>::CompareByFirst>
::top((priority_queue<std::pair<float,unsigned_int>,std::vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>,alaya::HNSWImpl<alaya::RawSpace<float,float,unsigned_int,alaya::SequentialStorage<float,unsigned_int>>,float,float,unsigned_int>::CompareByFirst>
*)local_10);
local_54 = (float)(*puVar6 ^ _DAT_0024d040);
lVar5 = std::
priority_queue<std::pair<float,unsigned_int>,std::vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>,alaya::HNSWImpl<alaya::RawSpace<float,float,unsigned_int,alaya::SequentialStorage<float,unsigned_int>>,float,float,unsigned_int>::CompareByFirst>
::top((priority_queue<std::pair<float,unsigned_int>,std::vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>,alaya::HNSWImpl<alaya::RawSpace<float,float,unsigned_int,alaya::SequentialStorage<float,unsigned_int>>,float,float,unsigned_int>::CompareByFirst>
*)local_10);
/* try { // try from 00135572 to 001357fa has its CatchHandler @ 0013559a */
std::
priority_queue<std::pair<float,unsigned_int>,std::vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>,std::less<std::pair<float,unsigned_int>>>
::emplace<float,unsigned_int_const&>(local_38,&local_54,(uint *)(lVar5 + 4));
std::
priority_queue<std::pair<float,unsigned_int>,std::vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>,alaya::HNSWImpl<alaya::RawSpace<float,float,unsigned_int,alaya::SequentialStorage<float,unsigned_int>>,float,float,unsigned_int>::CompareByFirst>
::pop((priority_queue<std::pair<float,unsigned_int>,std::vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>,alaya::HNSWImpl<alaya::RawSpace<float,float,unsigned_int,alaya::SequentialStorage<float,unsigned_int>>,float,float,unsigned_int>::CompareByFirst>
*)local_10);
}
while ((lVar5 = std::
priority_queue<std::pair<float,unsigned_int>,std::vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>,std::less<std::pair<float,unsigned_int>>>
::size(local_38), lVar5 != 0 &&
(uVar4 = std::
vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>
::size(local_50), uVar4 < local_18))) {
puVar7 = (int8 *)
std::
priority_queue<std::pair<float,unsigned_int>,std::vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>,std::less<std::pair<float,unsigned_int>>>
::top(local_38);
local_70 = *puVar7;
local_74 = (float)((uint)local_70 ^ _DAT_0024d040);
std::
priority_queue<std::pair<float,unsigned_int>,std::vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>,std::less<std::pair<float,unsigned_int>>>
::pop(local_38);
local_75 = 1;
local_80 = local_50;
local_88 = std::
vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>
::begin(local_80);
local_90 = std::
vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>
::end(local_80);
while (bVar1 = _ZN9__gnu_cxxeqIPSt4pairIfjESt6vectorIS2_SaIS2_EEEEbRKNS_17__normal_iteratorIT_T0_EESC_QrqXeqcldtfp_4baseEcldtfp0_4baseERSt14convertible_toIbEE
(&local_88,&local_90), ((bVar1 ^ 0xff) & 1) != 0) {
puVar7 = (int8 *)
__gnu_cxx::
__normal_iterator<std::pair<float,unsigned_int>*,std::vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>>
::operator*((__normal_iterator<std::pair<float,unsigned_int>*,std::vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>>
*)&local_88);
local_98 = *puVar7;
this_00 = (RawSpace<float,float,unsigned_int,alaya::SequentialStorage<float,unsigned_int>> *
)std::
__shared_ptr_access<alaya::RawSpace<float,float,unsigned_int,alaya::SequentialStorage<float,unsigned_int>>,(__gnu_cxx::_Lock_policy)2,false,false>
::operator->((__shared_ptr_access<alaya::RawSpace<float,float,unsigned_int,alaya::SequentialStorage<float,unsigned_int>>,(__gnu_cxx::_Lock_policy)2,false,false>
*)(this + 0xe8));
uVar2 = get_external_label(this,local_98._4_4_);
uVar3 = get_external_label(this,local_70._4_4_);
local_9c = (float)RawSpace<float,float,unsigned_int,alaya::SequentialStorage<float,unsigned_int>>
::get_distance(this_00,uVar2,uVar3);
if (local_9c < local_74) {
local_75 = 0;
break;
}
__gnu_cxx::
__normal_iterator<std::pair<float,unsigned_int>*,std::vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>>
::operator++((__normal_iterator<std::pair<float,unsigned_int>*,std::vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>>
*)&local_88);
}
if ((local_75 & 1) != 0) {
std::vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>::
push_back(local_50,(pair *)&local_70);
}
}
local_a8 = local_50;
local_b0 = std::
vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>::
begin(local_a8);
local_b8 = std::
vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>::
end(local_a8);
while (bVar1 = _ZN9__gnu_cxxeqIPSt4pairIfjESt6vectorIS2_SaIS2_EEEEbRKNS_17__normal_iteratorIT_T0_EESC_QrqXeqcldtfp_4baseEcldtfp0_4baseERSt14convertible_toIbEE
(&local_b0,&local_b8), ((bVar1 ^ 0xff) & 1) != 0) {
puVar7 = (int8 *)
__gnu_cxx::
__normal_iterator<std::pair<float,unsigned_int>*,std::vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>>
::operator*((__normal_iterator<std::pair<float,unsigned_int>*,std::vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>>
*)&local_b0);
local_c0 = *puVar7;
local_c4 = (float)((uint)local_c0 ^ _DAT_0024d040);
std::
priority_queue<std::pair<float,unsigned_int>,std::vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>,alaya::HNSWImpl<alaya::RawSpace<float,float,unsigned_int,alaya::SequentialStorage<float,unsigned_int>>,float,float,unsigned_int>::CompareByFirst>
::emplace<float,unsigned_int&>
((priority_queue<std::pair<float,unsigned_int>,std::vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>,alaya::HNSWImpl<alaya::RawSpace<float,float,unsigned_int,alaya::SequentialStorage<float,unsigned_int>>,float,float,unsigned_int>::CompareByFirst>
*)local_10,&local_c4,(uint *)((long)&local_c0 + 4));
__gnu_cxx::
__normal_iterator<std::pair<float,unsigned_int>*,std::vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>>
::operator++((__normal_iterator<std::pair<float,unsigned_int>*,std::vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>>
*)&local_b0);
}
std::vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>::
~vector(local_50);
std::
priority_queue<std::pair<float,unsigned_int>,std::vector<std::pair<float,unsigned_int>,std::allocator<std::pair<float,unsigned_int>>>,std::less<std::pair<float,unsigned_int>>>
::~priority_queue(local_38);
}
return;
}
|
|
18,450
|
my_fill_utf8mb3_mb
|
eloqsql/strings/ctype-utf8.c
|
static void
my_fill_utf8mb3_mb(CHARSET_INFO *cs, char *str, size_t length, int fill)
{
char *end= str + length;
char buf[10];
char buflen= my_ci_native_to_mb(cs, (my_wc_t) fill, (uchar*) buf,
(uchar*) buf + sizeof(buf));
DBUG_ASSERT(buflen > 0);
for ( ; str + buflen <= end ; )
{
memcpy(str, buf, buflen);
str+= buflen;
}
for ( ; str < end; )
*str++= ' ';
}
|
O0
|
c
|
my_fill_utf8mb3_mb:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movl %ecx, -0x34(%rbp)
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0xd8(%rax), %rax
movq -0x20(%rbp), %rdi
movslq -0x34(%rbp), %rsi
leaq -0x12(%rbp), %rdx
leaq -0x12(%rbp), %rcx
addq $0xa, %rcx
callq *%rax
movb %al, -0x41(%rbp)
jmp 0x67bfd
jmp 0x67bff
movq -0x28(%rbp), %rax
movsbl -0x41(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
cmpq -0x40(%rbp), %rax
ja 0x67c39
movq -0x28(%rbp), %rdi
leaq -0x12(%rbp), %rsi
movsbq -0x41(%rbp), %rdx
callq 0x24200
movsbl -0x41(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x67bff
jmp 0x67c3b
movq -0x28(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x67c59
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb $0x20, (%rax)
jmp 0x67c3b
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x67c71
addq $0x50, %rsp
popq %rbp
retq
callq 0x242b0
nopw %cs:(%rax,%rax)
|
my_fill_utf8mb3_mb:
push rbp
mov rbp, rsp
sub rsp, 50h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_20], rdi
mov [rbp+var_28], rsi
mov [rbp+var_30], rdx
mov [rbp+var_34], ecx
mov rax, [rbp+var_28]
add rax, [rbp+var_30]
mov [rbp+var_40], rax
mov rax, [rbp+var_20]
mov rax, [rax+0B8h]
mov rax, [rax+0D8h]
mov rdi, [rbp+var_20]
movsxd rsi, [rbp+var_34]
lea rdx, [rbp+var_12]
lea rcx, [rbp+var_12]
add rcx, 0Ah
call rax
mov [rbp+var_41], al
jmp short $+2
loc_67BFD:
jmp short $+2
loc_67BFF:
mov rax, [rbp+var_28]
movsx ecx, [rbp+var_41]
movsxd rcx, ecx
add rax, rcx
cmp rax, [rbp+var_40]
ja short loc_67C39
mov rdi, [rbp+var_28]
lea rsi, [rbp+var_12]
movsx rdx, [rbp+var_41]
call _memcpy
movsx ecx, [rbp+var_41]
mov rax, [rbp+var_28]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_28], rax
jmp short loc_67BFF
loc_67C39:
jmp short $+2
loc_67C3B:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_40]
jnb short loc_67C59
mov rax, [rbp+var_28]
mov rcx, rax
add rcx, 1
mov [rbp+var_28], rcx
mov byte ptr [rax], 20h ; ' '
jmp short loc_67C3B
loc_67C59:
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_67C71
add rsp, 50h
pop rbp
retn
loc_67C71:
call ___stack_chk_fail
|
unsigned long long my_fill_utf8mb3_mb(long long a1, _BYTE *a2, long long a3, int a4)
{
_BYTE *v4; // rax
char i; // [rsp+Fh] [rbp-41h]
unsigned long long v7; // [rsp+10h] [rbp-40h]
_BYTE *v8; // [rsp+28h] [rbp-28h]
_BYTE v9[10]; // [rsp+3Eh] [rbp-12h] BYREF
unsigned long long v10; // [rsp+48h] [rbp-8h] BYREF
v10 = __readfsqword(0x28u);
v8 = a2;
v7 = (unsigned long long)&a2[a3];
for ( i = (*(long long ( **)(long long, _QWORD, _BYTE *, unsigned long long *))(*(_QWORD *)(a1 + 184) + 216LL))(
a1,
a4,
v9,
&v10); (unsigned long long)&v8[i] <= v7; v8 += i )
memcpy(v8, v9, i);
while ( (unsigned long long)v8 < v7 )
{
v4 = v8++;
*v4 = 32;
}
return __readfsqword(0x28u);
}
|
my_fill_utf8mb3_mb:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x20],RDI
MOV qword ptr [RBP + -0x28],RSI
MOV qword ptr [RBP + -0x30],RDX
MOV dword ptr [RBP + -0x34],ECX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0xd8]
MOV RDI,qword ptr [RBP + -0x20]
MOVSXD RSI,dword ptr [RBP + -0x34]
LEA RDX,[RBP + -0x12]
LEA RCX,[RBP + -0x12]
ADD RCX,0xa
CALL RAX
MOV byte ptr [RBP + -0x41],AL
JMP 0x00167bfd
LAB_00167bfd:
JMP 0x00167bff
LAB_00167bff:
MOV RAX,qword ptr [RBP + -0x28]
MOVSX ECX,byte ptr [RBP + -0x41]
MOVSXD RCX,ECX
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x40]
JA 0x00167c39
MOV RDI,qword ptr [RBP + -0x28]
LEA RSI,[RBP + -0x12]
MOVSX RDX,byte ptr [RBP + -0x41]
CALL 0x00124200
MOVSX ECX,byte ptr [RBP + -0x41]
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00167bff
LAB_00167c39:
JMP 0x00167c3b
LAB_00167c3b:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x00167c59
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x28],RCX
MOV byte ptr [RAX],0x20
JMP 0x00167c3b
LAB_00167c59:
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00167c71
ADD RSP,0x50
POP RBP
RET
LAB_00167c71:
CALL 0x001242b0
|
void my_fill_utf8mb3_mb(long param_1,int1 *param_2,long param_3,int param_4)
{
char cVar1;
long in_FS_OFFSET;
int1 *local_30;
int1 local_1a [10];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
cVar1 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xd8))(param_1,(long)param_4,local_1a,&local_10);
for (local_30 = param_2; local_30 + (int)cVar1 <= param_2 + param_3;
local_30 = local_30 + (int)cVar1) {
memcpy(local_30,local_1a,(long)cVar1);
}
while (local_30 < param_2 + param_3) {
*local_30 = 0x20;
local_30 = local_30 + 1;
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
}
|
|
18,451
|
ma_apply_redo_insert_row_blobs
|
eloqsql/storage/maria/ma_blockrec.c
|
uint _ma_apply_redo_insert_row_blobs(MARIA_HA *info,
LSN lsn, const uchar *header,
LSN redo_lsn,
uint * const number_of_blobs,
uint * const number_of_ranges,
pgcache_page_no_t * const first_page,
pgcache_page_no_t * const last_page)
{
MARIA_SHARE *share= info->s;
const uchar *data;
uint data_size= FULL_PAGE_SIZE(share);
uint blob_count, ranges;
uint16 sid;
pgcache_page_no_t first_page2= ULONGLONG_MAX, last_page2= 0;
DBUG_ENTER("_ma_apply_redo_insert_row_blobs");
share->state.changed|= (STATE_CHANGED | STATE_NOT_ZEROFILLED |
STATE_NOT_MOVABLE);
sid= fileid_korr(header);
header+= FILEID_STORE_SIZE;
*number_of_ranges= ranges= pagerange_korr(header);
header+= PAGERANGE_STORE_SIZE;
*number_of_blobs= blob_count= pagerange_korr(header);
header+= PAGERANGE_STORE_SIZE;
DBUG_ASSERT(ranges >= blob_count);
data= (header + ranges * ROW_EXTENT_SIZE +
blob_count * (SUB_RANGE_SIZE + BLOCK_FILLER_SIZE));
while (blob_count--)
{
uint sub_ranges, empty_space;
sub_ranges= uint2korr(header);
header+= SUB_RANGE_SIZE;
empty_space= uint2korr(header);
header+= BLOCK_FILLER_SIZE;
DBUG_ASSERT(sub_ranges <= ranges && empty_space < data_size);
ranges-= sub_ranges;
while (sub_ranges--)
{
uint i;
uint res;
uint page_range;
pgcache_page_no_t page;
uchar *buff;
uint data_on_page= data_size;
page= page_korr(header);
header+= PAGE_STORE_SIZE;
page_range= pagerange_korr(header);
header+= PAGERANGE_STORE_SIZE;
for (i= page_range; i-- > 0 ; page++, data+= data_on_page)
{
MARIA_PINNED_PAGE page_link;
enum pagecache_page_lock unlock_method;
enum pagecache_page_pin unpin_method;
set_if_smaller(first_page2, page);
set_if_bigger(last_page2, page);
if (i == 0 && sub_ranges == 0)
data_on_page= data_size - empty_space; /* data on last page */
if (_ma_redo_not_needed_for_page(sid, redo_lsn, page, FALSE))
continue;
if (((page + 1) * share->block_size) >
share->state.state.data_file_length)
{
/* New page or half written page at end of file */
DBUG_PRINT("info", ("Enlarging data file from %lu to %lu",
(ulong) share->state.state.data_file_length,
(ulong) ((page + 1 ) * share->block_size)));
share->state.state.data_file_length= (page + 1) * share->block_size;
buff= info->keyread_buff;
info->keyread_buff_used= 1;
make_empty_page(info, buff, BLOB_PAGE, 0);
unlock_method= PAGECACHE_LOCK_LEFT_UNLOCKED;
unpin_method= PAGECACHE_PIN_LEFT_UNPINNED;
}
else
{
share->pagecache->readwrite_flags&= ~MY_WME;
share->silence_encryption_errors= 1;
buff= pagecache_read(share->pagecache,
&info->dfile,
page, 0, 0,
PAGECACHE_PLAIN_PAGE,
PAGECACHE_LOCK_WRITE, &page_link.link);
share->pagecache->readwrite_flags= share->pagecache->
org_readwrite_flags;
share->silence_encryption_errors= 0;
if (!buff)
{
if (my_errno != HA_ERR_FILE_TOO_SHORT &&
my_errno != HA_ERR_WRONG_CRC &&
my_errno != HA_ERR_DECRYPTION_FAILED)
{
/* If not read outside of file */
pagecache_unlock_by_link(share->pagecache, page_link.link,
PAGECACHE_LOCK_WRITE_UNLOCK,
PAGECACHE_UNPIN, LSN_IMPOSSIBLE,
LSN_IMPOSSIBLE, 0, FALSE);
goto err;
}
/*
Physical file was too short, create new page. It can be that
recovery started with a file with N pages, wrote page N+2 into
pagecache (increased data_file_length but not physical file
length), now reads page N+1: the read fails.
*/
buff= pagecache_block_link_to_buffer(page_link.link);
make_empty_page(info, buff, BLOB_PAGE, 0);
}
else
{
#ifdef DBUG_ASSERT_EXISTS
uchar found_page_type= (buff[PAGE_TYPE_OFFSET] & PAGE_TYPE_MASK);
#endif
if (lsn_korr(buff) >= lsn)
{
/* Already applied */
check_skipped_lsn(info, lsn_korr(buff), 1, page);
pagecache_unlock_by_link(share->pagecache, page_link.link,
PAGECACHE_LOCK_WRITE_UNLOCK,
PAGECACHE_UNPIN, LSN_IMPOSSIBLE,
LSN_IMPOSSIBLE, 0, FALSE);
goto fix_bitmap;
}
DBUG_ASSERT((found_page_type == (uchar) BLOB_PAGE) ||
(found_page_type == (uchar) UNALLOCATED_PAGE));
}
unlock_method= PAGECACHE_LOCK_WRITE_UNLOCK;
unpin_method= PAGECACHE_UNPIN;
}
/*
Blob pages are never updated twice in same redo-undo chain, so
it's safe to update lsn for them here
*/
lsn_store(buff, lsn);
buff[PAGE_TYPE_OFFSET]= BLOB_PAGE;
bzero(buff + LSN_SIZE + PAGE_TYPE_SIZE,
FULL_PAGE_HEADER_SIZE(share) - (LSN_SIZE + PAGE_TYPE_SIZE));
if (data_on_page != data_size)
{
/*
Last page may be only partly filled. We zero the rest, like
write_full_pages() does.
*/
bzero(buff + share->block_size - PAGE_SUFFIX_SIZE - empty_space,
empty_space);
}
memcpy(buff + FULL_PAGE_HEADER_SIZE(share), data, data_on_page);
if (pagecache_write(share->pagecache,
&info->dfile, page, 0,
buff, PAGECACHE_PLAIN_PAGE,
unlock_method, unpin_method,
PAGECACHE_WRITE_DELAY, 0, LSN_IMPOSSIBLE))
goto err;
fix_bitmap:
/** @todo leave bitmap lock to the bitmap code... */
mysql_mutex_lock(&share->bitmap.bitmap_lock);
res= _ma_bitmap_set_full_page_bits(info, &share->bitmap, page,
1);
mysql_mutex_unlock(&share->bitmap.bitmap_lock);
if (res)
goto err;
}
}
}
*first_page= first_page2;
*last_page= last_page2;
DBUG_RETURN(0);
err:
_ma_mark_file_crashed(share);
DBUG_ASSERT(!maria_assert_if_crashed_table);
DBUG_RETURN(1);
}
|
O3
|
c
|
ma_apply_redo_insert_row_blobs:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, %rbx
movq (%rdi), %r12
movl 0x7bc(%r12), %r10d
subl 0xc18(%r12), %r10d
orl $0x181, 0x170(%r12) # imm = 0x181
movzwl (%rdx), %eax
movzwl 0x2(%rdx), %ecx
movl %ecx, (%r9)
movzwl 0x4(%rdx), %r9d
movl %r9d, (%r8)
testl %r9d, %r9d
je 0x4cd95
addl $-0xc, %r10d
leaq (,%rcx,8), %r8
subq %rcx, %r8
leaq (%rdx,%r8), %rcx
addq $0x6, %rcx
addq $0x6, %rdx
leaq (%rcx,%r9,4), %rcx
movq %rcx, -0x78(%rbp)
leaq 0x470(%rdi), %rcx
movq %rcx, -0x70(%rbp)
movq %rsi, %rcx
shrq $0x20, %rcx
movq %rcx, -0xb0(%rbp)
movq %rsi, %rcx
shrq $0x28, %rcx
movq %rcx, -0xa8(%rbp)
movq %rsi, %rcx
shrq $0x30, %rcx
movq %rcx, -0xa0(%rbp)
leaq 0xa10(%r12), %rcx
movq %rcx, -0xb8(%rbp)
leaq 0xa98(%r12), %rcx
movq %rcx, -0x50(%rbp)
movq $-0x1, %r8
movzwl %ax, %eax
movl %eax, -0x54(%rbp)
xorl %r11d, %r11d
movq %r12, -0x48(%rbp)
movq %rbx, -0xc8(%rbp)
movl %r10d, -0x38(%rbp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x68(%rbp)
movq %r9, -0x80(%rbp)
movzwl (%rdx), %esi
leaq 0x4(%rdx), %rcx
testl %esi, %esi
je 0x4cd83
movzwl 0x2(%rdx), %eax
movl %r10d, %edx
subl %eax, %edx
movl %edx, -0x58(%rbp)
movq %rax, -0x98(%rbp)
negq %rax
movq %rax, -0x90(%rbp)
decl %esi
movzwl 0x5(%rcx), %ebx
testl %ebx, %ebx
movq %rcx, -0x88(%rbp)
je 0x4cd6c
movzbl 0x4(%rcx), %eax
shlq $0x20, %rax
movl (%rcx), %r15d
orq %rax, %r15
decl %ebx
movl %r10d, -0x34(%rbp)
movl %esi, -0x5c(%rbp)
cmpq %r15, %r8
cmovaeq %r15, %r8
movq %r8, -0xd8(%rbp)
cmpq %r15, %r11
cmovbeq %r15, %r11
movq %r11, -0xd0(%rbp)
movl %ebx, %eax
orl %esi, %eax
movl -0x34(%rbp), %r14d
cmovel -0x58(%rbp), %r14d
movl -0x54(%rbp), %edi
movq -0xc8(%rbp), %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x74f7f
leaq 0x1(%r15), %rcx
movl %r14d, -0x34(%rbp)
movl %r14d, %r13d
testb %al, %al
jne 0x4ccd4
movl 0x7bc(%r12), %eax
movq %rcx, -0xc0(%rbp)
imulq %rcx, %rax
cmpq 0x40(%r12), %rax
jbe 0x4ca70
movq %rax, 0x40(%r12)
movq -0x40(%rbp), %rax
movq 0x380(%rax), %r12
movb $0x1, 0x685(%rax)
movl $0x1, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
jmp 0x4cb68
movq 0x600(%r12), %rax
movl $0xffffffef, %ecx # imm = 0xFFFFFFEF
andq %rcx, 0x198(%rax)
movb $0x1, 0x7ec(%r12)
movq 0x600(%r12), %rdi
movq -0x70(%rbp), %rsi
movq %r15, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movl $0x1, %r9d
leaq -0xf0(%rbp), %rax
pushq %rax
pushq $0x4
callq 0x70b16
addq $0x10, %rsp
movq %r12, %rdx
movq %rax, %r12
movq 0x600(%rdx), %rax
movq 0x1a0(%rax), %rcx
movq %rcx, 0x198(%rax)
movb $0x0, 0x7ec(%rdx)
testq %r12, %r12
je 0x4cb1c
movzwl (%r12), %eax
shlq $0x20, %rax
movzbl 0x2(%r12), %ecx
shlq $0x30, %rcx
orq %rax, %rcx
movl 0x3(%r12), %esi
orq %rcx, %rsi
movq -0x68(%rbp), %rax
cmpq %rax, %rsi
jge 0x4ccf7
movl $0x3, -0x30(%rbp)
movl $0x6, -0x2c(%rbp)
jmp 0x4cb90
callq 0xa8ec2
cmpl $0xaf, (%rax)
je 0x4cb47
callq 0xa8ec2
cmpl $0xb0, (%rax)
je 0x4cb47
callq 0xa8ec2
cmpl $0xc0, (%rax)
jne 0x4cdb1
movq -0xf0(%rbp), %rdi
callq 0x72ff9
movq %rax, %r12
movl $0x3, -0x30(%rbp)
movl $0x6, -0x2c(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rax
movl 0xc18(%rax), %edx
addl $0xc, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x2a290
movw $0x3, 0x7(%r12)
movb $-0x1, 0x9(%r12)
movq -0x68(%rbp), %rax
movq -0xb0(%rbp), %rcx
movb %cl, (%r12)
movq -0xa8(%rbp), %rcx
movb %cl, 0x1(%r12)
movq -0xa0(%rbp), %rcx
movb %cl, 0x2(%r12)
movl %eax, 0x3(%r12)
movb $0x3, 0x7(%r12)
leaq 0x8(%r12), %rdi
movq -0x48(%rbp), %r14
movl 0xc18(%r14), %edx
xorl %esi, %esi
callq 0x2a290
movl -0x34(%rbp), %eax
cmpl -0x38(%rbp), %eax
je 0x4cc04
movl 0x7bc(%r14), %eax
addq %r12, %rax
movq -0x90(%rbp), %rcx
leaq (%rcx,%rax), %rdi
addq $-0x4, %rdi
xorl %esi, %esi
movq -0x98(%rbp), %rdx
callq 0x2a290
movl 0xc18(%r14), %edi
addl $0x8, %edi
addq %r12, %rdi
movq -0x78(%rbp), %rsi
movq %r13, %rdx
callq 0x2a0a0
movq 0x600(%r14), %rdi
movl 0x80(%rdi), %eax
subq $0x40, %rsp
movl %eax, 0x30(%rsp)
xorl %eax, %eax
movl %eax, 0x28(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsp)
movl %eax, 0x10(%rsp)
movl -0x30(%rbp), %eax
movl %eax, 0x8(%rsp)
movl -0x2c(%rbp), %eax
movl %eax, (%rsp)
movq -0x70(%rbp), %rsi
movq %r15, %rdx
xorl %ecx, %ecx
movq %r12, %r8
movl $0x1, %r9d
callq 0x71f7a
addq $0x40, %rsp
testb %al, %al
movq %r14, %r12
jne 0x4cde1
cmpq $0x0, 0xad8(%r12)
jne 0x4cd3d
movq -0x50(%rbp), %rdi
callq 0x2a1f0
movq -0x40(%rbp), %rdi
movq -0xb8(%rbp), %rsi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x525c8
movl %eax, %r15d
movq 0xad8(%r12), %rdi
testq %rdi, %rdi
jne 0x4cd57
movq -0x50(%rbp), %rdi
callq 0x2a1c0
testb %r15b, %r15b
movq -0xc0(%rbp), %rcx
jne 0x4cde1
addq %r13, -0x78(%rbp)
movq %rcx, %r15
addl $-0x1, %ebx
movq -0xd8(%rbp), %r8
movq -0xd0(%rbp), %r11
movl -0x5c(%rbp), %esi
jb 0x4c9dc
jmp 0x4cd6c
movq -0x40(%rbp), %rdi
movl $0x1, %edx
movq %r15, %rcx
callq 0x6b725
movq -0x48(%rbp), %r12
movq 0x600(%r12), %rdi
movq -0xf0(%rbp), %rsi
movl $0x6, %edx
movl $0x3, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
pushq %rax
pushq %rax
callq 0x70831
addq $0x10, %rsp
jmp 0x4cc77
movq -0x50(%rbp), %rdi
leaq 0x94c57(%rip), %rsi # 0xe199f
movl $0x1b5a, %edx # imm = 0x1B5A
callq 0x2ff2f
jmp 0x4cc8f
leaq 0x343dba(%rip), %rax # 0x390b18
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x4ccbb
movq -0x88(%rbp), %rcx
addq $0x7, %rcx
testl %esi, %esi
movl -0x38(%rbp), %r10d
jne 0x4c9b0
movq %rcx, %rdx
movq -0x80(%rbp), %r9
decl %r9d
jne 0x4c980
jmp 0x4cd9f
movq $-0x1, %r8
xorl %r11d, %r11d
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rcx
movq %r8, (%rcx)
movq %r11, (%rax)
xorl %eax, %eax
jmp 0x4cdee
movq -0x48(%rbp), %r12
movq 0x600(%r12), %rdi
movq -0xf0(%rbp), %rsi
xorl %eax, %eax
movl $0x6, %edx
movl $0x3, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %rax
callq 0x70831
addq $0x10, %rsp
movq %r12, %rdi
callq 0x40832
movl $0x1, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ma_apply_redo_insert_row_blobs:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0C8h
mov rbx, rcx
mov r12, [rdi]
mov r10d, [r12+7BCh]
sub r10d, [r12+0C18h]
or dword ptr [r12+170h], 181h
movzx eax, word ptr [rdx]
movzx ecx, word ptr [rdx+2]
mov [r9], ecx
movzx r9d, word ptr [rdx+4]
mov [r8], r9d
test r9d, r9d
jz loc_4CD95
add r10d, 0FFFFFFF4h
lea r8, ds:0[rcx*8]
sub r8, rcx
lea rcx, [rdx+r8]
add rcx, 6
add rdx, 6
lea rcx, [rcx+r9*4]
mov [rbp+var_78], rcx
lea rcx, [rdi+470h]
mov [rbp+var_70], rcx
mov rcx, rsi
shr rcx, 20h
mov [rbp+var_B0], rcx
mov rcx, rsi
shr rcx, 28h
mov [rbp+var_A8], rcx
mov rcx, rsi
shr rcx, 30h
mov [rbp+var_A0], rcx
lea rcx, [r12+0A10h]
mov [rbp+var_B8], rcx
lea rcx, [r12+0A98h]
mov [rbp+var_50], rcx
mov r8, 0FFFFFFFFFFFFFFFFh
movzx eax, ax
mov [rbp+var_54], eax
xor r11d, r11d
mov [rbp+var_48], r12
mov [rbp+var_C8], rbx
mov [rbp+var_38], r10d
mov [rbp+var_40], rdi
mov [rbp+var_68], rsi
loc_4C980:
mov [rbp+var_80], r9
movzx esi, word ptr [rdx]
lea rcx, [rdx+4]
test esi, esi
jz loc_4CD83
movzx eax, word ptr [rdx+2]
mov edx, r10d
sub edx, eax
mov [rbp+var_58], edx
mov [rbp+var_98], rax
neg rax
mov [rbp+var_90], rax
loc_4C9B0:
dec esi
movzx ebx, word ptr [rcx+5]
test ebx, ebx
mov [rbp+var_88], rcx
jz loc_4CD6C
movzx eax, byte ptr [rcx+4]
shl rax, 20h
mov r15d, [rcx]
or r15, rax
dec ebx
mov [rbp+var_34], r10d
mov [rbp+var_5C], esi
loc_4C9DC:
cmp r8, r15
cmovnb r8, r15
mov [rbp+var_D8], r8
cmp r11, r15
cmovbe r11, r15
mov [rbp+var_D0], r11
mov eax, ebx
or eax, esi
mov r14d, [rbp+var_34]
cmovz r14d, [rbp+var_58]
mov edi, [rbp+var_54]
mov rsi, [rbp+var_C8]
mov rdx, r15
xor ecx, ecx
call _ma_redo_not_needed_for_page
lea rcx, [r15+1]
mov [rbp+var_34], r14d
mov r13d, r14d
test al, al
jnz loc_4CCD4
mov eax, [r12+7BCh]
mov [rbp+var_C0], rcx
imul rax, rcx
cmp rax, [r12+40h]
jbe short loc_4CA70
mov [r12+40h], rax
mov rax, [rbp+var_40]
mov r12, [rax+380h]
mov byte ptr [rax+685h], 1
mov [rbp+var_30], 1
mov [rbp+var_2C], 0
jmp loc_4CB68
loc_4CA70:
mov rax, [r12+600h]
mov ecx, 0FFFFFFEFh
and [rax+198h], rcx
mov byte ptr [r12+7ECh], 1
mov rdi, [r12+600h]
mov rsi, [rbp+var_70]
mov rdx, r15
xor ecx, ecx
xor r8d, r8d
mov r9d, 1
lea rax, [rbp+var_F0]
push rax
push 4
call pagecache_read
add rsp, 10h
mov rdx, r12
mov r12, rax
mov rax, [rdx+600h]
mov rcx, [rax+1A0h]
mov [rax+198h], rcx
mov byte ptr [rdx+7ECh], 0
test r12, r12
jz short loc_4CB1C
movzx eax, word ptr [r12]
shl rax, 20h
movzx ecx, byte ptr [r12+2]
shl rcx, 30h
or rcx, rax
mov esi, [r12+3]
or rsi, rcx
mov rax, [rbp+var_68]
cmp rsi, rax
jge loc_4CCF7
mov [rbp+var_30], 3
mov [rbp+var_2C], 6
jmp short loc_4CB90
loc_4CB1C:
call _my_thread_var
cmp dword ptr [rax], 0AFh
jz short loc_4CB47
call _my_thread_var
cmp dword ptr [rax], 0B0h
jz short loc_4CB47
call _my_thread_var
cmp dword ptr [rax], 0C0h
jnz loc_4CDB1
loc_4CB47:
mov rdi, [rbp+var_F0]
call pagecache_block_link_to_buffer
mov r12, rax
mov [rbp+var_30], 3
mov [rbp+var_2C], 6
mov rax, [rbp+var_40]
loc_4CB68:
mov rax, [rax]
mov edx, [rax+0C18h]
add edx, 0Ch
mov rdi, r12
xor esi, esi
call _memset
mov word ptr [r12+7], 3
mov byte ptr [r12+9], 0FFh
mov rax, [rbp+var_68]
loc_4CB90:
mov rcx, [rbp+var_B0]
mov [r12], cl
mov rcx, [rbp+var_A8]
mov [r12+1], cl
mov rcx, [rbp+var_A0]
mov [r12+2], cl
mov [r12+3], eax
mov byte ptr [r12+7], 3
lea rdi, [r12+8]
mov r14, [rbp+var_48]
mov edx, [r14+0C18h]
xor esi, esi
call _memset
mov eax, [rbp+var_34]
cmp eax, [rbp+var_38]
jz short loc_4CC04
mov eax, [r14+7BCh]
add rax, r12
mov rcx, [rbp+var_90]
lea rdi, [rcx+rax]
add rdi, 0FFFFFFFFFFFFFFFCh
xor esi, esi
mov rdx, [rbp+var_98]
call _memset
loc_4CC04:
mov edi, [r14+0C18h]
add edi, 8
add rdi, r12
mov rsi, [rbp+var_78]
mov rdx, r13
call _memcpy
mov rdi, [r14+600h]
mov eax, [rdi+80h]
sub rsp, 40h
mov [rsp+130h+var_100], eax
xor eax, eax
mov [rsp+130h+var_108], eax
xorps xmm0, xmm0
movups [rsp+130h+var_118], xmm0
mov [rsp+130h+var_120], eax
mov eax, [rbp+var_30]
mov [rsp+130h+var_128], eax
mov eax, [rbp+var_2C]
mov [rsp+130h+var_130], eax
mov rsi, [rbp+var_70]
mov rdx, r15
xor ecx, ecx
mov r8, r12
mov r9d, 1
call pagecache_write_part
add rsp, 40h
test al, al
mov r12, r14
jnz loc_4CDE1
loc_4CC77:
cmp qword ptr [r12+0AD8h], 0
jnz loc_4CD3D
mov rdi, [rbp+var_50]
call _pthread_mutex_lock
loc_4CC8F:
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_B8]
mov rdx, r15
mov ecx, 1
call _ma_bitmap_set_full_page_bits
mov r15d, eax
mov rdi, [r12+0AD8h]
test rdi, rdi
jnz loc_4CD57
loc_4CCBB:
mov rdi, [rbp+var_50]
call _pthread_mutex_unlock
test r15b, r15b
mov rcx, [rbp+var_C0]
jnz loc_4CDE1
loc_4CCD4:
add [rbp+var_78], r13
mov r15, rcx
add ebx, 0FFFFFFFFh
mov r8, [rbp+var_D8]
mov r11, [rbp+var_D0]
mov esi, [rbp+var_5C]
jb loc_4C9DC
jmp short loc_4CD6C
loc_4CCF7:
mov rdi, [rbp+var_40]
mov edx, 1
mov rcx, r15
call check_skipped_lsn
mov r12, [rbp+var_48]
mov rdi, [r12+600h]
mov rsi, [rbp+var_F0]
mov edx, 6
mov ecx, 3
xor r8d, r8d
xor r9d, r9d
xor eax, eax
push rax
push rax
call pagecache_unlock_by_link
add rsp, 10h
jmp loc_4CC77
loc_4CD3D:
mov rdi, [rbp+var_50]
lea rsi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 1B5Ah
call psi_mutex_lock
jmp loc_4CC8F
loc_4CD57:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_4CCBB
loc_4CD6C:
mov rcx, [rbp+var_88]
add rcx, 7
test esi, esi
mov r10d, [rbp+var_38]
jnz loc_4C9B0
loc_4CD83:
mov rdx, rcx
mov r9, [rbp+var_80]
dec r9d
jnz loc_4C980
jmp short loc_4CD9F
loc_4CD95:
mov r8, 0FFFFFFFFFFFFFFFFh
xor r11d, r11d
loc_4CD9F:
mov rax, [rbp+arg_8]
mov rcx, [rbp+arg_0]
mov [rcx], r8
mov [rax], r11
xor eax, eax
jmp short loc_4CDEE
loc_4CDB1:
mov r12, [rbp+var_48]
mov rdi, [r12+600h]
mov rsi, [rbp+var_F0]
xor eax, eax
mov edx, 6
mov ecx, 3
xor r8d, r8d
xor r9d, r9d
push rax
push rax
call pagecache_unlock_by_link
add rsp, 10h
loc_4CDE1:
mov rdi, r12
call _ma_mark_file_crashed
mov eax, 1
loc_4CDEE:
add rsp, 0C8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long ma_apply_redo_insert_row_blobs(
long long *a1,
unsigned long long a2,
unsigned __int16 *a3,
long long a4,
_DWORD *a5,
_DWORD *a6,
unsigned long long *a7,
unsigned long long *a8)
{
long long v9; // r12
int v10; // r10d
unsigned __int16 v11; // ax
long long v12; // rcx
long long v13; // r9
int v14; // r10d
long long v15; // rcx
unsigned __int16 *v16; // rdx
unsigned long long v17; // r8
unsigned long long v18; // r11
int v19; // esi
unsigned __int16 *v20; // rcx
long long v21; // rax
int v22; // ebx
unsigned long long v23; // r15
int v24; // ebx
unsigned int v25; // r14d
char v26; // al
unsigned long long v27; // rcx
long long v28; // r13
long long v29; // rax
unsigned long long v30; // rax
long long *v31; // rax
long long v32; // r12
long long v33; // rdi
unsigned __int16 *v34; // rax
long long v35; // rdx
signed long long v36; // rsi
int v37; // eax
long long v38; // r14
char v39; // al
char v40; // r15
bool v41; // cf
long long v43[3]; // [rsp+40h] [rbp-F0h] BYREF
unsigned long long v44; // [rsp+58h] [rbp-D8h]
unsigned long long v45; // [rsp+60h] [rbp-D0h]
long long v46; // [rsp+68h] [rbp-C8h]
unsigned long long v47; // [rsp+70h] [rbp-C0h]
long long v48; // [rsp+78h] [rbp-B8h]
unsigned long long v49; // [rsp+80h] [rbp-B0h]
unsigned long long v50; // [rsp+88h] [rbp-A8h]
unsigned long long v51; // [rsp+90h] [rbp-A0h]
long long v52; // [rsp+98h] [rbp-98h]
long long v53; // [rsp+A0h] [rbp-90h]
unsigned __int16 *v54; // [rsp+A8h] [rbp-88h]
long long v55; // [rsp+B0h] [rbp-80h]
long long v56; // [rsp+B8h] [rbp-78h]
long long *v57; // [rsp+C0h] [rbp-70h]
signed long long v58; // [rsp+C8h] [rbp-68h]
int v59; // [rsp+D4h] [rbp-5Ch]
unsigned int v60; // [rsp+D8h] [rbp-58h]
unsigned int v61; // [rsp+DCh] [rbp-54h]
long long v62; // [rsp+E0h] [rbp-50h]
long long v63; // [rsp+E8h] [rbp-48h]
long long *v64; // [rsp+F0h] [rbp-40h]
int v65; // [rsp+F8h] [rbp-38h]
int v66; // [rsp+FCh] [rbp-34h]
int v67; // [rsp+100h] [rbp-30h]
int v68; // [rsp+104h] [rbp-2Ch]
v9 = *a1;
v10 = *(_DWORD *)(*a1 + 1980) - *(_DWORD *)(*a1 + 3096);
*(_DWORD *)(*a1 + 368) |= 0x181u;
v11 = *a3;
v12 = a3[1];
*a6 = v12;
v13 = a3[2];
*a5 = v13;
if ( !(_DWORD)v13 )
{
v17 = -1LL;
v18 = 0LL;
LABEL_40:
*a7 = v17;
*a8 = v18;
return 0LL;
}
v14 = v10 - 12;
v15 = (long long)a3 + 7 * v12 + 6;
v16 = a3 + 3;
v56 = v15 + 4 * v13;
v57 = a1 + 142;
v49 = HIDWORD(a2);
v50 = a2 >> 40;
v51 = HIWORD(a2);
v48 = v9 + 2576;
v62 = v9 + 2712;
v17 = -1LL;
v61 = v11;
v18 = 0LL;
v63 = v9;
v46 = a4;
v65 = v14;
v64 = a1;
v58 = a2;
while ( 1 )
{
v55 = v13;
v19 = *v16;
v20 = v16 + 2;
if ( *v16 )
break;
LABEL_37:
v16 = v20;
v13 = (unsigned int)(v55 - 1);
if ( (_DWORD)v55 == 1 )
goto LABEL_40;
}
v21 = v16[1];
v60 = v14 - v21;
v52 = v21;
v53 = -v21;
while ( 1 )
{
--v19;
v22 = *(unsigned __int16 *)((char *)v20 + 5);
v54 = v20;
if ( v22 )
break;
LABEL_36:
v20 = (unsigned __int16 *)((char *)v54 + 7);
v14 = v65;
if ( !v19 )
goto LABEL_37;
}
v23 = ((unsigned long long)*((unsigned __int8 *)v20 + 4) << 32) | *(unsigned int *)v20;
v24 = v22 - 1;
v66 = v14;
v59 = v19;
while ( 1 )
{
if ( v17 >= v23 )
v17 = v23;
v44 = v17;
if ( v18 <= v23 )
v18 = v23;
v45 = v18;
v25 = v66;
if ( !(v19 | v24) )
v25 = v60;
v26 = ma_redo_not_needed_for_page(v61, v46, v23, 0LL);
v27 = v23 + 1;
v66 = v25;
v28 = v25;
if ( v26 )
goto LABEL_32;
v29 = *(unsigned int *)(v9 + 1980);
v47 = v23 + 1;
v30 = v27 * v29;
if ( v30 > *(_QWORD *)(v9 + 64) )
{
*(_QWORD *)(v9 + 64) = v30;
v31 = v64;
v32 = v64[112];
*((_BYTE *)v64 + 1669) = 1;
v67 = 1;
v68 = 0;
LABEL_23:
memset(v32, 0LL, (unsigned int)(*(_DWORD *)(*v31 + 3096) + 12));
*(_WORD *)(v32 + 7) = 3;
*(_BYTE *)(v32 + 9) = -1;
v37 = v58;
LABEL_24:
*(_BYTE *)v32 = v49;
*(_BYTE *)(v32 + 1) = v50;
*(_BYTE *)(v32 + 2) = v51;
*(_DWORD *)(v32 + 3) = v37;
*(_BYTE *)(v32 + 7) = 3;
v38 = v63;
memset(v32 + 8, 0LL, *(unsigned int *)(v63 + 3096));
if ( v66 != v65 )
memset(v53 + v32 + *(unsigned int *)(v38 + 1980) - 4, 0LL, v52);
memcpy(v32 + (unsigned int)(*(_DWORD *)(v38 + 3096) + 8), v56, v28);
v39 = pagecache_write_part(
*(_QWORD *)(v38 + 1536),
(_DWORD)v57,
v23,
0,
v32,
1,
v68,
v67,
0,
0LL,
0LL,
0,
*(_DWORD *)(*(_QWORD *)(v38 + 1536) + 128LL));
v9 = v38;
if ( v39 )
goto LABEL_42;
goto LABEL_27;
}
*(_QWORD *)(*(_QWORD *)(v9 + 1536) + 408LL) &= 0xFFFFFFEFuLL;
*(_BYTE *)(v9 + 2028) = 1;
v33 = *(_QWORD *)(v9 + 1536);
v34 = (unsigned __int16 *)pagecache_read(v33, (_DWORD)v57, v23, 0, 0, 1, 4, (long long)v43);
v35 = v9;
v32 = (long long)v34;
*(_QWORD *)(*(_QWORD *)(v35 + 1536) + 408LL) = *(_QWORD *)(*(_QWORD *)(v35 + 1536) + 416LL);
*(_BYTE *)(v35 + 2028) = 0;
if ( !v34 )
break;
v36 = ((unsigned long long)*v34 << 32) | ((unsigned long long)*((unsigned __int8 *)v34 + 2) << 48) | *(unsigned int *)((char *)v34 + 3);
v37 = v58;
if ( v36 < v58 )
{
v67 = 3;
v68 = 6;
goto LABEL_24;
}
check_skipped_lsn(v64, v36, 1LL, v23);
v9 = v63;
pagecache_unlock_by_link(*(_QWORD *)(v63 + 1536), v43[0], 6, 3, 0, 0, 0LL, 0LL);
LABEL_27:
if ( *(_QWORD *)(v9 + 2776) )
psi_mutex_lock(v62, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_blockrec.c", 0x1B5Au);
else
pthread_mutex_lock(v62);
v40 = ma_bitmap_set_full_page_bits(v64, v48, v23, 1LL);
if ( *(_QWORD *)(v9 + 2776) )
PSI_server[44]();
pthread_mutex_unlock(v62);
v27 = v47;
if ( v40 )
goto LABEL_42;
LABEL_32:
v56 += v28;
v23 = v27;
v41 = v24-- != 0;
v17 = v44;
v18 = v45;
v19 = v59;
if ( !v41 )
goto LABEL_36;
}
if ( *(_DWORD *)my_thread_var(v33) == 175
|| *(_DWORD *)my_thread_var(v33) == 176
|| *(_DWORD *)my_thread_var(v33) == 192 )
{
v32 = pagecache_block_link_to_buffer(v43[0]);
v67 = 3;
v68 = 6;
v31 = v64;
goto LABEL_23;
}
v9 = v63;
pagecache_unlock_by_link(*(_QWORD *)(v63 + 1536), v43[0], 6, 3, 0, 0, 0LL, 0LL);
LABEL_42:
ma_mark_file_crashed(v9);
return 1LL;
}
|
_ma_apply_redo_insert_row_blobs:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xc8
MOV RBX,RCX
MOV R12,qword ptr [RDI]
MOV R10D,dword ptr [R12 + 0x7bc]
SUB R10D,dword ptr [R12 + 0xc18]
OR dword ptr [R12 + 0x170],0x181
MOVZX EAX,word ptr [RDX]
MOVZX ECX,word ptr [RDX + 0x2]
MOV dword ptr [R9],ECX
MOVZX R9D,word ptr [RDX + 0x4]
MOV dword ptr [R8],R9D
TEST R9D,R9D
JZ 0x0014cd95
ADD R10D,-0xc
LEA R8,[RCX*0x8]
SUB R8,RCX
LEA RCX,[RDX + R8*0x1]
ADD RCX,0x6
ADD RDX,0x6
LEA RCX,[RCX + R9*0x4]
MOV qword ptr [RBP + -0x78],RCX
LEA RCX,[RDI + 0x470]
MOV qword ptr [RBP + -0x70],RCX
MOV RCX,RSI
SHR RCX,0x20
MOV qword ptr [RBP + -0xb0],RCX
MOV RCX,RSI
SHR RCX,0x28
MOV qword ptr [RBP + -0xa8],RCX
MOV RCX,RSI
SHR RCX,0x30
MOV qword ptr [RBP + -0xa0],RCX
LEA RCX,[R12 + 0xa10]
MOV qword ptr [RBP + -0xb8],RCX
LEA RCX,[R12 + 0xa98]
MOV qword ptr [RBP + -0x50],RCX
MOV R8,-0x1
MOVZX EAX,AX
MOV dword ptr [RBP + -0x54],EAX
XOR R11D,R11D
MOV qword ptr [RBP + -0x48],R12
MOV qword ptr [RBP + -0xc8],RBX
MOV dword ptr [RBP + -0x38],R10D
MOV qword ptr [RBP + -0x40],RDI
MOV qword ptr [RBP + -0x68],RSI
LAB_0014c980:
MOV qword ptr [RBP + -0x80],R9
MOVZX ESI,word ptr [RDX]
LEA RCX,[RDX + 0x4]
TEST ESI,ESI
JZ 0x0014cd83
MOVZX EAX,word ptr [RDX + 0x2]
MOV EDX,R10D
SUB EDX,EAX
MOV dword ptr [RBP + -0x58],EDX
MOV qword ptr [RBP + -0x98],RAX
NEG RAX
MOV qword ptr [RBP + -0x90],RAX
LAB_0014c9b0:
DEC ESI
MOVZX EBX,word ptr [RCX + 0x5]
TEST EBX,EBX
MOV qword ptr [RBP + -0x88],RCX
JZ 0x0014cd6c
MOVZX EAX,byte ptr [RCX + 0x4]
SHL RAX,0x20
MOV R15D,dword ptr [RCX]
OR R15,RAX
DEC EBX
MOV dword ptr [RBP + -0x34],R10D
MOV dword ptr [RBP + -0x5c],ESI
LAB_0014c9dc:
CMP R8,R15
CMOVNC R8,R15
MOV qword ptr [RBP + -0xd8],R8
CMP R11,R15
CMOVBE R11,R15
MOV qword ptr [RBP + -0xd0],R11
MOV EAX,EBX
OR EAX,ESI
MOV R14D,dword ptr [RBP + -0x34]
CMOVZ R14D,dword ptr [RBP + -0x58]
MOV EDI,dword ptr [RBP + -0x54]
MOV RSI,qword ptr [RBP + -0xc8]
MOV RDX,R15
XOR ECX,ECX
CALL 0x00174f7f
LEA RCX,[R15 + 0x1]
MOV dword ptr [RBP + -0x34],R14D
MOV R13D,R14D
TEST AL,AL
JNZ 0x0014ccd4
MOV EAX,dword ptr [R12 + 0x7bc]
MOV qword ptr [RBP + -0xc0],RCX
IMUL RAX,RCX
CMP RAX,qword ptr [R12 + 0x40]
JBE 0x0014ca70
MOV qword ptr [R12 + 0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV R12,qword ptr [RAX + 0x380]
MOV byte ptr [RAX + 0x685],0x1
MOV dword ptr [RBP + -0x30],0x1
MOV dword ptr [RBP + -0x2c],0x0
JMP 0x0014cb68
LAB_0014ca70:
MOV RAX,qword ptr [R12 + 0x600]
MOV ECX,0xffffffef
AND qword ptr [RAX + 0x198],RCX
MOV byte ptr [R12 + 0x7ec],0x1
MOV RDI,qword ptr [R12 + 0x600]
MOV RSI,qword ptr [RBP + -0x70]
MOV RDX,R15
XOR ECX,ECX
XOR R8D,R8D
MOV R9D,0x1
LEA RAX,[RBP + -0xf0]
PUSH RAX
PUSH 0x4
CALL 0x00170b16
ADD RSP,0x10
MOV RDX,R12
MOV R12,RAX
MOV RAX,qword ptr [RDX + 0x600]
MOV RCX,qword ptr [RAX + 0x1a0]
MOV qword ptr [RAX + 0x198],RCX
MOV byte ptr [RDX + 0x7ec],0x0
TEST R12,R12
JZ 0x0014cb1c
MOVZX EAX,word ptr [R12]
SHL RAX,0x20
MOVZX ECX,byte ptr [R12 + 0x2]
SHL RCX,0x30
OR RCX,RAX
MOV ESI,dword ptr [R12 + 0x3]
OR RSI,RCX
MOV RAX,qword ptr [RBP + -0x68]
CMP RSI,RAX
JGE 0x0014ccf7
MOV dword ptr [RBP + -0x30],0x3
MOV dword ptr [RBP + -0x2c],0x6
JMP 0x0014cb90
LAB_0014cb1c:
CALL 0x001a8ec2
CMP dword ptr [RAX],0xaf
JZ 0x0014cb47
CALL 0x001a8ec2
CMP dword ptr [RAX],0xb0
JZ 0x0014cb47
CALL 0x001a8ec2
CMP dword ptr [RAX],0xc0
JNZ 0x0014cdb1
LAB_0014cb47:
MOV RDI,qword ptr [RBP + -0xf0]
CALL 0x00172ff9
MOV R12,RAX
MOV dword ptr [RBP + -0x30],0x3
MOV dword ptr [RBP + -0x2c],0x6
MOV RAX,qword ptr [RBP + -0x40]
LAB_0014cb68:
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RAX + 0xc18]
ADD EDX,0xc
MOV RDI,R12
XOR ESI,ESI
CALL 0x0012a290
MOV word ptr [R12 + 0x7],0x3
MOV byte ptr [R12 + 0x9],0xff
MOV RAX,qword ptr [RBP + -0x68]
LAB_0014cb90:
MOV RCX,qword ptr [RBP + -0xb0]
MOV byte ptr [R12],CL
MOV RCX,qword ptr [RBP + -0xa8]
MOV byte ptr [R12 + 0x1],CL
MOV RCX,qword ptr [RBP + -0xa0]
MOV byte ptr [R12 + 0x2],CL
MOV dword ptr [R12 + 0x3],EAX
MOV byte ptr [R12 + 0x7],0x3
LEA RDI,[R12 + 0x8]
MOV R14,qword ptr [RBP + -0x48]
MOV EDX,dword ptr [R14 + 0xc18]
XOR ESI,ESI
CALL 0x0012a290
MOV EAX,dword ptr [RBP + -0x34]
CMP EAX,dword ptr [RBP + -0x38]
JZ 0x0014cc04
MOV EAX,dword ptr [R14 + 0x7bc]
ADD RAX,R12
MOV RCX,qword ptr [RBP + -0x90]
LEA RDI,[RCX + RAX*0x1]
ADD RDI,-0x4
XOR ESI,ESI
MOV RDX,qword ptr [RBP + -0x98]
CALL 0x0012a290
LAB_0014cc04:
MOV EDI,dword ptr [R14 + 0xc18]
ADD EDI,0x8
ADD RDI,R12
MOV RSI,qword ptr [RBP + -0x78]
MOV RDX,R13
CALL 0x0012a0a0
MOV RDI,qword ptr [R14 + 0x600]
MOV EAX,dword ptr [RDI + 0x80]
SUB RSP,0x40
MOV dword ptr [RSP + 0x30],EAX
XOR EAX,EAX
MOV dword ptr [RSP + 0x28],EAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSP + 0x18],XMM0
MOV dword ptr [RSP + 0x10],EAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RSP + 0x8],EAX
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RSP],EAX
MOV RSI,qword ptr [RBP + -0x70]
MOV RDX,R15
XOR ECX,ECX
MOV R8,R12
MOV R9D,0x1
CALL 0x00171f7a
ADD RSP,0x40
TEST AL,AL
MOV R12,R14
JNZ 0x0014cde1
LAB_0014cc77:
CMP qword ptr [R12 + 0xad8],0x0
JNZ 0x0014cd3d
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x0012a1f0
LAB_0014cc8f:
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0xb8]
MOV RDX,R15
MOV ECX,0x1
CALL 0x001525c8
MOV R15D,EAX
MOV RDI,qword ptr [R12 + 0xad8]
TEST RDI,RDI
JNZ 0x0014cd57
LAB_0014ccbb:
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x0012a1c0
TEST R15B,R15B
MOV RCX,qword ptr [RBP + -0xc0]
JNZ 0x0014cde1
LAB_0014ccd4:
ADD qword ptr [RBP + -0x78],R13
MOV R15,RCX
ADD EBX,-0x1
MOV R8,qword ptr [RBP + -0xd8]
MOV R11,qword ptr [RBP + -0xd0]
MOV ESI,dword ptr [RBP + -0x5c]
JC 0x0014c9dc
JMP 0x0014cd6c
LAB_0014ccf7:
MOV RDI,qword ptr [RBP + -0x40]
MOV EDX,0x1
MOV RCX,R15
CALL 0x0016b725
MOV R12,qword ptr [RBP + -0x48]
MOV RDI,qword ptr [R12 + 0x600]
MOV RSI,qword ptr [RBP + -0xf0]
MOV EDX,0x6
MOV ECX,0x3
XOR R8D,R8D
XOR R9D,R9D
XOR EAX,EAX
PUSH RAX
PUSH RAX
CALL 0x00170831
ADD RSP,0x10
JMP 0x0014cc77
LAB_0014cd3d:
MOV RDI,qword ptr [RBP + -0x50]
LEA RSI,[0x1e199f]
MOV EDX,0x1b5a
CALL 0x0012ff2f
JMP 0x0014cc8f
LAB_0014cd57:
LEA RAX,[0x490b18]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0014ccbb
LAB_0014cd6c:
MOV RCX,qword ptr [RBP + -0x88]
ADD RCX,0x7
TEST ESI,ESI
MOV R10D,dword ptr [RBP + -0x38]
JNZ 0x0014c9b0
LAB_0014cd83:
MOV RDX,RCX
MOV R9,qword ptr [RBP + -0x80]
DEC R9D
JNZ 0x0014c980
JMP 0x0014cd9f
LAB_0014cd95:
MOV R8,-0x1
XOR R11D,R11D
LAB_0014cd9f:
MOV RAX,qword ptr [RBP + 0x18]
MOV RCX,qword ptr [RBP + 0x10]
MOV qword ptr [RCX],R8
MOV qword ptr [RAX],R11
XOR EAX,EAX
JMP 0x0014cdee
LAB_0014cdb1:
MOV R12,qword ptr [RBP + -0x48]
MOV RDI,qword ptr [R12 + 0x600]
MOV RSI,qword ptr [RBP + -0xf0]
XOR EAX,EAX
MOV EDX,0x6
MOV ECX,0x3
XOR R8D,R8D
XOR R9D,R9D
PUSH RAX
PUSH RAX
CALL 0x00170831
ADD RSP,0x10
LAB_0014cde1:
MOV RDI,R12
CALL 0x00140832
MOV EAX,0x1
LAB_0014cdee:
ADD RSP,0xc8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
_ma_apply_redo_insert_row_blobs
(long *param_1,ulong param_2,ushort *param_3,int8 param_4,uint *param_5,
uint *param_6,ulong *param_7,ulong *param_8)
{
ulong *puVar1;
ushort uVar2;
ushort uVar3;
ushort uVar4;
int iVar5;
int iVar6;
uint uVar7;
char cVar8;
ulong uVar9;
ushort *__s;
int *piVar10;
uint5 *puVar11;
uint uVar12;
ulong uVar13;
long lVar14;
ulong uVar15;
ulong in_stack_fffffffffffffef0;
int8 local_f8 [3];
ulong local_e0;
ulong local_d8;
int8 local_d0;
ulong local_c8;
long local_c0;
ulong local_b8;
ulong local_b0;
ulong local_a8;
ulong local_a0;
long local_98;
uint5 *local_90;
ulong local_88;
void *local_80;
long *local_78;
ulong local_70;
uint local_64;
uint local_60;
uint local_5c;
pthread_mutex_t *local_58;
long local_50;
long *local_48;
uint local_40;
uint local_3c;
int4 local_38;
int4 local_34;
lVar14 = *param_1;
iVar5 = *(int *)(lVar14 + 0x7bc);
iVar6 = *(int *)(lVar14 + 0xc18);
*(uint *)(lVar14 + 0x170) = *(uint *)(lVar14 + 0x170) | 0x181;
uVar2 = *param_3;
uVar3 = param_3[1];
*param_6 = (uint)uVar3;
uVar4 = param_3[2];
local_88 = (ulong)uVar4;
*param_5 = (uint)uVar4;
if (uVar4 == 0) {
local_e0 = 0xffffffffffffffff;
local_d8 = 0;
}
else {
local_3c = (iVar5 - iVar6) - 0xc;
local_80 = (void *)((long)param_3 + local_88 * 4 + (ulong)uVar3 * 7 + 6);
local_78 = param_1 + 0x8e;
local_b8 = param_2 >> 0x20;
local_b0 = param_2 >> 0x28;
local_a8 = param_2 >> 0x30;
local_c0 = lVar14 + 0xa10;
local_58 = (pthread_mutex_t *)(lVar14 + 0xa98);
local_e0 = 0xffffffffffffffff;
local_5c = (uint)uVar2;
local_d8 = 0;
puVar11 = (uint5 *)(param_3 + 3);
local_d0 = param_4;
local_70 = param_2;
local_50 = lVar14;
local_48 = param_1;
local_40 = local_3c;
do {
local_64 = (uint)(ushort)*puVar11;
local_90 = (uint5 *)((long)puVar11 + 4);
if ((ushort)*puVar11 != 0) {
local_a0 = (ulong)*(ushort *)((long)puVar11 + 2);
local_60 = local_3c - *(ushort *)((long)puVar11 + 2);
local_98 = -local_a0;
do {
local_64 = local_64 - 1;
if (*(ushort *)((long)local_90 + 5) != 0) {
uVar12 = (uint)*(ushort *)((long)local_90 + 5);
uVar15 = (ulong)*local_90;
do {
uVar12 = uVar12 - 1;
if (uVar15 <= local_e0) {
local_e0 = uVar15;
}
if (local_d8 <= uVar15) {
local_d8 = uVar15;
}
uVar7 = local_3c;
if (uVar12 == 0 && local_64 == 0) {
uVar7 = local_60;
}
cVar8 = _ma_redo_not_needed_for_page(local_5c,local_d0,uVar15,0);
uVar13 = uVar15 + 1;
local_3c = uVar7;
if (cVar8 == '\0') {
uVar9 = *(uint *)(lVar14 + 0x7bc) * uVar13;
local_c8 = uVar13;
if (uVar9 < *(ulong *)(lVar14 + 0x40) || uVar9 - *(ulong *)(lVar14 + 0x40) == 0) {
puVar1 = (ulong *)(*(long *)(lVar14 + 0x600) + 0x198);
*puVar1 = *puVar1 & 0xffffffef;
*(int1 *)(lVar14 + 0x7ec) = 1;
in_stack_fffffffffffffef0 = 0;
__s = (ushort *)
pagecache_read(*(int8 *)(lVar14 + 0x600),local_78,uVar15,0,0,1,4,
local_f8);
*(int8 *)(*(long *)(lVar14 + 0x600) + 0x198) =
*(int8 *)(*(long *)(lVar14 + 0x600) + 0x1a0);
*(int1 *)(lVar14 + 0x7ec) = 0;
if (__s == (ushort *)0x0) {
piVar10 = (int *)_my_thread_var();
if (((*piVar10 != 0xaf) && (piVar10 = (int *)_my_thread_var(), *piVar10 != 0xb0)
) && (piVar10 = (int *)_my_thread_var(), lVar14 = local_50, *piVar10 != 0xc0
)) {
pagecache_unlock_by_link
(*(int8 *)(local_50 + 0x600),local_f8[0],6,3,0,0,0,0);
goto LAB_0014cde1;
}
__s = (ushort *)pagecache_block_link_to_buffer(local_f8[0]);
local_38 = 3;
local_34 = 6;
goto LAB_0014cb68;
}
uVar13 = (ulong)*(uint *)((long)__s + 3) |
(ulong)(byte)__s[1] << 0x30 | (ulong)*__s << 0x20;
if ((long)uVar13 < (long)local_70) {
local_38 = 3;
local_34 = 6;
goto LAB_0014cb90;
}
check_skipped_lsn(local_48,uVar13,1,uVar15);
lVar14 = local_50;
in_stack_fffffffffffffef0 = 0;
pagecache_unlock_by_link
(*(int8 *)(local_50 + 0x600),local_f8[0],6,3,0,0,0,0);
}
else {
*(ulong *)(lVar14 + 0x40) = uVar9;
__s = (ushort *)local_48[0x70];
*(int1 *)((long)local_48 + 0x685) = 1;
local_38 = 1;
local_34 = 0;
LAB_0014cb68:
memset(__s,0,(ulong)(*(int *)(*local_48 + 0xc18) + 0xc));
*(int2 *)((long)__s + 7) = 3;
*(int1 *)((long)__s + 9) = 0xff;
LAB_0014cb90:
lVar14 = local_50;
*(char *)__s = (char)local_b8;
*(char *)((long)__s + 1) = (char)local_b0;
*(char *)(__s + 1) = (char)local_a8;
*(int *)((long)__s + 3) = (int)local_70;
*(int1 *)((long)__s + 7) = 3;
memset(__s + 4,0,(ulong)*(uint *)(local_50 + 0xc18));
if (local_3c != local_40) {
memset((void *)((long)__s + local_98 + (ulong)*(uint *)(lVar14 + 0x7bc) + -4),0,
local_a0);
}
memcpy((void *)((ulong)(*(int *)(lVar14 + 0xc18) + 8) + (long)__s),local_80,
(ulong)uVar7);
in_stack_fffffffffffffef0 = in_stack_fffffffffffffef0 & 0xffffffff00000000;
cVar8 = pagecache_write_part
(*(long *)(lVar14 + 0x600),local_78,uVar15,0,__s,1,local_34,
local_38,0,0,0,in_stack_fffffffffffffef0,
*(int4 *)(*(long *)(lVar14 + 0x600) + 0x80));
if (cVar8 != '\0') goto LAB_0014cde1;
}
if (*(long *)(lVar14 + 0xad8) == 0) {
pthread_mutex_lock(local_58);
}
else {
psi_mutex_lock(local_58,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_blockrec.c"
,0x1b5a);
}
cVar8 = _ma_bitmap_set_full_page_bits(local_48,local_c0,uVar15,1);
if (*(long *)(lVar14 + 0xad8) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(local_58);
uVar13 = local_c8;
if (cVar8 != '\0') {
LAB_0014cde1:
_ma_mark_file_crashed(lVar14);
return 1;
}
}
local_80 = (void *)((long)local_80 + (ulong)uVar7);
uVar15 = uVar13;
} while (uVar12 != 0);
}
local_90 = (uint5 *)((long)local_90 + 7);
local_3c = local_40;
} while (local_64 != 0);
}
uVar12 = (int)local_88 - 1;
local_88 = (ulong)uVar12;
puVar11 = local_90;
} while (uVar12 != 0);
}
*param_7 = local_e0;
*param_8 = local_d8;
return 0;
}
|
|
18,452
|
bc_get_u64
|
bluesky950520[P]quickjs/quickjs.c
|
static int bc_get_u64(BCReaderState *s, uint64_t *pval)
{
uint64_t v;
if (unlikely(s->buf_end - s->ptr < 8)) {
*pval = 0; /* avoid warning */
return bc_read_error_end(s);
}
v = get_u64(s->ptr);
if (is_be())
v = bswap64(v);
*pval = v;
s->ptr += 8;
return 0;
}
|
O0
|
c
|
bc_get_u64:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
cmpq $0x8, %rax
setl %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x792f7
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
movq 0x18(%rsp), %rdi
callq 0x791d0
movl %eax, 0x24(%rsp)
jmp 0x79348
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x7bc60
movq %rax, 0x8(%rsp)
callq 0x2b9a0
cmpb $0x0, %al
je 0x79322
movq 0x8(%rsp), %rdi
callq 0x78190
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
|
bc_get_u64:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_18], rsi
mov rax, [rsp+28h+var_10]
mov rax, [rax+18h]
mov rcx, [rsp+28h+var_10]
mov rcx, [rcx+10h]
sub rax, rcx
cmp rax, 8
setl al
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_792F7
mov rax, [rsp+28h+var_18]
mov qword ptr [rax], 0
mov rdi, [rsp+28h+var_10]
call bc_read_error_end
mov [rsp+28h+var_4], eax
jmp short loc_79348
loc_792F7:
mov rax, [rsp+28h+var_10]
mov rdi, [rax+10h]
call get_u64
mov [rsp+28h+var_20], rax
call is_be_0
cmp al, 0
jz short loc_79322
mov rdi, [rsp+28h+var_20]
call bswap64
mov [rsp+28h+var_20], rax
loc_79322:
mov rcx, [rsp+28h+var_20]
mov rax, [rsp+28h+var_18]
mov [rax], rcx
mov rax, [rsp+28h+var_10]
mov rcx, [rax+10h]
add rcx, 8
mov [rax+10h], rcx
mov [rsp+28h+var_4], 0
loc_79348:
mov eax, [rsp+28h+var_4]
add rsp, 28h
retn
|
long long bc_get_u64(
long long a1,
unsigned long long *a2,
long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
long long a12,
long long a13,
long long a14)
{
long long v14; // rcx
unsigned long long u64; // [rsp+8h] [rbp-20h]
v14 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 24) - v14 >= 8 )
{
u64 = get_u64(*(_QWORD *)(a1 + 16));
if ( is_be_0() )
u64 = bswap64(u64);
*a2 = u64;
*(_QWORD *)(a1 + 16) += 8LL;
return 0;
}
else
{
*a2 = 0LL;
return (unsigned int)bc_read_error_end(a1, a4, a5, a6, a7, a8, a9, a10, a11, (long long)a2, a3, v14, a13, a14);
}
}
|
bc_get_u64:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV qword ptr [RSP + 0x10],RSI
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RCX + 0x10]
SUB RAX,RCX
CMP RAX,0x8
SETL AL
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001792f7
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX],0x0
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001791d0
MOV dword ptr [RSP + 0x24],EAX
JMP 0x00179348
LAB_001792f7:
MOV RAX,qword ptr [RSP + 0x18]
MOV RDI,qword ptr [RAX + 0x10]
CALL 0x0017bc60
MOV qword ptr [RSP + 0x8],RAX
CALL 0x0012b9a0
CMP AL,0x0
JZ 0x00179322
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x00178190
MOV qword ptr [RSP + 0x8],RAX
LAB_00179322:
MOV RCX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RAX + 0x10]
ADD RCX,0x8
MOV qword ptr [RAX + 0x10],RCX
MOV dword ptr [RSP + 0x24],0x0
LAB_00179348:
MOV EAX,dword ptr [RSP + 0x24]
ADD RSP,0x28
RET
|
int4 bc_get_u64(long param_1,int8 *param_2)
{
char cVar1;
int8 local_20;
int4 local_4;
if (*(long *)(param_1 + 0x18) - *(long *)(param_1 + 0x10) < 8) {
*param_2 = 0;
local_4 = bc_read_error_end(param_1);
}
else {
local_20 = get_u64(*(int8 *)(param_1 + 0x10));
cVar1 = is_be();
if (cVar1 != '\0') {
local_20 = bswap64(local_20);
}
*param_2 = local_20;
*(long *)(param_1 + 0x10) = *(long *)(param_1 + 0x10) + 8;
local_4 = 0;
}
return local_4;
}
|
|
18,453
|
bc_get_u64
|
bluesky950520[P]quickjs/quickjs.c
|
static int bc_get_u64(BCReaderState *s, uint64_t *pval)
{
uint64_t v;
if (unlikely(s->buf_end - s->ptr < 8)) {
*pval = 0; /* avoid warning */
return bc_read_error_end(s);
}
v = get_u64(s->ptr);
if (is_be())
v = bswap64(v);
*pval = v;
s->ptr += 8;
return 0;
}
|
O1
|
c
|
bc_get_u64:
movq %rdi, %rax
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rdx
subq %rcx, %rdx
cmpq $0x7, %rdx
jle 0x45033
movq (%rcx), %rdx
movq %rdx, (%rsi)
addq $0x8, %rcx
movq %rcx, 0x10(%rax)
xorl %eax, %eax
retq
pushq %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x13446
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x8, %rsp
retq
|
bc_get_u64:
mov rax, rdi
mov rcx, [rdi+10h]
mov rdx, [rdi+18h]
sub rdx, rcx
cmp rdx, 7
jle short loc_45033
mov rdx, [rcx]
mov [rsi], rdx
add rcx, 8
mov [rax+10h], rcx
xor eax, eax
retn
loc_45033:
push rax
mov rdi, rsi
mov rsi, rax
call bc_get_u64_cold_1
mov eax, 0FFFFFFFFh
add rsp, 8
retn
|
long long bc_get_u64(long long a1, _QWORD *a2, long long a3, long long a4, int a5, int a6)
{
_QWORD *v6; // rcx
long long v7; // rdx
v6 = *(_QWORD **)(a1 + 16);
v7 = *(_QWORD *)(a1 + 24) - (_QWORD)v6;
if ( v7 <= 7 )
{
bc_get_u64_cold_1(a2, a1, v7, (int)v6, a5, a6);
return 0xFFFFFFFFLL;
}
else
{
*a2 = *v6;
*(_QWORD *)(a1 + 16) = v6 + 1;
return 0LL;
}
}
|
bc_get_u64:
MOV RAX,RDI
MOV RCX,qword ptr [RDI + 0x10]
MOV RDX,qword ptr [RDI + 0x18]
SUB RDX,RCX
CMP RDX,0x7
JLE 0x00145033
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSI],RDX
ADD RCX,0x8
MOV qword ptr [RAX + 0x10],RCX
XOR EAX,EAX
RET
LAB_00145033:
PUSH RAX
MOV RDI,RSI
MOV RSI,RAX
CALL 0x00113446
MOV EAX,0xffffffff
ADD RSP,0x8
RET
|
int8 bc_get_u64(long param_1,int8 *param_2)
{
int8 *puVar1;
puVar1 = *(int8 **)(param_1 + 0x10);
if (7 < *(long *)(param_1 + 0x18) - (long)puVar1) {
*param_2 = *puVar1;
*(int8 **)(param_1 + 0x10) = puVar1 + 1;
return 0;
}
bc_get_u64_cold_1(param_2,param_1);
return 0xffffffff;
}
|
|
18,454
|
std::hash<minja::Value>::operator()(minja::Value const&) const
|
monkey531[P]llama/common/minja.hpp
|
size_t operator()(const minja::Value & v) const {
if (!v.is_hashable())
throw std::runtime_error("Unsupported type for hashing: " + v.dump());
return std::hash<json>()(v.get<json>());
}
|
O1
|
cpp
|
std::hash<minja::Value>::operator()(minja::Value const&) const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
cmpq $0x0, 0x10(%rsi)
jne 0xd686c
cmpq $0x0, 0x20(%r14)
jne 0xd686c
cmpq $0x0, 0x30(%r14)
jne 0xd686c
movq %rsp, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd6940
movq %rbx, %rdi
callq 0xd6e2c
movq %rax, %rbx
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x8974c
movq %r14, %rdi
callq 0x8ed0c
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x1d5b0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0xab4e2
leaq 0x42ec8(%rip), %rsi # 0x11975c
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x9d29f
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1e420
xorl %ebp, %ebp
movq 0x82730(%rip), %rsi # 0x158fe8
movq 0x82699(%rip), %rdx # 0x158f58
movq %rbx, %rdi
callq 0x1e5a0
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd68ed
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1dc40
jmp 0xd68ed
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd6910
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1dc40
jmp 0xd6910
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xd6937
movq %rbx, %rdi
callq 0x1d8b0
jmp 0xd6937
movq %rax, %r14
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x8974c
movq %rbx, %rdi
callq 0x8ed0c
movq %r14, %rdi
callq 0x1e650
nop
|
_ZNKSt4hashIN5minja5ValueEEclERKS1_:
push rbp
push r14
push rbx
sub rsp, 40h
mov r14, rsi
cmp qword ptr [rsi+10h], 0
jnz short loc_D686C
cmp qword ptr [r14+20h], 0
jnz short loc_D686C
cmp qword ptr [r14+30h], 0
jnz short loc_D686C
mov rbx, rsp
mov rdi, rbx
mov rsi, r14
call _ZNK5minja5Value3getIN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEEET_v; minja::Value::get<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>>(void)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail4hashINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEEmRKT_; nlohmann::json_abi_v3_11_3::detail::hash<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rbx, rax
mov r14, rsp
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rax, rbx
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
loc_D686C:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+58h+var_38]
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aUnsupportedTyp; "Unsupported type for hashing: "
mov rdi, rsp
lea rdx, [rsp+58h+var_38]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
mov rsi, rsp
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_D68ED
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_D68ED
mov r14, rax
mov bpl, 1
loc_D68ED:
lea rax, [rsp+58h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_D6910
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_D6910
mov r14, rax
mov bpl, 1
loc_D6910:
test bpl, bpl
jz short loc_D6937
mov rdi, rbx; void *
call ___cxa_free_exception
jmp short loc_D6937
mov r14, rax
mov rbx, rsp
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_D6937:
mov rdi, r14
call __Unwind_Resume
|
long long std::hash<minja::Value>::operator()(long long a1, _QWORD *a2)
{
long long v2; // rbx
void *exception; // rbx
char v5[16]; // [rsp+0h] [rbp-58h] BYREF
_BYTE v6[16]; // [rsp+20h] [rbp-38h] BYREF
if ( a2[2] || a2[4] || a2[6] )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v6, (long long)a2, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v5, (long long)"Unsupported type for hashing: ", (long long)v6);
std::runtime_error::runtime_error(exception, v5);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Value::get<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>>(
v5,
a2);
v2 = nlohmann::json_abi_v3_11_3::detail::hash<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>>(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>::assert_invariant(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 v2;
}
|
operator():
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RSI
CMP qword ptr [RSI + 0x10],0x0
JNZ 0x001d686c
CMP qword ptr [R14 + 0x20],0x0
JNZ 0x001d686c
CMP qword ptr [R14 + 0x30],0x0
JNZ 0x001d686c
MOV RBX,RSP
MOV RDI,RBX
MOV RSI,R14
CALL 0x001d6940
LAB_001d6840:
MOV RDI,RBX
CALL 0x001d6e2c
LAB_001d6848:
MOV RBX,RAX
MOV R14,RSP
MOV RDI,R14
XOR ESI,ESI
CALL 0x0018974c
MOV RDI,R14
CALL 0x0018ed0c
MOV RAX,RBX
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
LAB_001d686c:
MOV EDI,0x10
CALL 0x0011d5b0
MOV RBX,RAX
LAB_001d6879:
LEA RDI,[RSP + 0x20]
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x001ab4e2
LAB_001d688d:
LEA RSI,[0x21975c]
MOV RDI,RSP
LEA RDX,[RSP + 0x20]
CALL 0x0019d29f
MOV BPL,0x1
LAB_001d68a4:
MOV RSI,RSP
MOV RDI,RBX
CALL 0x0011e420
XOR EBP,EBP
MOV RSI,qword ptr [0x00258fe8]
MOV RDX,qword ptr [0x00258f58]
MOV RDI,RBX
CALL 0x0011e5a0
|
/* std::hash<minja::Value>::TEMPNAMEPLACEHOLDERVALUE(minja::Value const&) const */
ulong __thiscall std::hash<minja::Value>::operator()(hash<minja::Value> *this,Value *param_1)
{
ulong uVar1;
runtime_error *this_00;
basic_json abStack_58 [32];
int1 local_38 [32];
if (((*(long *)(param_1 + 0x10) == 0) && (*(long *)(param_1 + 0x20) == 0)) &&
(*(long *)(param_1 + 0x30) == 0)) {
minja::Value::
get<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>>
();
/* try { // try from 001d6840 to 001d6847 has its CatchHandler @ 001d691f */
uVar1 = nlohmann::json_abi_v3_11_3::detail::
hash<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>>
(abStack_58);
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(abStack_58,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 *)abStack_58);
return uVar1;
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001d6879 to 001d688c has its CatchHandler @ 001d690a */
minja::Value::dump_abi_cxx11_((int)local_38,SUB81(param_1,0));
/* try { // try from 001d688d to 001d68a0 has its CatchHandler @ 001d68e7 */
operator+((char *)abStack_58,(string *)"Unsupported type for hashing: ");
/* try { // try from 001d68a4 to 001d68c6 has its CatchHandler @ 001d68c7 */
std::runtime_error::runtime_error(this_00,(string *)abStack_58);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_00258fe8,PTR__runtime_error_00258f58);
}
|
|
18,455
|
std::hash<minja::Value>::operator()(minja::Value const&) const
|
monkey531[P]llama/common/minja.hpp
|
size_t operator()(const minja::Value & v) const {
if (!v.is_hashable())
throw std::runtime_error("Unsupported type for hashing: " + v.dump());
return std::hash<json>()(v.get<json>());
}
|
O2
|
cpp
|
std::hash<minja::Value>::operator()(minja::Value const&) const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rsi, %rdi
callq 0x7f8b0
testb %al, %al
je 0x9ee00
movq %rsp, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9ee9c
movq %rbx, %rdi
callq 0x9f250
movq %rax, %rbx
movq %rsp, %rdi
callq 0x651aa
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x265e0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
pushq $-0x1
popq %rdx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x7f8c0
leaq 0x34828(%rip), %rsi # 0xd364c
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x74fe2
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x27450
xorl %ebp, %ebp
movq 0x831a8(%rip), %rsi # 0x121ff0
movq 0x83109(%rip), %rdx # 0x121f58
movq %rbx, %rdi
callq 0x275b0
movq %rax, %r14
movq %rsp, %rdi
callq 0x27998
jmp 0x9ee6a
movq %rax, %r14
movb $0x1, %bpl
leaq 0x20(%rsp), %rdi
callq 0x27998
testb %bpl, %bpl
jne 0x9ee7e
jmp 0x9ee93
movq %rax, %r14
movq %rbx, %rdi
callq 0x268f0
jmp 0x9ee93
movq %rax, %r14
movq %rsp, %rdi
callq 0x651aa
movq %r14, %rdi
callq 0x27660
nop
|
_ZNKSt4hashIN5minja5ValueEEclERKS1_:
push rbp
push r14
push rbx
sub rsp, 40h
mov r14, rsi
mov rdi, rsi; this
call _ZNK5minja5Value12is_primitiveEv; minja::Value::is_primitive(void)
test al, al
jz short loc_9EE00
mov rbx, rsp
mov rdi, rbx
mov rsi, r14
call _ZNK5minja5Value3getIN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEEET_v; minja::Value::get<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>>(void)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail4hashINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEEmRKT_; nlohmann::json_abi_v3_11_3::detail::hash<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rbx, rax
mov rdi, rsp
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
mov rax, rbx
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
loc_9EE00:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+58h+var_38]
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rsi, r14
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aUnsupportedTyp; "Unsupported type for hashing: "
mov rdi, rsp
lea rdx, [rsp+58h+var_38]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
mov rsi, rsp
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rdi, rsp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_9EE6A
mov r14, rax
mov bpl, 1
loc_9EE6A:
lea rdi, [rsp+58h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_9EE7E
jmp short loc_9EE93
mov r14, rax
loc_9EE7E:
mov rdi, rbx; void *
call ___cxa_free_exception
jmp short loc_9EE93
mov r14, rax
mov rdi, rsp
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
loc_9EE93:
mov rdi, r14
call __Unwind_Resume
|
long long std::hash<minja::Value>::operator()(long long a1, minja::Value *a2)
{
long long v2; // rbx
void *exception; // rbx
_BYTE v5[32]; // [rsp+0h] [rbp-58h] BYREF
_BYTE v6[56]; // [rsp+20h] [rbp-38h] BYREF
if ( !minja::Value::is_primitive(a2) )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v6, (long long)a2, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v5, (long long)"Unsupported type for hashing: ", (long long)v6);
std::runtime_error::runtime_error(exception, v5);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Value::get<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>>(
v5,
a2);
v2 = nlohmann::json_abi_v3_11_3::detail::hash<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>>(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>::~basic_json((long long)v5);
return v2;
}
|
operator():
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RSI
MOV RDI,RSI
CALL 0x0017f8b0
TEST AL,AL
JZ 0x0019ee00
MOV RBX,RSP
MOV RDI,RBX
MOV RSI,R14
CALL 0x0019ee9c
LAB_0019ede1:
MOV RDI,RBX
CALL 0x0019f250
LAB_0019ede9:
MOV RBX,RAX
MOV RDI,RSP
CALL 0x001651aa
MOV RAX,RBX
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
LAB_0019ee00:
PUSH 0x10
POP RDI
CALL 0x001265e0
MOV RBX,RAX
LAB_0019ee0b:
LEA RDI,[RSP + 0x20]
PUSH -0x1
POP RDX
MOV RSI,R14
XOR ECX,ECX
CALL 0x0017f8c0
LAB_0019ee1d:
LEA RSI,[0x1d364c]
MOV RDI,RSP
LEA RDX,[RSP + 0x20]
CALL 0x00174fe2
MOV BPL,0x1
LAB_0019ee34:
MOV RSI,RSP
MOV RDI,RBX
CALL 0x00127450
XOR EBP,EBP
MOV RSI,qword ptr [0x00221ff0]
MOV RDX,qword ptr [0x00221f58]
MOV RDI,RBX
CALL 0x001275b0
|
/* std::hash<minja::Value>::TEMPNAMEPLACEHOLDERVALUE(minja::Value const&) const */
ulong __thiscall std::hash<minja::Value>::operator()(hash<minja::Value> *this,Value *param_1)
{
char cVar1;
ulong uVar2;
runtime_error *this_00;
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>
abStack_58 [32];
int1 local_38 [32];
cVar1 = minja::Value::is_primitive(param_1);
if (cVar1 != '\0') {
minja::Value::
get<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>>
();
/* try { // try from 0019ede1 to 0019ede8 has its CatchHandler @ 0019ee88 */
uVar2 = nlohmann::json_abi_v3_11_3::detail::
hash<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>>
(abStack_58);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::~basic_json(abStack_58);
return uVar2;
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0019ee0b to 0019ee1c has its CatchHandler @ 0019ee7b */
minja::Value::dump_abi_cxx11_((int)local_38,SUB81(param_1,0));
/* try { // try from 0019ee1d to 0019ee30 has its CatchHandler @ 0019ee64 */
operator+((char *)abStack_58,(string *)"Unsupported type for hashing: ");
/* try { // try from 0019ee34 to 0019ee56 has its CatchHandler @ 0019ee57 */
std::runtime_error::runtime_error(this_00,(string *)abStack_58);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_00221ff0,PTR__runtime_error_00221f58);
}
|
|
18,456
|
std::hash<minja::Value>::operator()(minja::Value const&) const
|
monkey531[P]llama/common/minja.hpp
|
size_t operator()(const minja::Value & v) const {
if (!v.is_hashable())
throw std::runtime_error("Unsupported type for hashing: " + v.dump());
return std::hash<json>()(v.get<json>());
}
|
O3
|
cpp
|
std::hash<minja::Value>::operator()(minja::Value const&) const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
cmpq $0x0, 0x10(%rsi)
jne 0xd54e6
cmpq $0x0, 0x20(%r14)
jne 0xd54e6
cmpq $0x0, 0x30(%r14)
jne 0xd54e6
movq %rsp, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd55ce
movq %rbx, %rdi
callq 0xd5aeb
movq %rax, %rbx
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x89876
movq %r14, %rdi
callq 0x8eb30
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x1d5b0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0xaa67c
leaq 0x4124e(%rip), %rsi # 0x11675c
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x9cdd5
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1e430
xorl %ebp, %ebp
movq 0x80ab6(%rip), %rsi # 0x155fe8
movq 0x80a1f(%rip), %rdx # 0x155f58
movq %rbx, %rdi
callq 0x1e5b0
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd555f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1dc50
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd557a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1dc50
testb %bpl, %bpl
jne 0xd55a4
jmp 0xd55c6
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd55a4
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1dc50
jmp 0xd55a4
movq %rax, %r14
movq %rbx, %rdi
callq 0x1d8c0
jmp 0xd55c6
movq %rax, %r14
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x89876
movq %rbx, %rdi
callq 0x8eb30
movq %r14, %rdi
callq 0x1e660
|
_ZNKSt4hashIN5minja5ValueEEclERKS1_:
push rbp
push r14
push rbx
sub rsp, 40h
mov r14, rsi
cmp qword ptr [rsi+10h], 0
jnz short loc_D54E6
cmp qword ptr [r14+20h], 0
jnz short loc_D54E6
cmp qword ptr [r14+30h], 0
jnz short loc_D54E6
mov rbx, rsp
mov rdi, rbx
mov rsi, r14
call _ZNK5minja5Value3getIN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEEET_v; minja::Value::get<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>>(void)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail4hashINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEEmRKT_; nlohmann::json_abi_v3_11_3::detail::hash<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rbx, rax
mov r14, rsp
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rax, rbx
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
loc_D54E6:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+58h+var_38]
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aUnsupportedTyp; "Unsupported type for hashing: "
mov rdi, rsp
lea rdx, [rsp+58h+var_38]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
mov rsi, rsp
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_D555F
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_D555F:
lea rax, [rsp+58h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_D557A
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_D557A:
test bpl, bpl
jnz short loc_D55A4
jmp short loc_D55C6
mov r14, rax
lea rax, [rsp+58h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_D55A4
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_D55A4
mov r14, rax
loc_D55A4:
mov rdi, rbx; void *
call ___cxa_free_exception
jmp short loc_D55C6
mov r14, rax
mov rbx, rsp
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_D55C6:
mov rdi, r14
call __Unwind_Resume
|
long long std::hash<minja::Value>::operator()(long long a1, _QWORD *a2)
{
long long v2; // rbx
void *exception; // rbx
char v5[16]; // [rsp+0h] [rbp-58h] BYREF
_BYTE v6[16]; // [rsp+20h] [rbp-38h] BYREF
if ( a2[2] || a2[4] || a2[6] )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v6, (long long)a2, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v5, (long long)"Unsupported type for hashing: ", (long long)v6);
std::runtime_error::runtime_error(exception, v5);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Value::get<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>>(
v5,
a2);
v2 = nlohmann::json_abi_v3_11_3::detail::hash<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>>(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>::assert_invariant(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 v2;
}
|
operator():
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RSI
CMP qword ptr [RSI + 0x10],0x0
JNZ 0x001d54e6
CMP qword ptr [R14 + 0x20],0x0
JNZ 0x001d54e6
CMP qword ptr [R14 + 0x30],0x0
JNZ 0x001d54e6
MOV RBX,RSP
MOV RDI,RBX
MOV RSI,R14
CALL 0x001d55ce
LAB_001d54ba:
MOV RDI,RBX
CALL 0x001d5aeb
LAB_001d54c2:
MOV RBX,RAX
MOV R14,RSP
MOV RDI,R14
XOR ESI,ESI
CALL 0x00189876
MOV RDI,R14
CALL 0x0018eb30
MOV RAX,RBX
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
LAB_001d54e6:
MOV EDI,0x10
CALL 0x0011d5b0
MOV RBX,RAX
LAB_001d54f3:
LEA RDI,[RSP + 0x20]
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x001aa67c
LAB_001d5507:
LEA RSI,[0x21675c]
MOV RDI,RSP
LEA RDX,[RSP + 0x20]
CALL 0x0019cdd5
MOV BPL,0x1
LAB_001d551e:
MOV RSI,RSP
MOV RDI,RBX
CALL 0x0011e430
XOR EBP,EBP
MOV RSI,qword ptr [0x00255fe8]
MOV RDX,qword ptr [0x00255f58]
MOV RDI,RBX
CALL 0x0011e5b0
|
/* std::hash<minja::Value>::TEMPNAMEPLACEHOLDERVALUE(minja::Value const&) const */
ulong __thiscall std::hash<minja::Value>::operator()(hash<minja::Value> *this,Value *param_1)
{
ulong uVar1;
runtime_error *this_00;
basic_json abStack_58 [32];
int1 local_38 [32];
if (((*(long *)(param_1 + 0x10) == 0) && (*(long *)(param_1 + 0x20) == 0)) &&
(*(long *)(param_1 + 0x30) == 0)) {
minja::Value::
get<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>>
();
/* try { // try from 001d54ba to 001d54c1 has its CatchHandler @ 001d55ae */
uVar1 = nlohmann::json_abi_v3_11_3::detail::
hash<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>>
(abStack_58);
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(abStack_58,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 *)abStack_58);
return uVar1;
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001d54f3 to 001d5506 has its CatchHandler @ 001d55a1 */
minja::Value::dump_abi_cxx11_((int)local_38,SUB81(param_1,0));
/* try { // try from 001d5507 to 001d551a has its CatchHandler @ 001d5581 */
operator+((char *)abStack_58,(string *)"Unsupported type for hashing: ");
/* try { // try from 001d551e to 001d5540 has its CatchHandler @ 001d5541 */
std::runtime_error::runtime_error(this_00,(string *)abStack_58);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_00255fe8,PTR__runtime_error_00255f58);
}
|
|
18,457
|
common_sampler_sample_and_accept_n(common_sampler*, llama_context*, std::vector<int, std::allocator<int>> const&, bool)
|
monkey531[P]llama/common/sampling.cpp
|
std::vector<llama_token> common_sampler_sample_and_accept_n(struct common_sampler * gsmpl, struct llama_context * ctx, const llama_tokens & draft, bool grammar_first) {
std::vector<int> idxs(draft.size() + 1);
for (size_t i = 0; i < idxs.size(); ++i) {
idxs[i] = i;
}
return common_sampler_sample_and_accept_n(gsmpl, ctx, idxs, draft, grammar_first);
}
|
O3
|
cpp
|
common_sampler_sample_and_accept_n(common_sampler*, llama_context*, std::vector<int, std::allocator<int>> const&, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rcx), %rsi
subq (%rcx), %rsi
sarq $0x2, %rsi
incq %rsi
leaq 0x10(%rsp), %r13
leaq 0xf(%rsp), %rdx
movq %r13, %rdi
callq 0x78ca2
movq (%r13), %rax
movq 0x8(%r13), %rdx
subq %rax, %rdx
je 0xcd570
sarq $0x2, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
leaq 0x1(%rdx), %rcx
andq $-0x2, %rcx
decq %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
movdqa 0x21332(%rip), %xmm1 # 0xee830
xorl %edx, %edx
movdqa 0x18fd8(%rip), %xmm2 # 0xe64e0
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x27b58(%rip), %xmm4 # 0xf5070
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7 # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5 # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %esi
notl %esi
testb $0x1, %sil
je 0xcd54d
movl %edx, (%rax,%rdx,4)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0xcd563
leal 0x1(%rdx), %esi
movl %esi, 0x4(%rax,%rdx,4)
addq $0x2, %rdx
paddq %xmm4, %xmm1
cmpq %rdx, %rcx
jne 0xcd518
movzbl %bpl, %r9d
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %r8
callq 0xcd2f1
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xcd5a1
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a8f0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xcd5cd
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a8f0
movq %rbx, %rdi
callq 0x1afd0
|
_Z34common_sampler_sample_and_accept_nP14common_samplerP13llama_contextRKSt6vectorIiSaIiEEb:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov ebp, r8d
mov r14, rcx
mov r15, rdx
mov r12, rsi
mov rbx, rdi
mov rsi, [rcx+8]
sub rsi, [rcx]
sar rsi, 2
inc rsi
lea r13, [rsp+58h+var_48]
lea rdx, [rsp+58h+var_49]
mov rdi, r13
call _ZNSt6vectorIiSaIiEEC2EmRKS0_; std::vector<int>::vector(ulong,std::allocator<int> const&)
mov rax, [r13+0]
mov rdx, [r13+8]
sub rdx, rax
jz loc_CD570
sar rdx, 2
cmp rdx, 1
adc rdx, 0
lea rcx, [rdx+1]
and rcx, 0FFFFFFFFFFFFFFFEh
dec rdx
movq xmm0, rdx
pshufd xmm0, xmm0, 44h ; 'D'
movdqa xmm1, cs:xmmword_EE830
xor edx, edx
movdqa xmm2, cs:xmmword_E64E0
pxor xmm0, xmm2
pcmpeqd xmm3, xmm3
movdqa xmm4, cs:xmmword_F5070
loc_CD518:
movdqa xmm5, xmm1
pxor xmm5, xmm2
movdqa xmm6, xmm5
pcmpgtd xmm6, xmm0
pcmpeqd xmm5, xmm0
pshufd xmm7, xmm5, 0F5h
pand xmm7, xmm6
pshufd xmm5, xmm6, 0F5h
por xmm5, xmm7
movd esi, xmm5
not esi
test sil, 1
jz short loc_CD54D
mov [rax+rdx*4], edx
loc_CD54D:
pxor xmm5, xmm3
pextrw esi, xmm5, 4
test sil, 1
jz short loc_CD563
lea esi, [rdx+1]
mov [rax+rdx*4+4], esi
loc_CD563:
add rdx, 2
paddq xmm1, xmm4
cmp rcx, rdx
jnz short loc_CD518
loc_CD570:
movzx r9d, bpl
lea rcx, [rsp+58h+var_48]
mov rdi, rbx
mov rsi, r12
mov rdx, r15
mov r8, r14
call _Z34common_sampler_sample_and_accept_nP14common_samplerP13llama_contextRKSt6vectorIiSaIiEES7_b; common_sampler_sample_and_accept_n(common_sampler *,llama_context *,std::vector<int> const&,std::vector<int> const&,bool)
mov rdi, [rsp+58h+var_48]; void *
test rdi, rdi
jz short loc_CD5A1
mov rsi, [rsp+58h+var_38]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_CD5A1:
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rsp+arg_8]; void *
test rdi, rdi
jz short loc_CD5CD
mov rsi, [rsp+arg_18]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_CD5CD:
mov rdi, rbx
call __Unwind_Resume
|
long long * common_sampler_sample_and_accept_n(
long long *a1,
_QWORD *a2,
long long a3,
long long *a4,
unsigned __int8 a5)
{
_DWORD *v8; // rax
long long v9; // rdx
unsigned long long v10; // rcx
__m128i v11; // xmm0
__m128i si128; // xmm1
long long v13; // rdx
__m128i v14; // xmm2
__m128i v15; // xmm0
__m128i v16; // xmm4
__m128i v17; // xmm5
__m128i v18; // xmm6
__m128i v19; // xmm5
void *v21; // [rsp+10h] [rbp-48h] BYREF
_BYTE *v22; // [rsp+18h] [rbp-40h]
long long v23; // [rsp+20h] [rbp-38h]
std::vector<int>::vector((long long)&v21, ((a4[1] - *a4) >> 2) + 1);
v8 = v21;
if ( v22 != v21 )
{
v9 = ((v22 - (_BYTE *)v21) >> 2 == 0) + ((v22 - (_BYTE *)v21) >> 2);
v10 = (v9 + 1) & 0xFFFFFFFFFFFFFFFELL;
v11 = _mm_shuffle_epi32((__m128i)(unsigned long long)(v9 - 1), 68);
si128 = _mm_load_si128((const __m128i *)&xmmword_EE830);
v13 = 0LL;
v14 = _mm_load_si128((const __m128i *)&xmmword_E64E0);
v15 = _mm_xor_si128(v11, v14);
v16 = _mm_load_si128((const __m128i *)&xmmword_F5070);
do
{
v17 = _mm_xor_si128(si128, v14);
v18 = _mm_cmpgt_epi32(v17, v15);
v19 = _mm_or_si128(
_mm_shuffle_epi32(v18, 245),
_mm_and_si128(_mm_shuffle_epi32(_mm_cmpeq_epi32(v17, v15), 245), v18));
if ( (~_mm_cvtsi128_si32(v19) & 1) != 0 )
v8[v13] = v13;
if ( (_mm_extract_epi16(_mm_xor_si128(v19, (__m128i)-1LL), 4) & 1) != 0 )
v8[v13 + 1] = v13 + 1;
v13 += 2LL;
si128 = _mm_add_epi64(si128, v16);
}
while ( v10 != v13 );
}
common_sampler_sample_and_accept_n(a1, a2, a3, &v21, a4, a5);
if ( v21 )
operator delete(v21, v23 - (_QWORD)v21);
return a1;
}
|
common_sampler_sample_and_accept_n:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV EBP,R8D
MOV R14,RCX
MOV R15,RDX
MOV R12,RSI
MOV RBX,RDI
MOV RSI,qword ptr [RCX + 0x8]
SUB RSI,qword ptr [RCX]
SAR RSI,0x2
INC RSI
LEA R13,[RSP + 0x10]
LEA RDX,[RSP + 0xf]
MOV RDI,R13
CALL 0x00178ca2
MOV RAX,qword ptr [R13]
MOV RDX,qword ptr [R13 + 0x8]
SUB RDX,RAX
JZ 0x001cd570
SAR RDX,0x2
CMP RDX,0x1
ADC RDX,0x0
LEA RCX,[RDX + 0x1]
AND RCX,-0x2
DEC RDX
MOVQ XMM0,RDX
PSHUFD XMM0,XMM0,0x44
MOVDQA XMM1,xmmword ptr [0x001ee830]
XOR EDX,EDX
MOVDQA XMM2,xmmword ptr [0x001e64e0]
PXOR XMM0,XMM2
PCMPEQD XMM3,XMM3
MOVDQA XMM4,xmmword ptr [0x001f5070]
LAB_001cd518:
MOVDQA XMM5,XMM1
PXOR XMM5,XMM2
MOVDQA XMM6,XMM5
PCMPGTD XMM6,XMM0
PCMPEQD XMM5,XMM0
PSHUFD XMM7,XMM5,0xf5
PAND XMM7,XMM6
PSHUFD XMM5,XMM6,0xf5
POR XMM5,XMM7
MOVD ESI,XMM5
NOT ESI
TEST SIL,0x1
JZ 0x001cd54d
MOV dword ptr [RAX + RDX*0x4],EDX
LAB_001cd54d:
PXOR XMM5,XMM3
PEXTRW ESI,XMM5,0x4
TEST SIL,0x1
JZ 0x001cd563
LEA ESI,[RDX + 0x1]
MOV dword ptr [RAX + RDX*0x4 + 0x4],ESI
LAB_001cd563:
ADD RDX,0x2
PADDQ XMM1,XMM4
CMP RCX,RDX
JNZ 0x001cd518
LAB_001cd570:
MOVZX R9D,BPL
LEA RCX,[RSP + 0x10]
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R15
MOV R8,R14
CALL 0x001cd2f1
LAB_001cd58a:
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x001cd5a1
MOV RSI,qword ptr [RSP + 0x20]
SUB RSI,RDI
CALL 0x0011a8f0
LAB_001cd5a1:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* common_sampler_sample_and_accept_n(common_sampler*, llama_context*, std::vector<int,
std::allocator<int> > const&, bool) */
common_sampler *
common_sampler_sample_and_accept_n
(common_sampler *param_1,llama_context *param_2,vector *param_3,bool param_4)
{
int1 auVar1 [16];
long lVar2;
long lVar3;
int7 in_register_00000009;
long lVar4;
long lVar5;
ulong uVar6;
int1 auVar7 [16];
int1 auVar8 [16];
int1 auVar9 [16];
void *local_48;
long local_40;
long local_38;
std::vector<int,std::allocator<int>>::vector
((ulong)&local_48,
(allocator *)
((((long *)CONCAT71(in_register_00000009,param_4))[1] -
*(long *)CONCAT71(in_register_00000009,param_4) >> 2) + 1));
lVar3 = _UNK_001f5078;
lVar2 = _DAT_001f5070;
auVar1 = _DAT_001e64e0;
if (local_40 - (long)local_48 != 0) {
lVar4 = local_40 - (long)local_48 >> 2;
lVar4 = lVar4 + (ulong)(lVar4 == 0);
lVar5 = lVar4 + -1;
auVar7._8_4_ = (int)lVar5;
auVar7._0_8_ = lVar5;
auVar7._12_4_ = (int)((ulong)lVar5 >> 0x20);
uVar6 = 0;
auVar7 = auVar7 ^ _DAT_001e64e0;
auVar8 = _DAT_001ee830;
do {
auVar9 = auVar8 ^ auVar1;
if ((bool)(~(auVar9._4_4_ == auVar7._4_4_ && auVar7._0_4_ < auVar9._0_4_ ||
auVar7._4_4_ < auVar9._4_4_) & 1)) {
*(int *)((long)local_48 + uVar6 * 4) = (int)uVar6;
}
if ((auVar9._12_4_ != auVar7._12_4_ || auVar9._8_4_ <= auVar7._8_4_) &&
auVar9._12_4_ <= auVar7._12_4_) {
*(int *)((long)local_48 + uVar6 * 4 + 4) = (int)uVar6 + 1;
}
uVar6 = uVar6 + 2;
lVar5 = auVar8._8_8_;
auVar8._0_8_ = auVar8._0_8_ + lVar2;
auVar8._8_8_ = lVar5 + lVar3;
} while ((lVar4 + 1U & 0xfffffffffffffffe) != uVar6);
}
/* try { // try from 001cd570 to 001cd589 has its CatchHandler @ 001cd5b3 */
common_sampler_sample_and_accept_n(param_1,param_2,param_3,(vector *)&local_48,param_4);
if (local_48 != (void *)0x0) {
operator_delete(local_48,local_38 - (long)local_48);
}
return param_1;
}
|
|
18,458
|
ma_calc_bin_pack_key_length
|
eloqsql/storage/maria/ma_search.c
|
int _ma_calc_bin_pack_key_length(const MARIA_KEY *int_key,
uint nod_flag,
uchar *next_key,
uchar *org_key, uchar *prev_key,
MARIA_KEY_PARAM *s_temp)
{
uint length,key_length,ref_length;
const uchar *key= int_key->data;
s_temp->totlength= key_length= (int_key->data_length + int_key->ref_length+
nod_flag);
#ifdef HAVE_valgrind
s_temp->n_length= s_temp->n_ref_length=0; /* For valgrind */
#endif
s_temp->key=key;
s_temp->prev_key=org_key;
if (prev_key) /* If not first key in block */
{
/* pack key against previous key */
/*
As keys may be identical when running a sort in maria_chk, we
have to guard against the case where keys may be identical
*/
const uchar *end;
end=key+key_length;
for ( ; *key == *prev_key && key < end; key++,prev_key++) ;
s_temp->ref_length= ref_length=(uint) (key-s_temp->key);
length=key_length - ref_length + get_pack_length(ref_length);
}
else
{
/* No previous key */
s_temp->ref_length=ref_length=0;
length=key_length+1;
}
if ((s_temp->next_key_pos=next_key)) /* If another key after */
{
/* pack key against next key */
uint next_length,next_length_pack;
get_key_pack_length(next_length,next_length_pack,next_key);
/* If first key and next key is packed (only on delete) */
if (!prev_key && org_key && next_length)
{
const uchar *end;
for (key= s_temp->key, end=key+next_length ;
*key == *org_key && key < end;
key++,org_key++) ;
ref_length= (uint) (key - s_temp->key);
}
if (next_length > ref_length)
{
/*
We put a key with different case between two keys with the same prefix
Extend next key to have same prefix as this key
*/
s_temp->n_ref_length= ref_length;
s_temp->prev_length= next_length-ref_length;
s_temp->prev_key+= ref_length;
return s_temp->move_length= ((int) (length+ s_temp->prev_length -
next_length_pack +
get_pack_length(ref_length)));
}
/* Check how many characters are identical to next key */
key= s_temp->key+next_length;
s_temp->prev_length= 0;
while (*key++ == *next_key++) ;
if ((ref_length= (uint) (key - s_temp->key)-1) == next_length)
{
s_temp->next_key_pos=0;
return (s_temp->move_length= length); /* Can't pack next key */
}
s_temp->n_ref_length=ref_length;
return s_temp->move_length= (int) (length-(ref_length - next_length) -
next_length_pack +
get_pack_length(ref_length));
}
return (s_temp->move_length= (int) length);
}
|
O0
|
c
|
ma_calc_bin_pack_key_length:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0x14(%rax), %ecx
addl -0x14(%rbp), %ecx
movl %ecx, -0x40(%rbp)
movq -0x38(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x50(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x30(%rbp)
je 0x9a5e8
movq -0x50(%rbp), %rax
movl -0x40(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
movzbl (%rax), %ecx
movq -0x30(%rbp), %rax
movzbl (%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x69(%rbp)
jne 0x9a586
movq -0x50(%rbp), %rax
cmpq -0x58(%rbp), %rax
setb %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x9a58f
jmp 0x9a5ab
jmp 0x9a591
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x9a561
movq -0x50(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movl %eax, %ecx
movl %ecx, -0x44(%rbp)
movq -0x38(%rbp), %rax
movl %ecx, 0x20(%rax)
movl -0x40(%rbp), %eax
subl -0x44(%rbp), %eax
movl -0x44(%rbp), %esi
movl $0x1, %ecx
movl $0x3, %edx
cmpl $0xff, %esi
cmovael %edx, %ecx
addl %ecx, %eax
movl %eax, -0x3c(%rbp)
jmp 0x9a603
movl $0x0, -0x44(%rbp)
movq -0x38(%rbp), %rax
movl $0x0, 0x20(%rax)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
je 0x9a822
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xff, %eax
je 0x9a645
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movzbl (%rax), %eax
movl %eax, -0x5c(%rbp)
movl $0x1, -0x60(%rbp)
jmp 0x9a679
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %eax
movzwl %ax, %eax
movq -0x20(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %eax
movl %eax, -0x5c(%rbp)
movq -0x20(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x20(%rbp)
movl $0x3, -0x60(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x9a705
cmpq $0x0, -0x28(%rbp)
je 0x9a705
cmpl $0x0, -0x5c(%rbp)
je 0x9a705
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movl -0x5c(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %rax
movzbl (%rax), %ecx
movq -0x28(%rbp), %rax
movzbl (%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x6a(%rbp)
jne 0x9a6cf
movq -0x50(%rbp), %rax
cmpq -0x68(%rbp), %rax
setb %al
movb %al, -0x6a(%rbp)
movb -0x6a(%rbp), %al
testb $0x1, %al
jne 0x9a6d8
jmp 0x9a6f4
jmp 0x9a6da
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x9a6aa
movq -0x50(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x44(%rbp)
movl -0x5c(%rbp), %eax
cmpl -0x44(%rbp), %eax
jbe 0x9a76c
movl -0x44(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x28(%rax)
movl -0x5c(%rbp), %ecx
subl -0x44(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x38(%rax)
movl -0x44(%rbp), %edx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
movl -0x3c(%rbp), %eax
movq -0x38(%rbp), %rcx
addl 0x38(%rcx), %eax
subl -0x60(%rbp), %eax
movl -0x44(%rbp), %esi
movl $0x1, %ecx
movl $0x3, %edx
cmpl $0xff, %esi
cmovael %edx, %ecx
addl %ecx, %eax
movq -0x38(%rbp), %rcx
movl %eax, 0x44(%rcx)
movl %eax, -0x4(%rbp)
jmp 0x9a82f
movq -0x38(%rbp), %rax
movq (%rax), %rax
movl -0x5c(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x50(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x50(%rbp)
movzbl (%rax), %eax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x9a7b2
jmp 0x9a788
movq -0x50(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
subl $0x1, %eax
movl %eax, -0x44(%rbp)
cmpl -0x5c(%rbp), %eax
jne 0x9a7e6
movq -0x38(%rbp), %rax
movq $0x0, 0x10(%rax)
movl -0x3c(%rbp), %eax
movq -0x38(%rbp), %rcx
movl %eax, 0x44(%rcx)
movl %eax, -0x4(%rbp)
jmp 0x9a82f
movl -0x44(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x28(%rax)
movl -0x3c(%rbp), %eax
movl -0x44(%rbp), %ecx
subl -0x5c(%rbp), %ecx
subl %ecx, %eax
subl -0x60(%rbp), %eax
movl -0x44(%rbp), %esi
movl $0x1, %ecx
movl $0x3, %edx
cmpl $0xff, %esi
cmovael %edx, %ecx
addl %ecx, %eax
movq -0x38(%rbp), %rcx
movl %eax, 0x44(%rcx)
movl %eax, -0x4(%rbp)
jmp 0x9a82f
movl -0x3c(%rbp), %eax
movq -0x38(%rbp), %rcx
movl %eax, 0x44(%rcx)
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_ma_calc_bin_pack_key_length:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_50], rax
mov rax, [rbp+var_10]
mov ecx, [rax+10h]
mov rax, [rbp+var_10]
add ecx, [rax+14h]
add ecx, [rbp+var_14]
mov [rbp+var_40], ecx
mov rax, [rbp+var_38]
mov [rax+30h], ecx
mov rcx, [rbp+var_50]
mov rax, [rbp+var_38]
mov [rax], rcx
mov rcx, [rbp+var_28]
mov rax, [rbp+var_38]
mov [rax+8], rcx
cmp [rbp+var_30], 0
jz loc_9A5E8
mov rax, [rbp+var_50]
mov ecx, [rbp+var_40]
add rax, rcx
mov [rbp+var_58], rax
loc_9A561:
mov rax, [rbp+var_50]
movzx ecx, byte ptr [rax]
mov rax, [rbp+var_30]
movzx edx, byte ptr [rax]
xor eax, eax
cmp ecx, edx
mov [rbp+var_69], al
jnz short loc_9A586
mov rax, [rbp+var_50]
cmp rax, [rbp+var_58]
setb al
mov [rbp+var_69], al
loc_9A586:
mov al, [rbp+var_69]
test al, 1
jnz short loc_9A58F
jmp short loc_9A5AB
loc_9A58F:
jmp short $+2
loc_9A591:
mov rax, [rbp+var_50]
add rax, 1
mov [rbp+var_50], rax
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
jmp short loc_9A561
loc_9A5AB:
mov rax, [rbp+var_50]
mov rcx, [rbp+var_38]
mov rcx, [rcx]
sub rax, rcx
mov ecx, eax
mov [rbp+var_44], ecx
mov rax, [rbp+var_38]
mov [rax+20h], ecx
mov eax, [rbp+var_40]
sub eax, [rbp+var_44]
mov esi, [rbp+var_44]
mov ecx, 1
mov edx, 3
cmp esi, 0FFh
cmovnb ecx, edx
add eax, ecx
mov [rbp+var_3C], eax
jmp short loc_9A603
loc_9A5E8:
mov [rbp+var_44], 0
mov rax, [rbp+var_38]
mov dword ptr [rax+20h], 0
mov eax, [rbp+var_40]
add eax, 1
mov [rbp+var_3C], eax
loc_9A603:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_38]
mov [rcx+10h], rax
cmp rax, 0
jz loc_9A822
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
cmp eax, 0FFh
jz short loc_9A645
mov rax, [rbp+var_20]
mov rcx, rax
add rcx, 1
mov [rbp+var_20], rcx
movzx eax, byte ptr [rax]
mov [rbp+var_5C], eax
mov [rbp+var_60], 1
jmp short loc_9A679
loc_9A645:
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+2]
movzx eax, ax
mov rcx, [rbp+var_20]
movzx ecx, byte ptr [rcx+1]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx eax, ax
mov [rbp+var_5C], eax
mov rax, [rbp+var_20]
add rax, 3
mov [rbp+var_20], rax
mov [rbp+var_60], 3
loc_9A679:
cmp [rbp+var_30], 0
jnz loc_9A705
cmp [rbp+var_28], 0
jz short loc_9A705
cmp [rbp+var_5C], 0
jz short loc_9A705
mov rax, [rbp+var_38]
mov rax, [rax]
mov [rbp+var_50], rax
mov rax, [rbp+var_50]
mov ecx, [rbp+var_5C]
add rax, rcx
mov [rbp+var_68], rax
loc_9A6AA:
mov rax, [rbp+var_50]
movzx ecx, byte ptr [rax]
mov rax, [rbp+var_28]
movzx edx, byte ptr [rax]
xor eax, eax
cmp ecx, edx
mov [rbp+var_6A], al
jnz short loc_9A6CF
mov rax, [rbp+var_50]
cmp rax, [rbp+var_68]
setb al
mov [rbp+var_6A], al
loc_9A6CF:
mov al, [rbp+var_6A]
test al, 1
jnz short loc_9A6D8
jmp short loc_9A6F4
loc_9A6D8:
jmp short $+2
loc_9A6DA:
mov rax, [rbp+var_50]
add rax, 1
mov [rbp+var_50], rax
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
jmp short loc_9A6AA
loc_9A6F4:
mov rax, [rbp+var_50]
mov rcx, [rbp+var_38]
mov rcx, [rcx]
sub rax, rcx
mov [rbp+var_44], eax
loc_9A705:
mov eax, [rbp+var_5C]
cmp eax, [rbp+var_44]
jbe short loc_9A76C
mov ecx, [rbp+var_44]
mov rax, [rbp+var_38]
mov [rax+28h], ecx
mov ecx, [rbp+var_5C]
sub ecx, [rbp+var_44]
mov rax, [rbp+var_38]
mov [rax+38h], ecx
mov edx, [rbp+var_44]
mov rax, [rbp+var_38]
mov rcx, [rax+8]
mov edx, edx
add rcx, rdx
mov [rax+8], rcx
mov eax, [rbp+var_3C]
mov rcx, [rbp+var_38]
add eax, [rcx+38h]
sub eax, [rbp+var_60]
mov esi, [rbp+var_44]
mov ecx, 1
mov edx, 3
cmp esi, 0FFh
cmovnb ecx, edx
add eax, ecx
mov rcx, [rbp+var_38]
mov [rcx+44h], eax
mov [rbp+var_4], eax
jmp loc_9A82F
loc_9A76C:
mov rax, [rbp+var_38]
mov rax, [rax]
mov ecx, [rbp+var_5C]
add rax, rcx
mov [rbp+var_50], rax
mov rax, [rbp+var_38]
mov dword ptr [rax+38h], 0
loc_9A788:
mov rax, [rbp+var_50]
mov rcx, rax
add rcx, 1
mov [rbp+var_50], rcx
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_20]
mov rdx, rcx
add rdx, 1
mov [rbp+var_20], rdx
movzx ecx, byte ptr [rcx]
cmp eax, ecx
jnz short loc_9A7B2
jmp short loc_9A788
loc_9A7B2:
mov rax, [rbp+var_50]
mov rcx, [rbp+var_38]
mov rcx, [rcx]
sub rax, rcx
sub eax, 1
mov [rbp+var_44], eax
cmp eax, [rbp+var_5C]
jnz short loc_9A7E6
mov rax, [rbp+var_38]
mov qword ptr [rax+10h], 0
mov eax, [rbp+var_3C]
mov rcx, [rbp+var_38]
mov [rcx+44h], eax
mov [rbp+var_4], eax
jmp short loc_9A82F
loc_9A7E6:
mov ecx, [rbp+var_44]
mov rax, [rbp+var_38]
mov [rax+28h], ecx
mov eax, [rbp+var_3C]
mov ecx, [rbp+var_44]
sub ecx, [rbp+var_5C]
sub eax, ecx
sub eax, [rbp+var_60]
mov esi, [rbp+var_44]
mov ecx, 1
mov edx, 3
cmp esi, 0FFh
cmovnb ecx, edx
add eax, ecx
mov rcx, [rbp+var_38]
mov [rcx+44h], eax
mov [rbp+var_4], eax
jmp short loc_9A82F
loc_9A822:
mov eax, [rbp+var_3C]
mov rcx, [rbp+var_38]
mov [rcx+44h], eax
mov [rbp+var_4], eax
loc_9A82F:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long ma_calc_bin_pack_key_length(
unsigned __int8 **a1,
int a2,
unsigned __int8 *a3,
unsigned __int8 *a4,
unsigned __int8 *a5,
unsigned __int8 **a6)
{
int v6; // ecx
int v7; // ecx
unsigned int v8; // eax
unsigned __int8 *v9; // rax
unsigned __int8 *v10; // rcx
int v11; // ecx
bool v13; // [rsp+0h] [rbp-6Ah]
bool v14; // [rsp+1h] [rbp-69h]
int v15; // [rsp+Ah] [rbp-60h]
unsigned int v16; // [rsp+Eh] [rbp-5Ch]
unsigned __int8 *v17; // [rsp+12h] [rbp-58h]
unsigned __int8 *v18; // [rsp+1Ah] [rbp-50h]
unsigned __int8 *i; // [rsp+1Ah] [rbp-50h]
unsigned __int8 *v20; // [rsp+1Ah] [rbp-50h]
unsigned int v21; // [rsp+26h] [rbp-44h]
unsigned int v22; // [rsp+26h] [rbp-44h]
int v23; // [rsp+2Ah] [rbp-40h]
unsigned int v24; // [rsp+2Eh] [rbp-3Ch]
unsigned __int8 *v25; // [rsp+3Ah] [rbp-30h]
unsigned __int8 *v26; // [rsp+42h] [rbp-28h]
unsigned __int8 *v27; // [rsp+4Ah] [rbp-20h]
v26 = a4;
v25 = a5;
v18 = *a1;
v23 = a2 + *((_DWORD *)a1 + 5) + *((_DWORD *)a1 + 4);
*((_DWORD *)a6 + 12) = v23;
*a6 = v18;
a6[1] = a4;
if ( a5 )
{
v17 = &v18[v23];
while ( 1 )
{
v14 = 0;
if ( *v18 == *v25 )
v14 = v18 < v17;
if ( !v14 )
break;
++v18;
++v25;
}
v21 = (_DWORD)v18 - (unsigned int)*a6;
*((_DWORD *)a6 + 8) = v21;
v6 = 1;
if ( v21 >= 0xFF )
v6 = 3;
v24 = v6 + v23 - v21;
}
else
{
v21 = 0;
*((_DWORD *)a6 + 8) = 0;
v24 = v23 + 1;
}
a6[2] = a3;
if ( a3 )
{
if ( *a3 == 255 )
{
v16 = _byteswap_ushort(*(_WORD *)(a3 + 1));
v27 = a3 + 3;
v15 = 3;
}
else
{
v27 = a3 + 1;
v16 = *a3;
v15 = 1;
}
if ( !v25 && v26 && v16 )
{
for ( i = *a6; ; ++i )
{
v13 = 0;
if ( *i == *v26 )
v13 = i < &(*a6)[v16];
if ( !v13 )
break;
++v26;
}
v21 = (_DWORD)i - *(_DWORD *)a6;
}
if ( v16 <= v21 )
{
v20 = &(*a6)[v16];
*((_DWORD *)a6 + 14) = 0;
do
{
v9 = v20++;
v10 = v27++;
}
while ( *v9 == *v10 );
v22 = (_DWORD)v20 - (unsigned int)*a6 - 1;
if ( v22 == v16 )
{
a6[2] = 0LL;
*((_DWORD *)a6 + 17) = v24;
return v24;
}
else
{
*((_DWORD *)a6 + 10) = v22;
v11 = 1;
if ( v22 >= 0xFF )
v11 = 3;
*((_DWORD *)a6 + 17) = v11 + v24 - (v22 - v16) - v15;
return v11 + v24 - (v22 - v16) - v15;
}
}
else
{
*((_DWORD *)a6 + 10) = v21;
*((_DWORD *)a6 + 14) = v16 - v21;
a6[1] += v21;
v7 = 1;
if ( v21 >= 0xFF )
v7 = 3;
v8 = v7 + *((_DWORD *)a6 + 14) + v24 - v15;
*((_DWORD *)a6 + 17) = v8;
return v8;
}
}
else
{
*((_DWORD *)a6 + 17) = v24;
return v24;
}
}
|
_ma_calc_bin_pack_key_length:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
ADD ECX,dword ptr [RAX + 0x14]
ADD ECX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x40],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x30],ECX
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x8],RCX
CMP qword ptr [RBP + -0x30],0x0
JZ 0x0019a5e8
MOV RAX,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RBP + -0x40]
ADD RAX,RCX
MOV qword ptr [RBP + -0x58],RAX
LAB_0019a561:
MOV RAX,qword ptr [RBP + -0x50]
MOVZX ECX,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EDX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,EDX
MOV byte ptr [RBP + -0x69],AL
JNZ 0x0019a586
MOV RAX,qword ptr [RBP + -0x50]
CMP RAX,qword ptr [RBP + -0x58]
SETC AL
MOV byte ptr [RBP + -0x69],AL
LAB_0019a586:
MOV AL,byte ptr [RBP + -0x69]
TEST AL,0x1
JNZ 0x0019a58f
JMP 0x0019a5ab
LAB_0019a58f:
JMP 0x0019a591
LAB_0019a591:
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x1
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0019a561
LAB_0019a5ab:
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RCX]
SUB RAX,RCX
MOV ECX,EAX
MOV dword ptr [RBP + -0x44],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x20],ECX
MOV EAX,dword ptr [RBP + -0x40]
SUB EAX,dword ptr [RBP + -0x44]
MOV ESI,dword ptr [RBP + -0x44]
MOV ECX,0x1
MOV EDX,0x3
CMP ESI,0xff
CMOVNC ECX,EDX
ADD EAX,ECX
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x0019a603
LAB_0019a5e8:
MOV dword ptr [RBP + -0x44],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x20],0x0
MOV EAX,dword ptr [RBP + -0x40]
ADD EAX,0x1
MOV dword ptr [RBP + -0x3c],EAX
LAB_0019a603:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x38]
MOV qword ptr [RCX + 0x10],RAX
CMP RAX,0x0
JZ 0x0019a822
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0xff
JZ 0x0019a645
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x20],RCX
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x5c],EAX
MOV dword ptr [RBP + -0x60],0x1
JMP 0x0019a679
LAB_0019a645:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x2]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RCX + 0x1]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX EAX,AX
MOV dword ptr [RBP + -0x5c],EAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x3
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x60],0x3
LAB_0019a679:
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x0019a705
CMP qword ptr [RBP + -0x28],0x0
JZ 0x0019a705
CMP dword ptr [RBP + -0x5c],0x0
JZ 0x0019a705
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RBP + -0x5c]
ADD RAX,RCX
MOV qword ptr [RBP + -0x68],RAX
LAB_0019a6aa:
MOV RAX,qword ptr [RBP + -0x50]
MOVZX ECX,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EDX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,EDX
MOV byte ptr [RBP + -0x6a],AL
JNZ 0x0019a6cf
MOV RAX,qword ptr [RBP + -0x50]
CMP RAX,qword ptr [RBP + -0x68]
SETC AL
MOV byte ptr [RBP + -0x6a],AL
LAB_0019a6cf:
MOV AL,byte ptr [RBP + -0x6a]
TEST AL,0x1
JNZ 0x0019a6d8
JMP 0x0019a6f4
LAB_0019a6d8:
JMP 0x0019a6da
LAB_0019a6da:
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x1
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0019a6aa
LAB_0019a6f4:
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RCX]
SUB RAX,RCX
MOV dword ptr [RBP + -0x44],EAX
LAB_0019a705:
MOV EAX,dword ptr [RBP + -0x5c]
CMP EAX,dword ptr [RBP + -0x44]
JBE 0x0019a76c
MOV ECX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x28],ECX
MOV ECX,dword ptr [RBP + -0x5c]
SUB ECX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x38],ECX
MOV EDX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RAX + 0x8]
MOV EDX,EDX
ADD RCX,RDX
MOV qword ptr [RAX + 0x8],RCX
MOV EAX,dword ptr [RBP + -0x3c]
MOV RCX,qword ptr [RBP + -0x38]
ADD EAX,dword ptr [RCX + 0x38]
SUB EAX,dword ptr [RBP + -0x60]
MOV ESI,dword ptr [RBP + -0x44]
MOV ECX,0x1
MOV EDX,0x3
CMP ESI,0xff
CMOVNC ECX,EDX
ADD EAX,ECX
MOV RCX,qword ptr [RBP + -0x38]
MOV dword ptr [RCX + 0x44],EAX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0019a82f
LAB_0019a76c:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x5c]
ADD RAX,RCX
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x38],0x0
LAB_0019a788:
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x50],RCX
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x20]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOVZX ECX,byte ptr [RCX]
CMP EAX,ECX
JNZ 0x0019a7b2
JMP 0x0019a788
LAB_0019a7b2:
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RCX]
SUB RAX,RCX
SUB EAX,0x1
MOV dword ptr [RBP + -0x44],EAX
CMP EAX,dword ptr [RBP + -0x5c]
JNZ 0x0019a7e6
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x10],0x0
MOV EAX,dword ptr [RBP + -0x3c]
MOV RCX,qword ptr [RBP + -0x38]
MOV dword ptr [RCX + 0x44],EAX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0019a82f
LAB_0019a7e6:
MOV ECX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x28],ECX
MOV EAX,dword ptr [RBP + -0x3c]
MOV ECX,dword ptr [RBP + -0x44]
SUB ECX,dword ptr [RBP + -0x5c]
SUB EAX,ECX
SUB EAX,dword ptr [RBP + -0x60]
MOV ESI,dword ptr [RBP + -0x44]
MOV ECX,0x1
MOV EDX,0x3
CMP ESI,0xff
CMOVNC ECX,EDX
ADD EAX,ECX
MOV RCX,qword ptr [RBP + -0x38]
MOV dword ptr [RCX + 0x44],EAX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0019a82f
LAB_0019a822:
MOV EAX,dword ptr [RBP + -0x3c]
MOV RCX,qword ptr [RBP + -0x38]
MOV dword ptr [RCX + 0x44],EAX
MOV dword ptr [RBP + -0x4],EAX
LAB_0019a82f:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int _ma_calc_bin_pack_key_length
(int8 *param_1,int param_2,byte *param_3,char *param_4,char *param_5,
long *param_6)
{
byte bVar1;
byte bVar2;
char *pcVar3;
uint uVar4;
byte *pbVar5;
int local_68;
uint local_64;
byte *local_58;
uint local_4c;
int local_44;
char *local_38;
char *local_30;
byte *local_28;
int local_c;
local_58 = (byte *)*param_1;
uVar4 = *(int *)(param_1 + 2) + *(int *)((long)param_1 + 0x14) + param_2;
*(uint *)(param_6 + 6) = uVar4;
*param_6 = (long)local_58;
param_6[1] = (long)param_4;
local_38 = param_5;
if (param_5 == (char *)0x0) {
local_4c = 0;
*(int4 *)(param_6 + 4) = 0;
local_44 = uVar4 + 1;
}
else {
pcVar3 = (char *)local_58 + uVar4;
for (; *local_58 == *local_38 && local_58 < pcVar3; local_58 = local_58 + 1) {
local_38 = local_38 + 1;
}
local_4c = (int)local_58 - (int)*param_6;
*(uint *)(param_6 + 4) = local_4c;
local_44 = 1;
if (0xfe < local_4c) {
local_44 = 3;
}
local_44 = (uVar4 - local_4c) + local_44;
}
param_6[2] = (long)param_3;
if (param_3 == (byte *)0x0) {
*(int *)((long)param_6 + 0x44) = local_44;
local_c = local_44;
}
else {
if (*param_3 == 0xff) {
local_64 = (uint)CONCAT11(param_3[1],param_3[2]);
local_28 = param_3 + 3;
local_68 = 3;
}
else {
local_28 = param_3 + 1;
local_64 = (uint)*param_3;
local_68 = 1;
}
if (((local_38 == (char *)0x0) && (param_4 != (char *)0x0)) && (local_64 != 0)) {
local_58 = (byte *)*param_6;
pcVar3 = (char *)local_58 + local_64;
local_30 = param_4;
for (; *local_58 == *local_30 && local_58 < pcVar3; local_58 = local_58 + 1) {
local_30 = local_30 + 1;
}
local_4c = (int)local_58 - (int)*param_6;
}
if (local_4c < local_64) {
*(uint *)(param_6 + 5) = local_4c;
*(uint *)(param_6 + 7) = local_64 - local_4c;
param_6[1] = param_6[1] + (ulong)local_4c;
local_c = 1;
if (0xfe < local_4c) {
local_c = 3;
}
local_c = ((local_44 + (int)param_6[7]) - local_68) + local_c;
*(int *)((long)param_6 + 0x44) = local_c;
}
else {
*(int4 *)(param_6 + 7) = 0;
local_58 = (byte *)(*param_6 + (ulong)local_64);
do {
pbVar5 = local_58 + 1;
bVar1 = *local_58;
bVar2 = *local_28;
local_58 = pbVar5;
local_28 = local_28 + 1;
} while (bVar1 == bVar2);
uVar4 = ((int)pbVar5 - (int)*param_6) - 1;
if (uVar4 == local_64) {
param_6[2] = 0;
*(int *)((long)param_6 + 0x44) = local_44;
local_c = local_44;
}
else {
*(uint *)(param_6 + 5) = uVar4;
local_c = 1;
if (0xfe < uVar4) {
local_c = 3;
}
local_c = ((local_44 - (uVar4 - local_64)) - local_68) + local_c;
*(int *)((long)param_6 + 0x44) = local_c;
}
}
}
return local_c;
}
|
|
18,459
|
ImPlot3D::RendererSurfaceFill<ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<signed char>, ImPlot3D::IndexerIdx<signed char>, ImPlot3D::IndexerIdx<signed char>>>::RendererSurfaceFill(ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<signed char>, ImPlot3D::IndexerIdx<signed char>, ImPlot3D::IndexerIdx<signed char>> const&, int, int, unsigned int, double, double)
|
zkingston[P]unknot/build_O0/_deps/implot3d-src/implot3d_items.cpp
|
RendererSurfaceFill(const _Getter& getter, int x_count, int y_count, ImU32 col, double scale_min, double scale_max) : RendererBase((x_count - 1) * (y_count - 1), 6, 4),
Getter(getter),
XCount(x_count),
YCount(y_count),
Col(col),
ScaleMin(scale_min),
ScaleMax(scale_max) {}
|
O0
|
cpp
|
ImPlot3D::RendererSurfaceFill<ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<signed char>, ImPlot3D::IndexerIdx<signed char>, ImPlot3D::IndexerIdx<signed char>>>::RendererSurfaceFill(ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<signed char>, ImPlot3D::IndexerIdx<signed char>, ImPlot3D::IndexerIdx<signed char>> const&, int, int, unsigned int, double, double):
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl %ecx, 0x20(%rsp)
movl %r8d, 0x1c(%rsp)
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
movl 0x24(%rsp), %esi
subl $0x1, %esi
movl 0x20(%rsp), %eax
subl $0x1, %eax
imull %eax, %esi
movl $0x6, %edx
movl $0x4, %ecx
callq 0xede80
movq (%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rdi)
addq $0x18, %rdi
callq 0xd8910
movq (%rsp), %rax
movl 0x24(%rsp), %ecx
movl %ecx, 0x28(%rax)
movl 0x20(%rsp), %ecx
movl %ecx, 0x2c(%rax)
movl 0x1c(%rsp), %ecx
movl %ecx, 0x30(%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x38(%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x40(%rax)
addq $0x38, %rsp
retq
nopw (%rax,%rax)
|
_ZN8ImPlot3D19RendererSurfaceFillINS_9GetterXYZINS_10IndexerIdxIyEES3_S3_EEEC2ERKS4_iijdd:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov [rsp+38h+var_10], rsi
mov [rsp+38h+var_14], edx
mov [rsp+38h+var_18], ecx
mov [rsp+38h+var_1C], r8d
movsd [rsp+38h+var_28], xmm0
movsd [rsp+38h+var_30], xmm1
mov rdi, [rsp+38h+var_8]; this
mov [rsp+38h+var_38], rdi
mov esi, [rsp+38h+var_14]
sub esi, 1
mov eax, [rsp+38h+var_18]
sub eax, 1
imul esi, eax; int
mov edx, 6; int
mov ecx, 4; int
call _ZN8ImPlot3D12RendererBaseC2Eiii; ImPlot3D::RendererBase::RendererBase(int,int,int)
mov rdi, [rsp+38h+var_38]
mov rax, [rsp+38h+var_10]
mov [rdi+10h], rax
add rdi, 18h; this
call _ZN6ImVec2C2Ev; ImVec2::ImVec2(void)
mov rax, [rsp+38h+var_38]
mov ecx, [rsp+38h+var_14]
mov [rax+28h], ecx
mov ecx, [rsp+38h+var_18]
mov [rax+2Ch], ecx
mov ecx, [rsp+38h+var_1C]
mov [rax+30h], ecx
movsd xmm0, [rsp+38h+var_28]
movsd qword ptr [rax+38h], xmm0
movsd xmm0, [rsp+38h+var_30]
movsd qword ptr [rax+40h], xmm0
add rsp, 38h
retn
|
long long ImPlot3D::RendererSurfaceFill<ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<unsigned long long>,ImPlot3D::IndexerIdx<unsigned long long>,ImPlot3D::IndexerIdx<unsigned long long>>>::RendererSurfaceFill(
long long a1,
long long a2,
int a3,
int a4,
int a5,
double a6,
double a7)
{
long long result; // rax
ImPlot3D::RendererBase::RendererBase((ImPlot3D::RendererBase *)a1, (a4 - 1) * (a3 - 1), 6, 4);
*(_QWORD *)(a1 + 16) = a2;
ImVec2::ImVec2((ImVec2 *)(a1 + 24));
result = a1;
*(_DWORD *)(a1 + 40) = a3;
*(_DWORD *)(a1 + 44) = a4;
*(_DWORD *)(a1 + 48) = a5;
*(double *)(a1 + 56) = a6;
*(double *)(a1 + 64) = a7;
return result;
}
|
operator():
SUB RSP,0x48
MOV qword ptr [RSP + 0x38],RSI
MOV qword ptr [RSP + 0x30],RDI
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RAX]
CMP dword ptr [RAX],0x0
JZ 0x001b2f1d
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX]
MOV EDI,dword ptr [RAX]
CALL 0x001b0670
MOV byte ptr [RSP + 0x7],AL
LEA RDI,[RSP + 0x38]
XOR ESI,ESI
CALL 0x001ac9d0
MOV qword ptr [RSP + 0x28],RAX
LEA RDI,[RSP + 0x28]
CALL 0x001ac9f0
MOV RDI,RAX
MOV AL,byte ptr [RSP + 0x7]
MOVSX ESI,AL
CALL 0x001aca00
LAB_001b2f1d:
MOV RDI,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RDI + 0x8]
MOV ESI,dword ptr [RAX]
MOV RAX,qword ptr [RDI + 0x10]
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RDI + 0x18]
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RDI + 0x20]
MOV AL,byte ptr [RAX]
MOV R9,qword ptr [RDI + 0x28]
MOV RDI,qword ptr [RSP + 0x18]
MOVSX R8D,AL
CALL 0x001b2fc0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x20],RCX
MOV RCX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x38],RCX
MOV RAX,qword ptr [RAX + 0x30]
CMP dword ptr [RAX],0x0
JLE 0x001b2fa0
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x10],RCX
MOV RCX,qword ptr [RAX + 0x30]
MOV ESI,dword ptr [RCX]
MOV RDX,qword ptr [RAX + 0x38]
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x001b1830
MOV qword ptr [RSP + 0x40],RAX
JMP 0x001b2faa
LAB_001b2fa0:
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x40],RAX
LAB_001b2faa:
MOV RAX,qword ptr [RSP + 0x40]
ADD RSP,0x48
RET
|
/* fmt::v11::detail::do_write_float<char, fmt::v11::basic_appender<char>,
fmt::v11::detail::dragonbox::decimal_fp<float>, fmt::v11::detail::digit_grouping<char>
>(fmt::v11::basic_appender<char>, fmt::v11::detail::dragonbox::decimal_fp<float> const&,
fmt::v11::format_specs const&, fmt::v11::sign, int,
fmt::v11::detail::locale_ref)::{lambda(fmt::v11::basic_appender<char>)#3}::TEMPNAMEPLACEHOLDERVALUE(fmt::v11::basic_appender<char>)
const */
int8 __thiscall
fmt::v11::detail::
do_write_float<char,fmt::v11::basic_appender<char>,fmt::v11::detail::dragonbox::decimal_fp<float>,fmt::v11::detail::digit_grouping<char>>(fmt::v11::basic_appender<char>,fmt::v11::detail::dragonbox::decimal_fp<float>const&,fmt::v11::format_specs_const&,fmt::v11::sign,int,fmt::v11::detail::locale_ref)
::{lambda(fmt::v11::basic_appender<char>)#3}::operator()
(_lambda_fmt__v11__basic_appender<char>__3_ *this,int8 param_2)
{
char cVar1;
basic_appender<char> *this_00;
int8 local_20;
_lambda_fmt__v11__basic_appender<char>__3_ *local_18;
int8 local_10;
int8 local_8;
local_18 = this;
local_10 = param_2;
if (**(int **)this != 0) {
cVar1 = getsign<char>(**(int4 **)this);
local_20 = basic_appender<char>::operator++((basic_appender<char> *)&local_10,0);
this_00 = (basic_appender<char> *)
basic_appender<char>::operator*((basic_appender<char> *)&local_20);
basic_appender<char>::operator=(this_00,cVar1);
}
local_10 = write_significand<fmt::v11::basic_appender<char>,char,unsigned_int,fmt::v11::detail::digit_grouping<char>>
(local_10,**(int4 **)(this + 8),**(int4 **)(this + 0x10),
**(int4 **)(this + 0x18),(int)**(char **)(this + 0x20),
*(int8 *)(this + 0x28));
local_8 = local_10;
if (0 < **(int **)(this + 0x30)) {
local_8 = fill_n<fmt::v11::basic_appender<char>,int,char>
(local_10,**(int4 **)(this + 0x30),*(int8 *)(this + 0x38));
}
return local_8;
}
|
|
18,460
|
JS_ReadArrayBuffer
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue JS_ReadArrayBuffer(BCReaderState *s)
{
JSContext *ctx = s->ctx;
uint32_t byte_length, max_byte_length;
uint64_t max_byte_length_u64, *pmax_byte_length = NULL;
JSValue obj;
if (bc_get_leb128(s, &byte_length))
return JS_EXCEPTION;
if (bc_get_leb128(s, &max_byte_length))
return JS_EXCEPTION;
if (max_byte_length < byte_length)
return JS_ThrowTypeError(ctx, "invalid array buffer");
if (max_byte_length != UINT32_MAX) {
max_byte_length_u64 = max_byte_length;
pmax_byte_length = &max_byte_length_u64;
}
if (unlikely(s->buf_end - s->ptr < byte_length)) {
bc_read_error_end(s);
return JS_EXCEPTION;
}
// makes a copy of the input
obj = js_array_buffer_constructor3(ctx, JS_UNDEFINED,
byte_length, pmax_byte_length,
JS_CLASS_ARRAY_BUFFER,
(uint8_t*)s->ptr,
js_array_buffer_free, NULL,
/*alloc_flag*/TRUE);
if (JS_IsException(obj))
goto fail;
if (BC_add_object_ref(s, obj))
goto fail;
s->ptr += byte_length;
return obj;
fail:
JS_FreeValue(ctx, obj);
return JS_EXCEPTION;
}
|
O0
|
c
|
JS_ReadArrayBuffer:
subq $0x88, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x68(%rsp)
movq $0x0, 0x50(%rsp)
movq 0x70(%rsp), %rdi
leaq 0x64(%rsp), %rsi
callq 0x78f20
cmpl $0x0, %eax
je 0x7aedf
movl $0x0, 0x78(%rsp)
movq $0x6, 0x80(%rsp)
jmp 0x7b0b1
movq 0x70(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x78f20
cmpl $0x0, %eax
je 0x7af0c
movl $0x0, 0x78(%rsp)
movq $0x6, 0x80(%rsp)
jmp 0x7b0b1
movl 0x60(%rsp), %eax
cmpl 0x64(%rsp), %eax
jae 0x7af3b
movq 0x68(%rsp), %rdi
leaq 0x923da(%rip), %rsi # 0x10d2fc
movb $0x0, %al
callq 0x2c040
movq %rax, 0x78(%rsp)
movq %rdx, 0x80(%rsp)
jmp 0x7b0b1
cmpl $-0x1, 0x60(%rsp)
je 0x7af55
movl 0x60(%rsp), %eax
movq %rax, 0x58(%rsp)
leaq 0x58(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x70(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x70(%rsp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movl 0x64(%rsp), %ecx
cmpq %rcx, %rax
setl %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x7afa8
movq 0x70(%rsp), %rdi
callq 0x791d0
movl $0x0, 0x78(%rsp)
movq $0x6, 0x80(%rsp)
jmp 0x7b0b1
movq 0x68(%rsp), %rdi
movl $0x0, 0x20(%rsp)
movq $0x3, 0x28(%rsp)
movl 0x64(%rsp), %eax
movl %eax, %ecx
movq 0x50(%rsp), %r8
movq 0x70(%rsp), %rax
movq 0x10(%rax), %r10
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movl $0x13, %r9d
leaq -0x243d9(%rip), %rax # 0x56c10
xorl %r11d, %r11d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movl $0x1, 0x18(%rsp)
callq 0x56690
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x22a00
cmpl $0x0, %eax
je 0x7b03f
jmp 0x7b089
movq 0x70(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x7c180
cmpl $0x0, %eax
je 0x7b05a
jmp 0x7b089
movl 0x64(%rsp), %edx
movq 0x70(%rsp), %rax
movq 0x10(%rax), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq 0x40(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x80(%rsp)
jmp 0x7b0b1
movq 0x68(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x229d0
movl $0x0, 0x78(%rsp)
movq $0x6, 0x80(%rsp)
movq 0x78(%rsp), %rax
movq 0x80(%rsp), %rdx
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
|
JS_ReadArrayBuffer:
sub rsp, 88h
mov [rsp+88h+var_18], rdi
mov rax, [rsp+88h+var_18]
mov rax, [rax]
mov [rsp+88h+var_20], rax
mov [rsp+88h+var_38], 0
mov rdi, [rsp+88h+var_18]
lea rsi, [rsp+88h+var_24]
call bc_get_leb128
cmp eax, 0
jz short loc_7AEDF
mov dword ptr [rsp+88h+var_10], 0
mov [rsp+88h+var_8], 6
jmp loc_7B0B1
loc_7AEDF:
mov rdi, [rsp+88h+var_18]
lea rsi, [rsp+88h+var_28]
call bc_get_leb128
cmp eax, 0
jz short loc_7AF0C
mov dword ptr [rsp+88h+var_10], 0
mov [rsp+88h+var_8], 6
jmp loc_7B0B1
loc_7AF0C:
mov eax, [rsp+88h+var_28]
cmp eax, [rsp+88h+var_24]
jnb short loc_7AF3B
mov rdi, [rsp+88h+var_20]
lea rsi, aInvalidArrayBu_0; "invalid array buffer"
mov al, 0
call JS_ThrowTypeError
mov [rsp+88h+var_10], rax
mov [rsp+88h+var_8], rdx
jmp loc_7B0B1
loc_7AF3B:
cmp [rsp+88h+var_28], 0FFFFFFFFh
jz short loc_7AF55
mov eax, [rsp+88h+var_28]
mov [rsp+88h+var_30], rax
lea rax, [rsp+88h+var_30]
mov [rsp+88h+var_38], rax
loc_7AF55:
mov rax, [rsp+88h+var_18]
mov rax, [rax+18h]
mov rcx, [rsp+88h+var_18]
mov rcx, [rcx+10h]
sub rax, rcx
mov ecx, [rsp+88h+var_24]
cmp rax, rcx
setl al
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_7AFA8
mov rdi, [rsp+88h+var_18]
call bc_read_error_end
mov dword ptr [rsp+88h+var_10], 0
mov [rsp+88h+var_8], 6
jmp loc_7B0B1
loc_7AFA8:
mov rdi, [rsp+88h+var_20]
mov dword ptr [rsp+88h+var_68], 0
mov [rsp+88h+var_60], 3
mov eax, [rsp+88h+var_24]
mov ecx, eax
mov r8, [rsp+88h+var_38]
mov rax, [rsp+88h+var_18]
mov r10, [rax+10h]
mov rsi, [rsp+88h+var_68]
mov rdx, [rsp+88h+var_60]
mov r9d, 13h
lea rax, js_array_buffer_free
xor r11d, r11d
mov [rsp+88h+var_88], r10
mov [rsp+88h+var_80], rax
mov [rsp+88h+var_78], 0
mov [rsp+88h+var_70], 1
call js_array_buffer_constructor3
mov [rsp+88h+var_58], rax
mov [rsp+88h+var_50], rdx
mov rax, [rsp+88h+var_58]
mov [rsp+88h+var_48], rax
mov rax, [rsp+88h+var_50]
mov [rsp+88h+var_40], rax
mov rdi, [rsp+88h+var_48]
mov rsi, [rsp+88h+var_40]
call JS_IsException_1
cmp eax, 0
jz short loc_7B03F
jmp short loc_7B089
loc_7B03F:
mov rdi, [rsp+88h+var_18]
mov rsi, [rsp+88h+var_48]
mov rdx, [rsp+88h+var_40]
call BC_add_object_ref
cmp eax, 0
jz short loc_7B05A
jmp short loc_7B089
loc_7B05A:
mov edx, [rsp+88h+var_24]
mov rax, [rsp+88h+var_18]
mov rcx, [rax+10h]
mov edx, edx
add rcx, rdx
mov [rax+10h], rcx
mov rax, [rsp+88h+var_48]
mov [rsp+88h+var_10], rax
mov rax, [rsp+88h+var_40]
mov [rsp+88h+var_8], rax
jmp short loc_7B0B1
loc_7B089:
mov rdi, [rsp+88h+var_20]
mov rsi, [rsp+88h+var_48]
mov rdx, [rsp+88h+var_40]
call JS_FreeValue
mov dword ptr [rsp+88h+var_10], 0
mov [rsp+88h+var_8], 6
loc_7B0B1:
mov rax, [rsp+88h+var_10]
mov rdx, [rsp+88h+var_8]
add rsp, 88h
retn
|
long long JS_ReadArrayBuffer(
long long *a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
double a6,
double a7,
__m128 a8,
__m128 a9)
{
long long v9; // rdx
long long v10; // rcx
long long v11; // r8
long long v12; // r9
__m128 v13; // xmm4
__m128 v14; // xmm5
long long v15; // rdx
long long v16; // rdx
char v18; // [rsp+0h] [rbp-88h]
long long v19; // [rsp+20h] [rbp-68h]
long long v20; // [rsp+30h] [rbp-58h]
long long v21; // [rsp+48h] [rbp-40h]
unsigned long long *v22; // [rsp+50h] [rbp-38h]
long long v23; // [rsp+58h] [rbp-30h] BYREF
unsigned int v24; // [rsp+60h] [rbp-28h] BYREF
unsigned int v25; // [rsp+64h] [rbp-24h] BYREF
long long v26; // [rsp+68h] [rbp-20h]
long long *v27; // [rsp+70h] [rbp-18h]
long long v28; // [rsp+78h] [rbp-10h]
long long v29; // [rsp+80h] [rbp-8h]
v27 = a1;
v26 = *a1;
v22 = 0LL;
if ( (unsigned int)bc_get_leb128((long long)a1, &v25) )
{
LODWORD(v28) = 0;
v29 = 6LL;
}
else if ( (unsigned int)bc_get_leb128((long long)v27, &v24) )
{
LODWORD(v28) = 0;
v29 = 6LL;
}
else if ( v24 >= v25 )
{
if ( v24 != -1 )
{
v23 = v24;
v22 = (unsigned long long *)&v23;
}
if ( v27[3] - v27[2] >= v25 )
{
LODWORD(v19) = 0;
v20 = js_array_buffer_constructor3(
v26,
v19,
3LL,
v25,
v22,
19LL,
a2,
a3,
a4,
a5,
v13,
v14,
a8,
a9,
v27[2],
(long long ( *)())js_array_buffer_free,
0LL,
1);
v21 = v16;
if ( JS_IsException_1(v20, v16) || (unsigned int)BC_add_object_ref(v27, v20, v21) )
{
JS_FreeValue(v26, v20, v21);
LODWORD(v28) = 0;
v29 = 6LL;
}
else
{
v27[2] += v25;
v28 = v20;
v29 = v21;
}
}
else
{
bc_read_error_end((long long)v27, a2, a3, a4, a5, v13, v14, a8, a9, (long long)&v24, v9, v25, v11, v12);
LODWORD(v28) = 0;
v29 = 6LL;
}
}
else
{
v28 = JS_ThrowTypeError(
v26,
(long long)"invalid array buffer",
v9,
v10,
v11,
v12,
a2,
a3,
a4,
a5,
v13,
v14,
a8,
a9,
v18);
v29 = v15;
}
return v28;
}
|
JS_ReadArrayBuffer:
SUB RSP,0x88
MOV qword ptr [RSP + 0x70],RDI
MOV RAX,qword ptr [RSP + 0x70]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0x68],RAX
MOV qword ptr [RSP + 0x50],0x0
MOV RDI,qword ptr [RSP + 0x70]
LEA RSI,[RSP + 0x64]
CALL 0x00178f20
CMP EAX,0x0
JZ 0x0017aedf
MOV dword ptr [RSP + 0x78],0x0
MOV qword ptr [RSP + 0x80],0x6
JMP 0x0017b0b1
LAB_0017aedf:
MOV RDI,qword ptr [RSP + 0x70]
LEA RSI,[RSP + 0x60]
CALL 0x00178f20
CMP EAX,0x0
JZ 0x0017af0c
MOV dword ptr [RSP + 0x78],0x0
MOV qword ptr [RSP + 0x80],0x6
JMP 0x0017b0b1
LAB_0017af0c:
MOV EAX,dword ptr [RSP + 0x60]
CMP EAX,dword ptr [RSP + 0x64]
JNC 0x0017af3b
MOV RDI,qword ptr [RSP + 0x68]
LEA RSI,[0x20d2fc]
MOV AL,0x0
CALL 0x0012c040
MOV qword ptr [RSP + 0x78],RAX
MOV qword ptr [RSP + 0x80],RDX
JMP 0x0017b0b1
LAB_0017af3b:
CMP dword ptr [RSP + 0x60],-0x1
JZ 0x0017af55
MOV EAX,dword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x58],RAX
LEA RAX,[RSP + 0x58]
MOV qword ptr [RSP + 0x50],RAX
LAB_0017af55:
MOV RAX,qword ptr [RSP + 0x70]
MOV RAX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RSP + 0x70]
MOV RCX,qword ptr [RCX + 0x10]
SUB RAX,RCX
MOV ECX,dword ptr [RSP + 0x64]
CMP RAX,RCX
SETL AL
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0017afa8
MOV RDI,qword ptr [RSP + 0x70]
CALL 0x001791d0
MOV dword ptr [RSP + 0x78],0x0
MOV qword ptr [RSP + 0x80],0x6
JMP 0x0017b0b1
LAB_0017afa8:
MOV RDI,qword ptr [RSP + 0x68]
MOV dword ptr [RSP + 0x20],0x0
MOV qword ptr [RSP + 0x28],0x3
MOV EAX,dword ptr [RSP + 0x64]
MOV ECX,EAX
MOV R8,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RSP + 0x70]
MOV R10,qword ptr [RAX + 0x10]
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
MOV R9D,0x13
LEA RAX,[0x156c10]
XOR R11D,R11D
MOV qword ptr [RSP],R10
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],0x0
MOV dword ptr [RSP + 0x18],0x1
CALL 0x00156690
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP + 0x38],RDX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x48],RAX
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x48]
CALL 0x00122a00
CMP EAX,0x0
JZ 0x0017b03f
JMP 0x0017b089
LAB_0017b03f:
MOV RDI,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x48]
CALL 0x0017c180
CMP EAX,0x0
JZ 0x0017b05a
JMP 0x0017b089
LAB_0017b05a:
MOV EDX,dword ptr [RSP + 0x64]
MOV RAX,qword ptr [RSP + 0x70]
MOV RCX,qword ptr [RAX + 0x10]
MOV EDX,EDX
ADD RCX,RDX
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x78],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x80],RAX
JMP 0x0017b0b1
LAB_0017b089:
MOV RDI,qword ptr [RSP + 0x68]
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x48]
CALL 0x001229d0
MOV dword ptr [RSP + 0x78],0x0
MOV qword ptr [RSP + 0x80],0x6
LAB_0017b0b1:
MOV RAX,qword ptr [RSP + 0x78]
MOV RDX,qword ptr [RSP + 0x80]
ADD RSP,0x88
RET
|
int1 [16] JS_ReadArrayBuffer(int8 *param_1)
{
int iVar1;
int8 uVar2;
int8 uVar3;
int1 auVar4 [16];
uint uStack_64;
ulong *local_38;
ulong local_30;
uint local_28;
uint local_24;
int8 local_20;
int8 *local_18;
int4 local_10;
int4 uStack_c;
int8 local_8;
local_20 = *param_1;
local_38 = (ulong *)0x0;
local_18 = param_1;
iVar1 = bc_get_leb128(param_1,&local_24);
if (iVar1 == 0) {
iVar1 = bc_get_leb128(local_18,&local_28);
if (iVar1 == 0) {
if (local_28 < local_24) {
auVar4 = JS_ThrowTypeError(local_20,"invalid array buffer");
local_10 = auVar4._0_4_;
uStack_c = auVar4._4_4_;
local_8 = auVar4._8_8_;
}
else {
if (local_28 != 0xffffffff) {
local_30 = (ulong)local_28;
local_38 = &local_30;
}
if ((long)(local_18[3] - local_18[2]) < (long)(ulong)local_24) {
bc_read_error_end(local_18);
local_10 = 0;
local_8 = 6;
}
else {
auVar4 = js_array_buffer_constructor3
(local_20,(ulong)uStack_64 << 0x20,3,local_24,local_38,0x13,local_18[2]
,js_array_buffer_free,0,1);
uVar3 = auVar4._8_8_;
uVar2 = auVar4._0_8_;
iVar1 = JS_IsException(uVar2,uVar3);
if ((iVar1 == 0) && (iVar1 = BC_add_object_ref(local_18,uVar2,uVar3), iVar1 == 0)) {
local_18[2] = local_18[2] + (ulong)local_24;
local_10 = auVar4._0_4_;
uStack_c = auVar4._4_4_;
local_8 = uVar3;
}
else {
JS_FreeValue(local_20,uVar2,uVar3);
local_10 = 0;
local_8 = 6;
}
}
}
}
else {
local_10 = 0;
local_8 = 6;
}
}
else {
local_10 = 0;
local_8 = 6;
}
auVar4._4_4_ = uStack_c;
auVar4._0_4_ = local_10;
auVar4._8_8_ = local_8;
return auVar4;
}
|
|
18,461
|
JS_ReadArrayBuffer
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue JS_ReadArrayBuffer(BCReaderState *s)
{
JSContext *ctx = s->ctx;
uint32_t byte_length, max_byte_length;
uint64_t max_byte_length_u64, *pmax_byte_length = NULL;
JSValue obj;
if (bc_get_leb128(s, &byte_length))
return JS_EXCEPTION;
if (bc_get_leb128(s, &max_byte_length))
return JS_EXCEPTION;
if (max_byte_length < byte_length)
return JS_ThrowTypeError(ctx, "invalid array buffer");
if (max_byte_length != UINT32_MAX) {
max_byte_length_u64 = max_byte_length;
pmax_byte_length = &max_byte_length_u64;
}
if (unlikely(s->buf_end - s->ptr < byte_length)) {
bc_read_error_end(s);
return JS_EXCEPTION;
}
// makes a copy of the input
obj = js_array_buffer_constructor3(ctx, JS_UNDEFINED,
byte_length, pmax_byte_length,
JS_CLASS_ARRAY_BUFFER,
(uint8_t*)s->ptr,
js_array_buffer_free, NULL,
/*alloc_flag*/TRUE);
if (JS_IsException(obj))
goto fail;
if (BC_add_object_ref(s, obj))
goto fail;
s->ptr += byte_length;
return obj;
fail:
JS_FreeValue(ctx, obj);
return JS_EXCEPTION;
}
|
O1
|
c
|
JS_ReadArrayBuffer:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
movq (%rdi), %r14
leaq 0xc(%rsp), %rsi
callq 0x44e61
movl $0x6, %ebx
testl %eax, %eax
jne 0x45d32
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x44e61
testl %eax, %eax
je 0x45d4f
xorl %r15d, %r15d
xorl %eax, %eax
orq %rax, %r15
movq %r15, %rax
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%rsp), %eax
movl 0xc(%rsp), %r12d
cmpl %r12d, %eax
jae 0x45d73
leaq 0x5859c(%rip), %rsi # 0x9e300
xorl %r15d, %r15d
movq %r14, %rdi
xorl %eax, %eax
callq 0x21953
jmp 0x45d35
cmpl $-0x1, %eax
je 0x45d82
leaq 0x10(%rsp), %r8
movq %rax, (%r8)
jmp 0x45d85
xorl %r8d, %r8d
movq 0x10(%r15), %rax
movq 0x18(%r15), %rcx
subq %rax, %rcx
cmpq %r12, %rcx
jl 0x45e0d
leaq -0xdaf7(%rip), %r10 # 0x382a5
movl $0x3, %edx
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rcx
movl $0x13, %r9d
pushq $0x1
pushq $0x0
pushq %r10
pushq %rax
callq 0x38005
addq $0x20, %rsp
movq %rax, %rbp
movq %rdx, %r13
cmpl $0x6, %r13d
je 0x45dda
movq %r15, %rdi
movq %rbp, %rsi
callq 0x4647d
testl %eax, %eax
je 0x45dee
movq 0x18(%r14), %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x1ccb2
jmp 0x45d32
addq %r12, 0x10(%r15)
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
movq %rbp, %rax
andq %rcx, %rax
movl %ebp, %r15d
movq %r13, %rbx
jmp 0x45d37
movq %r15, %rdi
callq 0x1346b
jmp 0x45d32
|
JS_ReadArrayBuffer:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r15, rdi
mov r14, [rdi]
lea rsi, [rsp+48h+var_3C]
call bc_get_leb128
mov ebx, 6
test eax, eax
jnz short loc_45D32
lea rsi, [rsp+48h+var_40]
mov rdi, r15
call bc_get_leb128
test eax, eax
jz short loc_45D4F
loc_45D32:
xor r15d, r15d
loc_45D35:
xor eax, eax
loc_45D37:
or r15, rax
mov rax, r15
mov rdx, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_45D4F:
mov eax, [rsp+48h+var_40]
mov r12d, [rsp+48h+var_3C]
cmp eax, r12d
jnb short loc_45D73
lea rsi, aInvalidArrayBu_0; "invalid array buffer"
xor r15d, r15d
mov rdi, r14
xor eax, eax
call JS_ThrowTypeError
jmp short loc_45D35
loc_45D73:
cmp eax, 0FFFFFFFFh
jz short loc_45D82
lea r8, [rsp+48h+var_38]
mov [r8], rax
jmp short loc_45D85
loc_45D82:
xor r8d, r8d
loc_45D85:
mov rax, [r15+10h]
mov rcx, [r15+18h]
sub rcx, rax
cmp rcx, r12
jl short loc_45E0D
lea r10, js_array_buffer_free
mov edx, 3
mov rdi, r14
xor esi, esi
mov rcx, r12
mov r9d, 13h
push 1
push 0
push r10
push rax
call js_array_buffer_constructor3
add rsp, 20h
mov rbp, rax
mov r13, rdx
cmp r13d, 6
jz short loc_45DDA
mov rdi, r15
mov rsi, rbp
call BC_add_object_ref1
test eax, eax
jz short loc_45DEE
loc_45DDA:
mov rdi, [r14+18h]
mov rsi, rbp
mov rdx, r13
call JS_FreeValueRT
jmp loc_45D32
loc_45DEE:
add [r15+10h], r12
mov rcx, 0FFFFFFFF00000000h
mov rax, rbp
and rax, rcx
mov r15d, ebp
mov rbx, r13
jmp loc_45D37
loc_45E0D:
mov rdi, r15
call JS_ReadArrayBuffer_cold_1
jmp loc_45D32
|
unsigned long long JS_ReadArrayBuffer(
long long *a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
double a6,
double a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
int a12,
unsigned long long a13)
{
long long v13; // r14
long long v14; // rdx
int v15; // ecx
unsigned long long v16; // r8
long long v17; // rdx
long long v18; // rcx
long long v19; // r8
long long v20; // r9
__m128 v21; // xmm4
__m128 v22; // xmm5
long long v23; // r15
unsigned long long v24; // rax
long long v26; // r12
int *v27; // r8
long long v28; // rax
long long v29; // rcx
unsigned long long v30; // rax
unsigned long long v31; // rbp
long long v32; // rdx
long long v33; // r13
char v34; // [rsp+0h] [rbp-48h]
unsigned int v35; // [rsp+8h] [rbp-40h] BYREF
unsigned int v36; // [rsp+Ch] [rbp-3Ch] BYREF
long long v37; // [rsp+10h] [rbp-38h] BYREF
v13 = *a1;
if ( !(unsigned int)bc_get_leb128((long long)a1, &v36, a11, a12, a13)
&& !(unsigned int)bc_get_leb128((long long)a1, &v35, v14, v15, v16) )
{
v26 = v36;
if ( v35 < v36 )
{
v23 = 0LL;
JS_ThrowTypeError(v13, (long long)"invalid array buffer", v17, v18, v19, v20, a2, a3, a4, a5, v21, v22, a8, a9, v34);
goto LABEL_4;
}
if ( v35 == -1 )
{
v27 = 0LL;
}
else
{
v27 = (int *)&v37;
v37 = v35;
}
v28 = a1[2];
v29 = a1[3] - v28;
if ( v29 < v36 )
{
JS_ReadArrayBuffer_cold_1((long long)a1, (long long)&v35, v17, v29, (int)v27, v20);
}
else
{
v30 = js_array_buffer_constructor3(
v13,
0LL,
3LL,
v36,
v27,
19LL,
a2,
a3,
a4,
a5,
v21,
v22,
a8,
a9,
v28,
(long long ( *)())js_array_buffer_free,
0LL,
1);
v31 = v30;
v33 = v32;
if ( (_DWORD)v32 != 6 && !(unsigned int)BC_add_object_ref1(a1, v30) )
{
a1[2] += v26;
v24 = v31 & 0xFFFFFFFF00000000LL;
v23 = (unsigned int)v31;
return v24 | v23;
}
JS_FreeValueRT(*(_QWORD *)(v13 + 24), (_DWORD *)v31, v33);
}
}
v23 = 0LL;
LABEL_4:
v24 = 0LL;
return v24 | v23;
}
|
JS_ReadArrayBuffer:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R15,RDI
MOV R14,qword ptr [RDI]
LEA RSI,[RSP + 0xc]
CALL 0x00144e61
MOV EBX,0x6
TEST EAX,EAX
JNZ 0x00145d32
LEA RSI,[RSP + 0x8]
MOV RDI,R15
CALL 0x00144e61
TEST EAX,EAX
JZ 0x00145d4f
LAB_00145d32:
XOR R15D,R15D
LAB_00145d35:
XOR EAX,EAX
LAB_00145d37:
OR R15,RAX
MOV RAX,R15
MOV RDX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00145d4f:
MOV EAX,dword ptr [RSP + 0x8]
MOV R12D,dword ptr [RSP + 0xc]
CMP EAX,R12D
JNC 0x00145d73
LEA RSI,[0x19e300]
XOR R15D,R15D
MOV RDI,R14
XOR EAX,EAX
CALL 0x00121953
JMP 0x00145d35
LAB_00145d73:
CMP EAX,-0x1
JZ 0x00145d82
LEA R8,[RSP + 0x10]
MOV qword ptr [R8],RAX
JMP 0x00145d85
LAB_00145d82:
XOR R8D,R8D
LAB_00145d85:
MOV RAX,qword ptr [R15 + 0x10]
MOV RCX,qword ptr [R15 + 0x18]
SUB RCX,RAX
CMP RCX,R12
JL 0x00145e0d
LEA R10,[0x1382a5]
MOV EDX,0x3
MOV RDI,R14
XOR ESI,ESI
MOV RCX,R12
MOV R9D,0x13
PUSH 0x1
PUSH 0x0
PUSH R10
PUSH RAX
CALL 0x00138005
ADD RSP,0x20
MOV RBP,RAX
MOV R13,RDX
CMP R13D,0x6
JZ 0x00145dda
MOV RDI,R15
MOV RSI,RBP
CALL 0x0014647d
TEST EAX,EAX
JZ 0x00145dee
LAB_00145dda:
MOV RDI,qword ptr [R14 + 0x18]
MOV RSI,RBP
MOV RDX,R13
CALL 0x0011ccb2
JMP 0x00145d32
LAB_00145dee:
ADD qword ptr [R15 + 0x10],R12
MOV RCX,-0x100000000
MOV RAX,RBP
AND RAX,RCX
MOV R15D,EBP
MOV RBX,R13
JMP 0x00145d37
LAB_00145e0d:
MOV RDI,R15
CALL 0x0011346b
JMP 0x00145d32
|
int1 [16] JS_ReadArrayBuffer(long *param_1)
{
long lVar1;
int iVar2;
ulong uVar3;
int8 uVar4;
ulong *puVar5;
ulong uVar6;
int1 auVar7 [16];
uint local_40;
uint local_3c;
ulong local_38;
lVar1 = *param_1;
iVar2 = bc_get_leb128(param_1,&local_3c);
if ((iVar2 == 0) && (iVar2 = bc_get_leb128(param_1,&local_40), iVar2 == 0)) {
uVar3 = (ulong)local_3c;
if (local_40 < local_3c) {
JS_ThrowTypeError(lVar1,"invalid array buffer");
}
else {
if (local_40 == 0xffffffff) {
puVar5 = (ulong *)0x0;
}
else {
puVar5 = &local_38;
local_38 = (ulong)local_40;
}
if (param_1[3] - param_1[2] < (long)uVar3) {
JS_ReadArrayBuffer_cold_1(param_1);
}
else {
auVar7 = js_array_buffer_constructor3
(lVar1,0,3,uVar3,puVar5,0x13,param_1[2],js_array_buffer_free,0,1);
uVar4 = auVar7._8_8_;
uVar6 = auVar7._0_8_;
if ((auVar7._8_4_ != 6) && (iVar2 = BC_add_object_ref1(param_1,uVar6), iVar2 == 0)) {
param_1[2] = param_1[2] + uVar3;
uVar3 = uVar6 & 0xffffffff00000000;
uVar6 = uVar6 & 0xffffffff;
goto LAB_00145d37;
}
JS_FreeValueRT(*(int8 *)(lVar1 + 0x18),uVar6,uVar4);
}
}
}
uVar6 = 0;
uVar3 = 0;
uVar4 = 6;
LAB_00145d37:
auVar7._8_8_ = uVar4;
auVar7._0_8_ = uVar6 | uVar3;
return auVar7;
}
|
|
18,462
|
JS_ReadArrayBuffer
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue JS_ReadArrayBuffer(BCReaderState *s)
{
JSContext *ctx = s->ctx;
uint32_t byte_length, max_byte_length;
uint64_t max_byte_length_u64, *pmax_byte_length = NULL;
JSValue obj;
if (bc_get_leb128(s, &byte_length))
return JS_EXCEPTION;
if (bc_get_leb128(s, &max_byte_length))
return JS_EXCEPTION;
if (max_byte_length < byte_length)
return JS_ThrowTypeError(ctx, "invalid array buffer");
if (max_byte_length != UINT32_MAX) {
max_byte_length_u64 = max_byte_length;
pmax_byte_length = &max_byte_length_u64;
}
if (unlikely(s->buf_end - s->ptr < byte_length)) {
bc_read_error_end(s);
return JS_EXCEPTION;
}
// makes a copy of the input
obj = js_array_buffer_constructor3(ctx, JS_UNDEFINED,
byte_length, pmax_byte_length,
JS_CLASS_ARRAY_BUFFER,
(uint8_t*)s->ptr,
js_array_buffer_free, NULL,
/*alloc_flag*/TRUE);
if (JS_IsException(obj))
goto fail;
if (BC_add_object_ref(s, obj))
goto fail;
s->ptr += byte_length;
return obj;
fail:
JS_FreeValue(ctx, obj);
return JS_EXCEPTION;
}
|
O3
|
c
|
JS_ReadArrayBuffer:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
movq (%rdi), %r14
leaq 0xc(%rsp), %rsi
callq 0x469d0
movl $0x6, %ebx
testl %eax, %eax
jne 0x47872
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x469d0
testl %eax, %eax
je 0x4788f
xorl %r15d, %r15d
xorl %eax, %eax
orq %rax, %r15
movq %r15, %rax
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%rsp), %eax
movl 0xc(%rsp), %r12d
cmpl %r12d, %eax
jae 0x478b3
leaq 0x59a2c(%rip), %rsi # 0xa12d0
xorl %r15d, %r15d
movq %r14, %rdi
xorl %eax, %eax
callq 0x2214f
jmp 0x47875
cmpl $-0x1, %eax
je 0x478c2
leaq 0x10(%rsp), %r8
movq %rax, (%r8)
jmp 0x478c5
xorl %r8d, %r8d
movq 0x10(%r15), %rax
movq 0x18(%r15), %rcx
subq %rax, %rcx
cmpq %r12, %rcx
jl 0x4796d
leaq -0xe34a(%rip), %r10 # 0x39596
movl $0x3, %edx
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rcx
movl $0x13, %r9d
pushq $0x1
pushq $0x0
pushq %r10
pushq %rax
callq 0x392b3
addq $0x20, %rsp
movq %rax, %rbp
movq %rdx, %r13
cmpl $0x6, %r13d
je 0x4791e
movq %r15, %rdi
movq %rbp, %rsi
callq 0x48064
testl %eax, %eax
je 0x4794e
cmpl $-0x9, %r13d
jb 0x47872
movq 0x18(%r14), %rdi
movl (%rbp), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rbp)
cmpl $0x1, %eax
jg 0x47872
movq %rbp, %rsi
movq %r13, %rdx
callq 0x20d90
jmp 0x47872
addq %r12, 0x10(%r15)
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
movq %rbp, %rax
andq %rcx, %rax
movl %ebp, %r15d
movq %r13, %rbx
jmp 0x47877
movq %r15, %rdi
callq 0x13d82
jmp 0x47872
|
JS_ReadArrayBuffer:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r15, rdi
mov r14, [rdi]
lea rsi, [rsp+48h+var_3C]
call bc_get_leb128
mov ebx, 6
test eax, eax
jnz short loc_47872
lea rsi, [rsp+48h+var_40]
mov rdi, r15
call bc_get_leb128
test eax, eax
jz short loc_4788F
loc_47872:
xor r15d, r15d
loc_47875:
xor eax, eax
loc_47877:
or r15, rax
mov rax, r15
mov rdx, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4788F:
mov eax, [rsp+48h+var_40]
mov r12d, [rsp+48h+var_3C]
cmp eax, r12d
jnb short loc_478B3
lea rsi, aInvalidArrayBu_0; "invalid array buffer"
xor r15d, r15d
mov rdi, r14
xor eax, eax
call JS_ThrowTypeError
jmp short loc_47875
loc_478B3:
cmp eax, 0FFFFFFFFh
jz short loc_478C2
lea r8, [rsp+48h+var_38]
mov [r8], rax
jmp short loc_478C5
loc_478C2:
xor r8d, r8d
loc_478C5:
mov rax, [r15+10h]
mov rcx, [r15+18h]
sub rcx, rax
cmp rcx, r12
jl loc_4796D
lea r10, js_array_buffer_free
mov edx, 3
mov rdi, r14
xor esi, esi
mov rcx, r12
mov r9d, 13h
push 1
push 0
push r10
push rax
call js_array_buffer_constructor3
add rsp, 20h
mov rbp, rax
mov r13, rdx
cmp r13d, 6
jz short loc_4791E
mov rdi, r15
mov rsi, rbp
call BC_add_object_ref1
test eax, eax
jz short loc_4794E
loc_4791E:
cmp r13d, 0FFFFFFF7h
jb loc_47872
mov rdi, [r14+18h]
mov eax, [rbp+0]
lea ecx, [rax-1]
mov [rbp+0], ecx
cmp eax, 1
jg loc_47872
mov rsi, rbp
mov rdx, r13
call js_free_value_rt
jmp loc_47872
loc_4794E:
add [r15+10h], r12
mov rcx, 0FFFFFFFF00000000h
mov rax, rbp
and rax, rcx
mov r15d, ebp
mov rbx, r13
jmp loc_47877
loc_4796D:
mov rdi, r15
call JS_ReadArrayBuffer_cold_1
jmp loc_47872
|
unsigned long long JS_ReadArrayBuffer(
long long *a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
double a6,
double a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
int a12,
int a13,
int a14)
{
long long v14; // r14
long long v15; // rdx
int v16; // ecx
int v17; // r8d
int v18; // r9d
long long v19; // rdx
long long v20; // rcx
long long v21; // r8
long long v22; // r9
__m128 v23; // xmm4
__m128 v24; // xmm5
long long v25; // r15
unsigned long long v26; // rax
long long v28; // r12
unsigned long long *v29; // r8
long long v30; // rax
long long v31; // rcx
unsigned long long v32; // rax
long long v33; // r8
long long v34; // r9
unsigned long long v35; // rbp
long long v36; // rdx
long long v37; // r13
long long v38; // rdi
int v39; // eax
long long v40; // rcx
char v41; // [rsp+0h] [rbp-48h]
unsigned int v42; // [rsp+8h] [rbp-40h] BYREF
unsigned int v43; // [rsp+Ch] [rbp-3Ch] BYREF
long long v44; // [rsp+10h] [rbp-38h] BYREF
v14 = *a1;
if ( !(unsigned int)bc_get_leb128((long long)a1, (int *)&v43, a11, a12, a13, a14)
&& !(unsigned int)bc_get_leb128((long long)a1, (int *)&v42, v15, v16, v17, v18) )
{
v28 = v43;
if ( v42 < v43 )
{
v25 = 0LL;
JS_ThrowTypeError(v14, (long long)"invalid array buffer", v19, v20, v21, v22, a2, a3, a4, a5, v23, v24, a8, a9, v41);
goto LABEL_4;
}
if ( v42 == -1 )
{
v29 = 0LL;
}
else
{
v29 = (unsigned long long *)&v44;
v44 = v42;
}
v30 = a1[2];
v31 = a1[3] - v30;
if ( v31 < v43 )
{
JS_ReadArrayBuffer_cold_1((long long)a1, (long long)&v42, v19, v31, (int)v29, v22);
}
else
{
v32 = js_array_buffer_constructor3(
v14,
0LL,
3LL,
v43,
v29,
19LL,
a2,
a3,
a4,
a5,
v23,
v24,
a8,
a9,
v30,
(long long ( *)())js_array_buffer_free,
0LL,
1u);
v35 = v32;
v37 = v36;
if ( (_DWORD)v36 != 6 && !(unsigned int)BC_add_object_ref1(a1, v32) )
{
a1[2] += v28;
v26 = v35 & 0xFFFFFFFF00000000LL;
v25 = (unsigned int)v35;
return v26 | v25;
}
if ( (unsigned int)v37 >= 0xFFFFFFF7 )
{
v38 = *(_QWORD *)(v14 + 24);
v39 = *(_DWORD *)v35;
v40 = (unsigned int)(*(_DWORD *)v35 - 1);
*(_DWORD *)v35 = v40;
if ( v39 <= 1 )
js_free_value_rt(v38, (_QWORD *)v35, v37, v40, v33, v34);
}
}
}
v25 = 0LL;
LABEL_4:
v26 = 0LL;
return v26 | v25;
}
|
JS_ReadArrayBuffer:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R15,RDI
MOV R14,qword ptr [RDI]
LEA RSI,[RSP + 0xc]
CALL 0x001469d0
MOV EBX,0x6
TEST EAX,EAX
JNZ 0x00147872
LEA RSI,[RSP + 0x8]
MOV RDI,R15
CALL 0x001469d0
TEST EAX,EAX
JZ 0x0014788f
LAB_00147872:
XOR R15D,R15D
LAB_00147875:
XOR EAX,EAX
LAB_00147877:
OR R15,RAX
MOV RAX,R15
MOV RDX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0014788f:
MOV EAX,dword ptr [RSP + 0x8]
MOV R12D,dword ptr [RSP + 0xc]
CMP EAX,R12D
JNC 0x001478b3
LEA RSI,[0x1a12d0]
XOR R15D,R15D
MOV RDI,R14
XOR EAX,EAX
CALL 0x0012214f
JMP 0x00147875
LAB_001478b3:
CMP EAX,-0x1
JZ 0x001478c2
LEA R8,[RSP + 0x10]
MOV qword ptr [R8],RAX
JMP 0x001478c5
LAB_001478c2:
XOR R8D,R8D
LAB_001478c5:
MOV RAX,qword ptr [R15 + 0x10]
MOV RCX,qword ptr [R15 + 0x18]
SUB RCX,RAX
CMP RCX,R12
JL 0x0014796d
LEA R10,[0x139596]
MOV EDX,0x3
MOV RDI,R14
XOR ESI,ESI
MOV RCX,R12
MOV R9D,0x13
PUSH 0x1
PUSH 0x0
PUSH R10
PUSH RAX
CALL 0x001392b3
ADD RSP,0x20
MOV RBP,RAX
MOV R13,RDX
CMP R13D,0x6
JZ 0x0014791e
MOV RDI,R15
MOV RSI,RBP
CALL 0x00148064
TEST EAX,EAX
JZ 0x0014794e
LAB_0014791e:
CMP R13D,-0x9
JC 0x00147872
MOV RDI,qword ptr [R14 + 0x18]
MOV EAX,dword ptr [RBP]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RBP],ECX
CMP EAX,0x1
JG 0x00147872
MOV RSI,RBP
MOV RDX,R13
CALL 0x00120d90
JMP 0x00147872
LAB_0014794e:
ADD qword ptr [R15 + 0x10],R12
MOV RCX,-0x100000000
MOV RAX,RBP
AND RAX,RCX
MOV R15D,EBP
MOV RBX,R13
JMP 0x00147877
LAB_0014796d:
MOV RDI,R15
CALL 0x00113d82
JMP 0x00147872
|
int1 [16] JS_ReadArrayBuffer(long *param_1)
{
long lVar1;
int8 uVar2;
int iVar3;
ulong uVar5;
int8 uVar6;
ulong *puVar7;
ulong uVar8;
int1 auVar9 [16];
uint local_40;
uint local_3c;
ulong local_38;
int *piVar4;
lVar1 = *param_1;
iVar3 = bc_get_leb128(param_1,&local_3c);
if ((iVar3 == 0) && (iVar3 = bc_get_leb128(param_1,&local_40), iVar3 == 0)) {
uVar5 = (ulong)local_3c;
if (local_40 < local_3c) {
JS_ThrowTypeError(lVar1,"invalid array buffer");
}
else {
if (local_40 == 0xffffffff) {
puVar7 = (ulong *)0x0;
}
else {
puVar7 = &local_38;
local_38 = (ulong)local_40;
}
if (param_1[3] - param_1[2] < (long)uVar5) {
JS_ReadArrayBuffer_cold_1(param_1);
}
else {
auVar9 = js_array_buffer_constructor3
(lVar1,0,3,uVar5,puVar7,0x13,param_1[2],js_array_buffer_free,0,1);
uVar6 = auVar9._8_8_;
piVar4 = auVar9._0_8_;
if ((auVar9._8_4_ != 6) && (iVar3 = BC_add_object_ref1(param_1,piVar4), iVar3 == 0)) {
param_1[2] = param_1[2] + uVar5;
uVar5 = (ulong)piVar4 & 0xffffffff00000000;
uVar8 = (ulong)piVar4 & 0xffffffff;
goto LAB_00147877;
}
if (0xfffffff6 < auVar9._8_4_) {
uVar2 = *(int8 *)(lVar1 + 0x18);
iVar3 = *piVar4;
*piVar4 = iVar3 + -1;
if (iVar3 < 2) {
js_free_value_rt(uVar2,piVar4,uVar6);
}
}
}
}
}
uVar8 = 0;
uVar5 = 0;
uVar6 = 6;
LAB_00147877:
auVar9._8_8_ = uVar6;
auVar9._0_8_ = uVar8 | uVar5;
return auVar9;
}
|
|
18,463
|
aimrt::common::util::StringHash::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
|
aimrt_mujoco_sim/_deps/aimrt-src/src/common/util/../util/string_util.h
|
std::size_t operator()(std::string const& str) const { return hash_type{}(str); }
|
O3
|
c
|
aimrt::common::util::StringHash::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const:
pushq %rax
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
movl $0xc70f6907, %edx # imm = 0xC70F6907
callq 0x1e220
popq %rcx
retq
movq %rax, %rdi
callq 0x23e15
|
_ZNK5aimrt6common4util10StringHashclERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rax
mov rdi, [rsi]; void *
mov rsi, [rsi+8]; unsigned __int64
mov edx, 0C70F6907h; unsigned __int64
call __ZSt11_Hash_bytesPKvmm; std::_Hash_bytes(void const*,ulong,ulong)
pop rcx
retn
mov rdi, rax
call __clang_call_terminate
|
long long aimrt::common::util::StringHash::operator()(long long a1, long long a2)
{
return std::_Hash_bytes(*(const void **)a2, *(_QWORD *)(a2 + 8), 0xC70F6907uLL);
}
|
operator():
PUSH RAX
MOV RDI,qword ptr [RSI]
MOV RSI,qword ptr [RSI + 0x8]
LAB_0013da5a:
MOV EDX,0xc70f6907
CALL 0x0011e220
POP RCX
RET
|
/* aimrt::common::util::StringHash::TEMPNAMEPLACEHOLDERVALUE(std::__cxx11::string const&) const */
void __thiscall aimrt::common::util::StringHash::operator()(StringHash *this,string *param_1)
{
/* try { // try from 0013da5a to 0013da63 has its CatchHandler @ 0013da66 */
std::_Hash_bytes(*(void **)param_1,*(ulong *)(param_1 + 8),0xc70f6907);
return;
}
|
|
18,464
|
mthd_my_read_rows
|
eloqsql/libmariadb/libmariadb/mariadb_lib.c
|
MYSQL_DATA *mthd_my_read_rows(MYSQL *mysql,MYSQL_FIELD *mysql_fields,
uint fields)
{
uint field;
ulong pkt_len;
ulong len;
uchar *cp;
char *to, *end_to;
MYSQL_DATA *result;
MYSQL_ROWS **prev_ptr,*cur;
NET *net = &mysql->net;
if ((pkt_len= ma_net_safe_read(mysql)) == packet_error)
return(0);
if (!(result=(MYSQL_DATA*) calloc(1, sizeof(MYSQL_DATA))))
{
SET_CLIENT_ERROR(mysql, CR_OUT_OF_MEMORY, SQLSTATE_UNKNOWN, 0);
return(0);
}
ma_init_alloc_root(&result->alloc,8192,0); /* Assume rowlength < 8192 */
result->alloc.min_malloc=sizeof(MYSQL_ROWS);
prev_ptr= &result->data;
result->rows=0;
result->fields=fields;
while (*(cp=net->read_pos) != 254 || pkt_len >= 8)
{
result->rows++;
if (!(cur= (MYSQL_ROWS*) ma_alloc_root(&result->alloc,
sizeof(MYSQL_ROWS))) ||
!(cur->data= ((MYSQL_ROW)
ma_alloc_root(&result->alloc,
(fields+1)*sizeof(char *)+fields+pkt_len))))
{
free_rows(result);
SET_CLIENT_ERROR(mysql, CR_OUT_OF_MEMORY, SQLSTATE_UNKNOWN, 0);
return(0);
}
*prev_ptr=cur;
prev_ptr= &cur->next;
to= (char*) (cur->data+fields+1);
end_to=to+fields+pkt_len-1;
for (field=0 ; field < fields ; field++)
{
if ((len=(ulong) net_field_length(&cp)) == NULL_LENGTH)
{ /* null field */
cur->data[field] = 0;
}
else
{
cur->data[field] = to;
if (len > (ulong)(end_to - to) || to > end_to)
{
free_rows(result);
SET_CLIENT_ERROR(mysql, CR_UNKNOWN_ERROR, SQLSTATE_UNKNOWN, 0);
return(0);
}
memcpy(to,(char*) cp,len); to[len]=0;
to+=len+1;
cp+=len;
if (mysql_fields)
{
if (mysql_fields[field].max_length < len)
mysql_fields[field].max_length=len;
}
}
}
cur->data[field]=to; /* End of last field */
if ((pkt_len=ma_net_safe_read(mysql)) == packet_error)
{
free_rows(result);
return(0);
}
}
*prev_ptr=0; /* last pointer is null */
/* save status */
if (pkt_len > 1)
{
cp++;
mysql->warning_count= uint2korr(cp);
cp+= 2;
mysql->server_status= uint2korr(cp);
}
return(result);
}
|
O3
|
c
|
mthd_my_read_rows:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, %ebx
movq %rsi, -0x60(%rbp)
movq %rdi, %r15
callq 0x26beb
movq %rax, %r14
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq %rax, %r14
je 0x296a6
movl $0x1, %edi
movl $0x60, %esi
callq 0x142f0
testq %rax, %rax
je 0x296ba
movq %rax, %r12
movq %rax, %rdi
addq $0x10, %rdi
movl $0x2000, %esi # imm = 0x2000
movq %rdi, -0x30(%rbp)
xorl %edx, %edx
callq 0x2f3b4
movq %r12, %rdx
movq $0x18, 0x28(%r12)
movq $0x0, 0x48(%r12)
movl %ebx, 0x50(%r12)
leal 0x1(%rbx), %eax
movq %rbx, -0x70(%rbp)
movl %ebx, %ecx
leaq (%rcx,%rax,8), %rax
movq %rax, -0x78(%rbp)
movq -0x60(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x68(%rbp)
movq %r12, %rbx
movq %r15, -0x58(%rbp)
movq %r12, -0x40(%rbp)
movq %rcx, -0x50(%rbp)
movq 0x20(%r15), %r13
cmpq $0x7, %r14
ja 0x29487
cmpb $-0x2, (%r13)
je 0x2977f
movq %r15, %r12
incq 0x48(%rdx)
movl $0x18, %esi
movq -0x30(%rbp), %r15
movq %r15, %rdi
callq 0x2f423
testq %rax, %rax
je 0x29710
movq %rax, %rcx
movq -0x78(%rbp), %rax
leaq (%rax,%r14), %rsi
movq %r15, %rdi
movq %rcx, -0x38(%rbp)
callq 0x2f423
movq -0x38(%rbp), %rdx
movq %rax, 0x8(%rdx)
testq %rax, %rax
je 0x29710
movq %rdx, (%rbx)
movq 0x8(%rdx), %rax
movq -0x50(%rbp), %rcx
leaq (%rax,%rcx,8), %rbx
addq $0x8, %rbx
cmpl $0x0, -0x70(%rbp)
je 0x295f3
leaq (%rax,%rcx,8), %rax
addq %rcx, %rax
addq $0x8, %rax
leaq (%r14,%rax), %r8
decq %r8
movq -0x68(%rbp), %r15
xorl %r12d, %r12d
movq -0x30(%rbp), %rdi
movq %r8, -0x48(%rbp)
movzbl (%r13), %r14d
cmpq $0xfa, %r14
ja 0x29573
incq %r13
movq 0x8(%rdx), %rax
movq %rbx, (%rax,%r12,8)
movq %r8, %rax
subq %rbx, %rax
cmpq %rax, %r14
ja 0x29641
cmpq %r8, %rbx
ja 0x29641
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x143a0
addq %r14, %r13
addq %r14, %rbx
incq %rbx
movb $0x0, -0x1(%rbx)
cmpq $0x0, -0x60(%rbp)
je 0x29599
cmpq %r14, (%r15)
movq -0x50(%rbp), %rcx
jae 0x2956d
movq %r14, (%r15)
movq -0x30(%rbp), %rdi
jmp 0x295a1
cmpq $0xfb, %r14
je 0x295d5
cmpl $0xfd, %r14d
je 0x295bb
cmpl $0xfc, %r14d
jne 0x295e6
movzwl 0x1(%r13), %r14d
addq $0x3, %r13
jmp 0x2951f
movq -0x30(%rbp), %rdi
movq -0x50(%rbp), %rcx
movq -0x38(%rbp), %rdx
movq -0x48(%rbp), %r8
incq %r12
subq $-0x80, %r15
cmpq %r12, %rcx
jne 0x2950e
jmp 0x295fa
movzwl 0x1(%r13), %eax
movzbl 0x3(%r13), %r14d
addq $0x4, %r13
shll $0x10, %r14d
orq %rax, %r14
jmp 0x2951f
incq %r13
movq 0x8(%rdx), %rax
movq $0x0, (%rax,%r12,8)
jmp 0x295a9
movl 0x1(%r13), %r14d
addq $0x9, %r13
jmp 0x2951f
xorl %ecx, %ecx
movq %r12, %r15
jmp 0x29602
movq 0x8(%rdx), %rax
movq -0x58(%rbp), %r15
movq %rdx, %r12
movq %rbx, (%rax,%rcx,8)
movq %r15, %rdi
callq 0x26beb
movq %rax, %r14
movq %r12, %rbx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq %rax, %r14
movq -0x40(%rbp), %rdx
jne 0x29472
movq %rdx, %rbx
movq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x2f53b
movq %rbx, %rdi
callq 0x14590
jmp 0x296a6
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x2f53b
movq -0x40(%rbp), %rdi
callq 0x14590
movq -0x58(%rbp), %r14
movl $0x7d0, 0x90(%r14) # imm = 0x7D0
leaq 0x297(%r14), %rdi
leaq 0x39380(%rip), %rax # 0x629f0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x14230
movb %bl, 0x29c(%r14)
leaq 0x97(%r14), %rdi
leaq 0x3936e(%rip), %rax # 0x62a00
movq (%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x14230
movb %bl, 0x296(%r14)
xorl %edx, %edx
movq %rdx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x7d8, 0x90(%r15) # imm = 0x7D8
leaq 0x297(%r15), %rdi
leaq 0x3931d(%rip), %rax # 0x629f0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x14230
xorl %eax, %eax
movb %al, 0x29c(%r15)
leaq 0x97(%r15), %rdi
leaq 0x39309(%rip), %rax # 0x62a00
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x14230
xorl %edx, %edx
movb %dl, 0x296(%r15)
jmp 0x296a8
xorl %ebx, %ebx
movq %r15, %rdi
xorl %esi, %esi
callq 0x2f53b
movq -0x40(%rbp), %rdi
callq 0x14590
movl $0x7d8, 0x90(%r12) # imm = 0x7D8
leaq 0x297(%r12), %rdi
leaq 0x392b0(%rip), %rax # 0x629f0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x14230
movb %bl, 0x29c(%r12)
leaq 0x97(%r12), %rdi
leaq 0x3929c(%rip), %rax # 0x62a00
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x14230
movb %bl, 0x296(%r12)
jmp 0x296a6
movq $0x0, (%rbx)
cmpq $0x2, %r14
jb 0x296a8
movzwl 0x1(%r13), %eax
movl %eax, 0x388(%r15)
movzwl 0x3(%r13), %eax
movl %eax, 0x380(%r15)
jmp 0x296a8
|
mthd_my_read_rows:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov ebx, edx
mov [rbp+var_60], rsi
mov r15, rdi
call ma_net_safe_read
mov r14, rax
mov eax, 0FFFFFFFFh
cmp r14, rax
jz loc_296A6
mov edi, 1
mov esi, 60h ; '`'
call _calloc
test rax, rax
jz loc_296BA
mov r12, rax
mov rdi, rax
add rdi, 10h
mov esi, 2000h
mov [rbp+var_30], rdi
xor edx, edx
call ma_init_alloc_root
mov rdx, r12
mov qword ptr [r12+28h], 18h
mov qword ptr [r12+48h], 0
mov [r12+50h], ebx
lea eax, [rbx+1]
mov [rbp+var_70], rbx
mov ecx, ebx
lea rax, [rcx+rax*8]
mov [rbp+var_78], rax
mov rax, [rbp+var_60]
add rax, 40h ; '@'
mov [rbp+var_68], rax
mov rbx, r12
mov [rbp+var_58], r15
mov [rbp+var_40], r12
mov [rbp+var_50], rcx
loc_29472:
mov r13, [r15+20h]
cmp r14, 7
ja short loc_29487
cmp byte ptr [r13+0], 0FEh
jz loc_2977F
loc_29487:
mov r12, r15
inc qword ptr [rdx+48h]
mov esi, 18h
mov r15, [rbp+var_30]
mov rdi, r15
call ma_alloc_root
test rax, rax
jz loc_29710
mov rcx, rax
mov rax, [rbp+var_78]
lea rsi, [rax+r14]
mov rdi, r15
mov [rbp+var_38], rcx
call ma_alloc_root
mov rdx, [rbp+var_38]
mov [rdx+8], rax
test rax, rax
jz loc_29710
mov [rbx], rdx
mov rax, [rdx+8]
mov rcx, [rbp+var_50]
lea rbx, [rax+rcx*8]
add rbx, 8
cmp dword ptr [rbp+var_70], 0
jz loc_295F3
lea rax, [rax+rcx*8]
add rax, rcx
add rax, 8
lea r8, [r14+rax]
dec r8
mov r15, [rbp+var_68]
xor r12d, r12d
mov rdi, [rbp+var_30]
mov [rbp+var_48], r8
loc_2950E:
movzx r14d, byte ptr [r13+0]
cmp r14, 0FAh
ja short loc_29573
inc r13
loc_2951F:
mov rax, [rdx+8]
mov [rax+r12*8], rbx
mov rax, r8
sub rax, rbx
cmp r14, rax
ja loc_29641
cmp rbx, r8
ja loc_29641
mov rdi, rbx
mov rsi, r13
mov rdx, r14
call _memcpy
add r13, r14
add rbx, r14
inc rbx
mov byte ptr [rbx-1], 0
cmp [rbp+var_60], 0
jz short loc_29599
cmp [r15], r14
mov rcx, [rbp+var_50]
jnb short loc_2956D
mov [r15], r14
loc_2956D:
mov rdi, [rbp+var_30]
jmp short loc_295A1
loc_29573:
cmp r14, 0FBh
jz short loc_295D5
cmp r14d, 0FDh
jz short loc_295BB
cmp r14d, 0FCh
jnz short loc_295E6
movzx r14d, word ptr [r13+1]
add r13, 3
jmp short loc_2951F
loc_29599:
mov rdi, [rbp+var_30]
mov rcx, [rbp+var_50]
loc_295A1:
mov rdx, [rbp+var_38]
mov r8, [rbp+var_48]
loc_295A9:
inc r12
sub r15, 0FFFFFFFFFFFFFF80h
cmp rcx, r12
jnz loc_2950E
jmp short loc_295FA
loc_295BB:
movzx eax, word ptr [r13+1]
movzx r14d, byte ptr [r13+3]
add r13, 4
shl r14d, 10h
or r14, rax
jmp loc_2951F
loc_295D5:
inc r13
mov rax, [rdx+8]
mov qword ptr [rax+r12*8], 0
jmp short loc_295A9
loc_295E6:
mov r14d, [r13+1]
add r13, 9
jmp loc_2951F
loc_295F3:
xor ecx, ecx
mov r15, r12
jmp short loc_29602
loc_295FA:
mov rax, [rdx+8]
mov r15, [rbp+var_58]
loc_29602:
mov r12, rdx
mov [rax+rcx*8], rbx
mov rdi, r15
call ma_net_safe_read
mov r14, rax
mov rbx, r12
mov eax, 0FFFFFFFFh
cmp r14, rax
mov rdx, [rbp+var_40]
jnz loc_29472
mov rbx, rdx
mov rdi, [rbp+var_30]
xor esi, esi
call ma_free_root
mov rdi, rbx
call _free
jmp short loc_296A6
loc_29641:
xor ebx, ebx
xor esi, esi
call ma_free_root
mov rdi, [rbp+var_40]
call _free
mov r14, [rbp+var_58]
mov dword ptr [r14+90h], 7D0h
lea rdi, [r14+297h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov [r14+29Ch], bl
lea rdi, [r14+97h]
lea rax, client_errors
mov rsi, [rax]
mov edx, 1FFh
call _strncpy
mov [r14+296h], bl
loc_296A6:
xor edx, edx
loc_296A8:
mov rax, rdx
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_296BA:
mov dword ptr [r15+90h], 7D8h
lea rdi, [r15+297h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor eax, eax
mov [r15+29Ch], al
lea rdi, [r15+97h]
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
xor edx, edx
mov [r15+296h], dl
jmp short loc_296A8
loc_29710:
xor ebx, ebx
mov rdi, r15
xor esi, esi
call ma_free_root
mov rdi, [rbp+var_40]
call _free
mov dword ptr [r12+90h], 7D8h
lea rdi, [r12+297h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov [r12+29Ch], bl
lea rdi, [r12+97h]
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov [r12+296h], bl
jmp loc_296A6
loc_2977F:
mov qword ptr [rbx], 0
cmp r14, 2
jb loc_296A8
movzx eax, word ptr [r13+1]
mov [r15+388h], eax
movzx eax, word ptr [r13+3]
mov [r15+380h], eax
jmp loc_296A8
|
long long mthd_my_read_rows(long long a1, long long a2, long long a3, long long a4, unsigned long long a5, int a6)
{
unsigned int v6; // ebx
long long v7; // r15
unsigned long long v8; // r14
long long v9; // rax
long long v10; // r12
long long v11; // rdx
long long v12; // rcx
_QWORD *v13; // rbx
unsigned __int8 *v14; // r13
long long v15; // rax
long long v16; // rsi
long long v17; // rax
unsigned long long v18; // r8
int v19; // r9d
long long v20; // rdx
long long v21; // rax
long long v22; // rcx
unsigned long long v23; // rbx
unsigned long long *v24; // r15
long long v25; // r12
long long v26; // rdi
unsigned long long v27; // r14
unsigned __int8 *v28; // r13
long long v29; // rax
int v30; // r14d
_QWORD *v31; // r12
long long v33; // [rsp+8h] [rbp-78h]
unsigned int v34; // [rsp+10h] [rbp-70h]
unsigned long long *v35; // [rsp+18h] [rbp-68h]
long long v38; // [rsp+30h] [rbp-50h]
unsigned long long v39; // [rsp+38h] [rbp-48h]
long long v40; // [rsp+40h] [rbp-40h]
long long v41; // [rsp+48h] [rbp-38h]
long long v42; // [rsp+50h] [rbp-30h]
v6 = a3;
v7 = a1;
v8 = ma_net_safe_read(a1, a2, a3, a4, a5, a6);
if ( v8 == 0xFFFFFFFF )
return 0LL;
v9 = calloc(1LL, 96LL);
if ( v9 )
{
v10 = v9;
v42 = v9 + 16;
ma_init_alloc_root(v9 + 16, 0x2000LL, 0LL);
v11 = v10;
*(_QWORD *)(v10 + 40) = 24LL;
*(_QWORD *)(v10 + 72) = 0LL;
*(_DWORD *)(v10 + 80) = v6;
v34 = v6;
v12 = v6;
v33 = v6 + 8LL * (v6 + 1);
v35 = (unsigned long long *)(a2 + 64);
v13 = (_QWORD *)v10;
v40 = v10;
v38 = v12;
while ( 1 )
{
v14 = *(unsigned __int8 **)(v7 + 32);
if ( v8 <= 7 && *v14 == 0xFE )
break;
++*(_QWORD *)(v11 + 72);
v15 = ma_alloc_root(v42, 24LL);
if ( !v15
|| (v16 = v33 + v8, v41 = v15,
v17 = ma_alloc_root(v42, v33 + v8),
v20 = v41,
(*(_QWORD *)(v41 + 8) = v17) == 0LL) )
{
ma_free_root(v42, 0LL);
free(v40);
*(_DWORD *)(v7 + 144) = 2008;
strncpy(v7 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(v7 + 668) = 0;
strncpy(v7 + 151, client_errors[8], 511LL);
*(_BYTE *)(v7 + 662) = 0;
return 0LL;
}
*v13 = v41;
v21 = *(_QWORD *)(v41 + 8);
v22 = v38;
v23 = v21 + 8 * v38 + 8;
if ( v34 )
{
v18 = v8 + v38 + v21 + 8 * v38 + 8 - 1;
v24 = v35;
v25 = 0LL;
v26 = v42;
v39 = v18;
while ( 1 )
{
v27 = *v14;
if ( v27 > 0xFA )
{
if ( v27 == 251 )
{
++v14;
*(_QWORD *)(*(_QWORD *)(v20 + 8) + 8 * v25) = 0LL;
goto LABEL_24;
}
if ( (_DWORD)v27 == 253 )
{
v29 = *(unsigned __int16 *)(v14 + 1);
v30 = v14[3];
v28 = v14 + 4;
v27 = v29 | (unsigned int)(v30 << 16);
}
else if ( (_DWORD)v27 == 252 )
{
v27 = *(unsigned __int16 *)(v14 + 1);
v28 = v14 + 3;
}
else
{
v27 = *(unsigned int *)(v14 + 1);
v28 = v14 + 9;
}
}
else
{
v28 = v14 + 1;
}
*(_QWORD *)(*(_QWORD *)(v20 + 8) + 8 * v25) = v23;
if ( v27 > v18 - v23 || v23 > v18 )
{
ma_free_root(v26, 0LL);
free(v40);
*(_DWORD *)(a1 + 144) = 2000;
strncpy(a1 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 668) = 0;
strncpy(a1 + 151, client_errors[0], 511LL);
*(_BYTE *)(a1 + 662) = 0;
return 0LL;
}
v16 = (long long)v28;
memcpy(v23, v28, v27);
v14 = &v28[v27];
v23 += v27 + 1;
*(_BYTE *)(v23 - 1) = 0;
if ( a2 )
{
v22 = v38;
if ( *v24 < v27 )
*v24 = v27;
v26 = v42;
}
else
{
v26 = v42;
v22 = v38;
}
v20 = v41;
v18 = v39;
LABEL_24:
++v25;
v24 += 16;
if ( v22 == v25 )
{
v21 = *(_QWORD *)(v20 + 8);
v7 = a1;
goto LABEL_30;
}
}
}
v22 = 0LL;
LABEL_30:
v31 = (_QWORD *)v20;
*(_QWORD *)(v21 + 8 * v22) = v23;
v8 = ma_net_safe_read(v7, v16, v20, v22, v18, v19);
v13 = v31;
v11 = v40;
if ( v8 == 0xFFFFFFFF )
{
ma_free_root(v42, 0LL);
free(v40);
return 0LL;
}
}
*v13 = 0LL;
if ( v8 >= 2 )
{
*(_DWORD *)(v7 + 904) = *(unsigned __int16 *)(v14 + 1);
*(_DWORD *)(v7 + 896) = *(unsigned __int16 *)(v14 + 3);
}
}
else
{
*(_DWORD *)(a1 + 144) = 2008;
strncpy(a1 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 668) = 0;
strncpy(a1 + 151, client_errors[8], 511LL);
v11 = 0LL;
*(_BYTE *)(a1 + 662) = 0;
}
return v11;
}
|
mthd_my_read_rows:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV EBX,EDX
MOV qword ptr [RBP + -0x60],RSI
MOV R15,RDI
CALL 0x00126beb
MOV R14,RAX
MOV EAX,0xffffffff
CMP R14,RAX
JZ 0x001296a6
MOV EDI,0x1
MOV ESI,0x60
CALL 0x001142f0
TEST RAX,RAX
JZ 0x001296ba
MOV R12,RAX
MOV RDI,RAX
ADD RDI,0x10
MOV ESI,0x2000
MOV qword ptr [RBP + -0x30],RDI
XOR EDX,EDX
CALL 0x0012f3b4
MOV RDX,R12
MOV qword ptr [R12 + 0x28],0x18
MOV qword ptr [R12 + 0x48],0x0
MOV dword ptr [R12 + 0x50],EBX
LEA EAX,[RBX + 0x1]
MOV qword ptr [RBP + -0x70],RBX
MOV ECX,EBX
LEA RAX,[RCX + RAX*0x8]
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x40
MOV qword ptr [RBP + -0x68],RAX
MOV RBX,R12
MOV qword ptr [RBP + -0x58],R15
MOV qword ptr [RBP + -0x40],R12
MOV qword ptr [RBP + -0x50],RCX
LAB_00129472:
MOV R13,qword ptr [R15 + 0x20]
CMP R14,0x7
JA 0x00129487
CMP byte ptr [R13],0xfe
JZ 0x0012977f
LAB_00129487:
MOV R12,R15
INC qword ptr [RDX + 0x48]
MOV ESI,0x18
MOV R15,qword ptr [RBP + -0x30]
MOV RDI,R15
CALL 0x0012f423
TEST RAX,RAX
JZ 0x00129710
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x78]
LEA RSI,[RAX + R14*0x1]
MOV RDI,R15
MOV qword ptr [RBP + -0x38],RCX
CALL 0x0012f423
MOV RDX,qword ptr [RBP + -0x38]
MOV qword ptr [RDX + 0x8],RAX
TEST RAX,RAX
JZ 0x00129710
MOV qword ptr [RBX],RDX
MOV RAX,qword ptr [RDX + 0x8]
MOV RCX,qword ptr [RBP + -0x50]
LEA RBX,[RAX + RCX*0x8]
ADD RBX,0x8
CMP dword ptr [RBP + -0x70],0x0
JZ 0x001295f3
LEA RAX,[RAX + RCX*0x8]
ADD RAX,RCX
ADD RAX,0x8
LEA R8,[R14 + RAX*0x1]
DEC R8
MOV R15,qword ptr [RBP + -0x68]
XOR R12D,R12D
MOV RDI,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x48],R8
LAB_0012950e:
MOVZX R14D,byte ptr [R13]
CMP R14,0xfa
JA 0x00129573
INC R13
LAB_0012951f:
MOV RAX,qword ptr [RDX + 0x8]
MOV qword ptr [RAX + R12*0x8],RBX
MOV RAX,R8
SUB RAX,RBX
CMP R14,RAX
JA 0x00129641
CMP RBX,R8
JA 0x00129641
MOV RDI,RBX
MOV RSI,R13
MOV RDX,R14
CALL 0x001143a0
ADD R13,R14
ADD RBX,R14
INC RBX
MOV byte ptr [RBX + -0x1],0x0
CMP qword ptr [RBP + -0x60],0x0
JZ 0x00129599
CMP qword ptr [R15],R14
MOV RCX,qword ptr [RBP + -0x50]
JNC 0x0012956d
MOV qword ptr [R15],R14
LAB_0012956d:
MOV RDI,qword ptr [RBP + -0x30]
JMP 0x001295a1
LAB_00129573:
CMP R14,0xfb
JZ 0x001295d5
CMP R14D,0xfd
JZ 0x001295bb
CMP R14D,0xfc
JNZ 0x001295e6
MOVZX R14D,word ptr [R13 + 0x1]
ADD R13,0x3
JMP 0x0012951f
LAB_00129599:
MOV RDI,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x50]
LAB_001295a1:
MOV RDX,qword ptr [RBP + -0x38]
MOV R8,qword ptr [RBP + -0x48]
LAB_001295a9:
INC R12
SUB R15,-0x80
CMP RCX,R12
JNZ 0x0012950e
JMP 0x001295fa
LAB_001295bb:
MOVZX EAX,word ptr [R13 + 0x1]
MOVZX R14D,byte ptr [R13 + 0x3]
ADD R13,0x4
SHL R14D,0x10
OR R14,RAX
JMP 0x0012951f
LAB_001295d5:
INC R13
MOV RAX,qword ptr [RDX + 0x8]
MOV qword ptr [RAX + R12*0x8],0x0
JMP 0x001295a9
LAB_001295e6:
MOV R14D,dword ptr [R13 + 0x1]
ADD R13,0x9
JMP 0x0012951f
LAB_001295f3:
XOR ECX,ECX
MOV R15,R12
JMP 0x00129602
LAB_001295fa:
MOV RAX,qword ptr [RDX + 0x8]
MOV R15,qword ptr [RBP + -0x58]
LAB_00129602:
MOV R12,RDX
MOV qword ptr [RAX + RCX*0x8],RBX
MOV RDI,R15
CALL 0x00126beb
MOV R14,RAX
MOV RBX,R12
MOV EAX,0xffffffff
CMP R14,RAX
MOV RDX,qword ptr [RBP + -0x40]
JNZ 0x00129472
MOV RBX,RDX
MOV RDI,qword ptr [RBP + -0x30]
XOR ESI,ESI
CALL 0x0012f53b
MOV RDI,RBX
CALL 0x00114590
JMP 0x001296a6
LAB_00129641:
XOR EBX,EBX
XOR ESI,ESI
CALL 0x0012f53b
MOV RDI,qword ptr [RBP + -0x40]
CALL 0x00114590
MOV R14,qword ptr [RBP + -0x58]
MOV dword ptr [R14 + 0x90],0x7d0
LEA RDI,[R14 + 0x297]
LEA RAX,[0x1629f0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00114230
MOV byte ptr [R14 + 0x29c],BL
LEA RDI,[R14 + 0x97]
LEA RAX,[0x162a00]
MOV RSI,qword ptr [RAX]
MOV EDX,0x1ff
CALL 0x00114230
MOV byte ptr [R14 + 0x296],BL
LAB_001296a6:
XOR EDX,EDX
LAB_001296a8:
MOV RAX,RDX
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001296ba:
MOV dword ptr [R15 + 0x90],0x7d8
LEA RDI,[R15 + 0x297]
LEA RAX,[0x1629f0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00114230
XOR EAX,EAX
MOV byte ptr [R15 + 0x29c],AL
LEA RDI,[R15 + 0x97]
LEA RAX,[0x162a00]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00114230
XOR EDX,EDX
MOV byte ptr [R15 + 0x296],DL
JMP 0x001296a8
LAB_00129710:
XOR EBX,EBX
MOV RDI,R15
XOR ESI,ESI
CALL 0x0012f53b
MOV RDI,qword ptr [RBP + -0x40]
CALL 0x00114590
MOV dword ptr [R12 + 0x90],0x7d8
LEA RDI,[R12 + 0x297]
LEA RAX,[0x1629f0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00114230
MOV byte ptr [R12 + 0x29c],BL
LEA RDI,[R12 + 0x97]
LEA RAX,[0x162a00]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00114230
MOV byte ptr [R12 + 0x296],BL
JMP 0x001296a6
LAB_0012977f:
MOV qword ptr [RBX],0x0
CMP R14,0x2
JC 0x001296a8
MOVZX EAX,word ptr [R13 + 0x1]
MOV dword ptr [R15 + 0x388],EAX
MOVZX EAX,word ptr [R13 + 0x3]
MOV dword ptr [R15 + 0x380],EAX
JMP 0x001296a8
|
int8 * mthd_my_read_rows(long param_1,long param_2,uint param_3)
{
byte bVar1;
ulong uVar2;
int8 *__ptr;
int8 *puVar3;
long lVar4;
ulong uVar5;
int8 *puVar6;
int1 *__dest;
int1 *puVar7;
int8 *puVar8;
int1 *puVar9;
byte *__src;
byte *pbVar10;
ulong __n;
ulong *puVar11;
uVar2 = ma_net_safe_read();
if (uVar2 != 0xffffffff) {
__ptr = (int8 *)calloc(1,0x60);
if (__ptr == (int8 *)0x0) {
*(int4 *)(param_1 + 0x90) = 0x7d8;
strncpy((char *)(param_1 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x29c) = 0;
strncpy((char *)(param_1 + 0x97),PTR_s_Client_run_out_of_memory_00162a40,0x1ff);
*(int1 *)(param_1 + 0x296) = 0;
return (int8 *)0x0;
}
puVar8 = __ptr + 2;
ma_init_alloc_root(puVar8,0x2000,0);
__ptr[5] = 0x18;
__ptr[9] = 0;
*(uint *)(__ptr + 10) = param_3;
uVar5 = (ulong)param_3;
puVar6 = __ptr;
do {
pbVar10 = *(byte **)(param_1 + 0x20);
if ((uVar2 < 8) && (*pbVar10 == 0xfe)) {
*puVar6 = 0;
if (1 < uVar2) {
*(uint *)(param_1 + 0x388) = (uint)*(ushort *)(pbVar10 + 1);
*(uint *)(param_1 + 0x380) = (uint)*(ushort *)(pbVar10 + 3);
return __ptr;
}
return __ptr;
}
__ptr[9] = __ptr[9] + 1;
puVar3 = (int8 *)ma_alloc_root(puVar8,0x18);
if (puVar3 == (int8 *)0x0) {
LAB_00129710:
ma_free_root(puVar8,0);
free(__ptr);
*(int4 *)(param_1 + 0x90) = 0x7d8;
strncpy((char *)(param_1 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x29c) = 0;
strncpy((char *)(param_1 + 0x97),PTR_s_Client_run_out_of_memory_00162a40,0x1ff);
*(int1 *)(param_1 + 0x296) = 0;
return (int8 *)0x0;
}
lVar4 = ma_alloc_root(puVar8,uVar5 + (ulong)(param_3 + 1) * 8 + uVar2);
puVar3[1] = lVar4;
if (lVar4 == 0) goto LAB_00129710;
*puVar6 = puVar3;
lVar4 = puVar3[1];
__dest = (int1 *)(lVar4 + uVar5 * 8 + 8);
if (param_3 == 0) {
uVar2 = 0;
}
else {
puVar9 = (int1 *)(uVar2 + lVar4 + uVar5 * 9 + 7);
uVar2 = 0;
puVar11 = (ulong *)(param_2 + 0x40);
do {
bVar1 = *pbVar10;
__n = (ulong)bVar1;
if (__n < 0xfb) {
__src = pbVar10 + 1;
LAB_0012951f:
*(int1 **)(puVar3[1] + uVar2 * 8) = __dest;
if (((ulong)((long)puVar9 - (long)__dest) < __n) || (puVar9 < __dest)) {
ma_free_root(puVar8,0);
free(__ptr);
*(int4 *)(param_1 + 0x90) = 2000;
strncpy((char *)(param_1 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x29c) = 0;
strncpy((char *)(param_1 + 0x97),client_errors,0x1ff);
*(int1 *)(param_1 + 0x296) = 0;
return (int8 *)0x0;
}
memcpy(__dest,__src,__n);
pbVar10 = __src + __n;
puVar7 = __dest + __n;
__dest = puVar7 + 1;
*puVar7 = 0;
if ((param_2 != 0) && (*puVar11 < __n)) {
*puVar11 = __n;
}
}
else {
if (__n != 0xfb) {
if (bVar1 == 0xfd) {
__src = pbVar10 + 4;
__n = (ulong)*(uint3 *)(pbVar10 + 1);
}
else if (bVar1 == 0xfc) {
__n = (ulong)*(ushort *)(pbVar10 + 1);
__src = pbVar10 + 3;
}
else {
__n = (ulong)*(uint *)(pbVar10 + 1);
__src = pbVar10 + 9;
}
goto LAB_0012951f;
}
pbVar10 = pbVar10 + 1;
*(int8 *)(puVar3[1] + uVar2 * 8) = 0;
}
uVar2 = uVar2 + 1;
puVar11 = puVar11 + 0x10;
} while (uVar5 != uVar2);
lVar4 = puVar3[1];
uVar2 = uVar5;
}
*(int1 **)(lVar4 + uVar2 * 8) = __dest;
uVar2 = ma_net_safe_read(param_1);
puVar6 = puVar3;
} while (uVar2 != 0xffffffff);
ma_free_root(puVar8,0);
free(__ptr);
}
return (int8 *)0x0;
}
|
|
18,465
|
fini_one_value
|
eloqsql/mysys/my_getopt.c
|
static void fini_one_value(const struct my_option *option, void *variable,
longlong value __attribute__ ((unused)))
{
DBUG_ENTER("fini_one_value");
switch ((option->var_type & GET_TYPE_MASK)) {
case GET_STR_ALLOC:
my_free(*((char**) variable));
*((char**) variable)= NULL;
break;
default: /* dummy default to avoid compiler warnings */
break;
}
DBUG_VOID_RETURN;
}
|
O0
|
c
|
fini_one_value:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
andl $0x3f, %eax
subl $0xa, %eax
jne 0x7a5be
jmp 0x7a5a5
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x7cd70
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
jmp 0x7a5c0
jmp 0x7a5c0
jmp 0x7a5c2
jmp 0x7a5c4
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
fini_one_value:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov eax, [rax+30h]
and eax, 3Fh
sub eax, 0Ah
jnz short loc_7A5BE
jmp short $+2
loc_7A5A5:
mov rax, [rbp+var_10]
mov rdi, [rax]
call my_free
mov rax, [rbp+var_10]
mov qword ptr [rax], 0
jmp short loc_7A5C0
loc_7A5BE:
jmp short $+2
loc_7A5C0:
jmp short $+2
loc_7A5C2:
jmp short $+2
loc_7A5C4:
add rsp, 20h
pop rbp
retn
|
_QWORD * fini_one_value(long long a1, _QWORD *a2)
{
_QWORD *result; // rax
result = (_QWORD *)((*(_DWORD *)(a1 + 48) & 0x3Fu) - 10);
if ( (*(_DWORD *)(a1 + 48) & 0x3F) == 0xA )
{
my_free(*a2);
result = a2;
*a2 = 0LL;
}
return result;
}
|
fini_one_value:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x30]
AND EAX,0x3f
SUB EAX,0xa
JNZ 0x0017a5be
JMP 0x0017a5a5
LAB_0017a5a5:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
CALL 0x0017cd70
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],0x0
JMP 0x0017a5c0
LAB_0017a5be:
JMP 0x0017a5c0
LAB_0017a5c0:
JMP 0x0017a5c2
LAB_0017a5c2:
JMP 0x0017a5c4
LAB_0017a5c4:
ADD RSP,0x20
POP RBP
RET
|
void fini_one_value(long param_1,int8 *param_2)
{
if ((*(uint *)(param_1 + 0x30) & 0x3f) == 10) {
my_free(*param_2);
*param_2 = 0;
}
return;
}
|
|
18,466
|
fct_update_rwlock_derived_flags(PFS_rwlock*)
|
eloqsql/storage/perfschema/pfs_instr.cc
|
static void fct_update_rwlock_derived_flags(PFS_rwlock *pfs)
{
PFS_rwlock_class *klass= sanitize_rwlock_class(pfs->m_class);
if (likely(klass != NULL))
{
pfs->m_enabled= klass->m_enabled && flag_global_instrumentation;
pfs->m_timed= klass->m_timed;
}
else
{
pfs->m_enabled= false;
pfs->m_timed= false;
}
}
|
O0
|
cpp
|
fct_update_rwlock_derived_flags(PFS_rwlock*):
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x4e330
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x464aa
movq -0x10(%rbp), %rcx
xorl %eax, %eax
testb $0x1, 0x4(%rcx)
movb %al, -0x11(%rbp)
je 0x4648a
leaq 0x3c557b(%rip), %rax # 0x40ba00
movb (%rax), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x4(%rax)
movq -0x10(%rbp), %rax
movb 0x5(%rax), %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x5(%rax)
jmp 0x464ba
movq -0x8(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x5(%rax)
addq $0x20, %rsp
popq %rbp
retq
|
_ZL31fct_update_rwlock_derived_flagsP10PFS_rwlock:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rdi, [rax+18h]
call _Z21sanitize_rwlock_classP16PFS_rwlock_class; sanitize_rwlock_class(PFS_rwlock_class *)
mov [rbp+var_10], rax
cmp [rbp+var_10], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_464AA
mov rcx, [rbp+var_10]
xor eax, eax
test byte ptr [rcx+4], 1
mov [rbp+var_11], al
jz short loc_4648A
lea rax, flag_global_instrumentation
mov al, [rax]
mov [rbp+var_11], al
loc_4648A:
mov cl, [rbp+var_11]
mov rax, [rbp+var_8]
and cl, 1
mov [rax+4], cl
mov rax, [rbp+var_10]
mov cl, [rax+5]
mov rax, [rbp+var_8]
and cl, 1
mov [rax+5], cl
jmp short loc_464BA
loc_464AA:
mov rax, [rbp+var_8]
mov byte ptr [rax+4], 0
mov rax, [rbp+var_8]
mov byte ptr [rax+5], 0
loc_464BA:
add rsp, 20h
pop rbp
retn
|
long long fct_update_rwlock_derived_flags(long long a1)
{
long long result; // rax
char v2; // [rsp+Fh] [rbp-11h]
long long v3; // [rsp+10h] [rbp-10h]
v3 = sanitize_rwlock_class(*(PFS_rwlock_class **)(a1 + 24));
if ( v3 )
{
v2 = 0;
if ( (*(_BYTE *)(v3 + 4) & 1) != 0 )
v2 = flag_global_instrumentation;
*(_BYTE *)(a1 + 4) = v2 & 1;
result = a1;
*(_BYTE *)(a1 + 5) = *(_BYTE *)(v3 + 5) & 1;
}
else
{
*(_BYTE *)(a1 + 4) = 0;
result = a1;
*(_BYTE *)(a1 + 5) = 0;
}
return result;
}
|
fct_update_rwlock_derived_flags:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x18]
CALL 0x0014e330
MOV qword ptr [RBP + -0x10],RAX
CMP qword ptr [RBP + -0x10],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x001464aa
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
TEST byte ptr [RCX + 0x4],0x1
MOV byte ptr [RBP + -0x11],AL
JZ 0x0014648a
LEA RAX,[0x50ba00]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x11],AL
LAB_0014648a:
MOV CL,byte ptr [RBP + -0x11]
MOV RAX,qword ptr [RBP + -0x8]
AND CL,0x1
MOV byte ptr [RAX + 0x4],CL
MOV RAX,qword ptr [RBP + -0x10]
MOV CL,byte ptr [RAX + 0x5]
MOV RAX,qword ptr [RBP + -0x8]
AND CL,0x1
MOV byte ptr [RAX + 0x5],CL
JMP 0x001464ba
LAB_001464aa:
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x4],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x5],0x0
LAB_001464ba:
ADD RSP,0x20
POP RBP
RET
|
/* fct_update_rwlock_derived_flags(PFS_rwlock*) */
void fct_update_rwlock_derived_flags(PFS_rwlock *param_1)
{
long lVar1;
byte local_19;
lVar1 = sanitize_rwlock_class(*(PFS_rwlock_class **)(param_1 + 0x18));
if (lVar1 == 0) {
param_1[4] = (PFS_rwlock)0x0;
param_1[5] = (PFS_rwlock)0x0;
}
else {
local_19 = 0;
if ((*(byte *)(lVar1 + 4) & 1) != 0) {
local_19 = flag_global_instrumentation;
}
param_1[4] = (PFS_rwlock)(local_19 & 1);
param_1[5] = (PFS_rwlock)(*(byte *)(lVar1 + 5) & 1);
}
return;
}
|
|
18,467
|
init_extent
|
eloqsql/storage/maria/ma_blockrec.c
|
static void init_extent(MARIA_EXTENT_CURSOR *extent, uchar *extent_info,
uint extents, MARIA_RECORD_POS *tail_positions)
{
uint page_count;
extent->extent= extent_info;
extent->extent_count= extents;
extent->page= page_korr(extent_info); /* First extent */
page_count= (uint2korr(extent_info + ROW_EXTENT_PAGE_SIZE) &
~START_EXTENT_BIT);
extent->tail= page_count & TAIL_BIT;
if (extent->tail)
{
extent->page_count= 1;
extent->tail_row_nr= page_count & ~TAIL_BIT;
}
else
extent->page_count= page_count;
extent->tail_positions= tail_positions;
extent->lock_for_tail_pages= PAGECACHE_LOCK_LEFT_UNLOCKED;
}
|
O0
|
c
|
init_extent:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rdi
callq 0x79610
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movzwl 0x5(%rax), %eax
andl $0xffffbfff, %eax # imm = 0xFFFFBFFF
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
andl $0x8000, %ecx # imm = 0x8000
movq -0x8(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
je 0x77747
movq -0x8(%rbp), %rax
movl $0x1, 0x20(%rax)
movl -0x24(%rbp), %ecx
andl $0xffff7fff, %ecx # imm = 0xFFFF7FFF
movq -0x8(%rbp), %rax
movl %ecx, 0x30(%rax)
jmp 0x77751
movl -0x24(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x24(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
|
init_extent:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
mov rcx, [rbp+var_10]
mov rax, [rbp+var_8]
mov [rax], rcx
mov ecx, [rbp+var_14]
mov rax, [rbp+var_8]
mov [rax+28h], ecx
mov rdi, [rbp+var_10]
call uint5korr_1
mov rcx, rax
mov rax, [rbp+var_8]
mov [rax+18h], rcx
mov rax, [rbp+var_10]
movzx eax, word ptr [rax+5]
and eax, 0FFFFBFFFh
mov [rbp+var_24], eax
mov ecx, [rbp+var_24]
and ecx, 8000h
mov rax, [rbp+var_8]
mov [rax+2Ch], ecx
mov rax, [rbp+var_8]
cmp dword ptr [rax+2Ch], 0
jz short loc_77747
mov rax, [rbp+var_8]
mov dword ptr [rax+20h], 1
mov ecx, [rbp+var_24]
and ecx, 0FFFF7FFFh
mov rax, [rbp+var_8]
mov [rax+30h], ecx
jmp short loc_77751
loc_77747:
mov ecx, [rbp+var_24]
mov rax, [rbp+var_8]
mov [rax+20h], ecx
loc_77751:
mov rcx, [rbp+var_20]
mov rax, [rbp+var_8]
mov [rax+10h], rcx
mov rax, [rbp+var_8]
mov dword ptr [rax+24h], 0
add rsp, 30h
pop rbp
retn
|
long long init_extent(long long a1, long long a2, int a3, long long a4)
{
long long result; // rax
int v5; // [rsp+Ch] [rbp-24h]
*(_QWORD *)a1 = a2;
*(_DWORD *)(a1 + 40) = a3;
*(_QWORD *)(a1 + 24) = uint5korr_1(a2);
v5 = *(_WORD *)(a2 + 5) & 0xBFFF;
*(_DWORD *)(a1 + 44) = *(_WORD *)(a2 + 5) & 0x8000;
if ( *(_DWORD *)(a1 + 44) )
{
*(_DWORD *)(a1 + 32) = 1;
*(_DWORD *)(a1 + 48) = v5 & 0xFFFF7FFF;
}
else
{
*(_DWORD *)(a1 + 32) = v5;
}
*(_QWORD *)(a1 + 16) = a4;
result = a1;
*(_DWORD *)(a1 + 36) = 0;
return result;
}
|
init_extent:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],RCX
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x28],ECX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00179610
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,word ptr [RAX + 0x5]
AND EAX,0xffffbfff
MOV dword ptr [RBP + -0x24],EAX
MOV ECX,dword ptr [RBP + -0x24]
AND ECX,0x8000
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x2c],ECX
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x2c],0x0
JZ 0x00177747
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x20],0x1
MOV ECX,dword ptr [RBP + -0x24]
AND ECX,0xffff7fff
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x30],ECX
JMP 0x00177751
LAB_00177747:
MOV ECX,dword ptr [RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x20],ECX
LAB_00177751:
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x24],0x0
ADD RSP,0x30
POP RBP
RET
|
void init_extent(long *param_1,long param_2,int4 param_3,long param_4)
{
uint uVar1;
long lVar2;
*param_1 = param_2;
*(int4 *)(param_1 + 5) = param_3;
lVar2 = uint5korr(param_2);
param_1[3] = lVar2;
uVar1 = (uint)*(ushort *)(param_2 + 5);
*(uint *)((long)param_1 + 0x2c) = uVar1 & 0x8000;
if (*(int *)((long)param_1 + 0x2c) == 0) {
*(uint *)(param_1 + 4) = uVar1 & 0xffffbfff;
}
else {
*(int4 *)(param_1 + 4) = 1;
*(uint *)(param_1 + 6) = uVar1 & 0xffff3fff;
}
param_1[2] = param_4;
*(int4 *)((long)param_1 + 0x24) = 0;
return;
}
|
|
18,468
|
skip
|
eloqsql/unittest/mytap/tap.c
|
void
skip(int how_many, char const * const fmt, ...)
{
char reason[80];
if (fmt && *fmt)
{
va_list ap;
va_start(ap, fmt);
vsnprintf(reason, sizeof(reason), fmt, ap);
va_end(ap);
}
else
reason[0] = '\0';
while (how_many-- > 0)
{
va_list ap;
memset((char*) &ap, 0, sizeof(ap)); /* Keep compiler happy */
vemit_tap(1, NULL, ap);
emit_dir("skip", reason);
emit_endl();
}
}
|
O3
|
c
|
skip:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movl %edi, %ebx
movq %rdx, -0x140(%rbp)
movq %rcx, -0x138(%rbp)
movq %r8, -0x130(%rbp)
movq %r9, -0x128(%rbp)
testb %al, %al
je 0x9144f
movaps %xmm0, -0x120(%rbp)
movaps %xmm1, -0x110(%rbp)
movaps %xmm2, -0x100(%rbp)
movaps %xmm3, -0xf0(%rbp)
movaps %xmm4, -0xe0(%rbp)
movaps %xmm5, -0xd0(%rbp)
movaps %xmm6, -0xc0(%rbp)
movaps %xmm7, -0xb0(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
testq %rsi, %rsi
je 0x914ad
movq %rsi, %r10
cmpb $0x0, (%rsi)
je 0x914ad
leaq -0x150(%rbp), %rax
leaq -0xa0(%rbp), %r9
movq %rax, 0x10(%r9)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%r9)
movabsq $0x3000000010, %rax # imm = 0x3000000010
movq %rax, (%r9)
leaq -0x80(%rbp), %rdi
movl $0x50, %esi
movl $0x50, %ecx
movl $0x1, %edx
movq %r10, %r8
callq 0x29180
jmp 0x914b1
movb $0x0, -0x80(%rbp)
testl %ebx, %ebx
jle 0x91541
incl %ebx
movq 0x2f2ad6(%rip), %r15 # 0x383f98
leaq 0x4a705(%rip), %r12 # 0xdbbce
leaq -0x80(%rbp), %r13
leaq 0x4e5ae(%rip), %r14 # 0xdfa82
xorps %xmm0, %xmm0
movaps %xmm0, -0xa0(%rbp)
movq $0x0, -0x90(%rbp)
movl $0x1, %edi
xorl %esi, %esi
leaq -0xa0(%rbp), %rdx
callq 0x91295
movq (%r15), %rdi
movl $0x1, %esi
leaq 0x4a72f(%rip), %rdx # 0xdbc3a
movq %r12, %rcx
movq %r13, %r8
xorl %eax, %eax
callq 0x291e0
movq (%r15), %rdi
callq 0x293f0
movq (%r15), %rdi
movl $0x1, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x291e0
movq (%r15), %rdi
callq 0x293f0
decl %ebx
cmpl $0x1, %ebx
ja 0x914d4
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x91562
addq $0x128, %rsp # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x29250
|
skip:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 128h
mov ebx, edi
mov [rbp+var_140], rdx
mov [rbp+var_138], rcx
mov [rbp+var_130], r8
mov [rbp+var_128], r9
test al, al
jz short loc_9144F
movaps [rbp+var_120], xmm0
movaps [rbp+var_110], xmm1
movaps [rbp+var_100], xmm2
movaps [rbp+var_F0], xmm3
movaps [rbp+var_E0], xmm4
movaps [rbp+var_D0], xmm5
movaps [rbp+var_C0], xmm6
movaps [rbp+var_B0], xmm7
loc_9144F:
mov rax, fs:28h
mov [rbp+var_30], rax
test rsi, rsi
jz short loc_914AD
mov r10, rsi
cmp byte ptr [rsi], 0
jz short loc_914AD
lea rax, [rbp+var_150]
lea r9, [rbp+var_A0]
mov [r9+10h], rax
lea rax, [rbp+arg_0]
mov [r9+8], rax
mov rax, 3000000010h
mov [r9], rax
lea rdi, [rbp+var_80]
mov esi, 50h ; 'P'
mov ecx, 50h ; 'P'
mov edx, 1
mov r8, r10
call ___vsnprintf_chk
jmp short loc_914B1
loc_914AD:
mov [rbp+var_80], 0
loc_914B1:
test ebx, ebx
jle loc_91541
inc ebx
mov r15, cs:stdout_ptr
lea r12, aSkip; "skip"
lea r13, [rbp+var_80]
lea r14, asc_DFA7F+3; "\n"
loc_914D4:
xorps xmm0, xmm0
movaps [rbp+var_A0], xmm0
mov [rbp+var_90], 0
mov edi, 1
xor esi, esi
lea rdx, [rbp+var_A0]
call vemit_tap
mov rdi, [r15]
mov esi, 1
lea rdx, aSS; " # %s %s"
mov rcx, r12
mov r8, r13
xor eax, eax
call ___fprintf_chk
mov rdi, [r15]
call _fflush
mov rdi, [r15]
mov esi, 1
mov rdx, r14
xor eax, eax
call ___fprintf_chk
mov rdi, [r15]
call _fflush
dec ebx
cmp ebx, 1
ja short loc_914D4
loc_91541:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_91562
add rsp, 128h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_91562:
call ___stack_chk_fail
|
unsigned long long skip(int a1, _BYTE *a2, ...)
{
unsigned int v2; // ebx
va_list va; // [rsp+B0h] [rbp-A0h] BYREF
char v5[80]; // [rsp+D0h] [rbp-80h] BYREF
unsigned long long v6; // [rsp+120h] [rbp-30h]
v6 = __readfsqword(0x28u);
if ( a2 && *a2 )
{
va_start(va, a2);
__vsnprintf_chk(v5, 80LL, 1LL, 80LL, a2, va);
}
else
{
v5[0] = 0;
}
if ( a1 > 0 )
{
v2 = a1 + 1;
do
{
memset(va, 0, sizeof(va));
vemit_tap(1, 0LL, (long long)va);
__fprintf_chk(stdout, 1LL, " # %s %s", "skip", v5);
fflush(stdout);
__fprintf_chk(stdout, 1LL, "\n");
fflush(stdout);
--v2;
}
while ( v2 > 1 );
}
return __readfsqword(0x28u);
}
|
skip:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x128
MOV EBX,EDI
MOV qword ptr [RBP + -0x140],RDX
MOV qword ptr [RBP + -0x138],RCX
MOV qword ptr [RBP + -0x130],R8
MOV qword ptr [RBP + -0x128],R9
TEST AL,AL
JZ 0x0019144f
MOVAPS xmmword ptr [RBP + -0x120],XMM0
MOVAPS xmmword ptr [RBP + -0x110],XMM1
MOVAPS xmmword ptr [RBP + -0x100],XMM2
MOVAPS xmmword ptr [RBP + -0xf0],XMM3
MOVAPS xmmword ptr [RBP + -0xe0],XMM4
MOVAPS xmmword ptr [RBP + -0xd0],XMM5
MOVAPS xmmword ptr [RBP + -0xc0],XMM6
MOVAPS xmmword ptr [RBP + -0xb0],XMM7
LAB_0019144f:
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
TEST RSI,RSI
JZ 0x001914ad
MOV R10,RSI
CMP byte ptr [RSI],0x0
JZ 0x001914ad
LEA RAX,[RBP + -0x150]
LEA R9,[RBP + -0xa0]
MOV qword ptr [R9 + 0x10],RAX
LEA RAX,[RBP + 0x10]
MOV qword ptr [R9 + 0x8],RAX
MOV RAX,0x3000000010
MOV qword ptr [R9],RAX
LEA RDI,[RBP + -0x80]
MOV ESI,0x50
MOV ECX,0x50
MOV EDX,0x1
MOV R8,R10
CALL 0x00129180
JMP 0x001914b1
LAB_001914ad:
MOV byte ptr [RBP + -0x80],0x0
LAB_001914b1:
TEST EBX,EBX
JLE 0x00191541
INC EBX
MOV R15,qword ptr [0x00483f98]
LEA R12,[0x1dbbce]
LEA R13,[RBP + -0x80]
LEA R14,[0x1dfa82]
LAB_001914d4:
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RBP + -0xa0],XMM0
MOV qword ptr [RBP + -0x90],0x0
MOV EDI,0x1
XOR ESI,ESI
LEA RDX,[RBP + -0xa0]
CALL 0x00191295
MOV RDI,qword ptr [R15]
MOV ESI,0x1
LEA RDX,[0x1dbc3a]
MOV RCX,R12
MOV R8,R13
XOR EAX,EAX
CALL 0x001291e0
MOV RDI,qword ptr [R15]
CALL 0x001293f0
MOV RDI,qword ptr [R15]
MOV ESI,0x1
MOV RDX,R14
XOR EAX,EAX
CALL 0x001291e0
MOV RDI,qword ptr [R15]
CALL 0x001293f0
DEC EBX
CMP EBX,0x1
JA 0x001914d4
LAB_00191541:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00191562
ADD RSP,0x128
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00191562:
CALL 0x00129250
|
void skip(int4 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,int param_9,
char *param_10,int8 param_11,int8 param_12,int8 param_13,
int8 param_14)
{
int *puVar1;
char in_AL;
uint uVar2;
long in_FS_OFFSET;
int1 local_158 [16];
int8 local_148;
int8 local_140;
int8 local_138;
int8 local_130;
int4 local_128;
int8 local_118;
int8 local_108;
int8 local_f8;
int8 local_e8;
int8 local_d8;
int8 local_c8;
int8 local_b8;
int8 local_a8;
int1 *puStack_a0;
int1 *local_98;
int1 local_88 [80];
long local_38;
if (in_AL != '\0') {
local_128 = param_1;
local_118 = param_2;
local_108 = param_3;
local_f8 = param_4;
local_e8 = param_5;
local_d8 = param_6;
local_c8 = param_7;
local_b8 = param_8;
}
local_38 = *(long *)(in_FS_OFFSET + 0x28);
local_148 = param_11;
local_140 = param_12;
local_138 = param_13;
local_130 = param_14;
if ((param_10 == (char *)0x0) || (*param_10 == '\0')) {
local_88[0] = 0;
}
else {
local_98 = local_158;
puStack_a0 = &stack0x00000008;
local_a8 = 0x3000000010;
__vsnprintf_chk(local_88,0x50,1,0x50,param_10);
}
puVar1 = PTR_stdout_00483f98;
if (0 < param_9) {
uVar2 = param_9 + 1;
do {
local_a8 = 0;
puStack_a0 = (int1 *)0x0;
local_98 = (int1 *)0x0;
vemit_tap(1,0,&local_a8);
__fprintf_chk(*(int8 *)puVar1,1," # %s %s",&DAT_001dbbce,local_88);
fflush(*(FILE **)puVar1);
__fprintf_chk(*(int8 *)puVar1,1,&DAT_001dfa82);
fflush(*(FILE **)puVar1);
uVar2 = uVar2 - 1;
} while (1 < uVar2);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
18,469
|
ma_get_binary_pack_key
|
eloqsql/storage/maria/ma_search.c
|
uint _ma_get_binary_pack_key(MARIA_KEY *int_key, uint page_flag, uint nod_flag,
register uchar **page_pos)
{
reg1 HA_KEYSEG *keyseg;
uchar *page, *page_end, *from, *from_end, *key;
uint length,tmp;
MARIA_KEYDEF *keyinfo= int_key->keyinfo;
DBUG_ENTER("_ma_get_binary_pack_key");
page= *page_pos;
page_end=page + MARIA_MAX_KEY_BUFF + 1;
key= int_key->data;
/*
Keys are compressed the following way:
prefix length Packed length of prefix common with prev key.
(1 or 3 bytes)
for each key segment:
[is null] Null indicator if can be null (1 byte, zero means null)
[length] Packed length if varlength (1 or 3 bytes)
key segment 'length' bytes of key segment value
pointer Reference to the data file (last_keyseg->length).
get_key_length() is a macro. It gets the prefix length from 'page'
and puts it into 'length'. It increments 'page' by 1 or 3, depending
on the packed length of the prefix length.
*/
get_key_length(length,page);
if (length)
{
if (length > keyinfo->maxlength)
{
DBUG_PRINT("error",
("Found too long binary packed key: %u of %u at %p",
length, keyinfo->maxlength, *page_pos));
DBUG_DUMP("key", *page_pos, 16);
_ma_set_fatal_error_with_share(keyinfo->share, HA_ERR_CRASHED);
DBUG_RETURN(0); /* Wrong key */
}
/* Key is packed against prev key, take prefix from prev key. */
from= key;
from_end= key + length;
}
else
{
/* Key is not packed against prev key, take all from page buffer. */
from= page;
from_end= page_end;
}
/*
The trouble is that key can be split in two parts:
The first part (prefix) is in from .. from_end - 1.
The second part starts at page.
The split can be at every byte position. So we need to check for
the end of the first part before using every byte.
*/
for (keyseg=keyinfo->seg ; keyseg->type ;keyseg++)
{
if (keyseg->flag & HA_NULL_PART)
{
/* If prefix is used up, switch to rest. */
if (from == from_end)
{
from=page;
from_end=page_end;
}
if (!(*key++ = *from++))
continue; /* Null part */
}
if (keyseg->flag & (HA_VAR_LENGTH_PART | HA_BLOB_PART | HA_SPACE_PACK))
{
/* If prefix is used up, switch to rest. */
if (from == from_end) { from=page; from_end=page_end; }
/* Get length of dynamic length key part */
if ((length= (uint) (uchar) (*key++ = *from++)) == 255)
{
/* If prefix is used up, switch to rest. */
if (from == from_end) { from=page; from_end=page_end; }
length= ((uint) (uchar) ((*key++ = *from++))) << 8;
/* If prefix is used up, switch to rest. */
if (from == from_end) { from=page; from_end=page_end; }
length+= (uint) (uchar) ((*key++ = *from++));
}
}
else
length=keyseg->length;
if ((tmp=(uint) (from_end-from)) <= length)
{
key+=tmp; /* Use old key */
length-=tmp;
from=page; from_end=page_end;
}
DBUG_ASSERT((int) length >= 0);
DBUG_PRINT("info",("key: %p from: %p length: %u",
key, from, length));
memmove(key, from, (size_t) length);
key+=length;
from+=length;
}
/*
Last segment (type == 0) contains length of data pointer.
If we have mixed key blocks with data pointer and key block pointer,
we have to copy both.
*/
int_key->data_length= (uint)(key - int_key->data);
int_key->ref_length= length= keyseg->length;
int_key->flag= 0;
if ((tmp=(uint) (from_end-from)) <= length)
{
/* Skip over the last common part of the data */
key+= tmp;
length-= tmp;
from= page;
}
else
{
/*
Remaining length is greater than max possible length.
This can happen only if we switched to the new key bytes already.
'page_end' is calculated with MARIA_MAX_KEY_BUFF. So it can be far
behind the real end of the key.
*/
if (from_end != page_end)
{
DBUG_PRINT("error",("Error when unpacking key"));
_ma_set_fatal_error_with_share(keyinfo->share, HA_ERR_CRASHED);
DBUG_RETURN(0); /* Error */
}
}
if (page_flag & KEYPAGE_FLAG_HAS_TRANSID)
{
uchar *end= from + length;
if (key_has_transid(end-1))
{
uint trans_length= transid_packed_length(end);
length+= trans_length;
int_key->ref_length+= trans_length;
int_key->flag= SEARCH_PAGE_KEY_HAS_TRANSID;
}
}
/* Copy rest of data ptr and, if appropriate, trans_id and node_ptr */
memcpy(key, from, length + nod_flag);
*page_pos= from + length + nod_flag;
#ifdef USEFUL_FOR_DEBUGGING
DBUG_DUMP("key", int_key->data,
(uint) (int_key->data_length + int_key->ref_length));
#endif
DBUG_RETURN(int_key->data_length + int_key->ref_length);
}
|
O3
|
c
|
ma_get_binary_pack_key:
movq (%rcx), %r8
movzbl (%r8), %eax
cmpl $0xff, %eax
je 0x578c6
movl $0x1, %r9d
jmp 0x578d8
movzwl 0x1(%r8), %eax
rolw $0x8, %ax
movzwl %ax, %eax
movl $0x3, %r9d
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq (%rdi), %r13
movq 0x8(%rdi), %r10
leaq 0x9d4(%r8), %r11
addq %r8, %r9
movq %r9, %r12
movq %r11, %r14
testl %eax, %eax
je 0x57922
movzwl 0xae(%r10), %r8d
cmpl %r8d, %eax
jbe 0x57919
movq (%r10), %rdi
jmp 0x57a94
movl %eax, %r14d
addq %r13, %r14
movq %r13, %r12
movl %esi, -0x34(%rbp)
movq %rdx, -0x48(%rbp)
movq %rcx, -0x50(%rbp)
movq %rdi, -0x30(%rbp)
movq %r10, -0x40(%rbp)
movq 0xc0(%r10), %rbx
cmpb $0x0, 0x18(%rbx)
je 0x57a5a
movq %r9, -0x60(%rbp)
movq %r11, -0x58(%rbp)
movzwl 0x12(%rbx), %eax
testb $0x10, %al
jne 0x5795b
movq %r14, %rcx
jmp 0x57987
movq %r9, %rax
movq %r11, %rcx
cmpq %r14, %r12
je 0x5796c
movq %r12, %rax
movq %r14, %rcx
movb (%rax), %dl
movq %rax, %r12
incq %r12
movb %dl, (%r13)
incq %r13
testb %dl, %dl
je 0x57a4c
movzwl 0x12(%rbx), %eax
testb $0x29, %al
je 0x579b5
movq %r9, %rdx
movq %r11, %r14
cmpq %rcx, %r12
je 0x5799c
movq %r12, %rdx
movq %rcx, %r14
movzbl (%rdx), %eax
movq %rdx, %r12
incq %r12
movb %al, (%r13)
cmpl $0xff, %eax
je 0x579be
incq %r13
jmp 0x579ff
movzwl 0x14(%rbx), %eax
movq %rcx, %r14
jmp 0x579ff
movq %r9, %rcx
movq %r11, %rdx
cmpq %r14, %r12
je 0x579cf
movq %r12, %rcx
movq %r14, %rdx
movzbl (%rcx), %eax
incq %rcx
movb %al, 0x1(%r13)
movq %r9, %r12
movq %r11, %r14
cmpq %rdx, %rcx
je 0x579ea
movq %rcx, %r12
movq %rdx, %r14
shll $0x8, %eax
movzbl (%r12), %ecx
incq %r12
movb %cl, 0x2(%r13)
addq $0x3, %r13
orl %ecx, %eax
movq %r14, %rdx
subq %r12, %rdx
movl %eax, %ecx
subl %edx, %ecx
jae 0x57a0f
movl %eax, %ecx
jmp 0x57a1a
movl %edx, %eax
addq %rax, %r13
movq %r9, %r12
movq %r11, %r14
movl %ecx, %r15d
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x29120
addq %r15, %r13
addq %r15, %r12
movq -0x60(%rbp), %r9
movq -0x58(%rbp), %r11
leaq 0x20(%rbx), %rax
cmpb $0x0, 0x38(%rbx)
movq %rax, %rbx
jne 0x5794e
jmp 0x57a51
movq %rcx, %r14
jmp 0x57a39
movq -0x30(%rbp), %rsi
movq (%rsi), %rcx
jmp 0x57a64
movq %r13, %rcx
movq %rbx, %rax
movq -0x30(%rbp), %rsi
movl %r13d, %edx
subl %ecx, %edx
movl %edx, 0x10(%rsi)
movzwl 0x14(%rax), %eax
movl %eax, 0x14(%rsi)
movl $0x0, 0x18(%rsi)
movq %r14, %rcx
subq %r12, %rcx
movl %eax, %ebx
subl %ecx, %ebx
jae 0x57aa2
movl %eax, %ebx
cmpq %r11, %r14
je 0x57aaa
movq -0x40(%rbp), %rax
movq (%rax), %rdi
movl $0x7e, %esi
callq 0x36a5a
xorl %eax, %eax
jmp 0x57b14
movl %ecx, %ecx
addq %rcx, %r13
movq %r9, %r12
testb $0x2, -0x34(%rbp)
je 0x57ae5
movl %ebx, %ecx
testb $0x1, -0x1(%r12,%rcx)
je 0x57ae5
movzbl (%r12,%rcx), %ecx
leal -0xf8(%rcx), %edx
cmpl $0xf3, %ecx
movl $0x1, %ecx
cmovael %edx, %ecx
addl %ecx, %ebx
addl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x14(%rax)
movl $0x100000, 0x18(%rax) # imm = 0x100000
movq -0x48(%rbp), %r14
leal (%rbx,%r14), %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x29080
movl %ebx, %eax
movl %r14d, %ecx
addq %r12, %rcx
addq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movl 0x14(%rcx), %eax
addl 0x10(%rcx), %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ma_get_binary_pack_key:
mov r8, [rcx]
movzx eax, byte ptr [r8]
cmp eax, 0FFh
jz short loc_578C6
mov r9d, 1
jmp short loc_578D8
loc_578C6:
movzx eax, word ptr [r8+1]
rol ax, 8
movzx eax, ax
mov r9d, 3
loc_578D8:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r13, [rdi]
mov r10, [rdi+8]
lea r11, [r8+9D4h]
add r9, r8
mov r12, r9
mov r14, r11
test eax, eax
jz short loc_57922
movzx r8d, word ptr [r10+0AEh]
cmp eax, r8d
jbe short loc_57919
mov rdi, [r10]
jmp loc_57A94
loc_57919:
mov r14d, eax
add r14, r13
mov r12, r13
loc_57922:
mov [rbp-34h], esi
mov [rbp-48h], rdx
mov [rbp-50h], rcx
mov [rbp-30h], rdi
mov [rbp-40h], r10
mov rbx, [r10+0C0h]
cmp byte ptr [rbx+18h], 0
jz loc_57A5A
mov [rbp-60h], r9
mov [rbp-58h], r11
loc_5794E:
movzx eax, word ptr [rbx+12h]
test al, 10h
jnz short loc_5795B
mov rcx, r14
jmp short loc_57987
loc_5795B:
mov rax, r9
mov rcx, r11
cmp r12, r14
jz short loc_5796C
mov rax, r12
mov rcx, r14
loc_5796C:
mov dl, [rax]
mov r12, rax
inc r12
mov [r13+0], dl
inc r13
test dl, dl
jz loc_57A4C
movzx eax, word ptr [rbx+12h]
loc_57987:
test al, 29h
jz short loc_579B5
mov rdx, r9
mov r14, r11
cmp r12, rcx
jz short loc_5799C
mov rdx, r12
mov r14, rcx
loc_5799C:
movzx eax, byte ptr [rdx]
mov r12, rdx
inc r12
mov [r13+0], al
cmp eax, 0FFh
jz short loc_579BE
inc r13
jmp short loc_579FF
loc_579B5:
movzx eax, word ptr [rbx+14h]
mov r14, rcx
jmp short loc_579FF
loc_579BE:
mov rcx, r9
mov rdx, r11
cmp r12, r14
jz short loc_579CF
mov rcx, r12
mov rdx, r14
loc_579CF:
movzx eax, byte ptr [rcx]
inc rcx
mov [r13+1], al
mov r12, r9
mov r14, r11
cmp rcx, rdx
jz short loc_579EA
mov r12, rcx
mov r14, rdx
loc_579EA:
shl eax, 8
movzx ecx, byte ptr [r12]
inc r12
mov [r13+2], cl
add r13, 3
or eax, ecx
loc_579FF:
mov rdx, r14
sub rdx, r12
mov ecx, eax
sub ecx, edx
jnb short loc_57A0F
mov ecx, eax
jmp short loc_57A1A
loc_57A0F:
mov eax, edx
add r13, rax
mov r12, r9
mov r14, r11
loc_57A1A:
mov r15d, ecx
mov rdi, r13
mov rsi, r12
mov rdx, r15
call _memmove
add r13, r15
add r12, r15
mov r9, [rbp-60h]
mov r11, [rbp-58h]
loc_57A39:
lea rax, [rbx+20h]
cmp byte ptr [rbx+38h], 0
mov rbx, rax
jnz loc_5794E
jmp short loc_57A51
loc_57A4C:
mov r14, rcx
jmp short loc_57A39
loc_57A51:
mov rsi, [rbp-30h]
mov rcx, [rsi]
jmp short loc_57A64
loc_57A5A:
mov rcx, r13
mov rax, rbx
mov rsi, [rbp-30h]
loc_57A64:
mov edx, r13d
sub edx, ecx
mov [rsi+10h], edx
movzx eax, word ptr [rax+14h]
mov [rsi+14h], eax
mov dword ptr [rsi+18h], 0
mov rcx, r14
sub rcx, r12
mov ebx, eax
sub ebx, ecx
jnb short loc_57AA2
mov ebx, eax
cmp r14, r11
jz short loc_57AAA
mov rax, [rbp-40h]
mov rdi, [rax]
loc_57A94:
mov esi, 7Eh ; '~'
call _ma_set_fatal_error_with_share
xor eax, eax
jmp short loc_57B14
loc_57AA2:
mov ecx, ecx
add r13, rcx
mov r12, r9
loc_57AAA:
test byte ptr [rbp-34h], 2
jz short loc_57AE5
mov ecx, ebx
test byte ptr [r12+rcx-1], 1
jz short loc_57AE5
movzx ecx, byte ptr [r12+rcx]
lea edx, [rcx-0F8h]
cmp ecx, 0F3h
mov ecx, 1
cmovnb ecx, edx
add ebx, ecx
add ecx, eax
mov rax, [rbp-30h]
mov [rax+14h], ecx
mov dword ptr [rax+18h], offset xmmword_100000
loc_57AE5:
mov r14, [rbp-48h]
lea edx, [rbx+r14]
mov rdi, r13
mov rsi, r12
call _memcpy
mov eax, ebx
mov ecx, r14d
add rcx, r12
add rcx, rax
mov rax, [rbp-50h]
mov [rax], rcx
mov rcx, [rbp-30h]
mov eax, [rcx+14h]
add eax, [rcx+10h]
loc_57B14:
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long ma_get_binary_pack_key(long long a1, char a2, long long a3, long long *a4)
{
long long v4; // r8
unsigned int v5; // eax
long long v6; // r9
unsigned __int8 *v7; // r13
long long v8; // r10
long long v9; // r11
unsigned __int8 *v10; // r9
unsigned __int8 *v11; // r12
unsigned __int8 *v12; // r14
long long v13; // rdi
long long v14; // rbx
__int16 v15; // ax
unsigned __int8 *v16; // rcx
unsigned __int8 *v17; // rax
unsigned __int8 v18; // dl
unsigned __int8 *v19; // rdx
unsigned int v20; // eax
unsigned __int8 *v21; // rcx
unsigned __int8 *v22; // rdx
int v23; // eax
unsigned __int8 *v24; // rcx
unsigned __int8 *v25; // r12
int v26; // ecx
unsigned int v27; // ecx
long long v28; // r15
long long v29; // rax
bool v30; // zf
long long v31; // rsi
unsigned __int8 *v32; // rcx
unsigned int v33; // eax
unsigned int v34; // ebx
unsigned int v36; // ecx
int v37; // edx
bool v38; // cf
int v39; // ecx
unsigned __int8 *v40; // [rsp-68h] [rbp-68h]
long long v41; // [rsp-60h] [rbp-60h]
long long *v42; // [rsp-58h] [rbp-58h]
int v43; // [rsp-50h] [rbp-50h]
long long *v44; // [rsp-48h] [rbp-48h]
v4 = *a4;
v5 = *(unsigned __int8 *)*a4;
if ( v5 == 255 )
{
v5 = (unsigned __int16)__ROL2__(*(_WORD *)(v4 + 1), 8);
v6 = 3LL;
}
else
{
v6 = 1LL;
}
v7 = *(unsigned __int8 **)a1;
v8 = *(_QWORD *)(a1 + 8);
v9 = v4 + 2516;
v10 = (unsigned __int8 *)(v4 + v6);
v11 = v10;
v12 = (unsigned __int8 *)(v4 + 2516);
if ( v5 )
{
v4 = *(unsigned __int16 *)(v8 + 174);
if ( v5 > (unsigned int)v4 )
{
v13 = *(_QWORD *)v8;
LABEL_38:
ma_set_fatal_error_with_share(v13, 126, a3, (long long)a4, v4, (int)v10);
return 0LL;
}
v12 = &v7[v5];
v11 = *(unsigned __int8 **)a1;
}
v43 = a3;
v42 = a4;
v44 = *(long long **)(a1 + 8);
v14 = *(_QWORD *)(v8 + 192);
if ( *(_BYTE *)(v14 + 24) )
{
v40 = v10;
v41 = v9;
while ( 1 )
{
v15 = *(_WORD *)(v14 + 18);
if ( (v15 & 0x10) == 0 )
break;
v17 = v10;
v16 = (unsigned __int8 *)v9;
if ( v11 != v12 )
{
v17 = v11;
v16 = v12;
}
v18 = *v17;
v11 = v17 + 1;
*v7++ = *v17;
if ( v18 )
{
v15 = *(_WORD *)(v14 + 18);
goto LABEL_16;
}
v12 = v16;
LABEL_31:
v29 = v14 + 32;
v30 = *(_BYTE *)(v14 + 56) == 0;
v14 += 32LL;
if ( v30 )
{
v31 = a1;
v32 = *(unsigned __int8 **)a1;
goto LABEL_35;
}
}
v16 = v12;
LABEL_16:
if ( (v15 & 0x29) != 0 )
{
v19 = v10;
v12 = (unsigned __int8 *)v9;
if ( v11 != v16 )
{
v19 = v11;
v12 = v16;
}
v20 = *v19;
v11 = v19 + 1;
*v7 = v20;
if ( v20 == 255 )
{
v21 = v10;
v22 = (unsigned __int8 *)v9;
if ( v11 != v12 )
{
v21 = v11;
v22 = v12;
}
v23 = *v21;
v24 = v21 + 1;
v7[1] = v23;
v25 = v10;
v12 = (unsigned __int8 *)v9;
if ( v24 != v22 )
{
v25 = v24;
v12 = v22;
}
v26 = *v25;
v11 = v25 + 1;
v7[2] = v26;
v7 += 3;
v20 = v26 | (v23 << 8);
}
else
{
++v7;
}
}
else
{
v20 = *(unsigned __int16 *)(v14 + 20);
v12 = v16;
}
v27 = v20 - ((_DWORD)v12 - (_DWORD)v11);
if ( v20 >= (int)v12 - (int)v11 )
{
v7 += (unsigned int)((_DWORD)v12 - (_DWORD)v11);
v11 = v10;
v12 = (unsigned __int8 *)v9;
}
else
{
v27 = v20;
}
v28 = v27;
memmove(v7, v11, v27);
v7 += v28;
v11 += v28;
v10 = v40;
v9 = v41;
goto LABEL_31;
}
LODWORD(v32) = *(_QWORD *)a1;
v29 = *(_QWORD *)(v8 + 192);
v31 = a1;
LABEL_35:
a3 = (unsigned int)((_DWORD)v7 - (_DWORD)v32);
*(_DWORD *)(v31 + 16) = a3;
v33 = *(unsigned __int16 *)(v29 + 20);
*(_QWORD *)(v31 + 20) = v33;
a4 = (long long *)(v12 - v11);
v34 = v33 - ((_DWORD)v12 - (_DWORD)v11);
if ( v33 >= (int)v12 - (int)v11 )
{
v7 += (unsigned int)a4;
v11 = v10;
}
else
{
v34 = v33;
if ( v12 != (unsigned __int8 *)v9 )
{
v13 = *v44;
goto LABEL_38;
}
}
if ( (a2 & 2) != 0 && (v11[v34 - 1] & 1) != 0 )
{
v36 = v11[v34];
v37 = v36 - 248;
v38 = v36 < 0xF3;
v39 = 1;
if ( !v38 )
v39 = v37;
v34 += v39;
*(_DWORD *)(a1 + 20) = v33 + v39;
*(_DWORD *)(a1 + 24) = (_DWORD)&xmmword_100000;
}
memcpy(v7, v11, v34 + v43);
*v42 = (long long)&v11[v43 + v34];
return (unsigned int)(*(_DWORD *)(a1 + 16) + *(_DWORD *)(a1 + 20));
}
|
_ma_get_binary_pack_key:
MOV R8,qword ptr [RCX]
MOVZX EAX,byte ptr [R8]
CMP EAX,0xff
JZ 0x001578c6
MOV R9D,0x1
JMP 0x001578d8
LAB_001578c6:
MOVZX EAX,word ptr [R8 + 0x1]
ROL AX,0x8
MOVZX EAX,AX
MOV R9D,0x3
LAB_001578d8:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R13,qword ptr [RDI]
MOV R10,qword ptr [RDI + 0x8]
LEA R11,[R8 + 0x9d4]
ADD R9,R8
MOV R12,R9
MOV R14,R11
TEST EAX,EAX
JZ 0x00157922
MOVZX R8D,word ptr [R10 + 0xae]
CMP EAX,R8D
JBE 0x00157919
MOV RDI,qword ptr [R10]
JMP 0x00157a94
LAB_00157919:
MOV R14D,EAX
ADD R14,R13
MOV R12,R13
LAB_00157922:
MOV dword ptr [RBP + -0x34],ESI
MOV qword ptr [RBP + -0x48],RDX
MOV qword ptr [RBP + -0x50],RCX
MOV qword ptr [RBP + -0x30],RDI
MOV qword ptr [RBP + -0x40],R10
MOV RBX,qword ptr [R10 + 0xc0]
CMP byte ptr [RBX + 0x18],0x0
JZ 0x00157a5a
MOV qword ptr [RBP + -0x60],R9
MOV qword ptr [RBP + -0x58],R11
LAB_0015794e:
MOVZX EAX,word ptr [RBX + 0x12]
TEST AL,0x10
JNZ 0x0015795b
MOV RCX,R14
JMP 0x00157987
LAB_0015795b:
MOV RAX,R9
MOV RCX,R11
CMP R12,R14
JZ 0x0015796c
MOV RAX,R12
MOV RCX,R14
LAB_0015796c:
MOV DL,byte ptr [RAX]
MOV R12,RAX
INC R12
MOV byte ptr [R13],DL
INC R13
TEST DL,DL
JZ 0x00157a4c
MOVZX EAX,word ptr [RBX + 0x12]
LAB_00157987:
TEST AL,0x29
JZ 0x001579b5
MOV RDX,R9
MOV R14,R11
CMP R12,RCX
JZ 0x0015799c
MOV RDX,R12
MOV R14,RCX
LAB_0015799c:
MOVZX EAX,byte ptr [RDX]
MOV R12,RDX
INC R12
MOV byte ptr [R13],AL
CMP EAX,0xff
JZ 0x001579be
INC R13
JMP 0x001579ff
LAB_001579b5:
MOVZX EAX,word ptr [RBX + 0x14]
MOV R14,RCX
JMP 0x001579ff
LAB_001579be:
MOV RCX,R9
MOV RDX,R11
CMP R12,R14
JZ 0x001579cf
MOV RCX,R12
MOV RDX,R14
LAB_001579cf:
MOVZX EAX,byte ptr [RCX]
INC RCX
MOV byte ptr [R13 + 0x1],AL
MOV R12,R9
MOV R14,R11
CMP RCX,RDX
JZ 0x001579ea
MOV R12,RCX
MOV R14,RDX
LAB_001579ea:
SHL EAX,0x8
MOVZX ECX,byte ptr [R12]
INC R12
MOV byte ptr [R13 + 0x2],CL
ADD R13,0x3
OR EAX,ECX
LAB_001579ff:
MOV RDX,R14
SUB RDX,R12
MOV ECX,EAX
SUB ECX,EDX
JNC 0x00157a0f
MOV ECX,EAX
JMP 0x00157a1a
LAB_00157a0f:
MOV EAX,EDX
ADD R13,RAX
MOV R12,R9
MOV R14,R11
LAB_00157a1a:
MOV R15D,ECX
MOV RDI,R13
MOV RSI,R12
MOV RDX,R15
CALL 0x00129120
ADD R13,R15
ADD R12,R15
MOV R9,qword ptr [RBP + -0x60]
MOV R11,qword ptr [RBP + -0x58]
LAB_00157a39:
LEA RAX,[RBX + 0x20]
CMP byte ptr [RBX + 0x38],0x0
MOV RBX,RAX
JNZ 0x0015794e
JMP 0x00157a51
LAB_00157a4c:
MOV R14,RCX
JMP 0x00157a39
LAB_00157a51:
MOV RSI,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RSI]
JMP 0x00157a64
LAB_00157a5a:
MOV RCX,R13
MOV RAX,RBX
MOV RSI,qword ptr [RBP + -0x30]
LAB_00157a64:
MOV EDX,R13D
SUB EDX,ECX
MOV dword ptr [RSI + 0x10],EDX
MOVZX EAX,word ptr [RAX + 0x14]
MOV dword ptr [RSI + 0x14],EAX
MOV dword ptr [RSI + 0x18],0x0
MOV RCX,R14
SUB RCX,R12
MOV EBX,EAX
SUB EBX,ECX
JNC 0x00157aa2
MOV EBX,EAX
CMP R14,R11
JZ 0x00157aaa
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RAX]
LAB_00157a94:
MOV ESI,0x7e
CALL 0x00136a5a
XOR EAX,EAX
JMP 0x00157b14
LAB_00157aa2:
MOV ECX,ECX
ADD R13,RCX
MOV R12,R9
LAB_00157aaa:
TEST byte ptr [RBP + -0x34],0x2
JZ 0x00157ae5
MOV ECX,EBX
TEST byte ptr [R12 + RCX*0x1 + -0x1],0x1
JZ 0x00157ae5
MOVZX ECX,byte ptr [R12 + RCX*0x1]
LEA EDX,[RCX + -0xf8]
CMP ECX,0xf3
MOV ECX,0x1
CMOVNC ECX,EDX
ADD EBX,ECX
ADD ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x14],ECX
MOV dword ptr [RAX + 0x18],0x100000
LAB_00157ae5:
MOV R14,qword ptr [RBP + -0x48]
LEA EDX,[RBX + R14*0x1]
MOV RDI,R13
MOV RSI,R12
CALL 0x00129080
MOV EAX,EBX
MOV ECX,R14D
ADD RCX,R12
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RCX + 0x14]
ADD EAX,dword ptr [RCX + 0x10]
LAB_00157b14:
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int _ma_get_binary_pack_key(int8 *param_1,uint param_2,uint param_3,int8 *param_4)
{
char *pcVar1;
byte *pbVar2;
byte bVar3;
byte bVar4;
int8 *puVar5;
ushort uVar6;
uint uVar7;
int iVar8;
byte *pbVar9;
uint uVar10;
byte *pbVar11;
uint uVar12;
long lVar13;
int8 uVar14;
long lVar15;
byte *pbVar16;
byte *pbVar17;
byte *__dest;
byte *pbVar18;
ulong __n;
pbVar16 = (byte *)*param_4;
uVar12 = (uint)*pbVar16;
if (*pbVar16 == 0xff) {
uVar12 = (uint)(ushort)(*(ushort *)(pbVar16 + 1) << 8 | *(ushort *)(pbVar16 + 1) >> 8);
lVar15 = 3;
}
else {
lVar15 = 1;
}
__dest = (byte *)*param_1;
puVar5 = (int8 *)param_1[1];
pbVar2 = pbVar16 + 0x9d4;
pbVar16 = pbVar16 + lVar15;
pbVar17 = pbVar16;
pbVar18 = pbVar2;
if (uVar12 == 0) {
LAB_00157922:
lVar15 = puVar5[0x18];
lVar13 = lVar15;
if (*(char *)(lVar15 + 0x18) == '\0') {
iVar8 = (int)__dest;
}
else {
do {
uVar6 = *(ushort *)(lVar13 + 0x12);
if ((uVar6 & 0x10) == 0) {
LAB_00157987:
if ((uVar6 & 0x29) == 0) {
uVar12 = (uint)*(ushort *)(lVar13 + 0x14);
}
else {
pbVar9 = pbVar16;
pbVar11 = pbVar2;
if (pbVar17 != pbVar18) {
pbVar9 = pbVar17;
pbVar11 = pbVar18;
}
pbVar18 = pbVar11;
bVar3 = *pbVar9;
uVar12 = (uint)bVar3;
pbVar17 = pbVar9 + 1;
*__dest = bVar3;
if (bVar3 == 0xff) {
pbVar9 = pbVar16;
pbVar11 = pbVar2;
if (pbVar17 != pbVar18) {
pbVar9 = pbVar17;
pbVar11 = pbVar18;
}
bVar3 = *pbVar9;
__dest[1] = bVar3;
pbVar17 = pbVar16;
pbVar18 = pbVar2;
if (pbVar9 + 1 != pbVar11) {
pbVar17 = pbVar9 + 1;
pbVar18 = pbVar11;
}
bVar4 = *pbVar17;
pbVar17 = pbVar17 + 1;
__dest[2] = bVar4;
__dest = __dest + 3;
uVar12 = (uint)CONCAT11(bVar3,bVar4);
}
else {
__dest = __dest + 1;
}
}
uVar7 = (uint)((long)pbVar18 - (long)pbVar17);
pbVar11 = pbVar18;
if (uVar7 <= uVar12) {
__dest = __dest + ((long)pbVar18 - (long)pbVar17 & 0xffffffff);
pbVar17 = pbVar16;
pbVar11 = pbVar2;
uVar12 = uVar12 - uVar7;
}
__n = (ulong)uVar12;
memmove(__dest,pbVar17,__n);
__dest = __dest + __n;
pbVar17 = pbVar17 + __n;
}
else {
pbVar9 = pbVar16;
pbVar11 = pbVar2;
if (pbVar17 != pbVar18) {
pbVar9 = pbVar17;
pbVar11 = pbVar18;
}
bVar3 = *pbVar9;
pbVar17 = pbVar9 + 1;
*__dest = bVar3;
__dest = __dest + 1;
if (bVar3 != 0) {
uVar6 = *(ushort *)(lVar13 + 0x12);
pbVar18 = pbVar11;
goto LAB_00157987;
}
}
lVar15 = lVar13 + 0x20;
pcVar1 = (char *)(lVar13 + 0x38);
lVar13 = lVar15;
pbVar18 = pbVar11;
} while (*pcVar1 != '\0');
iVar8 = (int)*param_1;
}
*(int *)(param_1 + 2) = (int)__dest - iVar8;
uVar6 = *(ushort *)(lVar15 + 0x14);
uVar7 = (uint)uVar6;
*(uint *)((long)param_1 + 0x14) = uVar7;
*(int4 *)(param_1 + 3) = 0;
uVar10 = (uint)((long)pbVar18 - (long)pbVar17);
uVar12 = uVar7 - uVar10;
if (uVar7 < uVar10) {
pbVar16 = pbVar17;
uVar12 = (uint)uVar6;
if (pbVar18 != pbVar2) {
uVar14 = *puVar5;
goto LAB_00157a94;
}
}
else {
__dest = __dest + ((long)pbVar18 - (long)pbVar17 & 0xffffffff);
}
if (((param_2 & 2) != 0) && ((pbVar16[(ulong)uVar12 - 1] & 1) != 0)) {
iVar8 = 1;
if (0xf2 < pbVar16[uVar12]) {
iVar8 = pbVar16[uVar12] - 0xf8;
}
uVar12 = uVar12 + iVar8;
*(uint *)((long)param_1 + 0x14) = iVar8 + (uint)uVar6;
*(int4 *)(param_1 + 3) = 0x100000;
}
memcpy(__dest,pbVar16,(ulong)(uVar12 + param_3));
*param_4 = pbVar16 + (ulong)uVar12 + (ulong)param_3;
iVar8 = *(int *)((long)param_1 + 0x14) + *(int *)(param_1 + 2);
}
else {
if (uVar12 <= *(ushort *)((long)puVar5 + 0xae)) {
pbVar18 = __dest + uVar12;
pbVar17 = __dest;
goto LAB_00157922;
}
uVar14 = *puVar5;
LAB_00157a94:
_ma_set_fatal_error_with_share(uVar14,0x7e);
iVar8 = 0;
}
return iVar8;
}
|
|
18,470
|
ma_close
|
eloqsql/libmariadb/libmariadb/ma_io.c
|
int ma_close(MA_FILE *file)
{
int rc;
if (!file)
return -1;
switch (file->type) {
case MA_FILE_LOCAL:
rc= fclose((FILE *)file->ptr);
free(file);
break;
#ifdef HAVE_REMOTEIO
case MA_FILE_REMOTE:
rc= rio_plugin->methods->mclose(file);
break;
#endif
default:
return -1;
}
return rc;
}
|
O3
|
c
|
ma_close:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x2a7c0
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x2, %eax
je 0x2a7ca
cmpl $0x1, %eax
jne 0x2a7c0
movq 0x8(%rbx), %rdi
callq 0x13460
movl %eax, %r14d
movq %rbx, %rdi
callq 0x13570
movl %r14d, %eax
jmp 0x2a7c5
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x232af(%rip), %rax # 0x4da80
movq (%rax), %rax
movq 0x58(%rax), %rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmpq *0x8(%rax)
|
ma_close:
push rbp
mov rbp, rsp
push r14
push rbx
test rdi, rdi
jz short loc_2A7C0
mov rbx, rdi
mov eax, [rdi]
cmp eax, 2
jz short loc_2A7CA
cmp eax, 1
jnz short loc_2A7C0
mov rdi, [rbx+8]
call _fclose
mov r14d, eax
mov rdi, rbx
call _free
mov eax, r14d
jmp short loc_2A7C5
loc_2A7C0:
mov eax, 0FFFFFFFFh
loc_2A7C5:
pop rbx
pop r14
pop rbp
retn
loc_2A7CA:
lea rax, rio_plugin
mov rax, [rax]
mov rax, [rax+58h]
mov rdi, rbx
pop rbx
pop r14
pop rbp
jmp qword ptr [rax+8]
|
long long ma_close(long long a1)
{
unsigned int v1; // r14d
if ( !a1 )
return 0xFFFFFFFFLL;
if ( *(_DWORD *)a1 != 2 )
{
if ( *(_DWORD *)a1 == 1 )
{
v1 = fclose(*(_QWORD *)(a1 + 8));
free(a1);
return v1;
}
return 0xFFFFFFFFLL;
}
return (*(long long ( **)(long long))(*(_QWORD *)(rio_plugin + 88LL) + 8LL))(a1);
}
|
ma_close:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
TEST RDI,RDI
JZ 0x0012a7c0
MOV RBX,RDI
MOV EAX,dword ptr [RDI]
CMP EAX,0x2
JZ 0x0012a7ca
CMP EAX,0x1
JNZ 0x0012a7c0
MOV RDI,qword ptr [RBX + 0x8]
CALL 0x00113460
MOV R14D,EAX
MOV RDI,RBX
CALL 0x00113570
MOV EAX,R14D
JMP 0x0012a7c5
LAB_0012a7c0:
MOV EAX,0xffffffff
LAB_0012a7c5:
POP RBX
POP R14
POP RBP
RET
LAB_0012a7ca:
LEA RAX,[0x14da80]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x58]
MOV RDI,RBX
POP RBX
POP R14
POP RBP
JMP qword ptr [RAX + 0x8]
|
ulong ma_close(int *param_1)
{
uint uVar1;
ulong uVar2;
if (param_1 != (int *)0x0) {
if (*param_1 == 2) {
/* WARNING: Could not recover jumptable at 0x0012a7df. Too many branches */
/* WARNING: Treating indirect jump as call */
uVar2 = (**(code **)(*(long *)(rio_plugin + 0x58) + 8))(param_1);
return uVar2;
}
if (*param_1 == 1) {
uVar1 = fclose(*(FILE **)(param_1 + 2));
free(param_1);
return (ulong)uVar1;
}
}
return 0xffffffff;
}
|
|
18,471
|
testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>>>::~MatcherBase()
|
AlayaLite/build_O3/_deps/googletest-src/googletest/include/gtest/gtest-matchers.h
|
~MatcherBase() override { Destroy(); }
|
O3
|
c
|
testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>>>::~MatcherBase():
pushq %rax
leaq 0x3864c(%rip), %rax # 0xb3a98
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x7b477
cmpq $0x0, 0x18(%rax)
je 0x7b477
movq 0x10(%rdi), %rax
lock
decl (%rax)
jne 0x7b477
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdi
callq *0x18(%rax)
popq %rax
retq
movq %rax, %rdi
callq 0x18a8f
nop
|
_ZN7testing8internal11MatcherBaseISt17basic_string_viewIcSt11char_traitsIcEEED2Ev:
push rax
lea rax, _ZTVN7testing8internal11MatcherBaseISt17basic_string_viewIcSt11char_traitsIcEEEE; `vtable for'testing::internal::MatcherBase<std::string_view>
add rax, 10h
mov [rdi], rax
mov rax, [rdi+8]
test rax, rax
jz short loc_7B477
cmp qword ptr [rax+18h], 0
jz short loc_7B477
mov rax, [rdi+10h]
lock dec dword ptr [rax]
jnz short loc_7B477
mov rax, [rdi+8]
mov rdi, [rdi+10h]
call qword ptr [rax+18h]
loc_7B477:
pop rax
retn
mov rdi, rax
call __clang_call_terminate
|
void __spoils<rdx,rcx,r8,r9,r10,r11,xmm4,xmm5> testing::internal::MatcherBase<std::string_view>::~MatcherBase(
long long a1)
{
long long v1; // rax
*(_QWORD *)a1 = &`vtable for'testing::internal::MatcherBase<std::string_view> + 2;
v1 = *(_QWORD *)(a1 + 8);
if ( v1 && *(_QWORD *)(v1 + 24) && !_InterlockedDecrement(*(volatile signed __int32 **)(a1 + 16)) )
(*(void ( **)(_QWORD))(*(_QWORD *)(a1 + 8) + 24LL))(*(_QWORD *)(a1 + 16));
}
|
~MatcherBase:
PUSH RAX
LEA RAX,[0x1b3a98]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RAX,qword ptr [RDI + 0x8]
TEST RAX,RAX
JZ 0x0017b477
CMP qword ptr [RAX + 0x18],0x0
JZ 0x0017b477
MOV RAX,qword ptr [RDI + 0x10]
DEC.LOCK dword ptr [RAX]
JNZ 0x0017b477
MOV RAX,qword ptr [RDI + 0x8]
MOV RDI,qword ptr [RDI + 0x10]
LAB_0017b474:
CALL qword ptr [RAX + 0x18]
LAB_0017b477:
POP RAX
RET
|
/* testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char> >
>::~MatcherBase() */
int8 __thiscall
testing::internal::MatcherBase<std::basic_string_view<char,std::char_traits<char>>>::~MatcherBase
(MatcherBase<std::basic_string_view<char,std::char_traits<char>>> *this)
{
int *piVar1;
int8 in_RAX;
*(int ***)this = &PTR__MatcherBase_001b3aa8;
if ((*(long *)(this + 8) != 0) && (*(long *)(*(long *)(this + 8) + 0x18) != 0)) {
piVar1 = *(int **)(this + 0x10);
LOCK();
*piVar1 = *piVar1 + -1;
UNLOCK();
if (*piVar1 == 0) {
/* try { // try from 0017b474 to 0017b476 has its CatchHandler @ 0017b479 */
(**(code **)(*(long *)(this + 8) + 0x18))(*(int8 *)(this + 0x10));
}
}
return in_RAX;
}
|
|
18,472
|
js_parse_from_clause
|
bluesky950520[P]quickjs/quickjs.c
|
static __exception JSAtom js_parse_from_clause(JSParseState *s)
{
JSAtom module_name;
if (!token_is_pseudo_keyword(s, JS_ATOM_from)) {
js_parse_error(s, "from clause expected");
return JS_ATOM_NULL;
}
if (next_token(s))
return JS_ATOM_NULL;
if (s->token.val != TOK_STRING) {
js_parse_error(s, "string expected");
return JS_ATOM_NULL;
}
module_name = JS_ValueToAtom(s->ctx, s->token.u.str.str);
if (module_name == JS_ATOM_NULL)
return JS_ATOM_NULL;
if (next_token(s)) {
JS_FreeAtom(s->ctx, module_name);
return JS_ATOM_NULL;
}
return module_name;
}
|
O1
|
c
|
js_parse_from_clause:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
cmpl $-0x7d, 0x20(%rdi)
jne 0x6c84b
cmpl $0x7b, 0x38(%r14)
jne 0x6c84b
cmpl $0x0, 0x3c(%r14)
je 0x6c865
leaq 0x34a8c(%rip), %rsi # 0xa12de
xorl %ebx, %ebx
movq %r14, %rdi
xorl %eax, %eax
callq 0x2fce9
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
callq 0x5d1cf
xorl %ebx, %ebx
testl %eax, %eax
jne 0x6c85e
cmpl $-0x7f, 0x20(%r14)
jne 0x6c8a8
movq (%r14), %rdi
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rdx
callq 0x24093
testl %eax, %eax
je 0x6c85e
movl %eax, %ebp
movq %r14, %rdi
callq 0x5d1cf
testl %eax, %eax
je 0x6c8b1
movq (%r14), %rdi
movl %ebp, %esi
callq 0x207d8
jmp 0x6c85e
leaq 0x32bb7(%rip), %rsi # 0x9f466
jmp 0x6c852
movl %ebp, %ebx
jmp 0x6c85e
|
js_parse_from_clause:
push rbp
push r14
push rbx
mov r14, rdi
cmp dword ptr [rdi+20h], 0FFFFFF83h
jnz short loc_6C84B
cmp dword ptr [r14+38h], 7Bh ; '{'
jnz short loc_6C84B
cmp dword ptr [r14+3Ch], 0
jz short loc_6C865
loc_6C84B:
lea rsi, aFromClauseExpe; "from clause expected"
loc_6C852:
xor ebx, ebx
mov rdi, r14
xor eax, eax
call js_parse_error
loc_6C85E:
mov eax, ebx
pop rbx
pop r14
pop rbp
retn
loc_6C865:
mov rdi, r14
call next_token
xor ebx, ebx
test eax, eax
jnz short loc_6C85E
cmp dword ptr [r14+20h], 0FFFFFF81h
jnz short loc_6C8A8
mov rdi, [r14]
mov rsi, [r14+38h]
mov rdx, [r14+40h]
call JS_ValueToAtom
test eax, eax
jz short loc_6C85E
mov ebp, eax
mov rdi, r14
call next_token
test eax, eax
jz short loc_6C8B1
mov rdi, [r14]
mov esi, ebp
call JS_FreeAtom
jmp short loc_6C85E
loc_6C8A8:
lea rsi, aStringExpected; "string expected"
jmp short loc_6C852
loc_6C8B1:
mov ebx, ebp
jmp short loc_6C85E
|
long long js_parse_from_clause(
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)
{
const char *v14; // rsi
unsigned int v15; // ebx
long long v17; // rsi
unsigned int v18; // eax
long long v19; // rdx
long long v20; // rcx
long long v21; // r8
long long v22; // r9
__m128 v23; // xmm4
__m128 v24; // xmm5
unsigned int v25; // ebp
char v26; // [rsp+0h] [rbp-18h]
if ( *(_DWORD *)(a1 + 32) != -125 || *(_DWORD *)(a1 + 56) != 123 || *(_DWORD *)(a1 + 60) )
{
v14 = "from clause expected";
LABEL_5:
v15 = 0;
js_parse_error((long long *)a1, (long long)v14, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v26);
return v15;
}
v15 = 0;
if ( (unsigned int)next_token(a1, a7, a8, a9, a10, a11, a12, a13, a14, a2, a3, a4, a5, a6) )
return v15;
if ( *(_DWORD *)(a1 + 32) != -127 )
{
v14 = "string expected";
goto LABEL_5;
}
v17 = *(_QWORD *)(a1 + 56);
v18 = JS_ValueToAtom(*(_QWORD *)a1, v17, *(_QWORD *)(a1 + 64));
if ( v18 )
{
v25 = v18;
if ( (unsigned int)next_token(a1, a7, a8, a9, a10, v23, v24, a13, a14, v17, v19, v20, v21, v22) )
JS_FreeAtom(*(_QWORD *)a1, v25);
else
return v25;
}
return v15;
}
| |||
18,473
|
js_parse_from_clause
|
bluesky950520[P]quickjs/quickjs.c
|
static __exception JSAtom js_parse_from_clause(JSParseState *s)
{
JSAtom module_name;
if (!token_is_pseudo_keyword(s, JS_ATOM_from)) {
js_parse_error(s, "from clause expected");
return JS_ATOM_NULL;
}
if (next_token(s))
return JS_ATOM_NULL;
if (s->token.val != TOK_STRING) {
js_parse_error(s, "string expected");
return JS_ATOM_NULL;
}
module_name = JS_ValueToAtom(s->ctx, s->token.u.str.str);
if (module_name == JS_ATOM_NULL)
return JS_ATOM_NULL;
if (next_token(s)) {
JS_FreeAtom(s->ctx, module_name);
return JS_ATOM_NULL;
}
return module_name;
}
|
O3
|
c
|
js_parse_from_clause:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
cmpl $-0x7d, 0x20(%rdi)
jne 0x6ea0e
cmpl $0x7b, 0x38(%r14)
jne 0x6ea0e
cmpl $0x0, 0x3c(%r14)
je 0x6ea28
leaq 0x35873(%rip), %rsi # 0xa4288
xorl %ebx, %ebx
movq %r14, %rdi
xorl %eax, %eax
callq 0x30b0d
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
callq 0x600a6
xorl %ebx, %ebx
testl %eax, %eax
jne 0x6ea21
cmpl $-0x7f, 0x20(%r14)
jne 0x6ea6b
movq (%r14), %rdi
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rdx
callq 0x2470d
testl %eax, %eax
je 0x6ea21
movl %eax, %ebp
movq %r14, %rdi
callq 0x600a6
testl %eax, %eax
je 0x6ea74
movq (%r14), %rdi
movl %ebp, %esi
callq 0x20f31
jmp 0x6ea21
leaq 0x339b4(%rip), %rsi # 0xa2426
jmp 0x6ea15
movl %ebp, %ebx
jmp 0x6ea21
|
js_parse_from_clause:
push rbp
push r14
push rbx
mov r14, rdi
cmp dword ptr [rdi+20h], 0FFFFFF83h
jnz short loc_6EA0E
cmp dword ptr [r14+38h], 7Bh ; '{'
jnz short loc_6EA0E
cmp dword ptr [r14+3Ch], 0
jz short loc_6EA28
loc_6EA0E:
lea rsi, aFromClauseExpe; "from clause expected"
loc_6EA15:
xor ebx, ebx
mov rdi, r14
xor eax, eax
call js_parse_error
loc_6EA21:
mov eax, ebx
pop rbx
pop r14
pop rbp
retn
loc_6EA28:
mov rdi, r14
call next_token
xor ebx, ebx
test eax, eax
jnz short loc_6EA21
cmp dword ptr [r14+20h], 0FFFFFF81h
jnz short loc_6EA6B
mov rdi, [r14]
mov rsi, [r14+38h]
mov rdx, [r14+40h]
call JS_ValueToAtom
test eax, eax
jz short loc_6EA21
mov ebp, eax
mov rdi, r14
call next_token
test eax, eax
jz short loc_6EA74
mov rdi, [r14]
mov esi, ebp
call JS_FreeAtom
jmp short loc_6EA21
loc_6EA6B:
lea rsi, aStringExpected; "string expected"
jmp short loc_6EA15
loc_6EA74:
mov ebx, ebp
jmp short loc_6EA21
|
long long js_parse_from_clause(
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)
{
const char *v14; // rsi
unsigned int v15; // ebx
long long v17; // rsi
unsigned int v18; // eax
long long v19; // rdx
long long v20; // rcx
long long v21; // r8
long long v22; // r9
__m128 v23; // xmm4
__m128 v24; // xmm5
unsigned int v25; // ebp
char v26; // [rsp+0h] [rbp-18h]
if ( *(_DWORD *)(a1 + 32) != -125 || *(_DWORD *)(a1 + 56) != 123 || *(_DWORD *)(a1 + 60) )
{
v14 = "from clause expected";
LABEL_5:
v15 = 0;
js_parse_error((long long *)a1, (long long)v14, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v26);
return v15;
}
v15 = 0;
if ( (unsigned int)next_token(a1, a7, a8, a9, a10, a11, a12, a13, a14, a2, a3, a4, a5, a6) )
return v15;
if ( *(_DWORD *)(a1 + 32) != -127 )
{
v14 = "string expected";
goto LABEL_5;
}
v17 = *(_QWORD *)(a1 + 56);
v18 = JS_ValueToAtom(*(_QWORD *)a1, v17, *(_QWORD *)(a1 + 64));
if ( v18 )
{
v25 = v18;
if ( (unsigned int)next_token(a1, a7, a8, a9, a10, v23, v24, a13, a14, v17, v19, v20, v21, v22) )
JS_FreeAtom(*(_QWORD *)a1, v25);
else
return v25;
}
return v15;
}
|
js_parse_from_clause:
PUSH RBP
PUSH R14
PUSH RBX
MOV R14,RDI
CMP dword ptr [RDI + 0x20],-0x7d
JNZ 0x0016ea0e
CMP dword ptr [R14 + 0x38],0x7b
JNZ 0x0016ea0e
CMP dword ptr [R14 + 0x3c],0x0
JZ 0x0016ea28
LAB_0016ea0e:
LEA RSI,[0x1a4288]
LAB_0016ea15:
XOR EBX,EBX
MOV RDI,R14
XOR EAX,EAX
CALL 0x00130b0d
LAB_0016ea21:
MOV EAX,EBX
POP RBX
POP R14
POP RBP
RET
LAB_0016ea28:
MOV RDI,R14
CALL 0x001600a6
XOR EBX,EBX
TEST EAX,EAX
JNZ 0x0016ea21
CMP dword ptr [R14 + 0x20],-0x7f
JNZ 0x0016ea6b
MOV RDI,qword ptr [R14]
MOV RSI,qword ptr [R14 + 0x38]
MOV RDX,qword ptr [R14 + 0x40]
CALL 0x0012470d
TEST EAX,EAX
JZ 0x0016ea21
MOV EBP,EAX
MOV RDI,R14
CALL 0x001600a6
TEST EAX,EAX
JZ 0x0016ea74
MOV RDI,qword ptr [R14]
MOV ESI,EBP
CALL 0x00120f31
JMP 0x0016ea21
LAB_0016ea6b:
LEA RSI,[0x1a2426]
JMP 0x0016ea15
LAB_0016ea74:
MOV EBX,EBP
JMP 0x0016ea21
|
int js_parse_from_clause(int8 *param_1)
{
int iVar1;
int iVar2;
char *pcVar3;
if (((*(int *)(param_1 + 4) == -0x7d) && (*(int *)(param_1 + 7) == 0x7b)) &&
(*(int *)((long)param_1 + 0x3c) == 0)) {
iVar1 = next_token(param_1);
if (iVar1 != 0) {
return 0;
}
if (*(int *)(param_1 + 4) == -0x7f) {
iVar1 = JS_ValueToAtom(*param_1,param_1[7],param_1[8]);
if (iVar1 == 0) {
return 0;
}
iVar2 = next_token(param_1);
if (iVar2 == 0) {
return iVar1;
}
JS_FreeAtom(*param_1,iVar1);
return 0;
}
pcVar3 = "string expected";
}
else {
pcVar3 = "from clause expected";
}
js_parse_error(param_1,pcVar3);
return 0;
}
|
|
18,474
|
minja::VariableExpr::~VariableExpr()
|
monkey531[P]llama/common/minja.hpp
|
VariableExpr(const Location & location, const std::string& n)
: Expression(location), name(n) {}
|
O3
|
cpp
|
minja::VariableExpr::~VariableExpr():
pushq %rbx
movq %rdi, %rbx
leaq 0x81d25(%rip), %rax # 0xdcdd0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x20(%rdi), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x5b0ca
movq (%rax), %rsi
incq %rsi
callq 0x186a0
leaq 0x811b7(%rip), %rax # 0xdc288
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x5b0e7
popq %rbx
jmp 0x30ed6
popq %rbx
retq
nop
|
_ZN5minja12VariableExprD2Ev:
push rbx
mov rbx, rdi
lea rax, _ZTVN5minja12VariableExprE; `vtable for'minja::VariableExpr
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+20h]; void *
lea rax, [rbx+30h]
cmp rdi, rax
jz short loc_5B0CA
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5B0CA:
lea rax, _ZTVN5minja10ExpressionE; `vtable for'minja::Expression
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+10h]
test rdi, rdi
jz short loc_5B0E7
pop rbx
jmp _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5B0E7:
pop rbx
retn
|
void minja::VariableExpr::~VariableExpr(minja::VariableExpr *this)
{
char *v2; // rdi
volatile signed __int32 *v3; // rdi
*(_QWORD *)this = &`vtable for'minja::VariableExpr + 2;
v2 = (char *)*((_QWORD *)this + 4);
if ( v2 != (char *)this + 48 )
operator delete(v2, *((_QWORD *)this + 6) + 1LL);
*(_QWORD *)this = &`vtable for'minja::Expression + 2;
v3 = (volatile signed __int32 *)*((_QWORD *)this + 2);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
}
|
~VariableExpr:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x1dcdd0]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x20]
LEA RAX,[RBX + 0x30]
CMP RDI,RAX
JZ 0x0015b0ca
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x001186a0
LAB_0015b0ca:
LEA RAX,[0x1dc288]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x10]
TEST RDI,RDI
JZ 0x0015b0e7
POP RBX
JMP 0x00130ed6
LAB_0015b0e7:
POP RBX
RET
|
/* minja::VariableExpr::~VariableExpr() */
void __thiscall minja::VariableExpr::~VariableExpr(VariableExpr *this)
{
*(int ***)this = &PTR_do_evaluate_001dcde0;
if (*(VariableExpr **)(this + 0x20) != this + 0x30) {
operator_delete(*(VariableExpr **)(this + 0x20),*(long *)(this + 0x30) + 1);
}
*(int ***)this = &PTR___cxa_pure_virtual_001dc298;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x10) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x10));
return;
}
return;
}
|
|
18,475
|
mul_trig
|
bluesky950520[P]quickjs/libbf.c
|
static no_inline void mul_trig(NTTLimb *buf,
limb_t n, limb_t c_mul, limb_t m, limb_t m_inv)
{
limb_t i, c0, c_mul_inv;
c0 = 1;
c_mul_inv = init_mul_mod_fast2(c_mul, m);
for(i = 0; i < n; i++) {
buf[i] = mul_mod_fast(buf[i], c0, m, m_inv);
c0 = mul_mod_fast2(c0, c_mul, m, c_mul_inv);
}
}
|
O1
|
c
|
mul_trig:
testq %rsi, %rsi
je 0x943c3
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
xorl %ebp, %ebp
xorl %edi, %edi
movq %rdx, %rsi
movq %rcx, %rdx
xorl %ecx, %ecx
callq 0x9a920
movq %rax, %rcx
leaq (%r14,%r14), %r9
movl $0x1, %esi
movq %rsi, %rax
mulq (%r13,%rbp,8)
movq %rax, %r8
movq %rdx, %rdi
movq %rdx, %rax
shldq $0x3, %r8, %rax
mulq %rbx
movq %rdx, %rax
mulq %r14
addq %r9, %rax
adcq $0x0, %rdx
subq %rax, %r8
sbbq %rdx, %rdi
movq %rdi, %rax
sarq %rax
andq %r14, %rax
addq %r8, %rax
adcq $0x0, %rdi
andq %r14, %rdi
addq %rax, %rdi
movq %rcx, %rax
mulq %rsi
imulq %r15, %rsi
imulq %r14, %rdx
subq %rdx, %rsi
cmpq %r14, %rsi
movl $0x0, %eax
cmovaeq %r14, %rax
movq %rdi, (%r13,%rbp,8)
subq %rax, %rsi
incq %rbp
cmpq %rbp, %r12
jne 0x94346
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
mul_trig:
test rsi, rsi
jz locret_943C3
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, r8
mov r14, rcx
mov r15, rdx
mov r12, rsi
mov r13, rdi
xor ebp, ebp
xor edi, edi
mov rsi, rdx
mov rdx, rcx
xor ecx, ecx
call __udivti3
mov rcx, rax
lea r9, [r14+r14]
mov esi, 1
loc_94346:
mov rax, rsi
mul qword ptr [r13+rbp*8+0]
mov r8, rax
mov rdi, rdx
mov rax, rdx
shld rax, r8, 3
mul rbx
mov rax, rdx
mul r14
add rax, r9
adc rdx, 0
sub r8, rax
sbb rdi, rdx
mov rax, rdi
sar rax, 1
and rax, r14
add rax, r8
adc rdi, 0
and rdi, r14
add rdi, rax
mov rax, rcx
mul rsi
imul rsi, r15
imul rdx, r14
sub rsi, rdx
cmp rsi, r14
mov eax, 0
cmovnb rax, r14
mov [r13+rbp*8+0], rdi
sub rsi, rax
inc rbp
cmp r12, rbp
jnz short loc_94346
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
locret_943C3:
retn
|
unsigned long long mul_trig(long long a1, long long a2, long long a3, unsigned long long a4, unsigned long long a5)
{
unsigned long long result; // rax
long long v10; // rbp
long long v11; // rcx
long long v12; // rsi
signed __int128 v13; // kr00_16
unsigned __int128 v14; // kr10_16
unsigned long long v15; // rsi
if ( a2 )
{
v10 = 0LL;
v11 = _udivti3(0LL, a3, a4, 0LL);
v12 = 1LL;
do
{
v13 = *(unsigned long long *)(a1 + 8 * v10) * (unsigned __int128)(unsigned long long)v12;
v15 = a3 * v12 - a4 * (((unsigned long long)v12 * (unsigned __int128)(unsigned long long)v11) >> 64);
result = 0LL;
if ( v15 >= a4 )
result = a4;
v14 = v13 - (2 * a4 + a4 * ((a5 * (unsigned __int128)(unsigned long long)(v13 >> 61)) >> 64));
*(_QWORD *)(a1 + 8 * v10) = v14
+ (a4 & (*((long long *)&v14 + 1) >> 1))
+ (a4 & ((v14 + (a4 & (*((long long *)&v14 + 1) >> 1))) >> 64));
v12 = v15 - result;
++v10;
}
while ( a2 != v10 );
}
return result;
}
|
mul_trig:
TEST RSI,RSI
JZ 0x001943c3
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,R8
MOV R14,RCX
MOV R15,RDX
MOV R12,RSI
MOV R13,RDI
XOR EBP,EBP
XOR EDI,EDI
MOV RSI,RDX
MOV RDX,RCX
XOR ECX,ECX
CALL 0x0019a920
MOV RCX,RAX
LEA R9,[R14 + R14*0x1]
MOV ESI,0x1
LAB_00194346:
MOV RAX,RSI
MUL qword ptr [R13 + RBP*0x8]
MOV R8,RAX
MOV RDI,RDX
MOV RAX,RDX
SHLD RAX,R8,0x3
MUL RBX
MOV RAX,RDX
MUL R14
ADD RAX,R9
ADC RDX,0x0
SUB R8,RAX
SBB RDI,RDX
MOV RAX,RDI
SAR RAX,0x1
AND RAX,R14
ADD RAX,R8
ADC RDI,0x0
AND RDI,R14
ADD RDI,RAX
MOV RAX,RCX
MUL RSI
IMUL RSI,R15
IMUL RDX,R14
SUB RSI,RDX
CMP RSI,R14
MOV EAX,0x0
CMOVNC RAX,R14
MOV qword ptr [R13 + RBP*0x8],RDI
SUB RSI,RAX
INC RBP
CMP R12,RBP
JNZ 0x00194346
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
LAB_001943c3:
RET
|
void mul_trig(long param_1,long param_2,long param_3,ulong param_4,ulong param_5)
{
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];
int1 auVar10 [16];
ulong uVar11;
ulong uVar12;
long lVar13;
ulong uVar14;
if (param_2 != 0) {
lVar13 = 0;
uVar11 = __udivti3(0,param_3,param_4,0);
auVar9._8_8_ = 0;
auVar9._0_8_ = param_4 * 2;
uVar14 = 1;
do {
auVar1._8_8_ = 0;
auVar1._0_8_ = uVar14;
auVar5._8_8_ = 0;
auVar5._0_8_ = *(ulong *)(param_1 + lVar13 * 8);
auVar1 = auVar1 * auVar5;
auVar2._8_8_ = 0;
auVar2._0_8_ = auVar1._8_8_ << 3 | auVar1._0_8_ >> 0x3d;
auVar6._8_8_ = 0;
auVar6._0_8_ = param_5;
auVar3._8_8_ = 0;
auVar3._0_8_ = SUB168(auVar2 * auVar6,8);
auVar7._8_8_ = 0;
auVar7._0_8_ = param_4;
auVar1 = auVar1 - (auVar3 * auVar7 + auVar9);
auVar10._8_8_ = 0;
auVar10._0_8_ = auVar1._8_8_ >> 1 & param_4;
auVar1 = auVar1 + auVar10;
auVar4._8_8_ = 0;
auVar4._0_8_ = uVar11;
auVar8._8_8_ = 0;
auVar8._0_8_ = uVar14;
uVar14 = uVar14 * param_3 - SUB168(auVar4 * auVar8,8) * param_4;
uVar12 = 0;
if (param_4 <= uVar14) {
uVar12 = param_4;
}
*(ulong *)(param_1 + lVar13 * 8) = (auVar1._8_8_ & param_4) + auVar1._0_8_;
uVar14 = uVar14 - uVar12;
lVar13 = lVar13 + 1;
} while (param_2 != lVar13);
}
return;
}
|
|
18,476
|
mul_trig
|
bluesky950520[P]quickjs/libbf.c
|
static no_inline void mul_trig(NTTLimb *buf,
limb_t n, limb_t c_mul, limb_t m, limb_t m_inv)
{
limb_t i, c0, c_mul_inv;
c0 = 1;
c_mul_inv = init_mul_mod_fast2(c_mul, m);
for(i = 0; i < n; i++) {
buf[i] = mul_mod_fast(buf[i], c0, m, m_inv);
c0 = mul_mod_fast2(c0, c_mul, m, c_mul_inv);
}
}
|
O2
|
c
|
mul_trig:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, %r14
movq %rsi, 0x10(%rsp)
movq %rdi, %r13
xorl %r15d, %r15d
xorl %edi, %edi
movq %rdx, %r12
movq %rdx, %rsi
movq %rcx, %rdx
xorl %ecx, %ecx
callq 0x81150
movq %rax, %rbp
pushq $0x1
popq %rbx
cmpq %r15, 0x10(%rsp)
je 0x7b779
movq (%r13,%r15,8), %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq 0x8(%rsp), %rcx
callq 0x7b1d8
movq %rax, (%r13,%r15,8)
movq %rbp, %rax
mulq %rbx
imulq %r12, %rbx
imulq %r14, %rdx
subq %rdx, %rbx
cmpq %r14, %rbx
movl $0x0, %eax
cmovaeq %r14, %rax
subq %rax, %rbx
incq %r15
jmp 0x7b733
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
mul_trig:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], r8
mov r14, rcx
mov [rsp+48h+var_38], rsi
mov r13, rdi
xor r15d, r15d
xor edi, edi
mov r12, rdx
mov rsi, rdx
mov rdx, rcx
xor ecx, ecx
call __udivti3
mov rbp, rax
push 1
pop rbx
loc_7B733:
cmp [rsp+48h+var_38], r15
jz short loc_7B779
mov rdi, [r13+r15*8+0]
mov rsi, rbx
mov rdx, r14
mov rcx, [rsp+48h+var_40]
call mul_mod_fast
mov [r13+r15*8+0], rax
mov rax, rbp
mul rbx
imul rbx, r12
imul rdx, r14
sub rbx, rdx
cmp rbx, r14
mov eax, 0
cmovnb rax, r14
sub rbx, rax
inc r15
jmp short loc_7B733
loc_7B779:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long mul_trig(long long a1, long long a2, long long a3, unsigned long long a4, long long a5)
{
long long v6; // r15
long long result; // rax
long long v9; // rbp
unsigned long long v10; // rbx
unsigned long long v11; // rbx
v6 = 0LL;
result = _udivti3(0LL, a3, a4, 0LL);
v9 = result;
v10 = 1LL;
while ( a2 != v6 )
{
*(_QWORD *)(a1 + 8 * v6) = mul_mod_fast(*(_QWORD *)(a1 + 8 * v6), v10, a4, a5);
v11 = a3 * v10 - a4 * ((v10 * (unsigned __int128)(unsigned long long)v9) >> 64);
result = 0LL;
if ( v11 >= a4 )
result = a4;
v10 = v11 - result;
++v6;
}
return result;
}
|
mul_trig:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],R8
MOV R14,RCX
MOV qword ptr [RSP + 0x10],RSI
MOV R13,RDI
XOR R15D,R15D
XOR EDI,EDI
MOV R12,RDX
MOV RSI,RDX
MOV RDX,RCX
XOR ECX,ECX
CALL 0x00181150
MOV RBP,RAX
PUSH 0x1
POP RBX
LAB_0017b733:
CMP qword ptr [RSP + 0x10],R15
JZ 0x0017b779
MOV RDI,qword ptr [R13 + R15*0x8]
MOV RSI,RBX
MOV RDX,R14
MOV RCX,qword ptr [RSP + 0x8]
CALL 0x0017b1d8
MOV qword ptr [R13 + R15*0x8],RAX
MOV RAX,RBP
MUL RBX
IMUL RBX,R12
IMUL RDX,R14
SUB RBX,RDX
CMP RBX,R14
MOV EAX,0x0
CMOVNC RAX,R14
SUB RBX,RAX
INC R15
JMP 0x0017b733
LAB_0017b779:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void mul_trig(long param_1,long param_2,long param_3,ulong param_4,int8 param_5)
{
int1 auVar1 [16];
int1 auVar2 [16];
ulong uVar3;
int8 uVar4;
ulong uVar5;
ulong uVar6;
long lVar7;
uVar3 = __udivti3(0,param_3,param_4,0);
uVar6 = 1;
for (lVar7 = 0; param_2 != lVar7; lVar7 = lVar7 + 1) {
uVar4 = mul_mod_fast(*(int8 *)(param_1 + lVar7 * 8),uVar6,param_4,param_5);
*(int8 *)(param_1 + lVar7 * 8) = uVar4;
auVar1._8_8_ = 0;
auVar1._0_8_ = uVar3;
auVar2._8_8_ = 0;
auVar2._0_8_ = uVar6;
uVar6 = uVar6 * param_3 - SUB168(auVar1 * auVar2,8) * param_4;
uVar5 = 0;
if (param_4 <= uVar6) {
uVar5 = param_4;
}
uVar6 = uVar6 - uVar5;
}
return;
}
|
|
18,477
|
mul_trig
|
bluesky950520[P]quickjs/libbf.c
|
static no_inline void mul_trig(NTTLimb *buf,
limb_t n, limb_t c_mul, limb_t m, limb_t m_inv)
{
limb_t i, c0, c_mul_inv;
c0 = 1;
c_mul_inv = init_mul_mod_fast2(c_mul, m);
for(i = 0; i < n; i++) {
buf[i] = mul_mod_fast(buf[i], c0, m, m_inv);
c0 = mul_mod_fast2(c0, c_mul, m, c_mul_inv);
}
}
|
O3
|
c
|
mul_trig:
testq %rsi, %rsi
je 0x96eff
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
xorl %ebp, %ebp
xorl %edi, %edi
movq %rdx, %rsi
movq %rcx, %rdx
xorl %ecx, %ecx
callq 0x9d250
movq %rax, %rcx
leaq (%r14,%r14), %r9
movl $0x1, %esi
movq %rsi, %rax
mulq (%r13,%rbp,8)
movq %rax, %r8
movq %rdx, %rdi
movq %rdx, %rax
shldq $0x3, %r8, %rax
mulq %rbx
movq %rdx, %rax
mulq %r14
addq %r9, %rax
adcq $0x0, %rdx
subq %rax, %r8
sbbq %rdx, %rdi
movq %rdi, %rax
sarq %rax
andq %r14, %rax
addq %r8, %rax
adcq $0x0, %rdi
andq %r14, %rdi
addq %rax, %rdi
movq %rcx, %rax
mulq %rsi
imulq %r15, %rsi
imulq %r14, %rdx
subq %rdx, %rsi
cmpq %r14, %rsi
movl $0x0, %eax
cmovaeq %r14, %rax
movq %rdi, (%r13,%rbp,8)
subq %rax, %rsi
incq %rbp
cmpq %rbp, %r12
jne 0x96e82
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
mul_trig:
test rsi, rsi
jz locret_96EFF
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, r8
mov r14, rcx
mov r15, rdx
mov r12, rsi
mov r13, rdi
xor ebp, ebp
xor edi, edi
mov rsi, rdx
mov rdx, rcx
xor ecx, ecx
call __udivti3
mov rcx, rax
lea r9, [r14+r14]
mov esi, 1
loc_96E82:
mov rax, rsi
mul qword ptr [r13+rbp*8+0]
mov r8, rax
mov rdi, rdx
mov rax, rdx
shld rax, r8, 3
mul rbx
mov rax, rdx
mul r14
add rax, r9
adc rdx, 0
sub r8, rax
sbb rdi, rdx
mov rax, rdi
sar rax, 1
and rax, r14
add rax, r8
adc rdi, 0
and rdi, r14
add rdi, rax
mov rax, rcx
mul rsi
imul rsi, r15
imul rdx, r14
sub rsi, rdx
cmp rsi, r14
mov eax, 0
cmovnb rax, r14
mov [r13+rbp*8+0], rdi
sub rsi, rax
inc rbp
cmp r12, rbp
jnz short loc_96E82
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
locret_96EFF:
retn
|
unsigned long long mul_trig(long long a1, long long a2, long long a3, unsigned long long a4, unsigned long long a5)
{
unsigned long long result; // rax
long long v10; // rbp
long long v11; // rcx
long long v12; // rsi
signed __int128 v13; // kr00_16
unsigned __int128 v14; // kr10_16
unsigned long long v15; // rsi
if ( a2 )
{
v10 = 0LL;
v11 = _udivti3(0LL, a3, a4, 0LL);
v12 = 1LL;
do
{
v13 = *(unsigned long long *)(a1 + 8 * v10) * (unsigned __int128)(unsigned long long)v12;
v15 = a3 * v12 - a4 * (((unsigned long long)v12 * (unsigned __int128)(unsigned long long)v11) >> 64);
result = 0LL;
if ( v15 >= a4 )
result = a4;
v14 = v13 - (2 * a4 + a4 * ((a5 * (unsigned __int128)(unsigned long long)(v13 >> 61)) >> 64));
*(_QWORD *)(a1 + 8 * v10) = v14
+ (a4 & (*((long long *)&v14 + 1) >> 1))
+ (a4 & ((v14 + (a4 & (*((long long *)&v14 + 1) >> 1))) >> 64));
v12 = v15 - result;
++v10;
}
while ( a2 != v10 );
}
return result;
}
|
mul_trig:
TEST RSI,RSI
JZ 0x00196eff
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,R8
MOV R14,RCX
MOV R15,RDX
MOV R12,RSI
MOV R13,RDI
XOR EBP,EBP
XOR EDI,EDI
MOV RSI,RDX
MOV RDX,RCX
XOR ECX,ECX
CALL 0x0019d250
MOV RCX,RAX
LEA R9,[R14 + R14*0x1]
MOV ESI,0x1
LAB_00196e82:
MOV RAX,RSI
MUL qword ptr [R13 + RBP*0x8]
MOV R8,RAX
MOV RDI,RDX
MOV RAX,RDX
SHLD RAX,R8,0x3
MUL RBX
MOV RAX,RDX
MUL R14
ADD RAX,R9
ADC RDX,0x0
SUB R8,RAX
SBB RDI,RDX
MOV RAX,RDI
SAR RAX,0x1
AND RAX,R14
ADD RAX,R8
ADC RDI,0x0
AND RDI,R14
ADD RDI,RAX
MOV RAX,RCX
MUL RSI
IMUL RSI,R15
IMUL RDX,R14
SUB RSI,RDX
CMP RSI,R14
MOV EAX,0x0
CMOVNC RAX,R14
MOV qword ptr [R13 + RBP*0x8],RDI
SUB RSI,RAX
INC RBP
CMP R12,RBP
JNZ 0x00196e82
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
LAB_00196eff:
RET
|
void mul_trig(long param_1,long param_2,long param_3,ulong param_4,ulong param_5)
{
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];
int1 auVar10 [16];
ulong uVar11;
ulong uVar12;
long lVar13;
ulong uVar14;
if (param_2 != 0) {
lVar13 = 0;
uVar11 = __udivti3(0,param_3,param_4,0);
auVar9._8_8_ = 0;
auVar9._0_8_ = param_4 * 2;
uVar14 = 1;
do {
auVar1._8_8_ = 0;
auVar1._0_8_ = uVar14;
auVar5._8_8_ = 0;
auVar5._0_8_ = *(ulong *)(param_1 + lVar13 * 8);
auVar1 = auVar1 * auVar5;
auVar2._8_8_ = 0;
auVar2._0_8_ = auVar1._8_8_ << 3 | auVar1._0_8_ >> 0x3d;
auVar6._8_8_ = 0;
auVar6._0_8_ = param_5;
auVar3._8_8_ = 0;
auVar3._0_8_ = SUB168(auVar2 * auVar6,8);
auVar7._8_8_ = 0;
auVar7._0_8_ = param_4;
auVar1 = auVar1 - (auVar3 * auVar7 + auVar9);
auVar10._8_8_ = 0;
auVar10._0_8_ = auVar1._8_8_ >> 1 & param_4;
auVar1 = auVar1 + auVar10;
auVar4._8_8_ = 0;
auVar4._0_8_ = uVar11;
auVar8._8_8_ = 0;
auVar8._0_8_ = uVar14;
uVar14 = uVar14 * param_3 - SUB168(auVar4 * auVar8,8) * param_4;
uVar12 = 0;
if (param_4 <= uVar14) {
uVar12 = param_4;
}
*(ulong *)(param_1 + lVar13 * 8) = (auVar1._8_8_ & param_4) + auVar1._0_8_;
uVar14 = uVar14 - uVar12;
lVar13 = lVar13 + 1;
} while (param_2 != lVar13);
}
return;
}
|
|
18,478
|
google::protobuf::compiler::cpp::DefaultInstancePtr[abi:cxx11](google::protobuf::Descriptor const*, google::protobuf::compiler::cpp::Options const&, bool)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/cpp/helpers.cc
|
std::string DefaultInstancePtr(const Descriptor* descriptor,
const Options& options, bool split) {
return DefaultInstanceName(descriptor, options, split) + "ptr_";
}
|
O3
|
cpp
|
google::protobuf::compiler::cpp::DefaultInstancePtr[abi:cxx11](google::protobuf::Descriptor const*, google::protobuf::compiler::cpp::Options const&, bool):
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x35348
leaq 0x168090(%rip), %rsi # 0x19d5a9
movq %r14, %rdi
callq 0x1f8e0
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x35543
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x35549
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x35573
callq 0x1f4a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x35594
callq 0x1f4a0
movq %rbx, %rdi
callq 0x1f860
|
_ZN6google8protobuf8compiler3cpp18DefaultInstancePtrB5cxx11EPKNS0_10DescriptorERKNS2_7OptionsEb:
push r14; int
push rbx; int
sub rsp, 28h
mov rbx, rdi
lea r14, [rsp+38h+var_30]
mov rdi, r14; int
call _ZN6google8protobuf8compiler3cpp19DefaultInstanceNameB5cxx11EPKNS0_10DescriptorERKNS2_7OptionsEb; google::protobuf::compiler::cpp::DefaultInstanceName(google::protobuf::Descriptor const*,google::protobuf::compiler::cpp::Options const&,bool)
lea rsi, aPtr; "ptr_"
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rdx, [rbx+10h]
mov [rbx], rdx
mov rsi, [rax]
mov rcx, rax
add rcx, 10h
cmp rsi, rcx
jz short loc_35543
mov [rbx], rsi
mov rdx, [rcx]
mov [rbx+10h], rdx
jmp short loc_35549
loc_35543:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rdx], xmm0
loc_35549:
mov rdx, [rax+8]
mov [rbx+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
lea rax, [rsp+38h+var_20]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_35573
call __ZdlPv; operator delete(void *)
loc_35573:
mov rax, rbx
add rsp, 28h
pop rbx
pop r14
retn
mov rbx, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_35594
call __ZdlPv; operator delete(void *)
loc_35594:
mov rdi, rbx
call __Unwind_Resume
|
long long google::protobuf::compiler::cpp::DefaultInstancePtr[abi:cxx11](
long long a1,
long long a2,
int a3,
int a4,
int a5,
int a6)
{
long long v6; // rax
_OWORD *v7; // rcx
int v9[4]; // [rsp+8h] [rbp-30h] BYREF
char v10; // [rsp+18h] [rbp-20h] BYREF
google::protobuf::compiler::cpp::DefaultInstanceName[abi:cxx11]((long long)v9, a2, a3, a4, a5, a6);
v6 = std::string::append(v9, "ptr_");
*(_QWORD *)a1 = a1 + 16;
v7 = (_OWORD *)(v6 + 16);
if ( *(_QWORD *)v6 == v6 + 16 )
{
*(_OWORD *)(a1 + 16) = *v7;
}
else
{
*(_QWORD *)a1 = *(_QWORD *)v6;
*(_QWORD *)(a1 + 16) = *(_QWORD *)v7;
}
*(_QWORD *)(a1 + 8) = *(_QWORD *)(v6 + 8);
*(_QWORD *)v6 = v7;
*(_QWORD *)(v6 + 8) = 0LL;
*(_BYTE *)(v6 + 16) = 0;
if ( *(char **)v9 != &v10 )
operator delete(*(void **)v9);
return a1;
}
|
DefaultInstancePtr[abi:cxx11]:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
LEA R14,[RSP + 0x8]
MOV RDI,R14
CALL 0x00135348
LAB_00135512:
LEA RSI,[0x29d5a9]
MOV RDI,R14
CALL 0x0011f8e0
LAB_00135521:
LEA RDX,[RBX + 0x10]
MOV qword ptr [RBX],RDX
MOV RSI,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RSI,RCX
JZ 0x00135543
MOV qword ptr [RBX],RSI
MOV RDX,qword ptr [RCX]
MOV qword ptr [RBX + 0x10],RDX
JMP 0x00135549
LAB_00135543:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RDX],XMM0
LAB_00135549:
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RBX + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00135573
CALL 0x0011f4a0
LAB_00135573:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R14
RET
|
/* google::protobuf::compiler::cpp::DefaultInstancePtr[abi:cxx11](google::protobuf::Descriptor
const*, google::protobuf::compiler::cpp::Options const&, bool) */
Descriptor *
google::protobuf::compiler::cpp::DefaultInstancePtr_abi_cxx11_
(Descriptor *param_1,Options *param_2,bool param_3)
{
long lVar1;
long *plVar2;
long *plVar3;
int1 *local_30 [2];
int1 local_20 [16];
DefaultInstanceName_abi_cxx11_((Descriptor *)local_30,param_2,param_3);
/* try { // try from 00135512 to 00135520 has its CatchHandler @ 0013557e */
plVar2 = (long *)std::__cxx11::string::append((char *)local_30);
*(Descriptor **)param_1 = param_1 + 0x10;
plVar3 = plVar2 + 2;
if ((long *)*plVar2 == plVar3) {
lVar1 = plVar2[3];
*(long *)(param_1 + 0x10) = *plVar3;
*(long *)(param_1 + 0x18) = lVar1;
}
else {
*(long **)param_1 = (long *)*plVar2;
*(long *)(param_1 + 0x10) = *plVar3;
}
*(long *)(param_1 + 8) = plVar2[1];
*plVar2 = (long)plVar3;
plVar2[1] = 0;
*(int1 *)(plVar2 + 2) = 0;
if (local_30[0] != local_20) {
operator_delete(local_30[0]);
}
return param_1;
}
|
|
18,479
|
js_promise_mark
|
bluesky950520[P]quickjs/quickjs.c
|
static void js_promise_mark(JSRuntime *rt, JSValue val,
JS_MarkFunc *mark_func)
{
JSPromiseData *s = JS_GetOpaque(val, JS_CLASS_PROMISE);
struct list_head *el;
int i;
if (!s)
return;
for(i = 0; i < 2; i++) {
list_for_each(el, &s->promise_reactions[i]) {
JSPromiseReactionData *rd =
list_entry(el, JSPromiseReactionData, link);
JS_MarkValue(rt, rd->resolving_funcs[0], mark_func);
JS_MarkValue(rt, rd->resolving_funcs[1], mark_func);
JS_MarkValue(rt, rd->handler, mark_func);
}
}
JS_MarkValue(rt, s->promise_result, mark_func);
}
|
O0
|
c
|
js_promise_mark:
subq $0x48, %rsp
movq %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq %rdi, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
movl $0x31, %edx
callq 0x38350
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x916ce
jmp 0x917bd
movl $0x0, 0x14(%rsp)
cmpl $0x2, 0x14(%rsp)
jge 0x917a1
movq 0x20(%rsp), %rax
addq $0x8, %rax
movslq 0x14(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
addq $0x8, %rcx
movslq 0x14(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
je 0x9178f
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
callq 0x2abe0
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
callq 0x2abe0
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x30(%rax), %rsi
movq 0x38(%rax), %rdx
callq 0x2abe0
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x916ff
jmp 0x91791
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x916d6
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x30(%rax), %rsi
movq 0x38(%rax), %rdx
callq 0x2abe0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
|
js_promise_mark:
sub rsp, 48h
mov [rsp+48h+var_10], rsi
mov [rsp+48h+var_8], rdx
mov [rsp+48h+var_18], rdi
mov [rsp+48h+var_20], rcx
mov rdi, [rsp+48h+var_10]
mov rsi, [rsp+48h+var_8]
mov edx, 31h ; '1'
call JS_GetOpaque
mov [rsp+48h+var_28], rax
cmp [rsp+48h+var_28], 0
jnz short loc_916CE
jmp loc_917BD
loc_916CE:
mov [rsp+48h+var_34], 0
loc_916D6:
cmp [rsp+48h+var_34], 2
jge loc_917A1
mov rax, [rsp+48h+var_28]
add rax, 8
movsxd rcx, [rsp+48h+var_34]
shl rcx, 4
add rax, rcx
mov rax, [rax+8]
mov [rsp+48h+var_30], rax
loc_916FF:
mov rax, [rsp+48h+var_30]
mov rcx, [rsp+48h+var_28]
add rcx, 8
movsxd rdx, [rsp+48h+var_34]
shl rdx, 4
add rcx, rdx
cmp rax, rcx
jz short loc_9178F
mov rax, [rsp+48h+var_30]
mov [rsp+48h+var_40], rax
mov rdi, [rsp+48h+var_18]
mov rax, [rsp+48h+var_40]
mov rcx, [rsp+48h+var_20]
mov rsi, [rax+10h]
mov rdx, [rax+18h]
call JS_MarkValue
mov rdi, [rsp+48h+var_18]
mov rax, [rsp+48h+var_40]
mov rcx, [rsp+48h+var_20]
mov rsi, [rax+20h]
mov rdx, [rax+28h]
call JS_MarkValue
mov rdi, [rsp+48h+var_18]
mov rax, [rsp+48h+var_40]
mov rcx, [rsp+48h+var_20]
mov rsi, [rax+30h]
mov rdx, [rax+38h]
call JS_MarkValue
mov rax, [rsp+48h+var_30]
mov rax, [rax+8]
mov [rsp+48h+var_30], rax
jmp loc_916FF
loc_9178F:
jmp short $+2
loc_91791:
mov eax, [rsp+48h+var_34]
add eax, 1
mov [rsp+48h+var_34], eax
jmp loc_916D6
loc_917A1:
mov rdi, [rsp+48h+var_18]
mov rax, [rsp+48h+var_28]
mov rcx, [rsp+48h+var_20]
mov rsi, [rax+30h]
mov rdx, [rax+38h]
call JS_MarkValue
loc_917BD:
add rsp, 48h
retn
|
long long js_promise_mark(long long a1, long long a2, int a3, long long ( *a4)(long long, long long))
{
long long result; // rax
long long *v5; // [rsp+8h] [rbp-40h]
int i; // [rsp+14h] [rbp-34h]
long long *j; // [rsp+18h] [rbp-30h]
long long v8; // [rsp+20h] [rbp-28h]
result = JS_GetOpaque(a2, a3, 49);
v8 = result;
if ( result )
{
for ( i = 0; i < 2; ++i )
{
for ( j = *(long long **)(16LL * i + v8 + 8 + 8); j != (long long *)(16LL * i + v8 + 8); j = (long long *)j[1] )
{
v5 = j;
JS_MarkValue(a1, j[2], j[3], a4);
JS_MarkValue(a1, v5[4], v5[5], a4);
JS_MarkValue(a1, v5[6], v5[7], a4);
}
}
return JS_MarkValue(a1, *(_QWORD *)(v8 + 48), *(_QWORD *)(v8 + 56), a4);
}
return result;
}
|
js_promise_mark:
SUB RSP,0x48
MOV qword ptr [RSP + 0x38],RSI
MOV qword ptr [RSP + 0x40],RDX
MOV qword ptr [RSP + 0x30],RDI
MOV qword ptr [RSP + 0x28],RCX
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x40]
MOV EDX,0x31
CALL 0x00138350
MOV qword ptr [RSP + 0x20],RAX
CMP qword ptr [RSP + 0x20],0x0
JNZ 0x001916ce
JMP 0x001917bd
LAB_001916ce:
MOV dword ptr [RSP + 0x14],0x0
LAB_001916d6:
CMP dword ptr [RSP + 0x14],0x2
JGE 0x001917a1
MOV RAX,qword ptr [RSP + 0x20]
ADD RAX,0x8
MOVSXD RCX,dword ptr [RSP + 0x14]
SHL RCX,0x4
ADD RAX,RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x18],RAX
LAB_001916ff:
MOV RAX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x20]
ADD RCX,0x8
MOVSXD RDX,dword ptr [RSP + 0x14]
SHL RDX,0x4
ADD RCX,RDX
CMP RAX,RCX
JZ 0x0019178f
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RAX + 0x10]
MOV RDX,qword ptr [RAX + 0x18]
CALL 0x0012abe0
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RAX + 0x20]
MOV RDX,qword ptr [RAX + 0x28]
CALL 0x0012abe0
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RAX + 0x30]
MOV RDX,qword ptr [RAX + 0x38]
CALL 0x0012abe0
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x18],RAX
JMP 0x001916ff
LAB_0019178f:
JMP 0x00191791
LAB_00191791:
MOV EAX,dword ptr [RSP + 0x14]
ADD EAX,0x1
MOV dword ptr [RSP + 0x14],EAX
JMP 0x001916d6
LAB_001917a1:
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RAX + 0x30]
MOV RDX,qword ptr [RAX + 0x38]
CALL 0x0012abe0
LAB_001917bd:
ADD RSP,0x48
RET
|
void js_promise_mark(int8 param_1,int8 param_2,int8 param_3,int8 param_4)
{
long lVar1;
int4 local_34;
int8 local_30;
lVar1 = JS_GetOpaque(param_2,param_3,0x31);
if (lVar1 != 0) {
for (local_34 = 0; local_34 < 2; local_34 = local_34 + 1) {
for (local_30 = *(long *)(lVar1 + (long)local_34 * 0x10 + 0x10);
local_30 != lVar1 + 8 + (long)local_34 * 0x10; local_30 = *(long *)(local_30 + 8)) {
JS_MarkValue(param_1,*(int8 *)(local_30 + 0x10),*(int8 *)(local_30 + 0x18),
param_4);
JS_MarkValue(param_1,*(int8 *)(local_30 + 0x20),*(int8 *)(local_30 + 0x28),
param_4);
JS_MarkValue(param_1,*(int8 *)(local_30 + 0x30),*(int8 *)(local_30 + 0x38),
param_4);
}
}
JS_MarkValue(param_1,*(int8 *)(lVar1 + 0x30),*(int8 *)(lVar1 + 0x38),param_4);
}
return;
}
|
|
18,480
|
js_promise_mark
|
bluesky950520[P]quickjs/quickjs.c
|
static void js_promise_mark(JSRuntime *rt, JSValue val,
JS_MarkFunc *mark_func)
{
JSPromiseData *s = JS_GetOpaque(val, JS_CLASS_PROMISE);
struct list_head *el;
int i;
if (!s)
return;
for(i = 0; i < 2; i++) {
list_for_each(el, &s->promise_reactions[i]) {
JSPromiseReactionData *rd =
list_entry(el, JSPromiseReactionData, link);
JS_MarkValue(rt, rd->resolving_funcs[0], mark_func);
JS_MarkValue(rt, rd->resolving_funcs[1], mark_func);
JS_MarkValue(rt, rd->handler, mark_func);
}
}
JS_MarkValue(rt, s->promise_result, mark_func);
}
|
O2
|
c
|
js_promise_mark:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl $-0x1, %edx
jne 0x46d1a
cmpw $0x31, 0x6(%rsi)
jne 0x46d1a
movq 0x30(%rsi), %rax
testq %rax, %rax
je 0x46d1a
movq %rcx, %r12
movq %rdi, %rbx
movl $0xfffffffe, %r15d # imm = 0xFFFFFFFE
movq %rax, 0x8(%rsp)
addq $0x8, %rax
movq %rax, 0x10(%rsp)
xorl %r14d, %r14d
cmpq $0x2, %r14
je 0x46cf0
movq %r14, %r13
shlq $0x4, %r13
addq 0x10(%rsp), %r13
movq %r13, %rbp
movq 0x8(%rbp), %rbp
cmpq %r13, %rbp
je 0x46ceb
movl 0x18(%rbp), %eax
andl $-0x2, %eax
cmpl %r15d, %eax
jne 0x46cbf
movq 0x10(%rbp), %rsi
movq %rbx, %rdi
callq *%r12
movl 0x28(%rbp), %eax
andl $-0x2, %eax
cmpl %r15d, %eax
jne 0x46cd4
movq 0x20(%rbp), %rsi
movq %rbx, %rdi
callq *%r12
movl 0x38(%rbp), %eax
andl $-0x2, %eax
cmpl %r15d, %eax
jne 0x46ca1
movq 0x30(%rbp), %rsi
movq %rbx, %rdi
callq *%r12
jmp 0x46ca1
incq %r14
jmp 0x46c8c
movq 0x8(%rsp), %rcx
movl 0x38(%rcx), %eax
andl $-0x2, %eax
cmpl %r15d, %eax
jne 0x46d1a
movq 0x30(%rcx), %rsi
movq %rbx, %rdi
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
js_promise_mark:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
cmp edx, 0FFFFFFFFh
jnz loc_46D1A
cmp word ptr [rsi+6], 31h ; '1'
jnz loc_46D1A
mov rax, [rsi+30h]
test rax, rax
jz loc_46D1A
mov r12, rcx
mov rbx, rdi
mov r15d, 0FFFFFFFEh
mov [rsp+48h+var_40], rax
add rax, 8
mov [rsp+48h+var_38], rax
xor r14d, r14d
loc_46C8C:
cmp r14, 2
jz short loc_46CF0
mov r13, r14
shl r13, 4
add r13, [rsp+48h+var_38]
mov rbp, r13
loc_46CA1:
mov rbp, [rbp+8]
cmp rbp, r13
jz short loc_46CEB
mov eax, [rbp+18h]
and eax, 0FFFFFFFEh
cmp eax, r15d
jnz short loc_46CBF
mov rsi, [rbp+10h]
mov rdi, rbx
call r12
loc_46CBF:
mov eax, [rbp+28h]
and eax, 0FFFFFFFEh
cmp eax, r15d
jnz short loc_46CD4
mov rsi, [rbp+20h]
mov rdi, rbx
call r12
loc_46CD4:
mov eax, [rbp+38h]
and eax, 0FFFFFFFEh
cmp eax, r15d
jnz short loc_46CA1
mov rsi, [rbp+30h]
mov rdi, rbx
call r12
jmp short loc_46CA1
loc_46CEB:
inc r14
jmp short loc_46C8C
loc_46CF0:
mov rcx, [rsp+48h+var_40]
mov eax, [rcx+38h]
and eax, 0FFFFFFFEh
cmp eax, r15d
jnz short loc_46D1A
mov rsi, [rcx+30h]
mov rdi, rbx
mov rax, r12
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp rax
loc_46D1A:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
void js_promise_mark(long long a1, long long a2, int a3, void ( *a4)(long long, _QWORD))
{
long long v4; // rax
long long i; // r14
long long v7; // rbp
long long v8; // [rsp+8h] [rbp-40h]
long long v9; // [rsp+10h] [rbp-38h]
if ( a3 == -1 && *(_WORD *)(a2 + 6) == 49 )
{
v4 = *(_QWORD *)(a2 + 48);
if ( v4 )
{
v8 = *(_QWORD *)(a2 + 48);
v9 = v4 + 8;
for ( i = 0LL; i != 2; ++i )
{
v7 = v9 + 16 * i;
while ( 1 )
{
v7 = *(_QWORD *)(v7 + 8);
if ( v7 == v9 + 16 * i )
break;
if ( (*(_DWORD *)(v7 + 24) & 0xFFFFFFFE) == 0xFFFFFFFE )
a4(a1, *(_QWORD *)(v7 + 16));
if ( (*(_DWORD *)(v7 + 40) & 0xFFFFFFFE) == 0xFFFFFFFE )
a4(a1, *(_QWORD *)(v7 + 32));
if ( (*(_DWORD *)(v7 + 56) & 0xFFFFFFFE) == 0xFFFFFFFE )
a4(a1, *(_QWORD *)(v7 + 48));
}
}
if ( (*(_DWORD *)(v8 + 56) & 0xFFFFFFFE) == 0xFFFFFFFE )
a4(a1, *(_QWORD *)(v8 + 48));
}
}
}
|
js_promise_mark:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
CMP EDX,-0x1
JNZ 0x00146d1a
CMP word ptr [RSI + 0x6],0x31
JNZ 0x00146d1a
MOV RAX,qword ptr [RSI + 0x30]
TEST RAX,RAX
JZ 0x00146d1a
MOV R12,RCX
MOV RBX,RDI
MOV R15D,0xfffffffe
MOV qword ptr [RSP + 0x8],RAX
ADD RAX,0x8
MOV qword ptr [RSP + 0x10],RAX
XOR R14D,R14D
LAB_00146c8c:
CMP R14,0x2
JZ 0x00146cf0
MOV R13,R14
SHL R13,0x4
ADD R13,qword ptr [RSP + 0x10]
MOV RBP,R13
LAB_00146ca1:
MOV RBP,qword ptr [RBP + 0x8]
CMP RBP,R13
JZ 0x00146ceb
MOV EAX,dword ptr [RBP + 0x18]
AND EAX,0xfffffffe
CMP EAX,R15D
JNZ 0x00146cbf
MOV RSI,qword ptr [RBP + 0x10]
MOV RDI,RBX
CALL R12
LAB_00146cbf:
MOV EAX,dword ptr [RBP + 0x28]
AND EAX,0xfffffffe
CMP EAX,R15D
JNZ 0x00146cd4
MOV RSI,qword ptr [RBP + 0x20]
MOV RDI,RBX
CALL R12
LAB_00146cd4:
MOV EAX,dword ptr [RBP + 0x38]
AND EAX,0xfffffffe
CMP EAX,R15D
JNZ 0x00146ca1
MOV RSI,qword ptr [RBP + 0x30]
MOV RDI,RBX
CALL R12
JMP 0x00146ca1
LAB_00146ceb:
INC R14
JMP 0x00146c8c
LAB_00146cf0:
MOV RCX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RCX + 0x38]
AND EAX,0xfffffffe
CMP EAX,R15D
JNZ 0x00146d1a
MOV RSI,qword ptr [RCX + 0x30]
MOV RDI,RBX
MOV RAX,R12
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP RAX
LAB_00146d1a:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void js_promise_mark(int8 param_1,long param_2,int param_3,code *UNRECOVERED_JUMPTABLE)
{
long lVar1;
long lVar2;
long lVar3;
long lVar4;
if (((param_3 == -1) && (*(short *)(param_2 + 6) == 0x31)) &&
(lVar1 = *(long *)(param_2 + 0x30), lVar1 != 0)) {
for (lVar4 = 0; lVar4 != 2; lVar4 = lVar4 + 1) {
lVar3 = lVar4 * 0x10 + lVar1 + 8;
lVar2 = lVar3;
while (lVar2 = *(long *)(lVar2 + 8), lVar2 != lVar3) {
if ((*(uint *)(lVar2 + 0x18) & 0xfffffffe) == 0xfffffffe) {
(*UNRECOVERED_JUMPTABLE)(param_1,*(int8 *)(lVar2 + 0x10));
}
if ((*(uint *)(lVar2 + 0x28) & 0xfffffffe) == 0xfffffffe) {
(*UNRECOVERED_JUMPTABLE)(param_1,*(int8 *)(lVar2 + 0x20));
}
if ((*(uint *)(lVar2 + 0x38) & 0xfffffffe) == 0xfffffffe) {
(*UNRECOVERED_JUMPTABLE)(param_1,*(int8 *)(lVar2 + 0x30));
}
}
}
if ((*(uint *)(lVar1 + 0x38) & 0xfffffffe) == 0xfffffffe) {
/* WARNING: Could not recover jumptable at 0x00146d18. Too many branches */
/* WARNING: Treating indirect jump as call */
(*UNRECOVERED_JUMPTABLE)(param_1,*(int8 *)(lVar1 + 0x30));
return;
}
}
return;
}
|
|
18,481
|
test_compress
|
eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c
|
static int test_compress(MYSQL *mysql)
{
MYSQL_STMT *stmt= mysql_stmt_init(mysql);
int rc;
rc= mariadb_stmt_execute_direct(stmt, SL("SELECT 1 FROM DUAL"));
check_stmt_rc(rc, stmt);
mysql_stmt_close(stmt);
return OK;
}
|
O3
|
c
|
test_compress:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0x322b8
movq %rax, %rbx
leaq 0x30457(%rip), %rsi # 0x47649
movl $0x12, %edx
movq %rax, %rdi
callq 0x33c38
movq %rbx, %rdi
testl %eax, %eax
je 0x1722f
callq 0x31d58
leaq 0x2efce(%rip), %rdi # 0x461e0
leaq 0x2faa4(%rip), %rdx # 0x46cbd
movq %rax, %rsi
movl $0x1245, %ecx # imm = 0x1245
xorl %eax, %eax
callq 0x264ef
movl $0x1, %eax
jmp 0x17236
callq 0x31cc9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
test_compress:
push rbp
mov rbp, rsp
push rbx
push rax
call mysql_stmt_init
mov rbx, rax
lea rsi, aSelect1FromDua; "SELECT 1 FROM DUAL"
mov edx, 12h
mov rdi, rax
call mariadb_stmt_execute_direct
mov rdi, rbx
test eax, eax
jz short loc_1722F
call mysql_stmt_error
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov rsi, rax
mov ecx, 1245h
xor eax, eax
call diag
mov eax, 1
jmp short loc_17236
loc_1722F:
call mysql_stmt_close
xor eax, eax
loc_17236:
add rsp, 8
pop rbx
pop rbp
retn
|
long long test_compress(long long a1)
{
long long v1; // rdi
int v2; // eax
int v3; // r8d
int v4; // r9d
v1 = mysql_stmt_init(a1);
if ( (unsigned int)mariadb_stmt_execute_direct(v1, "SELECT 1 FROM DUAL", 18LL) )
{
v2 = mysql_stmt_error(v1);
diag(
(unsigned int)"Error: %s (%s: %d)",
v2,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
4677,
v3,
v4);
return 1LL;
}
else
{
mysql_stmt_close(v1);
return 0LL;
}
}
|
test_compress:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
CALL 0x001322b8
MOV RBX,RAX
LEA RSI,[0x147649]
MOV EDX,0x12
MOV RDI,RAX
CALL 0x00133c38
MOV RDI,RBX
TEST EAX,EAX
JZ 0x0011722f
CALL 0x00131d58
LEA RDI,[0x1461e0]
LEA RDX,[0x146cbd]
MOV RSI,RAX
MOV ECX,0x1245
XOR EAX,EAX
CALL 0x001264ef
MOV EAX,0x1
JMP 0x00117236
LAB_0011722f:
CALL 0x00131cc9
XOR EAX,EAX
LAB_00117236:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
bool test_compress(void)
{
int iVar1;
int8 uVar2;
uVar2 = mysql_stmt_init();
iVar1 = mariadb_stmt_execute_direct(uVar2,"SELECT 1 FROM DUAL",0x12);
if (iVar1 == 0) {
mysql_stmt_close(uVar2);
}
else {
uVar2 = mysql_stmt_error();
diag("Error: %s (%s: %d)",uVar2,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",0x1245)
;
}
return iVar1 != 0;
}
|
|
18,482
|
nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<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>>>>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
monkey531[P]llama/common/json.hpp
|
T& operator[](const key_type& key)
{
return emplace(key, T{}).first->second;
}
|
O1
|
cpp
|
nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<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>>>>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movb $0x0, (%r15)
movq $0x0, 0x8(%r15)
movq %r15, %rdi
movl $0x1, %esi
callq 0x8974c
movq %r15, %rdi
movl $0x1, %esi
callq 0x8974c
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x90394
movq %rax, %rbx
addq $0x20, %rbx
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x8974c
movq %r14, %rdi
callq 0x8ed0c
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x8974c
movq %r14, %rdi
callq 0x8ed0c
movq %rbx, %rdi
callq 0x1e650
nop
|
_ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEEixERSH_:
push r15
push r14
push rbx
sub rsp, 10h
mov rbx, rsi
mov r14, rdi
mov r15, rsp
mov byte ptr [r15], 0
mov qword ptr [r15+8], 0
mov rdi, r15
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, r15
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
mov rsi, rbx
mov rdx, r15
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE7emplaceERSH_OSD_; nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::emplace(std::string const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&&)
mov rbx, rax
add rbx, 20h ; ' '
mov r14, rsp
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rax, rbx
add rsp, 10h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov r14, rsp
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, rbx
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::operator[](
long long a1,
long long a2)
{
long long v2; // rbx
char v4[8]; // [rsp+0h] [rbp-28h] BYREF
long long v5; // [rsp+8h] [rbp-20h]
v4[0] = 0;
v5 = 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(v4);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v4);
v2 = nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::emplace(
a1,
a2,
v4)
+ 32;
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(v4);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v4);
return v2;
}
|
operator[]:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV RBX,RSI
MOV R14,RDI
MOV R15,RSP
MOV byte ptr [R15],0x0
MOV qword ptr [R15 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x0018974c
MOV RDI,R15
MOV ESI,0x1
CALL 0x0018974c
LAB_00190300:
MOV RDI,R14
MOV RSI,RBX
MOV RDX,R15
CALL 0x00190394
LAB_0019030e:
MOV RBX,RAX
ADD RBX,0x20
MOV R14,RSP
MOV RDI,R14
XOR ESI,ESI
CALL 0x0018974c
MOV RDI,R14
CALL 0x0018ed0c
MOV RAX,RBX
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
/* nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::string,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::string const,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> > > >::operator[](std::__cxx11::string const&) */
long __thiscall
nlohmann::json_abi_v3_11_3::
ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::operator[](ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*this,string *param_1)
{
long lVar1;
bool bVar2;
basic_json local_28 [8];
int8 local_20;
local_28[0] = (basic_json)0x0;
local_20 = 0;
bVar2 = SUB81(local_28,0);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar2);
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(bVar2);
/* try { // try from 00190300 to 0019030d has its CatchHandler @ 00190337 */
lVar1 = emplace(this,param_1,local_28);
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(bVar2);
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 lVar1 + 0x20;
}
|
|
18,483
|
nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<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>>>>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
monkey531[P]llama/common/json.hpp
|
T& operator[](const key_type& key)
{
return emplace(key, T{}).first->second;
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<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>>>>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x40(%rsp), %r14
movq $0x0, 0x8(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%r14)
movaps %xmm0, -0x30(%r14)
movaps %xmm0, -0x20(%r14)
movaps %xmm0, -0x10(%r14)
movb $0x0, (%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x89876
movq %r14, %rdi
movl $0x1, %esi
callq 0x89876
movq %rsp, %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0xb2fea
movq %rax, %rbx
movq %r14, %rdi
xorl %esi, %esi
callq 0x89876
movq %r14, %rdi
callq 0x8eb30
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0xb2f71
callq 0x516f8
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xb2f80
callq 0x516f8
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xb2f8f
callq 0x516f8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xb2fc5
movq 0xa2fe0(%rip), %rax # 0x155f80
cmpb $0x0, (%rax)
je 0xb2fb0
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0xb2fba
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0xb2fc5
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x10, %rbx
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xaa35a
movq %rbx, %rdi
callq 0x1e660
nop
|
_ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEEixERSJ_:
push r15
push r14
push rbx
sub rsp, 50h
mov rbx, rsi
mov r15, rdi
lea r14, [rsp+68h+var_28]
mov qword ptr [r14+8], 0
xorps xmm0, xmm0
movaps xmmword ptr [r14-40h], xmm0
movaps xmmword ptr [r14-30h], xmm0
movaps xmmword ptr [r14-20h], xmm0
movaps xmmword ptr [r14-10h], xmm0
mov byte ptr [r14], 0
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdx, rsp
mov rdi, r15
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE7emplaceERSJ_OSF_; 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>>>::emplace(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&&)
mov rbx, rax
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, [rsp+68h+var_30]
test rdi, rdi
jz short loc_B2F71
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_B2F71:
mov rdi, [rsp+68h+var_40]
test rdi, rdi
jz short loc_B2F80
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_B2F80:
mov rdi, [rsp+68h+var_50]
test rdi, rdi
jz short loc_B2F8F
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_B2F8F:
mov rdi, [rsp+68h+var_60]
test rdi, rdi
jz short loc_B2FC5
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_B2FB0
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_B2FBA
loc_B2FB0:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_B2FBA:
cmp eax, 1
jnz short loc_B2FC5
mov rax, [rdi]
call qword ptr [rax+18h]
loc_B2FC5:
add rbx, 10h
mov rax, rbx
add rsp, 50h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov rdi, rsp; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rdi, rbx
call __Unwind_Resume
|
long long 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>>>::operator[](
long long a1,
long long a2)
{
long long v2; // rbx
long long v3; // rdi
signed __int32 v4; // eax
__int128 v6; // [rsp+0h] [rbp-68h] BYREF
__int128 v7; // [rsp+10h] [rbp-58h]
__int128 v8; // [rsp+20h] [rbp-48h]
__int128 v9; // [rsp+30h] [rbp-38h]
char v10[8]; // [rsp+40h] [rbp-28h] BYREF
long long v11; // [rsp+48h] [rbp-20h]
v11 = 0LL;
v6 = 0LL;
v7 = 0LL;
v8 = 0LL;
v9 = 0LL;
v10[0] = 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(v10);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v10);
v2 = 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>>>::emplace(
a1,
a2,
&v6);
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(v10);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v10);
if ( *((_QWORD *)&v9 + 1) )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(*((volatile signed __int32 **)&v9 + 1));
if ( *((_QWORD *)&v8 + 1) )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(*((volatile signed __int32 **)&v8 + 1));
if ( *((_QWORD *)&v7 + 1) )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(*((volatile signed __int32 **)&v7 + 1));
v3 = *((_QWORD *)&v6 + 1);
if ( *((_QWORD *)&v6 + 1) )
{
if ( _libc_single_threaded )
{
v4 = *(_DWORD *)(*((_QWORD *)&v6 + 1) + 12LL);
*(_DWORD *)(*((_QWORD *)&v6 + 1) + 12LL) = v4 - 1;
}
else
{
v4 = _InterlockedExchangeAdd((volatile signed __int32 *)(*((_QWORD *)&v6 + 1) + 12LL), 0xFFFFFFFF);
}
if ( v4 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v3 + 24LL))(v3, 0LL);
}
return v2 + 16;
}
|
operator[]:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV RBX,RSI
MOV R15,RDI
LEA R14,[RSP + 0x40]
MOV qword ptr [R14 + 0x8],0x0
XORPS XMM0,XMM0
MOVAPS xmmword ptr [R14 + -0x40],XMM0
MOVAPS xmmword ptr [R14 + -0x30],XMM0
MOVAPS xmmword ptr [R14 + -0x20],XMM0
MOVAPS xmmword ptr [R14 + -0x10],XMM0
MOV byte ptr [R14],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x00189876
MOV RDI,R14
MOV ESI,0x1
CALL 0x00189876
LAB_001b2f3f:
MOV RDX,RSP
MOV RDI,R15
MOV RSI,RBX
CALL 0x001b2fea
LAB_001b2f4d:
MOV RBX,RAX
MOV RDI,R14
XOR ESI,ESI
CALL 0x00189876
MOV RDI,R14
CALL 0x0018eb30
MOV RDI,qword ptr [RSP + 0x38]
TEST RDI,RDI
JZ 0x001b2f71
CALL 0x001516f8
LAB_001b2f71:
MOV RDI,qword ptr [RSP + 0x28]
TEST RDI,RDI
JZ 0x001b2f80
CALL 0x001516f8
LAB_001b2f80:
MOV RDI,qword ptr [RSP + 0x18]
TEST RDI,RDI
JZ 0x001b2f8f
CALL 0x001516f8
LAB_001b2f8f:
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x001b2fc5
MOV RAX,qword ptr [0x00255f80]
CMP byte ptr [RAX],0x0
JZ 0x001b2fb0
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x001b2fba
LAB_001b2fb0:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_001b2fba:
CMP EAX,0x1
JNZ 0x001b2fc5
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_001b2fc5:
ADD RBX,0x10
MOV RAX,RBX
ADD RSP,0x50
POP RBX
POP R14
POP R15
RET
|
/* nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::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>, minja::Value,
std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >,
std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const, minja::Value> >
>::operator[](nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&) */
long __thiscall
nlohmann::json_abi_v3_11_3::
ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::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>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
::operator[](ordered_map<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>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
*this,basic_json *param_1)
{
int *piVar1;
int iVar2;
long lVar3;
bool bVar4;
int8 local_68;
long *plStack_60;
int8 local_58;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Stack_50;
int8 local_48;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Stack_40;
int8 local_38;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Stack_30;
data local_28 [8];
int8 local_20;
local_20 = 0;
local_68 = 0;
plStack_60 = (long *)0x0;
local_58 = 0;
p_Stack_50 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0;
local_48 = 0;
p_Stack_40 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0;
local_38 = 0;
p_Stack_30 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0;
local_28[0] = (data)0x0;
bVar4 = SUB81(local_28,0);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar4);
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(bVar4);
/* try { // try from 001b2f3f to 001b2f4c has its CatchHandler @ 001b2fd6 */
lVar3 = emplace(this,param_1,(Value *)&local_68);
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(bVar4);
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_28);
if (p_Stack_30 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(p_Stack_30);
}
if (p_Stack_40 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(p_Stack_40);
}
if (p_Stack_50 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(p_Stack_50);
}
if (plStack_60 != (long *)0x0) {
if (*PTR___libc_single_threaded_00255f80 == '\0') {
LOCK();
piVar1 = (int *)((long)plStack_60 + 0xc);
iVar2 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar2 = *(int *)((long)plStack_60 + 0xc);
*(int *)((long)plStack_60 + 0xc) = iVar2 + -1;
}
if (iVar2 == 1) {
(**(code **)(*plStack_60 + 0x18))();
}
}
return lVar3 + 0x10;
}
|
|
18,484
|
sapphire_plugins::shared::ProcessorShim<sapphire_plugins::elastika::ElastikaClap>::paramsInfo(unsigned int, clap_param_info*) const
|
sapphire-plugins/src/shared/processor_shim.h
|
bool paramsInfo(uint32_t paramIndex, clap_param_info *info) const noexcept override
{
return sst::plugininfra::patch_support::patchParamsInfo(paramIndex, info,
asProcessor()->patch);
}
|
O3
|
c
|
sapphire_plugins::shared::ProcessorShim<sapphire_plugins::elastika::ElastikaClap>::paramsInfo(unsigned int, clap_param_info*) const:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %eax
movq 0x100260(%rdi), %rcx
movq (%rcx,%rax,8), %r14
leaq 0x8(%r14), %rdi
movq %rdx, %rsi
callq 0xdbe5e
movq %r14, 0x8(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
_ZNK16sapphire_plugins6shared13ProcessorShimINS_6galaxy10GalaxyClapEE10paramsInfoEjP15clap_param_info:
push r14
push rbx
push rax
mov rbx, rdx
mov eax, esi
mov rcx, [rdi+100260h]
mov r14, [rcx+rax*8]
lea rdi, [r14+8]
mov rsi, rdx
call _ZNK3sst12basic_blocks6params13ParamMetaData15toClapParamInfoILi256E15clap_param_infoEEvPT0_; sst::basic_blocks::params::ParamMetaData::toClapParamInfo<256,clap_param_info>(clap_param_info *)
mov [rbx+8], r14
mov al, 1
add rsp, 8
pop rbx
pop r14
retn
|
char sapphire_plugins::shared::ProcessorShim<sapphire_plugins::galaxy::GalaxyClap>::paramsInfo(
long long a1,
unsigned int a2,
long long a3)
{
__m64 *v4; // r14
v4 = *(__m64 **)(*(_QWORD *)(a1 + 1049184) + 8LL * a2);
sst::basic_blocks::params::ParamMetaData::toClapParamInfo<256,clap_param_info>(v4 + 1, a3);
*(_QWORD *)(a3 + 8) = v4;
return 1;
}
|
paramsInfo:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV EAX,ESI
MOV RCX,qword ptr [RDI + 0x100260]
MOV R14,qword ptr [RCX + RAX*0x8]
LEA RDI,[R14 + 0x8]
MOV RSI,RDX
CALL 0x001dbe5e
MOV qword ptr [RBX + 0x8],R14
MOV AL,0x1
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* sapphire_plugins::shared::ProcessorShim<sapphire_plugins::galaxy::GalaxyClap>::paramsInfo(unsigned
int, clap_param_info*) const */
int8 __thiscall
sapphire_plugins::shared::ProcessorShim<sapphire_plugins::galaxy::GalaxyClap>::paramsInfo
(ProcessorShim<sapphire_plugins::galaxy::GalaxyClap> *this,uint param_1,
clap_param_info *param_2)
{
long lVar1;
lVar1 = *(long *)(*(long *)(this + 0x100260) + (ulong)param_1 * 8);
sst::basic_blocks::params::ParamMetaData::toClapParamInfo<256,clap_param_info>
((ParamMetaData *)(lVar1 + 8),param_2);
*(long *)(param_2 + 8) = lVar1;
return 1;
}
|
|
18,485
|
testing::Matcher<std::basic_string_view<char, std::char_traits<char>> const&>::~Matcher()
|
AlayaLite/build_O0/_deps/googletest-src/googletest/include/gtest/gtest-matchers.h
|
class GTEST_API_ Matcher<const internal::StringView&>
: public internal::MatcherBase<const internal::StringView&> {
public:
Matcher() = default;
explicit Matcher(const MatcherInterface<const internal::StringView&>* impl)
: internal::MatcherBase<const internal::StringView&>(impl) {}
template <typename M, typename = typename std::remove_reference<
M>::type::is_gtest_matcher>
Matcher(M&& m) // NOLINT
: internal::MatcherBase<const internal::StringView&>(std::forward<M>(m)) {
}
// Allows the user to write str instead of Eq(str) sometimes, where
// str is a std::string object.
Matcher(const std::string& s); // NOLINT
// Allows the user to write "foo" instead of Eq("foo") sometimes.
Matcher(const char* s); // NOLINT
// Allows the user to pass absl::string_views or std::string_views directly.
Matcher(internal::StringView s); // NOLINT
}
|
O0
|
c
|
testing::Matcher<std::basic_string_view<char, std::char_traits<char>> const&>::~Matcher():
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xec350
movq 0x8(%rsp), %rdi
movl $0x18, %esi
callq 0x16720
addq $0x18, %rsp
retq
nopl (%rax)
|
_ZN7testing7MatcherIRKSt17basic_string_viewIcSt11char_traitsIcEEED0Ev:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov rdi, [rsp+18h+var_8]
mov [rsp+18h+var_10], rdi
call _ZN7testing7MatcherIRKSt17basic_string_viewIcSt11char_traitsIcEEED2Ev; testing::Matcher<std::string_view const&>::~Matcher()
mov rdi, [rsp+18h+var_10]; void *
mov esi, 18h; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
add rsp, 18h
retn
|
void testing::Matcher<std::string_view const&>::~Matcher(void *a1)
{
testing::Matcher<std::string_view const&>::~Matcher((long long)a1);
operator delete(a1, 0x18uLL);
}
|
~Matcher:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x001ec350
MOV RDI,qword ptr [RSP + 0x8]
MOV ESI,0x18
CALL 0x00116720
ADD RSP,0x18
RET
|
/* testing::Matcher<std::basic_string_view<char, std::char_traits<char> > const&>::~Matcher() */
void __thiscall
testing::Matcher<std::basic_string_view<char,std::char_traits<char>>const&>::~Matcher
(Matcher<std::basic_string_view<char,std::char_traits<char>>const&> *this)
{
~Matcher(this);
operator_delete(this,0x18);
return;
}
|
|
18,486
|
OpenSubdiv::v3_6_0::Vtr::internal::Level::gatherTriRegularCornerVertexPatchPoints(int, int*, int) const
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/vtr/level.cpp
|
int
Level::gatherTriRegularCornerVertexPatchPoints(Index fIndex, Index points[], int cornerFaceVert) const
{
ConstIndexArray fVerts = getFaceVertices(fIndex);
Index v0 = fVerts[cornerFaceVert];
Index v1 = fVerts[(cornerFaceVert + 1) % 3];
Index v2 = fVerts[(cornerFaceVert + 2) % 3];
ConstIndexArray v1Edges = getVertexEdges(v1);
ConstIndexArray v2Edges = getVertexEdges(v2);
points[0] = v0;
points[1] = v1;
points[2] = v2;
points[3] = otherOfTwo(getEdgeVertices(v1Edges[0]), v1);
points[4] = otherOfTwo(getEdgeVertices(v1Edges[1]), v1);
points[5] = otherOfTwo(getEdgeVertices(v2Edges[3]), v2);
return 6;
}
|
O0
|
cpp
|
OpenSubdiv::v3_6_0::Vtr::internal::Level::gatherTriRegularCornerVertexPatchPoints(int, int*, int) const:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
movl -0xc(%rbp), %esi
callq 0xce580
movl %edx, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %esi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0xcabf0
movq -0x110(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movl -0x1c(%rbp), %edx
movl %edx, %ecx
incl %ecx
movl %edx, %eax
movslq %ecx, %rcx
imulq $0x55555556, %rcx, %rdx # imm = 0x55555556
movq %rdx, %rcx
shrq $0x3f, %rcx
shrq $0x20, %rdx
addl %ecx, %edx
movl %edx, %ecx
leal (%rcx,%rcx,2), %edx
negl %edx
movl %edx, %ecx
leal 0x1(%rax,%rcx), %esi
callq 0xcabf0
movq -0x110(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x48(%rbp)
movl -0x1c(%rbp), %edx
movl %edx, %ecx
addl $0x2, %ecx
movl %edx, %eax
movslq %ecx, %rcx
imulq $0x55555556, %rcx, %rdx # imm = 0x55555556
movq %rdx, %rcx
shrq $0x3f, %rcx
shrq $0x20, %rdx
addl %ecx, %edx
movl %edx, %ecx
leal (%rcx,%rcx,2), %edx
negl %edx
movl %edx, %ecx
leal 0x2(%rax,%rcx), %esi
callq 0xcabf0
movq -0xf8(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
movl -0x48(%rbp), %esi
callq 0xd31e0
movq -0xf8(%rbp), %rdi
movl %edx, -0x68(%rbp)
movq %rax, -0x70(%rbp)
movl -0x68(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x4c(%rbp), %esi
callq 0xd31e0
movl %edx, -0x88(%rbp)
movq %rax, -0x90(%rbp)
movl -0x88(%rbp), %eax
movl %eax, -0x78(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0x44(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x48(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x4c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x108(%rbp)
xorl %esi, %esi
callq 0xcabf0
movq -0xf8(%rbp), %rdi
movl (%rax), %esi
callq 0xd32c0
movl %edx, -0xa8(%rbp)
movq %rax, -0xb0(%rbp)
movl -0xa8(%rbp), %eax
movl %eax, -0x98(%rbp)
movq -0xb0(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0xa0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movq %rsi, -0x100(%rbp)
callq 0xee770
movq -0x108(%rbp), %rdi
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movl $0x1, %esi
callq 0xcabf0
movq -0xf8(%rbp), %rdi
movl (%rax), %esi
callq 0xd32c0
movq -0x100(%rbp), %rsi
movl %edx, -0xc8(%rbp)
movq %rax, -0xd0(%rbp)
movl -0xc8(%rbp), %eax
movl %eax, -0xb8(%rbp)
movq -0xd0(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0xee770
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
leaq -0x80(%rbp), %rdi
movl $0x3, %esi
callq 0xcabf0
movq -0xf8(%rbp), %rdi
movl (%rax), %esi
callq 0xd32c0
movl %edx, -0xe8(%rbp)
movq %rax, -0xf0(%rbp)
movq -0xf0(%rbp), %rax
movq %rax, -0xe0(%rbp)
movl -0xe8(%rbp), %eax
movl %eax, -0xd8(%rbp)
leaq -0xe0(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
callq 0xee770
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x14(%rax)
movl $0x6, %eax
addq $0x110, %rsp # imm = 0x110
popq %rbp
retq
nopw (%rax,%rax)
|
_ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level39gatherTriRegularCornerVertexPatchPointsEiPii:
push rbp
mov rbp, rsp
sub rsp, 110h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov rdi, [rbp+var_8]; this
mov [rbp+var_F8], rdi
mov esi, [rbp+var_C]; int
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level15getFaceVerticesEi; OpenSubdiv::v3_6_0::Vtr::internal::Level::getFaceVertices(int)
mov [rbp+var_38], edx
mov [rbp+var_40], rax
mov eax, [rbp+var_38]
mov [rbp+var_28], eax
mov rax, [rbp+var_40]
mov [rbp+var_30], rax
mov esi, [rbp+var_1C]
lea rdi, [rbp+var_30]
mov [rbp+var_110], rdi
call __ZNK10OpenSubdiv6v3_6_03Vtr10ConstArrayIiEixEi; OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::operator[](int)
mov rdi, [rbp+var_110]
mov eax, [rax]
mov [rbp+var_44], eax
mov edx, [rbp+var_1C]
mov ecx, edx
inc ecx
mov eax, edx
movsxd rcx, ecx
imul rdx, rcx, 55555556h
mov rcx, rdx
shr rcx, 3Fh
shr rdx, 20h
add edx, ecx
mov ecx, edx
lea edx, [rcx+rcx*2]
neg edx
mov ecx, edx
lea esi, [rax+rcx+1]
call __ZNK10OpenSubdiv6v3_6_03Vtr10ConstArrayIiEixEi; OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::operator[](int)
mov rdi, [rbp+var_110]
mov eax, [rax]
mov [rbp+var_48], eax
mov edx, [rbp+var_1C]
mov ecx, edx
add ecx, 2
mov eax, edx
movsxd rcx, ecx
imul rdx, rcx, 55555556h
mov rcx, rdx
shr rcx, 3Fh
shr rdx, 20h
add edx, ecx
mov ecx, edx
lea edx, [rcx+rcx*2]
neg edx
mov ecx, edx
lea esi, [rax+rcx+2]
call __ZNK10OpenSubdiv6v3_6_03Vtr10ConstArrayIiEixEi; OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::operator[](int)
mov rdi, [rbp+var_F8]; this
mov eax, [rax]
mov [rbp+var_4C], eax
mov esi, [rbp+var_48]; int
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level14getVertexEdgesEi; OpenSubdiv::v3_6_0::Vtr::internal::Level::getVertexEdges(int)
mov rdi, [rbp+var_F8]; this
mov [rbp+var_68], edx
mov [rbp+var_70], rax
mov eax, [rbp+var_68]
mov [rbp+var_58], eax
mov rax, [rbp+var_70]
mov [rbp+var_60], rax
mov esi, [rbp+var_4C]; int
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level14getVertexEdgesEi; OpenSubdiv::v3_6_0::Vtr::internal::Level::getVertexEdges(int)
mov [rbp+var_88], edx
mov [rbp+var_90], rax
mov eax, [rbp+var_88]
mov [rbp+var_78], eax
mov rax, [rbp+var_90]
mov [rbp+var_80], rax
mov ecx, [rbp+var_44]
mov rax, [rbp+var_18]
mov [rax], ecx
mov ecx, [rbp+var_48]
mov rax, [rbp+var_18]
mov [rax+4], ecx
mov ecx, [rbp+var_4C]
mov rax, [rbp+var_18]
mov [rax+8], ecx
lea rdi, [rbp+var_60]
mov [rbp+var_108], rdi
xor esi, esi
call __ZNK10OpenSubdiv6v3_6_03Vtr10ConstArrayIiEixEi; OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::operator[](int)
mov rdi, [rbp+var_F8]; this
mov esi, [rax]; int
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level15getEdgeVerticesEi; OpenSubdiv::v3_6_0::Vtr::internal::Level::getEdgeVertices(int)
mov [rbp+var_A8], edx
mov [rbp+var_B0], rax
mov eax, [rbp+var_A8]
mov [rbp+var_98], eax
mov rax, [rbp+var_B0]
mov [rbp+var_A0], rax
lea rdi, [rbp+var_A0]
lea rsi, [rbp+var_48]
mov [rbp+var_100], rsi
call _ZN10OpenSubdiv6v3_6_03Vtr8internal12_GLOBAL__N_110otherOfTwoINS1_10ConstArrayIiEEiEET0_RKT_RKS7_; OpenSubdiv::v3_6_0::Vtr::internal::`anonymous namespace'::otherOfTwo<OpenSubdiv::v3_6_0::Vtr::ConstArray<int>,int>(OpenSubdiv::v3_6_0::Vtr::ConstArray<int> const&,int const&)
mov rdi, [rbp+var_108]
mov ecx, eax
mov rax, [rbp+var_18]
mov [rax+0Ch], ecx
mov esi, 1
call __ZNK10OpenSubdiv6v3_6_03Vtr10ConstArrayIiEixEi; OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::operator[](int)
mov rdi, [rbp+var_F8]; this
mov esi, [rax]; int
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level15getEdgeVerticesEi; OpenSubdiv::v3_6_0::Vtr::internal::Level::getEdgeVertices(int)
mov rsi, [rbp+var_100]
mov [rbp+var_C8], edx
mov [rbp+var_D0], rax
mov eax, [rbp+var_C8]
mov [rbp+var_B8], eax
mov rax, [rbp+var_D0]
mov [rbp+var_C0], rax
lea rdi, [rbp+var_C0]
call _ZN10OpenSubdiv6v3_6_03Vtr8internal12_GLOBAL__N_110otherOfTwoINS1_10ConstArrayIiEEiEET0_RKT_RKS7_; OpenSubdiv::v3_6_0::Vtr::internal::`anonymous namespace'::otherOfTwo<OpenSubdiv::v3_6_0::Vtr::ConstArray<int>,int>(OpenSubdiv::v3_6_0::Vtr::ConstArray<int> const&,int const&)
mov ecx, eax
mov rax, [rbp+var_18]
mov [rax+10h], ecx
lea rdi, [rbp+var_80]
mov esi, 3
call __ZNK10OpenSubdiv6v3_6_03Vtr10ConstArrayIiEixEi; OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::operator[](int)
mov rdi, [rbp+var_F8]; this
mov esi, [rax]; int
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level15getEdgeVerticesEi; OpenSubdiv::v3_6_0::Vtr::internal::Level::getEdgeVertices(int)
mov [rbp+var_E8], edx
mov [rbp+var_F0], rax
mov rax, [rbp+var_F0]
mov [rbp+var_E0], rax
mov eax, [rbp+var_E8]
mov [rbp+var_D8], eax
lea rdi, [rbp+var_E0]
lea rsi, [rbp+var_4C]
call _ZN10OpenSubdiv6v3_6_03Vtr8internal12_GLOBAL__N_110otherOfTwoINS1_10ConstArrayIiEEiEET0_RKT_RKS7_; OpenSubdiv::v3_6_0::Vtr::internal::`anonymous namespace'::otherOfTwo<OpenSubdiv::v3_6_0::Vtr::ConstArray<int>,int>(OpenSubdiv::v3_6_0::Vtr::ConstArray<int> const&,int const&)
mov ecx, eax
mov rax, [rbp+var_18]
mov [rax+14h], ecx
mov eax, 6
add rsp, 110h
pop rbp
retn
|
long long OpenSubdiv::v3_6_0::Vtr::internal::Level::gatherTriRegularCornerVertexPatchPoints(
OpenSubdiv::v3_6_0::Vtr::internal::Level *this,
int a2,
int *a3,
unsigned int a4)
{
long long FaceVertices; // rax
int v5; // edx
long long VertexEdges; // rax
int v7; // edx
long long v8; // rax
int v9; // edx
int *v10; // rax
long long EdgeVertices; // rax
int v12; // edx
int v13; // eax
int *v14; // rax
long long v15; // rax
int v16; // edx
int v17; // eax
int *v18; // rax
int v19; // edx
int v20; // eax
long long v22; // [rsp+30h] [rbp-E0h] BYREF
int v23; // [rsp+38h] [rbp-D8h]
long long v24; // [rsp+40h] [rbp-D0h]
int v25; // [rsp+48h] [rbp-C8h]
long long v26; // [rsp+50h] [rbp-C0h] BYREF
int v27; // [rsp+58h] [rbp-B8h]
long long v28; // [rsp+60h] [rbp-B0h]
int v29; // [rsp+68h] [rbp-A8h]
long long v30; // [rsp+70h] [rbp-A0h] BYREF
int v31; // [rsp+78h] [rbp-98h]
long long v32; // [rsp+80h] [rbp-90h]
int v33; // [rsp+88h] [rbp-88h]
long long v34; // [rsp+90h] [rbp-80h] BYREF
int v35; // [rsp+98h] [rbp-78h]
long long v36; // [rsp+A0h] [rbp-70h]
int v37; // [rsp+A8h] [rbp-68h]
long long v38; // [rsp+B0h] [rbp-60h] BYREF
int v39; // [rsp+B8h] [rbp-58h]
int v40; // [rsp+C4h] [rbp-4Ch] BYREF
int v41; // [rsp+C8h] [rbp-48h] BYREF
int v42; // [rsp+CCh] [rbp-44h]
long long v43; // [rsp+D0h] [rbp-40h]
int v44; // [rsp+D8h] [rbp-38h]
long long v45; // [rsp+E0h] [rbp-30h] BYREF
int v46; // [rsp+E8h] [rbp-28h]
unsigned int v47; // [rsp+F4h] [rbp-1Ch]
int *v48; // [rsp+F8h] [rbp-18h]
int v49; // [rsp+104h] [rbp-Ch]
OpenSubdiv::v3_6_0::Vtr::internal::Level *v50; // [rsp+108h] [rbp-8h]
v50 = this;
v49 = a2;
v48 = a3;
v47 = a4;
FaceVertices = OpenSubdiv::v3_6_0::Vtr::internal::Level::getFaceVertices(this, a2);
v44 = v5;
v43 = FaceVertices;
v46 = v5;
v45 = FaceVertices;
v42 = *(_DWORD *)OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::operator[](&v45, v47);
v41 = *(_DWORD *)OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::operator[](&v45, v47 - 3 * ((int)(v47 + 1) / 3) + 1);
v40 = *(_DWORD *)OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::operator[](&v45, v47 - 3 * ((int)(v47 + 2) / 3) + 2);
VertexEdges = OpenSubdiv::v3_6_0::Vtr::internal::Level::getVertexEdges(this, v41);
v37 = v7;
v36 = VertexEdges;
v39 = v7;
v38 = VertexEdges;
v8 = OpenSubdiv::v3_6_0::Vtr::internal::Level::getVertexEdges(this, v40);
v33 = v9;
v32 = v8;
v35 = v9;
v34 = v8;
*v48 = v42;
v48[1] = v41;
v48[2] = v40;
v10 = (int *)OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::operator[](&v38, 0LL);
EdgeVertices = OpenSubdiv::v3_6_0::Vtr::internal::Level::getEdgeVertices(this, *v10);
v29 = v12;
v28 = EdgeVertices;
v31 = v12;
v30 = EdgeVertices;
v13 = OpenSubdiv::v3_6_0::Vtr::internal::`anonymous namespace'::otherOfTwo<OpenSubdiv::v3_6_0::Vtr::ConstArray<int>,int>(
(long long)&v30,
&v41);
v48[3] = v13;
v14 = (int *)OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::operator[](&v38, 1LL);
v15 = OpenSubdiv::v3_6_0::Vtr::internal::Level::getEdgeVertices(this, *v14);
v25 = v16;
v24 = v15;
v27 = v16;
v26 = v15;
v17 = OpenSubdiv::v3_6_0::Vtr::internal::`anonymous namespace'::otherOfTwo<OpenSubdiv::v3_6_0::Vtr::ConstArray<int>,int>(
(long long)&v26,
&v41);
v48[4] = v17;
v18 = (int *)OpenSubdiv::v3_6_0::Vtr::ConstArray<int>::operator[](&v34, 3LL);
v22 = OpenSubdiv::v3_6_0::Vtr::internal::Level::getEdgeVertices(this, *v18);
v23 = v19;
v20 = OpenSubdiv::v3_6_0::Vtr::internal::`anonymous namespace'::otherOfTwo<OpenSubdiv::v3_6_0::Vtr::ConstArray<int>,int>(
(long long)&v22,
&v40);
v48[5] = v20;
return 6LL;
}
|
gatherTriRegularCornerVertexPatchPoints:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x110
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0xf8],RDI
MOV ESI,dword ptr [RBP + -0xc]
CALL 0x001ce580
MOV dword ptr [RBP + -0x38],EDX
MOV qword ptr [RBP + -0x40],RAX
MOV EAX,dword ptr [RBP + -0x38]
MOV dword ptr [RBP + -0x28],EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x30],RAX
MOV ESI,dword ptr [RBP + -0x1c]
LEA RDI,[RBP + -0x30]
MOV qword ptr [RBP + -0x110],RDI
CALL 0x001cabf0
MOV RDI,qword ptr [RBP + -0x110]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x44],EAX
MOV EDX,dword ptr [RBP + -0x1c]
MOV ECX,EDX
INC ECX
MOV EAX,EDX
MOVSXD RCX,ECX
IMUL RDX,RCX,0x55555556
MOV RCX,RDX
SHR RCX,0x3f
SHR RDX,0x20
ADD EDX,ECX
MOV ECX,EDX
LEA EDX,[RCX + RCX*0x2]
NEG EDX
MOV ECX,EDX
LEA ESI,[RAX + RCX*0x1 + 0x1]
CALL 0x001cabf0
MOV RDI,qword ptr [RBP + -0x110]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x48],EAX
MOV EDX,dword ptr [RBP + -0x1c]
MOV ECX,EDX
ADD ECX,0x2
MOV EAX,EDX
MOVSXD RCX,ECX
IMUL RDX,RCX,0x55555556
MOV RCX,RDX
SHR RCX,0x3f
SHR RDX,0x20
ADD EDX,ECX
MOV ECX,EDX
LEA EDX,[RCX + RCX*0x2]
NEG EDX
MOV ECX,EDX
LEA ESI,[RAX + RCX*0x1 + 0x2]
CALL 0x001cabf0
MOV RDI,qword ptr [RBP + -0xf8]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4c],EAX
MOV ESI,dword ptr [RBP + -0x48]
CALL 0x001d31e0
MOV RDI,qword ptr [RBP + -0xf8]
MOV dword ptr [RBP + -0x68],EDX
MOV qword ptr [RBP + -0x70],RAX
MOV EAX,dword ptr [RBP + -0x68]
MOV dword ptr [RBP + -0x58],EAX
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x60],RAX
MOV ESI,dword ptr [RBP + -0x4c]
CALL 0x001d31e0
MOV dword ptr [RBP + -0x88],EDX
MOV qword ptr [RBP + -0x90],RAX
MOV EAX,dword ptr [RBP + -0x88]
MOV dword ptr [RBP + -0x78],EAX
MOV RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RBP + -0x80],RAX
MOV ECX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX],ECX
MOV ECX,dword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x4],ECX
MOV ECX,dword ptr [RBP + -0x4c]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x8],ECX
LEA RDI,[RBP + -0x60]
MOV qword ptr [RBP + -0x108],RDI
XOR ESI,ESI
CALL 0x001cabf0
MOV RDI,qword ptr [RBP + -0xf8]
MOV ESI,dword ptr [RAX]
CALL 0x001d32c0
MOV dword ptr [RBP + -0xa8],EDX
MOV qword ptr [RBP + -0xb0],RAX
MOV EAX,dword ptr [RBP + -0xa8]
MOV dword ptr [RBP + -0x98],EAX
MOV RAX,qword ptr [RBP + -0xb0]
MOV qword ptr [RBP + -0xa0],RAX
LEA RDI,[RBP + -0xa0]
LEA RSI,[RBP + -0x48]
MOV qword ptr [RBP + -0x100],RSI
CALL 0x001ee770
MOV RDI,qword ptr [RBP + -0x108]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0xc],ECX
MOV ESI,0x1
CALL 0x001cabf0
MOV RDI,qword ptr [RBP + -0xf8]
MOV ESI,dword ptr [RAX]
CALL 0x001d32c0
MOV RSI,qword ptr [RBP + -0x100]
MOV dword ptr [RBP + -0xc8],EDX
MOV qword ptr [RBP + -0xd0],RAX
MOV EAX,dword ptr [RBP + -0xc8]
MOV dword ptr [RBP + -0xb8],EAX
MOV RAX,qword ptr [RBP + -0xd0]
MOV qword ptr [RBP + -0xc0],RAX
LEA RDI,[RBP + -0xc0]
CALL 0x001ee770
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x10],ECX
LEA RDI,[RBP + -0x80]
MOV ESI,0x3
CALL 0x001cabf0
MOV RDI,qword ptr [RBP + -0xf8]
MOV ESI,dword ptr [RAX]
CALL 0x001d32c0
MOV dword ptr [RBP + -0xe8],EDX
MOV qword ptr [RBP + -0xf0],RAX
MOV RAX,qword ptr [RBP + -0xf0]
MOV qword ptr [RBP + -0xe0],RAX
MOV EAX,dword ptr [RBP + -0xe8]
MOV dword ptr [RBP + -0xd8],EAX
LEA RDI,[RBP + -0xe0]
LEA RSI,[RBP + -0x4c]
CALL 0x001ee770
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x14],ECX
MOV EAX,0x6
ADD RSP,0x110
POP RBP
RET
|
/* OpenSubdiv::v3_6_0::Vtr::internal::Level::gatherTriRegularCornerVertexPatchPoints(int, int*, int)
const */
int8 __thiscall
OpenSubdiv::v3_6_0::Vtr::internal::Level::gatherTriRegularCornerVertexPatchPoints
(Level *this,int param_1,int *param_2,int param_3)
{
int iVar1;
int *piVar2;
ConstArray local_e8 [16];
int1 local_d8 [12];
ConstArray local_c8 [16];
int1 local_b8 [12];
ConstArray local_a8 [16];
int1 local_98 [12];
ConstArray<int> local_88 [16];
int1 local_78 [12];
ConstArray<int> local_68 [20];
int local_54;
int local_50;
int local_4c;
int1 local_48 [12];
ConstArray<int> local_38 [20];
int local_24;
int *local_20;
int local_14;
Level *local_10;
local_24 = param_3;
local_20 = param_2;
local_14 = param_1;
local_10 = this;
local_48 = getFaceVertices(this,param_1);
local_38._0_12_ = local_48;
piVar2 = (int *)ConstArray<int>::operator[](local_38,local_24);
local_4c = *piVar2;
piVar2 = (int *)ConstArray<int>::operator[](local_38,local_24 + 1 + ((local_24 + 1) / 3) * -3);
local_50 = *piVar2;
piVar2 = (int *)ConstArray<int>::operator[](local_38,local_24 + 2 + ((local_24 + 2) / 3) * -3);
local_54 = *piVar2;
local_78 = getVertexEdges(this,local_50);
local_68._0_12_ = local_78;
local_98 = getVertexEdges(this,local_54);
*local_20 = local_4c;
local_20[1] = local_50;
local_20[2] = local_54;
local_88._0_12_ = local_98;
piVar2 = (int *)ConstArray<int>::operator[](local_68,0);
local_b8 = getEdgeVertices(this,*piVar2);
local_a8._0_12_ = local_b8;
iVar1 = (anonymous_namespace)::otherOfTwo<OpenSubdiv::v3_6_0::Vtr::ConstArray<int>,int>
(local_a8,&local_50);
local_20[3] = iVar1;
piVar2 = (int *)ConstArray<int>::operator[](local_68,1);
local_d8 = getEdgeVertices(this,*piVar2);
local_c8._0_12_ = local_d8;
iVar1 = (anonymous_namespace)::otherOfTwo<OpenSubdiv::v3_6_0::Vtr::ConstArray<int>,int>
(local_c8,&local_50);
local_20[4] = iVar1;
piVar2 = (int *)ConstArray<int>::operator[](local_88,3);
local_e8._0_12_ = getEdgeVertices(this,*piVar2);
iVar1 = (anonymous_namespace)::otherOfTwo<OpenSubdiv::v3_6_0::Vtr::ConstArray<int>,int>
(local_e8,&local_54);
local_20[5] = iVar1;
return 6;
}
|
|
18,487
|
OpenSubdiv::v3_6_0::Vtr::internal::Level::gatherTriRegularCornerVertexPatchPoints(int, int*, int) const
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/vtr/level.cpp
|
int
Level::gatherTriRegularCornerVertexPatchPoints(Index fIndex, Index points[], int cornerFaceVert) const
{
ConstIndexArray fVerts = getFaceVertices(fIndex);
Index v0 = fVerts[cornerFaceVert];
Index v1 = fVerts[(cornerFaceVert + 1) % 3];
Index v2 = fVerts[(cornerFaceVert + 2) % 3];
ConstIndexArray v1Edges = getVertexEdges(v1);
ConstIndexArray v2Edges = getVertexEdges(v2);
points[0] = v0;
points[1] = v1;
points[2] = v2;
points[3] = otherOfTwo(getEdgeVertices(v1Edges[0]), v1);
points[4] = otherOfTwo(getEdgeVertices(v1Edges[1]), v1);
points[5] = otherOfTwo(getEdgeVertices(v2Edges[3]), v2);
return 6;
}
|
O2
|
cpp
|
OpenSubdiv::v3_6_0::Vtr::internal::Level::gatherTriRegularCornerVertexPatchPoints(int, int*, int) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rdi, %r14
callq 0x52db0
movq %rax, %rcx
movslq %ebp, %rsi
movl (%rax,%rsi,4), %r13d
leal 0x1(%rsi), %eax
pushq $0x3
popq %rdi
cltd
idivl %edi
movslq %edx, %rax
movl (%rcx,%rax,4), %r15d
addl $0x2, %esi
movl %esi, %eax
cltd
idivl %edi
movslq %edx, %rax
movl (%rcx,%rax,4), %ebp
movq %r14, %rdi
movl %r15d, %esi
callq 0x54550
movq %rax, %r12
movq %r14, %rdi
movl %ebp, %esi
callq 0x54550
movl %r13d, (%rbx)
movl %r15d, 0x4(%rbx)
movl %ebp, 0x8(%rbx)
movslq (%r12), %rcx
movq 0x78(%r14), %rdx
leaq (%rdx,%rcx,8), %rcx
xorl %esi, %esi
cmpl (%rcx), %r15d
sete %sil
movl (%rcx,%rsi,4), %ecx
movl %ecx, 0xc(%rbx)
movslq 0x4(%r12), %rcx
leaq (%rdx,%rcx,8), %rcx
xorl %esi, %esi
cmpl (%rcx), %r15d
sete %sil
movl (%rcx,%rsi,4), %ecx
movl %ecx, 0x10(%rbx)
movslq 0xc(%rax), %rax
leaq (%rdx,%rax,8), %rax
xorl %ecx, %ecx
cmpl (%rax), %ebp
sete %cl
movl (%rax,%rcx,4), %eax
movl %eax, 0x14(%rbx)
pushq $0x6
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level39gatherTriRegularCornerVertexPatchPointsEiPii:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebp, ecx
mov rbx, rdx
mov r14, rdi
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level15getFaceVerticesEi; OpenSubdiv::v3_6_0::Vtr::internal::Level::getFaceVertices(int)
mov rcx, rax
movsxd rsi, ebp
mov r13d, [rax+rsi*4]
lea eax, [rsi+1]
push 3
pop rdi
cdq
idiv edi
movsxd rax, edx
mov r15d, [rcx+rax*4]
add esi, 2
mov eax, esi
cdq
idiv edi
movsxd rax, edx
mov ebp, [rcx+rax*4]
mov rdi, r14; this
mov esi, r15d; int
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level14getVertexEdgesEi; OpenSubdiv::v3_6_0::Vtr::internal::Level::getVertexEdges(int)
mov r12, rax
mov rdi, r14; this
mov esi, ebp; int
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level14getVertexEdgesEi; OpenSubdiv::v3_6_0::Vtr::internal::Level::getVertexEdges(int)
mov [rbx], r13d
mov [rbx+4], r15d
mov [rbx+8], ebp
movsxd rcx, dword ptr [r12]
mov rdx, [r14+78h]
lea rcx, [rdx+rcx*8]
xor esi, esi
cmp r15d, [rcx]
setz sil
mov ecx, [rcx+rsi*4]
mov [rbx+0Ch], ecx
movsxd rcx, dword ptr [r12+4]
lea rcx, [rdx+rcx*8]
xor esi, esi
cmp r15d, [rcx]
setz sil
mov ecx, [rcx+rsi*4]
mov [rbx+10h], ecx
movsxd rax, dword ptr [rax+0Ch]
lea rax, [rdx+rax*8]
xor ecx, ecx
cmp ebp, [rax]
setz cl
mov eax, [rax+rcx*4]
mov [rbx+14h], eax
push 6
pop rax
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long OpenSubdiv::v3_6_0::Vtr::internal::Level::gatherTriRegularCornerVertexPatchPoints(
OpenSubdiv::v3_6_0::Vtr::internal::Level *this,
int a2,
int *a3,
int a4)
{
long long FaceVertices; // rax
int v7; // r13d
int v8; // r15d
int v9; // ebp
int *VertexEdges; // r12
long long v11; // rax
long long v12; // rdx
_DWORD *v13; // rcx
_DWORD *v14; // rax
FaceVertices = OpenSubdiv::v3_6_0::Vtr::internal::Level::getFaceVertices(this, a2);
v7 = *(_DWORD *)(FaceVertices + 4LL * a4);
v8 = *(_DWORD *)(FaceVertices + 4LL * ((a4 + 1) % 3));
v9 = *(_DWORD *)(FaceVertices + 4LL * ((a4 + 2) % 3));
VertexEdges = (int *)OpenSubdiv::v3_6_0::Vtr::internal::Level::getVertexEdges(this, v8);
v11 = OpenSubdiv::v3_6_0::Vtr::internal::Level::getVertexEdges(this, v9);
*a3 = v7;
a3[1] = v8;
a3[2] = v9;
v12 = *((_QWORD *)this + 15);
a3[3] = *(_DWORD *)(v12 + 8LL * *VertexEdges + 4LL * (v8 == *(_DWORD *)(v12 + 8LL * *VertexEdges)));
v13 = (_DWORD *)(v12 + 8LL * VertexEdges[1]);
a3[4] = v13[v8 == *v13];
v14 = (_DWORD *)(v12 + 8LL * *(int *)(v11 + 12));
a3[5] = v14[v9 == *v14];
return 6LL;
}
|
gatherTriRegularCornerVertexPatchPoints:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EBP,ECX
MOV RBX,RDX
MOV R14,RDI
CALL 0x00152db0
MOV RCX,RAX
MOVSXD RSI,EBP
MOV R13D,dword ptr [RAX + RSI*0x4]
LEA EAX,[RSI + 0x1]
PUSH 0x3
POP RDI
CDQ
IDIV EDI
MOVSXD RAX,EDX
MOV R15D,dword ptr [RCX + RAX*0x4]
ADD ESI,0x2
MOV EAX,ESI
CDQ
IDIV EDI
MOVSXD RAX,EDX
MOV EBP,dword ptr [RCX + RAX*0x4]
MOV RDI,R14
MOV ESI,R15D
CALL 0x00154550
MOV R12,RAX
MOV RDI,R14
MOV ESI,EBP
CALL 0x00154550
MOV dword ptr [RBX],R13D
MOV dword ptr [RBX + 0x4],R15D
MOV dword ptr [RBX + 0x8],EBP
MOVSXD RCX,dword ptr [R12]
MOV RDX,qword ptr [R14 + 0x78]
LEA RCX,[RDX + RCX*0x8]
XOR ESI,ESI
CMP R15D,dword ptr [RCX]
SETZ SIL
MOV ECX,dword ptr [RCX + RSI*0x4]
MOV dword ptr [RBX + 0xc],ECX
MOVSXD RCX,dword ptr [R12 + 0x4]
LEA RCX,[RDX + RCX*0x8]
XOR ESI,ESI
CMP R15D,dword ptr [RCX]
SETZ SIL
MOV ECX,dword ptr [RCX + RSI*0x4]
MOV dword ptr [RBX + 0x10],ECX
MOVSXD RAX,dword ptr [RAX + 0xc]
LEA RAX,[RDX + RAX*0x8]
XOR ECX,ECX
CMP EBP,dword ptr [RAX]
SETZ CL
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV dword ptr [RBX + 0x14],EAX
PUSH 0x6
POP RAX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* OpenSubdiv::v3_6_0::Vtr::internal::Level::gatherTriRegularCornerVertexPatchPoints(int, int*, int)
const */
int8 __thiscall
OpenSubdiv::v3_6_0::Vtr::internal::Level::gatherTriRegularCornerVertexPatchPoints
(Level *this,int param_1,int *param_2,int param_3)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
long lVar5;
int *piVar6;
long lVar7;
lVar5 = getFaceVertices(this,param_1);
iVar2 = *(int *)(lVar5 + (long)param_3 * 4);
iVar3 = *(int *)(lVar5 + (long)((param_3 + 1) % 3) * 4);
iVar4 = *(int *)(lVar5 + (long)((param_3 + 2) % 3) * 4);
piVar6 = (int *)getVertexEdges(this,iVar3);
lVar7 = getVertexEdges(this,iVar4);
*param_2 = iVar2;
param_2[1] = iVar3;
param_2[2] = iVar4;
lVar5 = *(long *)(this + 0x78);
piVar1 = (int *)(lVar5 + (long)*piVar6 * 8);
param_2[3] = piVar1[iVar3 == *piVar1];
piVar1 = (int *)(lVar5 + (long)piVar6[1] * 8);
param_2[4] = piVar1[iVar3 == *piVar1];
piVar1 = (int *)(lVar5 + (long)*(int *)(lVar7 + 0xc) * 8);
param_2[5] = piVar1[iVar4 == *piVar1];
return 6;
}
|
|
18,488
|
serial_cpp::Serial::read(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long)
|
ami-iit[P]serial_cpp/src/serial.cc
|
size_t
Serial::read (std::string &buffer, size_t size)
{
ScopedReadLock lock(this->pimpl_);
uint8_t *buffer_ = new uint8_t[size];
size_t bytes_read = 0;
try {
bytes_read = this->pimpl_->read (buffer_, size);
}
catch (const std::exception &e) {
delete[] buffer_;
throw;
}
buffer.append (reinterpret_cast<const char*>(buffer_), bytes_read);
delete[] buffer_;
return bytes_read;
}
|
O2
|
cpp
|
serial_cpp::Serial::read(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movq 0x8(%rdi), %rdi
movq %rdi, (%rsp)
callq 0x6f28
movq %r15, %rdi
callq 0x3030
movq %rax, %rbx
movq 0x8(%r12), %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x5bb4
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3060
movq %rbx, %rdi
callq 0x3370
movq %rsp, %rdi
callq 0x4968
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x424a
movq %rax, %r14
cmpl $0x1, %edx
jne 0x424d
movq %r14, %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3370
callq 0x33f0
movq %rax, %r14
callq 0x3460
jmp 0x424d
movq %rax, %rdi
callq 0x3e6c
movq %rax, %r14
movq %rsp, %rdi
callq 0x4968
movq %r14, %rdi
callq 0x34d0
nop
|
_ZN10serial_cpp6Serial4readERNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEm:
push r15
push r14
push r12
push rbx
push rax
mov r15, rdx
mov r14, rsi
mov r12, rdi
mov rdi, [rdi+8]; this
mov [rsp+28h+var_28], rdi
call _ZN10serial_cpp6Serial10SerialImpl8readLockEv; serial_cpp::Serial::SerialImpl::readLock(void)
mov rdi, r15; unsigned __int64
call __Znam; operator new[](ulong)
mov rbx, rax
mov rdi, [r12+8]; this
mov rsi, rax; unsigned __int8 *
mov rdx, r15; unsigned __int64
call _ZN10serial_cpp6Serial10SerialImpl4readEPhm; serial_cpp::Serial::SerialImpl::read(uchar *,ulong)
mov r15, rax
mov rdi, r14
mov rsi, rbx
mov rdx, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
mov rdi, rbx; void *
call __ZdaPv; operator delete[](void *)
mov rdi, rsp; this
call _ZN10serial_cpp6Serial14ScopedReadLockD2Ev; serial_cpp::Serial::ScopedReadLock::~ScopedReadLock()
mov rax, r15
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
jmp short loc_424A
mov r14, rax
cmp edx, 1
jnz short loc_424D
mov rdi, r14; void *
call ___cxa_begin_catch
mov rdi, rbx; void *
call __ZdaPv; operator delete[](void *)
call ___cxa_rethrow
mov r14, rax
call ___cxa_end_catch
jmp short loc_424D
mov rdi, rax
call __clang_call_terminate
loc_424A:
mov r14, rax
loc_424D:
mov rdi, rsp; this
call _ZN10serial_cpp6Serial14ScopedReadLockD2Ev; serial_cpp::Serial::ScopedReadLock::~ScopedReadLock()
mov rdi, r14
call __Unwind_Resume
|
long long serial_cpp::Serial::read(long long a1, long long a2, unsigned long long a3)
{
serial_cpp::Serial::SerialImpl *v3; // rax
unsigned __int8 *v5; // rbx
long long v6; // r15
serial_cpp::Serial::SerialImpl *v8; // [rsp+0h] [rbp-28h] BYREF
v8 = v3;
v8 = *(serial_cpp::Serial::SerialImpl **)(a1 + 8);
serial_cpp::Serial::SerialImpl::readLock(v8);
v5 = (unsigned __int8 *)operator new[](a3);
v6 = serial_cpp::Serial::SerialImpl::read(*(serial_cpp::Serial::SerialImpl **)(a1 + 8), v5, a3);
std::string::append(a2, v5, v6);
operator delete[](v5);
serial_cpp::Serial::ScopedReadLock::~ScopedReadLock((serial_cpp::Serial::ScopedReadLock *)&v8);
return v6;
}
|
read:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDX
MOV R14,RSI
MOV R12,RDI
MOV RDI,qword ptr [RDI + 0x8]
MOV qword ptr [RSP],RDI
CALL 0x00106f28
LAB_001041ce:
MOV RDI,R15
CALL 0x00103030
MOV RBX,RAX
MOV RDI,qword ptr [R12 + 0x8]
LAB_001041de:
MOV RSI,RAX
MOV RDX,R15
CALL 0x00105bb4
LAB_001041e9:
MOV R15,RAX
MOV RDI,R14
MOV RSI,RBX
MOV RDX,RAX
CALL 0x00103060
LAB_001041fa:
MOV RDI,RBX
CALL 0x00103370
MOV RDI,RSP
CALL 0x00104968
MOV RAX,R15
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* serial_cpp::Serial::read(std::__cxx11::string&, unsigned long) */
int8 __thiscall serial_cpp::Serial::read(Serial *this,string *param_1,ulong param_2)
{
uchar *puVar1;
int8 uVar2;
SerialImpl *local_28;
local_28 = *(SerialImpl **)(this + 8);
SerialImpl::readLock(local_28);
/* try { // try from 001041ce to 001041d5 has its CatchHandler @ 0010424a */
puVar1 = (uchar *)operator_new__(param_2);
/* try { // try from 001041de to 001041e8 has its CatchHandler @ 0010421b */
uVar2 = SerialImpl::read(*(SerialImpl **)(this + 8),puVar1,param_2);
/* try { // try from 001041e9 to 001041f9 has its CatchHandler @ 00104219 */
std::__cxx11::string::append((char *)param_1,(ulong)puVar1);
operator_delete__(puVar1);
ScopedReadLock::~ScopedReadLock((ScopedReadLock *)&local_28);
return uVar2;
}
|
|
18,489
|
serial_cpp::Serial::read(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long)
|
ami-iit[P]serial_cpp/src/serial.cc
|
size_t
Serial::read (std::string &buffer, size_t size)
{
ScopedReadLock lock(this->pimpl_);
uint8_t *buffer_ = new uint8_t[size];
size_t bytes_read = 0;
try {
bytes_read = this->pimpl_->read (buffer_, size);
}
catch (const std::exception &e) {
delete[] buffer_;
throw;
}
buffer.append (reinterpret_cast<const char*>(buffer_), bytes_read);
delete[] buffer_;
return bytes_read;
}
|
O3
|
cpp
|
serial_cpp::Serial::read(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r13
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x7b98
movq %r12, %rdi
callq 0x3030
movq %rax, %r14
movq 0x8(%r13), %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x6468
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x3070
movq %r14, %rdi
callq 0x3380
movq %rbx, %rdi
callq 0x7c4e
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x467c
jmp 0x4669
movq %rax, %r15
cmpl $0x1, %edx
jne 0x466c
movq %r15, %rdi
callq 0x3120
movq %r14, %rdi
callq 0x3380
callq 0x3400
movq %rax, %r15
callq 0x3480
jmp 0x466c
jmp 0x467c
movq %rax, %r15
movq %rbx, %rdi
callq 0x7c4e
movq %r15, %rdi
callq 0x34f0
movq %rax, %rdi
callq 0x41cf
|
_ZN10serial_cpp6Serial4readERNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEm:
push r15
push r14
push r13
push r12
push rbx
mov r12, rdx
mov r15, rsi
mov r13, rdi
mov rbx, [rdi+8]
mov rdi, rbx; this
call _ZN10serial_cpp6Serial10SerialImpl8readLockEv; serial_cpp::Serial::SerialImpl::readLock(void)
mov rdi, r12; unsigned __int64
call __Znam; operator new[](ulong)
mov r14, rax
mov rdi, [r13+8]; this
mov rsi, rax; unsigned __int8 *
mov rdx, r12; unsigned __int64
call _ZN10serial_cpp6Serial10SerialImpl4readEPhm; serial_cpp::Serial::SerialImpl::read(uchar *,ulong)
mov r12, rax
mov rdi, r15
mov rsi, r14
mov rdx, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
mov rdi, r14; void *
call __ZdaPv; operator delete[](void *)
mov rdi, rbx; this
call _ZN10serial_cpp6Serial10SerialImpl10readUnlockEv; serial_cpp::Serial::SerialImpl::readUnlock(void)
mov rax, r12
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
jmp short loc_467C
jmp short loc_4669
mov r15, rax
cmp edx, 1
jnz short loc_466C
mov rdi, r15; void *
call ___cxa_begin_catch
mov rdi, r14; void *
call __ZdaPv; operator delete[](void *)
call ___cxa_rethrow
mov r15, rax
call ___cxa_end_catch
jmp short loc_466C
jmp short loc_467C
loc_4669:
mov r15, rax
loc_466C:
mov rdi, rbx; this
call _ZN10serial_cpp6Serial10SerialImpl10readUnlockEv; serial_cpp::Serial::SerialImpl::readUnlock(void)
mov rdi, r15
call __Unwind_Resume
loc_467C:
mov rdi, rax
call __clang_call_terminate
|
long long serial_cpp::Serial::read(long long a1, long long a2, unsigned long long a3)
{
serial_cpp::Serial::SerialImpl *v4; // rbx
unsigned __int8 *v5; // r14
long long v6; // r12
v4 = *(serial_cpp::Serial::SerialImpl **)(a1 + 8);
serial_cpp::Serial::SerialImpl::readLock(v4);
v5 = (unsigned __int8 *)operator new[](a3);
v6 = serial_cpp::Serial::SerialImpl::read(*(serial_cpp::Serial::SerialImpl **)(a1 + 8), v5, a3);
std::string::append(a2, v5, v6);
operator delete[](v5);
serial_cpp::Serial::SerialImpl::readUnlock(v4);
return v6;
}
|
read:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R12,RDX
MOV R15,RSI
MOV R13,RDI
MOV RBX,qword ptr [RDI + 0x8]
MOV RDI,RBX
CALL 0x00107b98
LAB_001045f4:
MOV RDI,R12
CALL 0x00103030
MOV R14,RAX
MOV RDI,qword ptr [R13 + 0x8]
LAB_00104603:
MOV RSI,RAX
MOV RDX,R12
CALL 0x00106468
LAB_0010460e:
MOV R12,RAX
MOV RDI,R15
MOV RSI,R14
MOV RDX,RAX
CALL 0x00103070
MOV RDI,R14
CALL 0x00103380
LAB_00104627:
MOV RDI,RBX
CALL 0x00107c4e
LAB_0010462f:
MOV RAX,R12
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* serial_cpp::Serial::read(std::__cxx11::string&, unsigned long) */
int8 __thiscall serial_cpp::Serial::read(Serial *this,string *param_1,ulong param_2)
{
SerialImpl *this_00;
uchar *puVar1;
int8 uVar2;
this_00 = *(SerialImpl **)(this + 8);
SerialImpl::readLock(this_00);
/* try { // try from 001045f4 to 001045fb has its CatchHandler @ 00104669 */
puVar1 = (uchar *)operator_new__(param_2);
/* try { // try from 00104603 to 0010460d has its CatchHandler @ 00104640 */
uVar2 = SerialImpl::read(*(SerialImpl **)(this + 8),puVar1,param_2);
/* try { // try from 0010460e to 0010461e has its CatchHandler @ 0010463e */
std::__cxx11::string::append((char *)param_1,(ulong)puVar1);
operator_delete__(puVar1);
/* try { // try from 00104627 to 0010462e has its CatchHandler @ 0010463c */
SerialImpl::readUnlock(this_00);
return uVar2;
}
|
|
18,490
|
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&)
|
monkey531[P]llama/common/json.hpp
|
basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {}
|
O1
|
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 0xa32de
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x59800
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x59800
movq %r14, %rdi
xorl %esi, %esi
callq 0x59800
movq %r14, %rdi
callq 0x5efec
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 0x001a32de
MOVUPS XMM0,xmmword ptr [R14]
MOVUPS xmmword ptr [RBX],XMM0
MOV RDI,R14
XOR ESI,ESI
CALL 0x00159800
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,RBX
MOV ESI,0x1
CALL 0x00159800
MOV RDI,R14
XOR ESI,ESI
CALL 0x00159800
MOV RDI,R14
CALL 0x0015efec
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;
}
|
|
18,491
|
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&)
|
monkey531[P]llama/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 0xa1aea
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x59184
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x59184
movq %r14, %rdi
xorl %esi, %esi
callq 0x59184
movq %r14, %rdi
callq 0x5e672
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 0x001a1aea
MOVUPS XMM0,xmmword ptr [R14]
MOVUPS xmmword ptr [RBX],XMM0
MOV RDI,R14
XOR ESI,ESI
CALL 0x00159184
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,RBX
MOV ESI,0x1
CALL 0x00159184
MOV RDI,R14
XOR ESI,ESI
CALL 0x00159184
MOV RDI,R14
CALL 0x0015e672
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;
}
|
|
18,492
|
ma_bitmap_end
|
eloqsql/storage/maria/ma_bitmap.c
|
my_bool _ma_bitmap_end(MARIA_SHARE *share)
{
my_bool res;
#ifndef DBUG_OFF
if (! share->internal_table)
mysql_mutex_assert_owner(&share->close_lock);
#endif
DBUG_ASSERT(share->bitmap.non_flushable == 0);
DBUG_ASSERT(share->bitmap.flush_all_requested == 0);
DBUG_ASSERT(share->bitmap.waiting_for_non_flushable == 0 &&
share->bitmap.waiting_for_flush_all_requested == 0);
DBUG_ASSERT(share->bitmap.pinned_pages.elements == 0);
res= _ma_bitmap_flush(share);
mysql_mutex_destroy(&share->bitmap.bitmap_lock);
mysql_cond_destroy(&share->bitmap.bitmap_cond);
delete_dynamic(&share->bitmap.pinned_pages);
my_free(share->bitmap.map);
share->bitmap.map= 0;
/*
This is to not get an assert in checkpoint. The bitmap will be flushed
at once by _ma_once_end_block_record() as part of the normal flush
of the kfile.
*/
share->bitmap.changed_not_flushed= 0;
return res;
}
|
O0
|
c
|
ma_bitmap_end:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x63d0e
jmp 0x63d10
jmp 0x63d12
jmp 0x63d14
jmp 0x63d16
jmp 0x63d18
jmp 0x63d1a
movq -0x8(%rbp), %rdi
callq 0x63da0
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
addq $0xa10, %rdi # imm = 0xA10
addq $0x88, %rdi
callq 0x63e50
movq -0x8(%rbp), %rdi
addq $0xa10, %rdi # imm = 0xA10
addq $0xd0, %rdi
callq 0x63ea0
movq -0x8(%rbp), %rdi
addq $0xa10, %rdi # imm = 0xA10
addq $0x140, %rdi # imm = 0x140
callq 0xdc500
movq -0x8(%rbp), %rax
movq 0xa18(%rax), %rdi
callq 0xf5560
movq -0x8(%rbp), %rax
movq $0x0, 0xa18(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0xa31(%rax)
movb -0x9(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nop
|
_ma_bitmap_end:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
jmp short $+2
loc_63D0E:
jmp short $+2
loc_63D10:
jmp short $+2
loc_63D12:
jmp short $+2
loc_63D14:
jmp short $+2
loc_63D16:
jmp short $+2
loc_63D18:
jmp short $+2
loc_63D1A:
mov rdi, [rbp+var_8]
call _ma_bitmap_flush
mov [rbp+var_9], al
mov rdi, [rbp+var_8]
add rdi, 0A10h
add rdi, 88h
call inline_mysql_mutex_destroy_2
mov rdi, [rbp+var_8]
add rdi, 0A10h
add rdi, 0D0h
call inline_mysql_cond_destroy_1
mov rdi, [rbp+var_8]
add rdi, 0A10h
add rdi, 140h
call delete_dynamic
mov rax, [rbp+var_8]
mov rdi, [rax+0A18h]
call my_free
mov rax, [rbp+var_8]
mov qword ptr [rax+0A18h], 0
mov rax, [rbp+var_8]
mov byte ptr [rax+0A31h], 0
mov al, [rbp+var_9]
add rsp, 10h
pop rbp
retn
|
char ma_bitmap_end(long long a1)
{
char v2; // [rsp+7h] [rbp-9h]
v2 = ma_bitmap_flush(a1);
inline_mysql_mutex_destroy_2(a1 + 2712);
inline_mysql_cond_destroy_1(a1 + 2784);
delete_dynamic(a1 + 2896);
my_free(*(_QWORD *)(a1 + 2584));
*(_QWORD *)(a1 + 2584) = 0LL;
*(_BYTE *)(a1 + 2609) = 0;
return v2;
}
|
_ma_bitmap_end:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
JMP 0x00163d0e
LAB_00163d0e:
JMP 0x00163d10
LAB_00163d10:
JMP 0x00163d12
LAB_00163d12:
JMP 0x00163d14
LAB_00163d14:
JMP 0x00163d16
LAB_00163d16:
JMP 0x00163d18
LAB_00163d18:
JMP 0x00163d1a
LAB_00163d1a:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00163da0
MOV byte ptr [RBP + -0x9],AL
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xa10
ADD RDI,0x88
CALL 0x00163e50
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xa10
ADD RDI,0xd0
CALL 0x00163ea0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xa10
ADD RDI,0x140
CALL 0x001dc500
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0xa18]
CALL 0x001f5560
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xa18],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0xa31],0x0
MOV AL,byte ptr [RBP + -0x9]
ADD RSP,0x10
POP RBP
RET
|
int1 _ma_bitmap_end(long param_1)
{
int1 uVar1;
uVar1 = _ma_bitmap_flush(param_1);
inline_mysql_mutex_destroy(param_1 + 0xa98);
inline_mysql_cond_destroy(param_1 + 0xae0);
delete_dynamic(param_1 + 0xb50);
my_free(*(int8 *)(param_1 + 0xa18));
*(int8 *)(param_1 + 0xa18) = 0;
*(int1 *)(param_1 + 0xa31) = 0;
return uVar1;
}
|
|
18,493
|
stbi__fill_bits(stbi__zbuf*)
|
monkey531[P]llama/examples/llava/../../common/stb_image.h
|
static void stbi__fill_bits(stbi__zbuf *z)
{
do {
if (z->code_buffer >= (1U << z->num_bits)) {
z->zbuffer = z->zbuffer_end; /* treat this as EOF so we fail. */
return;
}
z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits;
z->num_bits += 8;
} while (z->num_bits <= 24);
}
|
O0
|
c
|
stbi__fill_bits(stbi__zbuf*):
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movl 0x18(%rax), %eax
movq (%rsp), %rcx
movl 0x10(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
cmpl %ecx, %eax
jb 0xb2d51
movq (%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
jmp 0xb2d89
movq (%rsp), %rdi
callq 0xb2cb0
movzbl %al, %eax
movq (%rsp), %rcx
movl 0x10(%rcx), %ecx
shll %cl, %eax
movl %eax, %ecx
movq (%rsp), %rax
orl 0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
movq (%rsp), %rax
movl 0x10(%rax), %ecx
addl $0x8, %ecx
movl %ecx, 0x10(%rax)
movq (%rsp), %rax
cmpl $0x18, 0x10(%rax)
jle 0xb2d25
popq %rax
retq
nopl (%rax,%rax)
|
_ZL15stbi__fill_bitsP10stbi__zbuf:
push rax
mov [rsp+8+var_8], rdi
loc_B2D25:
mov rax, [rsp+8+var_8]
mov eax, [rax+18h]
mov rcx, [rsp+8+var_8]
mov ecx, [rcx+10h]
mov edx, 1
shl edx, cl
mov ecx, edx
cmp eax, ecx
jb short loc_B2D51
mov rax, [rsp+8+var_8]
mov rcx, [rax+8]
mov rax, [rsp+8+var_8]
mov [rax], rcx
jmp short loc_B2D89
loc_B2D51:
mov rdi, [rsp+8+var_8]
call _ZL11stbi__zget8P10stbi__zbuf; stbi__zget8(stbi__zbuf *)
movzx eax, al
mov rcx, [rsp+8+var_8]
mov ecx, [rcx+10h]
shl eax, cl
mov ecx, eax
mov rax, [rsp+8+var_8]
or ecx, [rax+18h]
mov [rax+18h], ecx
mov rax, [rsp+8+var_8]
mov ecx, [rax+10h]
add ecx, 8
mov [rax+10h], ecx
mov rax, [rsp+8+var_8]
cmp dword ptr [rax+10h], 18h
jle short loc_B2D25
loc_B2D89:
pop rax
retn
|
long long stbi__fill_bits(long long a1)
{
while ( *(_DWORD *)(a1 + 24) < (unsigned int)(1 << *(_DWORD *)(a1 + 16)) )
{
*(_DWORD *)(a1 + 24) |= (unsigned __int8)stbi__zget8((_QWORD *)a1) << *(_DWORD *)(a1 + 16);
*(_DWORD *)(a1 + 16) += 8;
if ( *(int *)(a1 + 16) > 24 )
return a1;
}
*(_QWORD *)a1 = *(_QWORD *)(a1 + 8);
return a1;
}
|
stbi__fill_bits:
PUSH RAX
MOV qword ptr [RSP],RDI
LAB_001b2d25:
MOV RAX,qword ptr [RSP]
MOV EAX,dword ptr [RAX + 0x18]
MOV RCX,qword ptr [RSP]
MOV ECX,dword ptr [RCX + 0x10]
MOV EDX,0x1
SHL EDX,CL
MOV ECX,EDX
CMP EAX,ECX
JC 0x001b2d51
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RSP]
MOV qword ptr [RAX],RCX
JMP 0x001b2d89
LAB_001b2d51:
MOV RDI,qword ptr [RSP]
CALL 0x001b2cb0
MOVZX EAX,AL
MOV RCX,qword ptr [RSP]
MOV ECX,dword ptr [RCX + 0x10]
SHL EAX,CL
MOV ECX,EAX
MOV RAX,qword ptr [RSP]
OR ECX,dword ptr [RAX + 0x18]
MOV dword ptr [RAX + 0x18],ECX
MOV RAX,qword ptr [RSP]
MOV ECX,dword ptr [RAX + 0x10]
ADD ECX,0x8
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RSP]
CMP dword ptr [RAX + 0x10],0x18
JLE 0x001b2d25
LAB_001b2d89:
POP RAX
RET
|
/* stbi__fill_bits(stbi__zbuf*) */
stbi__zbuf * stbi__fill_bits(stbi__zbuf *param_1)
{
byte bVar1;
do {
if ((uint)(1 << ((byte)*(int4 *)(param_1 + 0x10) & 0x1f)) <= *(uint *)(param_1 + 0x18)) {
*(int8 *)param_1 = *(int8 *)(param_1 + 8);
return param_1;
}
bVar1 = stbi__zget8(param_1);
*(uint *)(param_1 + 0x18) =
(uint)bVar1 << ((byte)*(int4 *)(param_1 + 0x10) & 0x1f) | *(uint *)(param_1 + 0x18);
*(int *)(param_1 + 0x10) = *(int *)(param_1 + 0x10) + 8;
} while (*(int *)(param_1 + 0x10) < 0x19);
return param_1;
}
|
|
18,494
|
js_init_module_std
|
bluesky950520[P]quickjs/quickjs-libc.c
|
JSModuleDef *js_init_module_std(JSContext *ctx, const char *module_name)
{
JSModuleDef *m;
m = JS_NewCModule(ctx, module_name, js_std_init);
if (!m)
return NULL;
JS_AddModuleExportList(ctx, m, js_std_funcs, countof(js_std_funcs));
JS_AddModuleExport(ctx, m, "in");
JS_AddModuleExport(ctx, m, "out");
JS_AddModuleExport(ctx, m, "err");
return m;
}
|
O0
|
c
|
js_init_module_std:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x91(%rip), %rdx # 0x16ae0
callq 0x4f810
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x16a6c
movq $0x0, 0x20(%rsp)
jmp 0x16ad3
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0x11fe33(%rip), %rdx # 0x1368b0
movl $0x16, %ecx
callq 0x535f0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0xfd76c(%rip), %rdx # 0x114204
callq 0x4fa70
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0xf9955(%rip), %rdx # 0x110403
callq 0x4fa70
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0xf9946(%rip), %rdx # 0x11040a
callq 0x4fa70
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
|
js_init_module_std:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_18], rsi
mov rdi, [rsp+28h+var_10]
mov rsi, [rsp+28h+var_18]
lea rdx, js_std_init
call JS_NewCModule
mov [rsp+28h+var_20], rax
cmp [rsp+28h+var_20], 0
jnz short loc_16A6C
mov [rsp+28h+var_8], 0
jmp short loc_16AD3
loc_16A6C:
mov rdi, [rsp+28h+var_10]
mov rsi, [rsp+28h+var_20]
lea rdx, js_std_funcs
mov ecx, 16h
call JS_AddModuleExportList
mov rdi, [rsp+28h+var_10]
mov rsi, [rsp+28h+var_20]
lea rdx, aCircularProtot+16h; "in"
call JS_AddModuleExport
mov rdi, [rsp+28h+var_10]
mov rsi, [rsp+28h+var_20]
lea rdx, aStdout_0+3; "out"
call JS_AddModuleExport
mov rdi, [rsp+28h+var_10]
mov rsi, [rsp+28h+var_20]
lea rdx, aStderr_0+3; "err"
call JS_AddModuleExport
mov rax, [rsp+28h+var_20]
mov [rsp+28h+var_8], rax
loc_16AD3:
mov rax, [rsp+28h+var_8]
add rsp, 28h
retn
|
long long js_init_module_std(long long a1, long long a2)
{
long long v3; // [rsp+8h] [rbp-20h]
v3 = JS_NewCModule(a1, a2, js_std_init);
if ( !v3 )
return 0LL;
JS_AddModuleExportList(a1, v3, &js_std_funcs, 22LL);
JS_AddModuleExport(a1, v3, "in");
JS_AddModuleExport(a1, v3, "out");
JS_AddModuleExport(a1, v3, "err");
return v3;
}
|
js_init_module_std:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV qword ptr [RSP + 0x10],RSI
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x10]
LEA RDX,[0x116ae0]
CALL 0x0014f810
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
JNZ 0x00116a6c
MOV qword ptr [RSP + 0x20],0x0
JMP 0x00116ad3
LAB_00116a6c:
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x8]
LEA RDX,[0x2368b0]
MOV ECX,0x16
CALL 0x001535f0
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x8]
LEA RDX,[0x214204]
CALL 0x0014fa70
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x8]
LEA RDX,[0x210403]
CALL 0x0014fa70
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x8]
LEA RDX,[0x21040a]
CALL 0x0014fa70
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x20],RAX
LAB_00116ad3:
MOV RAX,qword ptr [RSP + 0x20]
ADD RSP,0x28
RET
|
long js_init_module_std(int8 param_1,int8 param_2)
{
long local_8;
local_8 = JS_NewCModule(param_1,param_2,js_std_init);
if (local_8 == 0) {
local_8 = 0;
}
else {
JS_AddModuleExportList(param_1,local_8,js_std_funcs,0x16);
JS_AddModuleExport(param_1,local_8,"in");
JS_AddModuleExport(param_1,local_8,"out");
JS_AddModuleExport(param_1,local_8,"err");
}
return local_8;
}
|
|
18,495
|
js_init_module_std
|
bluesky950520[P]quickjs/quickjs-libc.c
|
JSModuleDef *js_init_module_std(JSContext *ctx, const char *module_name)
{
JSModuleDef *m;
m = JS_NewCModule(ctx, module_name, js_std_init);
if (!m)
return NULL;
JS_AddModuleExportList(ctx, m, js_std_funcs, countof(js_std_funcs));
JS_AddModuleExport(ctx, m, "in");
JS_AddModuleExport(ctx, m, "out");
JS_AddModuleExport(ctx, m, "err");
return m;
}
|
O1
|
c
|
js_init_module_std:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x69(%rip), %rdx # 0x18c5b
callq 0x348af
testq %rax, %rax
je 0x18c4e
movq %rax, %rbx
leaq 0xb2b5a(%rip), %rdx # 0xcb760
movq %r14, %rdi
movq %rax, %rsi
movl $0x16, %ecx
callq 0x370ac
leaq 0x8a5fb(%rip), %rdx # 0xa3218
movq %r14, %rdi
movq %rbx, %rsi
callq 0x348ef
leaq 0x87728(%rip), %rdx # 0xa0357
movq %r14, %rdi
movq %rbx, %rsi
callq 0x348ef
leaq 0x8771d(%rip), %rdx # 0xa035e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x348ef
jmp 0x18c50
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
js_init_module_std:
push r14
push rbx
push rax
mov r14, rdi
lea rdx, js_std_init
call JS_NewCModule
test rax, rax
jz short loc_18C4E
mov rbx, rax
lea rdx, js_std_funcs
mov rdi, r14
mov rsi, rax
mov ecx, 16h
call JS_AddModuleExportList
lea rdx, aCircularProtot+16h; "in"
mov rdi, r14
mov rsi, rbx
call JS_AddModuleExport
lea rdx, aStdout_0+3; "out"
mov rdi, r14
mov rsi, rbx
call JS_AddModuleExport
lea rdx, aStderr_0+3; "err"
mov rdi, r14
mov rsi, rbx
call JS_AddModuleExport
jmp short loc_18C50
loc_18C4E:
xor ebx, ebx
loc_18C50:
mov rax, rbx
add rsp, 8
pop rbx
pop r14
retn
|
long long js_init_module_std(long long a1, long long a2)
{
long long v2; // rax
long long v3; // rbx
v2 = JS_NewCModule(a1, a2, js_std_init);
if ( !v2 )
return 0LL;
v3 = v2;
JS_AddModuleExportList(a1, v2, &js_std_funcs, 22LL);
JS_AddModuleExport(a1, v3, "in");
JS_AddModuleExport(a1, v3, "out");
JS_AddModuleExport(a1, v3, "err");
return v3;
}
|
js_init_module_std:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RDI
LEA RDX,[0x118c5b]
CALL 0x001348af
TEST RAX,RAX
JZ 0x00118c4e
MOV RBX,RAX
LEA RDX,[0x1cb760]
MOV RDI,R14
MOV RSI,RAX
MOV ECX,0x16
CALL 0x001370ac
LEA RDX,[0x1a3218]
MOV RDI,R14
MOV RSI,RBX
CALL 0x001348ef
LEA RDX,[0x1a0357]
MOV RDI,R14
MOV RSI,RBX
CALL 0x001348ef
LEA RDX,[0x1a035e]
MOV RDI,R14
MOV RSI,RBX
CALL 0x001348ef
JMP 0x00118c50
LAB_00118c4e:
XOR EBX,EBX
LAB_00118c50:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
long js_init_module_std(int8 param_1,int8 param_2)
{
long lVar1;
lVar1 = JS_NewCModule(param_1,param_2,js_std_init);
if (lVar1 == 0) {
lVar1 = 0;
}
else {
JS_AddModuleExportList(param_1,lVar1,js_std_funcs,0x16);
JS_AddModuleExport(param_1,lVar1,"in");
JS_AddModuleExport(param_1,lVar1,"out");
JS_AddModuleExport(param_1,lVar1,"err");
}
return lVar1;
}
|
|
18,496
|
js_init_module_std
|
bluesky950520[P]quickjs/quickjs-libc.c
|
JSModuleDef *js_init_module_std(JSContext *ctx, const char *module_name)
{
JSModuleDef *m;
m = JS_NewCModule(ctx, module_name, js_std_init);
if (!m)
return NULL;
JS_AddModuleExportList(ctx, m, js_std_funcs, countof(js_std_funcs));
JS_AddModuleExport(ctx, m, "in");
JS_AddModuleExport(ctx, m, "out");
JS_AddModuleExport(ctx, m, "err");
return m;
}
|
O2
|
c
|
js_init_module_std:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x63(%rip), %rdx # 0x13770
callq 0x2c9fb
movq %rax, %r14
testq %rax, %rax
je 0x13765
leaq 0xa50bf(%rip), %rdx # 0xb87e0
pushq $0x16
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x302fa
leaq 0x75a32(%rip), %rdx # 0x89168
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2caee
leaq 0x72baf(%rip), %rdx # 0x862f7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2caee
leaq 0x72ba4(%rip), %rdx # 0x862fe
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2caee
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
js_init_module_std:
push r14
push rbx
push rax
mov rbx, rdi
lea rdx, js_std_init
call JS_NewCModule
mov r14, rax
test rax, rax
jz short loc_13765
lea rdx, js_std_funcs
push 16h
pop rcx
mov rdi, rbx
mov rsi, r14
call JS_AddModuleExportList
lea rdx, aCircularProtot+16h; "in"
mov rdi, rbx
mov rsi, r14
call JS_AddModuleExport
lea rdx, aStdout_0+3; "out"
mov rdi, rbx
mov rsi, r14
call JS_AddModuleExport
lea rdx, aStderr_0+3; "err"
mov rdi, rbx
mov rsi, r14
call JS_AddModuleExport
loc_13765:
mov rax, r14
add rsp, 8
pop rbx
pop r14
retn
|
long long js_init_module_std(long long a1, long long a2)
{
long long v2; // rax
long long v3; // r14
v2 = JS_NewCModule(a1, a2, js_std_init);
v3 = v2;
if ( v2 )
{
JS_AddModuleExportList(a1, v2, &js_std_funcs, 22LL);
JS_AddModuleExport(a1, v3, "in");
JS_AddModuleExport(a1, v3, "out");
JS_AddModuleExport(a1, v3, "err");
}
return v3;
}
|
js_init_module_std:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA RDX,[0x113770]
CALL 0x0012c9fb
MOV R14,RAX
TEST RAX,RAX
JZ 0x00113765
LEA RDX,[0x1b87e0]
PUSH 0x16
POP RCX
MOV RDI,RBX
MOV RSI,R14
CALL 0x001302fa
LEA RDX,[0x189168]
MOV RDI,RBX
MOV RSI,R14
CALL 0x0012caee
LEA RDX,[0x1862f7]
MOV RDI,RBX
MOV RSI,R14
CALL 0x0012caee
LEA RDX,[0x1862fe]
MOV RDI,RBX
MOV RSI,R14
CALL 0x0012caee
LAB_00113765:
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
RET
|
long js_init_module_std(int8 param_1,int8 param_2)
{
long lVar1;
lVar1 = JS_NewCModule(param_1,param_2,js_std_init);
if (lVar1 != 0) {
JS_AddModuleExportList(param_1,lVar1,js_std_funcs,0x16);
JS_AddModuleExport(param_1,lVar1,"in");
JS_AddModuleExport(param_1,lVar1,"out");
JS_AddModuleExport(param_1,lVar1,"err");
}
return lVar1;
}
|
|
18,497
|
my_strnncollsp_simple_nopad
|
eloqsql/strings/ctype-simple.c
|
int my_strnncollsp_simple_nopad(CHARSET_INFO * cs,
const uchar *a, size_t a_length,
const uchar *b, size_t b_length)
{
return my_strnncoll_simple(cs, a, a_length, b, b_length, FALSE);
}
|
O3
|
c
|
my_strnncollsp_simple_nopad:
pushq %rbp
movq %rsp, %rbp
cmpq %r8, %rdx
movq %r8, %r9
cmovbq %rdx, %r9
movq 0x58(%rdi), %rdi
xorl %r10d, %r10d
cmpq %r10, %r9
je 0x59b23
movzbl (%rsi,%r10), %eax
movzbl (%rdi,%rax), %eax
movzbl (%rcx,%r10), %r11d
movzbl (%rdi,%r11), %r11d
incq %r10
cmpb %r11b, %al
je 0x59afe
subl %r11d, %eax
jmp 0x59b35
xorl %ecx, %ecx
cmpq %r8, %rdx
sbbl %ecx, %ecx
cmpq %r8, %rdx
movl $0x1, %eax
cmovbel %ecx, %eax
popq %rbp
retq
|
my_strnncollsp_simple_nopad:
push rbp
mov rbp, rsp
cmp rdx, r8
mov r9, r8
cmovb r9, rdx
mov rdi, [rdi+58h]
xor r10d, r10d
loc_59AFE:
cmp r9, r10
jz short loc_59B23
movzx eax, byte ptr [rsi+r10]
movzx eax, byte ptr [rdi+rax]
movzx r11d, byte ptr [rcx+r10]
movzx r11d, byte ptr [rdi+r11]
inc r10
cmp al, r11b
jz short loc_59AFE
sub eax, r11d
jmp short loc_59B35
loc_59B23:
xor ecx, ecx
cmp rdx, r8
sbb ecx, ecx
cmp rdx, r8
mov eax, 1
cmovbe eax, ecx
loc_59B35:
pop rbp
retn
|
long long my_strnncollsp_simple_nopad(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
unsigned long long a5)
{
unsigned long long v5; // r9
long long v6; // rdi
long long v7; // r10
int v8; // eax
int v9; // r11d
long long result; // rax
v5 = a5;
if ( a3 < a5 )
v5 = a3;
v6 = *(_QWORD *)(a1 + 88);
v7 = 0LL;
while ( v5 != v7 )
{
v8 = *(unsigned __int8 *)(v6 + *(unsigned __int8 *)(a2 + v7));
v9 = *(unsigned __int8 *)(v6 + *(unsigned __int8 *)(a4 + v7++));
if ( (_BYTE)v8 != (_BYTE)v9 )
return (unsigned int)(v8 - v9);
}
result = 1LL;
if ( a3 <= a5 )
return (unsigned int)-(a3 < a5);
return result;
}
|
my_strnncollsp_simple_nopad:
PUSH RBP
MOV RBP,RSP
CMP RDX,R8
MOV R9,R8
CMOVC R9,RDX
MOV RDI,qword ptr [RDI + 0x58]
XOR R10D,R10D
LAB_00159afe:
CMP R9,R10
JZ 0x00159b23
MOVZX EAX,byte ptr [RSI + R10*0x1]
MOVZX EAX,byte ptr [RDI + RAX*0x1]
MOVZX R11D,byte ptr [RCX + R10*0x1]
MOVZX R11D,byte ptr [RDI + R11*0x1]
INC R10
CMP AL,R11B
JZ 0x00159afe
SUB EAX,R11D
JMP 0x00159b35
LAB_00159b23:
XOR ECX,ECX
CMP RDX,R8
SBB ECX,ECX
CMP RDX,R8
MOV EAX,0x1
CMOVBE EAX,ECX
LAB_00159b35:
POP RBP
RET
|
int my_strnncollsp_simple_nopad(long param_1,long param_2,ulong param_3,long param_4,ulong param_5)
{
byte bVar1;
byte bVar2;
ulong uVar3;
ulong uVar4;
uVar3 = param_5;
if (param_3 < param_5) {
uVar3 = param_3;
}
uVar4 = 0;
do {
if (uVar3 == uVar4) {
if (param_5 < param_3) {
return 1;
}
return -(uint)(param_3 < param_5);
}
bVar1 = *(byte *)(*(long *)(param_1 + 0x58) + (ulong)*(byte *)(param_2 + uVar4));
bVar2 = *(byte *)(*(long *)(param_1 + 0x58) + (ulong)*(byte *)(param_4 + uVar4));
uVar4 = uVar4 + 1;
} while (bVar1 == bVar2);
return (uint)bVar1 - (uint)bVar2;
}
|
|
18,498
|
LefDefParser::lefwNonDefaultRuleLayer(char const*, double, double, double, double, double, double)
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp
|
int
lefwNonDefaultRuleLayer(const char *routingLayerName,
double width,
double minSpacing,
double wireExtension,
double resist,
double capacitance,
double edgeCap)
{
lefwObsoleteNum = LEFW_NONDEFAULTRULELAYER;
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (!lefwDidInit)
return LEFW_BAD_ORDER;
if (lefwState != LEFW_NONDEFAULTRULE_START &&
lefwState != LEFW_NONDEFAULTRULE)
return LEFW_BAD_ORDER;
if (!routingLayerName || routingLayerName == 0 || *routingLayerName == 0)
return LEFW_BAD_DATA;
if (versionNum >= 5.6 && (resist || capacitance || edgeCap))
return LEFW_OBSOLETE;
if (lefwWriteEncrypt) {
encPrint(lefwFile, (char*) " LAYER %s\n", routingLayerName);
encPrint(lefwFile, (char*) " WIDTH %.11g ;\n", width);
encPrint(lefwFile, (char*) " SPACING %.11g ;\n", minSpacing);
if (wireExtension) {
encPrint(lefwFile,
(char*) " WIREEXTENSION %.11g ;\n", wireExtension);
lefwLines++;
}
if (resist) {
encPrint(lefwFile, (char*) " RESISTANCE RPERSQ %.11g ;\n", resist);
lefwLines++;
}
if (capacitance) {
encPrint(lefwFile, (char*) " CAPACITANCE CPERSQDIST %.11g ;\n",
capacitance);
lefwLines++;
}
if (edgeCap) {
encPrint(lefwFile, (char*) " EDGECAPACITANCE %.11g ;\n", edgeCap);
lefwLines++;
}
encPrint(lefwFile, (char*) " END %s\n\n", routingLayerName);
} else {
fprintf(lefwFile, " LAYER %s\n", routingLayerName);
fprintf(lefwFile, " WIDTH %.11g ;\n", width);
fprintf(lefwFile, " SPACING %.11g ;\n", minSpacing);
if (wireExtension) {
fprintf(lefwFile, " WIREEXTENSION %.11g ;\n", wireExtension);
lefwLines++;
}
if (resist) {
fprintf(lefwFile, " RESISTANCE RPERSQ %.11g ;\n", resist);
lefwLines++;
}
if (capacitance) {
fprintf(lefwFile,
" CAPACITANCE CPERSQDIST %.11g ;\n", capacitance);
lefwLines++;
}
if (edgeCap) {
fprintf(lefwFile, " EDGECAPACITANCE %.11g ;\n", edgeCap);
lefwLines++;
}
fprintf(lefwFile, " END %s\n\n", routingLayerName);
}
lefwLines = lefwLines + 4;
lefwSynArray[LEFW_NONDEFAULTRULE] = 1;
lefwState = LEFW_NONDEFAULTRULE;
return LEFW_OK;
}
|
O3
|
cpp
|
LefDefParser::lefwNonDefaultRuleLayer(char const*, double, double, double, double, double, double):
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl $0x3c, 0x14d31(%rip) # 0x24d48
leaq 0x14de2(%rip), %r15 # 0x24e00
movq (%r15), %rdi
testq %rdi, %rdi
je 0x101f0
leaq 0x15023(%rip), %rcx # 0x25054
movl $0x2, %eax
cmpl $0x0, (%rcx)
je 0x101f5
leaq 0x1500a(%rip), %r14 # 0x25050
movl (%r14), %ecx
cmpl $0x3b, %ecx
je 0x10057
cmpl $0xb, %ecx
jne 0x101f5
movl $0x3, %eax
testq %rbx, %rbx
je 0x101f5
cmpb $0x0, (%rbx)
je 0x101f5
movsd 0x14cca(%rip), %xmm6 # 0x24d40
ucomisd 0x908a(%rip), %xmm6 # 0x19108
jb 0x100b9
xorpd %xmm6, %xmm6
ucomisd %xmm6, %xmm3
movl $0x7, %eax
jne 0x101f5
jp 0x101f5
ucomisd %xmm6, %xmm4
jne 0x101f5
jp 0x101f5
ucomisd %xmm6, %xmm5
jne 0x101f5
jp 0x101f5
movsd %xmm0, (%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm2, 0x10(%rsp)
movsd %xmm3, 0x18(%rsp)
movsd %xmm4, 0x20(%rsp)
movsd %xmm5, 0x28(%rsp)
cmpb $0x1, 0x15009(%rip) # 0x250ec
jne 0x101ff
leaq 0xb32c(%rip), %rsi # 0x1b41c
movq %rbx, %rdx
xorl %eax, %eax
callq 0x18c35
movq (%r15), %rdi
leaq 0xbd2a(%rip), %rsi # 0x1be2e
movsd (%rsp), %xmm0
movb $0x1, %al
callq 0x18c35
movq (%r15), %rdi
leaq 0xb30f(%rip), %rsi # 0x1b429
movsd 0x8(%rsp), %xmm0
movb $0x1, %al
callq 0x18c35
xorpd %xmm1, %xmm1
movsd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jne 0x10139
jnp 0x10157
movq (%r15), %rdi
leaq 0xb2fd(%rip), %rsi # 0x1b440
movb $0x1, %al
callq 0x18c35
xorpd %xmm1, %xmm1
leaq 0x14ef7(%rip), %rax # 0x2504c
incl (%rax)
movsd 0x18(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jne 0x10165
jnp 0x1017f
movq (%r15), %rdi
leaq 0xb2ee(%rip), %rsi # 0x1b45d
movb $0x1, %al
callq 0x18c35
leaq 0x14ecf(%rip), %rax # 0x2504c
incl (%rax)
xorpd %xmm1, %xmm1
movsd 0x20(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jne 0x10191
jnp 0x101af
movq (%r15), %rdi
leaq 0xb2e3(%rip), %rsi # 0x1b47e
movb $0x1, %al
callq 0x18c35
xorpd %xmm1, %xmm1
leaq 0x14e9f(%rip), %rax # 0x2504c
incl (%rax)
movsd 0x28(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jne 0x101bd
jnp 0x101d7
movq (%r15), %rdi
leaq 0xb2dd(%rip), %rsi # 0x1b4a4
movb $0x1, %al
callq 0x18c35
leaq 0x14e77(%rip), %rax # 0x2504c
incl (%rax)
movq (%r15), %rdi
leaq 0xb1f7(%rip), %rsi # 0x1b3d8
movq %rbx, %rdx
xorl %eax, %eax
callq 0x18c35
jmp 0x10301
movl $0x1, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xb216(%rip), %rsi # 0x1b41c
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10f0
movq (%r15), %rdi
leaq 0xbc14(%rip), %rsi # 0x1be2e
movsd (%rsp), %xmm0
movb $0x1, %al
callq 0x10f0
movq (%r15), %rdi
leaq 0xb1f9(%rip), %rsi # 0x1b429
movsd 0x8(%rsp), %xmm0
movb $0x1, %al
callq 0x10f0
xorpd %xmm1, %xmm1
movsd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jne 0x1024f
jnp 0x1026d
movq (%r15), %rdi
leaq 0xb1e7(%rip), %rsi # 0x1b440
movb $0x1, %al
callq 0x10f0
xorpd %xmm1, %xmm1
leaq 0x14de1(%rip), %rax # 0x2504c
incl (%rax)
movsd 0x18(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jne 0x1027b
jnp 0x10295
movq (%r15), %rdi
leaq 0xb1d8(%rip), %rsi # 0x1b45d
movb $0x1, %al
callq 0x10f0
leaq 0x14db9(%rip), %rax # 0x2504c
incl (%rax)
xorpd %xmm1, %xmm1
movsd 0x20(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jne 0x102a7
jnp 0x102c5
movq (%r15), %rdi
leaq 0xb1cd(%rip), %rsi # 0x1b47e
movb $0x1, %al
callq 0x10f0
xorpd %xmm1, %xmm1
leaq 0x14d89(%rip), %rax # 0x2504c
incl (%rax)
movsd 0x28(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jne 0x102d3
jnp 0x102ed
movq (%r15), %rdi
leaq 0xb1c7(%rip), %rsi # 0x1b4a4
movb $0x1, %al
callq 0x10f0
leaq 0x14d61(%rip), %rax # 0x2504c
incl (%rax)
movq (%r15), %rdi
leaq 0xb0e1(%rip), %rsi # 0x1b3d8
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10f0
leaq 0x14d44(%rip), %rax # 0x2504c
addl $0x4, (%rax)
leaq 0x14afe(%rip), %rax # 0x24e10
movl $0x1, 0xec(%rax)
movl $0x3b, (%r14)
xorl %eax, %eax
jmp 0x101f5
|
_ZN12LefDefParser23lefwNonDefaultRuleLayerEPKcdddddd:
push r15
push r14
push rbx
sub rsp, 30h
mov rbx, rdi
mov cs:_ZN12LefDefParserL15lefwObsoleteNumE, 3Ch ; '<'; LefDefParser::lefwObsoleteNum
lea r15, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [r15]
test rdi, rdi
jz loc_101F0
lea rcx, _ZN12LefDefParser11lefwDidInitE; LefDefParser::lefwDidInit
mov eax, 2
cmp dword ptr [rcx], 0
jz loc_101F5
lea r14, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
mov ecx, [r14]
cmp ecx, 3Bh ; ';'
jz short loc_10057
cmp ecx, 0Bh
jnz loc_101F5
loc_10057:
mov eax, 3
test rbx, rbx
jz loc_101F5
cmp byte ptr [rbx], 0
jz loc_101F5
movsd xmm6, cs:_ZN12LefDefParserL10versionNumE; LefDefParser::versionNum
ucomisd xmm6, cs:dbl_19108
jb short loc_100B9
xorpd xmm6, xmm6
ucomisd xmm3, xmm6
mov eax, 7
jnz loc_101F5
jp loc_101F5
ucomisd xmm4, xmm6
jnz loc_101F5
jp loc_101F5
ucomisd xmm5, xmm6
jnz loc_101F5
jp loc_101F5
loc_100B9:
movsd [rsp+48h+var_48], xmm0
movsd [rsp+48h+var_40], xmm1
movsd [rsp+48h+var_38], xmm2
movsd [rsp+48h+var_30], xmm3
movsd [rsp+48h+var_28], xmm4
movsd [rsp+48h+var_20], xmm5
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 1; LefDefParser::lefwWriteEncrypt
jnz loc_101FF
lea rsi, aLayerS; " LAYER %s\n"
mov rdx, rbx
xor eax, eax
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
mov rdi, [r15]
lea rsi, aWidth11g+3; " WIDTH %.11g ;\n"
movsd xmm0, [rsp+48h+var_48]
mov al, 1
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
mov rdi, [r15]
lea rsi, aSpacing11g_1; " SPACING %.11g ;\n"
movsd xmm0, [rsp+48h+var_40]
mov al, 1
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
xorpd xmm1, xmm1
movsd xmm0, [rsp+48h+var_38]
ucomisd xmm0, xmm1
jnz short loc_10139
jnp short loc_10157
loc_10139:
mov rdi, [r15]
lea rsi, aWireextension1; " WIREEXTENSION %.11g ;\n"
mov al, 1
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
xorpd xmm1, xmm1
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
inc dword ptr [rax]
loc_10157:
movsd xmm0, [rsp+48h+var_30]
ucomisd xmm0, xmm1
jnz short loc_10165
jnp short loc_1017F
loc_10165:
mov rdi, [r15]
lea rsi, aResistanceRper_0; " RESISTANCE RPERSQ %.11g ;\n"
mov al, 1
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
inc dword ptr [rax]
loc_1017F:
xorpd xmm1, xmm1
movsd xmm0, [rsp+48h+var_28]
ucomisd xmm0, xmm1
jnz short loc_10191
jnp short loc_101AF
loc_10191:
mov rdi, [r15]
lea rsi, aCapacitanceCpe_0; " CAPACITANCE CPERSQDIST %.11g ;\n"
mov al, 1
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
xorpd xmm1, xmm1
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
inc dword ptr [rax]
loc_101AF:
movsd xmm0, [rsp+48h+var_20]
ucomisd xmm0, xmm1
jnz short loc_101BD
jnp short loc_101D7
loc_101BD:
mov rdi, [r15]
lea rsi, aEdgecapacitanc; " EDGECAPACITANCE %.11g ;\n"
mov al, 1
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
inc dword ptr [rax]
loc_101D7:
mov rdi, [r15]
lea rsi, aEndS; " END %s\n\n"
mov rdx, rbx
xor eax, eax
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp loc_10301
loc_101F0:
mov eax, 1
loc_101F5:
add rsp, 30h
pop rbx
pop r14
pop r15
retn
loc_101FF:
lea rsi, aLayerS; " LAYER %s\n"
mov rdx, rbx
xor eax, eax
call _fprintf
mov rdi, [r15]
lea rsi, aWidth11g+3; " WIDTH %.11g ;\n"
movsd xmm0, [rsp+48h+var_48]
mov al, 1
call _fprintf
mov rdi, [r15]
lea rsi, aSpacing11g_1; " SPACING %.11g ;\n"
movsd xmm0, [rsp+48h+var_40]
mov al, 1
call _fprintf
xorpd xmm1, xmm1
movsd xmm0, [rsp+48h+var_38]
ucomisd xmm0, xmm1
jnz short loc_1024F
jnp short loc_1026D
loc_1024F:
mov rdi, [r15]
lea rsi, aWireextension1; " WIREEXTENSION %.11g ;\n"
mov al, 1
call _fprintf
xorpd xmm1, xmm1
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
inc dword ptr [rax]
loc_1026D:
movsd xmm0, [rsp+48h+var_30]
ucomisd xmm0, xmm1
jnz short loc_1027B
jnp short loc_10295
loc_1027B:
mov rdi, [r15]
lea rsi, aResistanceRper_0; " RESISTANCE RPERSQ %.11g ;\n"
mov al, 1
call _fprintf
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
inc dword ptr [rax]
loc_10295:
xorpd xmm1, xmm1
movsd xmm0, [rsp+48h+var_28]
ucomisd xmm0, xmm1
jnz short loc_102A7
jnp short loc_102C5
loc_102A7:
mov rdi, [r15]
lea rsi, aCapacitanceCpe_0; " CAPACITANCE CPERSQDIST %.11g ;\n"
mov al, 1
call _fprintf
xorpd xmm1, xmm1
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
inc dword ptr [rax]
loc_102C5:
movsd xmm0, [rsp+48h+var_20]
ucomisd xmm0, xmm1
jnz short loc_102D3
jnp short loc_102ED
loc_102D3:
mov rdi, [r15]
lea rsi, aEdgecapacitanc; " EDGECAPACITANCE %.11g ;\n"
mov al, 1
call _fprintf
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
inc dword ptr [rax]
loc_102ED:
mov rdi, [r15]
lea rsi, aEndS; " END %s\n\n"
mov rdx, rbx
xor eax, eax
call _fprintf
loc_10301:
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
add dword ptr [rax], 4
lea rax, _ZN12LefDefParser12lefwSynArrayE; LefDefParser::lefwSynArray
mov dword ptr [rax+0ECh], 1
mov dword ptr [r14], 3Bh ; ';'
xor eax, eax
jmp loc_101F5
|
long long LefDefParser::lefwNonDefaultRuleLayer(
LefDefParser *this,
const char *a2,
double a3,
double a4,
double a5,
double a6,
double a7,
double a8,
long long a9,
long long a10,
int a11,
int a12)
{
long long result; // rax
int v13; // edx
int v14; // ecx
int v15; // r8d
int v16; // r9d
int v17; // edx
int v18; // ecx
int v19; // r8d
int v20; // r9d
int v21; // edx
int v22; // ecx
int v23; // r8d
int v24; // r9d
LefDefParser::lefwObsoleteNum = 60;
if ( !*(_QWORD *)&LefDefParser::lefwFile )
return 1LL;
result = 2LL;
if ( LefDefParser::lefwDidInit && (LefDefParser::lefwState == 59 || LefDefParser::lefwState == 11) )
{
result = 3LL;
if ( this )
{
if ( *(_BYTE *)this )
{
if ( *(double *)&LefDefParser::versionNum < 5.6 || (result = 7LL, a6 == 0.0) && a7 == 0.0 && a8 == 0.0 )
{
if ( LefDefParser::lefwWriteEncrypt == 1 )
{
LefDefParser::encPrint(
LefDefParser::lefwFile,
(unsigned int)" LAYER %s\n",
(_DWORD)this,
LefDefParser::lefwState,
a11,
a12);
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)" WIDTH %.11g ;\n", v13, v14, v15, v16);
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)" SPACING %.11g ;\n", v17, v18, v19, v20);
if ( a5 != 0.0 )
{
LefDefParser::encPrint(
LefDefParser::lefwFile,
(unsigned int)" WIREEXTENSION %.11g ;\n",
v21,
v22,
v23,
v24);
++LefDefParser::lefwLines;
}
if ( a6 != 0.0 )
{
LefDefParser::encPrint(
LefDefParser::lefwFile,
(unsigned int)" RESISTANCE RPERSQ %.11g ;\n",
v21,
v22,
v23,
v24);
++LefDefParser::lefwLines;
}
if ( a7 != 0.0 )
{
LefDefParser::encPrint(
LefDefParser::lefwFile,
(unsigned int)" CAPACITANCE CPERSQDIST %.11g ;\n",
v21,
v22,
v23,
v24);
++LefDefParser::lefwLines;
}
if ( a8 != 0.0 )
{
LefDefParser::encPrint(
LefDefParser::lefwFile,
(unsigned int)" EDGECAPACITANCE %.11g ;\n",
v21,
v22,
v23,
v24);
++LefDefParser::lefwLines;
}
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)" END %s\n\n", (_DWORD)this, v22, v23, v24);
}
else
{
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " LAYER %s\n", (const char *)this);
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " WIDTH %.11g ;\n", a3);
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " SPACING %.11g ;\n", a4);
if ( a5 != 0.0 )
{
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " WIREEXTENSION %.11g ;\n", a5);
++LefDefParser::lefwLines;
}
if ( a6 != 0.0 )
{
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " RESISTANCE RPERSQ %.11g ;\n", a6);
++LefDefParser::lefwLines;
}
if ( a7 != 0.0 )
{
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " CAPACITANCE CPERSQDIST %.11g ;\n", a7);
++LefDefParser::lefwLines;
}
if ( a8 != 0.0 )
{
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " EDGECAPACITANCE %.11g ;\n", a8);
++LefDefParser::lefwLines;
}
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " END %s\n\n", (const char *)this);
}
LefDefParser::lefwLines += 4;
LefDefParser::lefwSynArray[59] = 1;
LefDefParser::lefwState = 59;
return 0LL;
}
}
}
}
return result;
}
|
lefwNonDefaultRuleLayer:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RBX,RDI
MOV dword ptr [0x00124d48],0x3c
LEA R15,[0x124e00]
MOV RDI,qword ptr [R15]
TEST RDI,RDI
JZ 0x001101f0
LEA RCX,[0x125054]
MOV EAX,0x2
CMP dword ptr [RCX],0x0
JZ 0x001101f5
LEA R14,[0x125050]
MOV ECX,dword ptr [R14]
CMP ECX,0x3b
JZ 0x00110057
CMP ECX,0xb
JNZ 0x001101f5
LAB_00110057:
MOV EAX,0x3
TEST RBX,RBX
JZ 0x001101f5
CMP byte ptr [RBX],0x0
JZ 0x001101f5
MOVSD XMM6,qword ptr [0x00124d40]
UCOMISD XMM6,qword ptr [0x00119108]
JC 0x001100b9
XORPD XMM6,XMM6
UCOMISD XMM3,XMM6
MOV EAX,0x7
JNZ 0x001101f5
JP 0x001101f5
UCOMISD XMM4,XMM6
JNZ 0x001101f5
JP 0x001101f5
UCOMISD XMM5,XMM6
JNZ 0x001101f5
JP 0x001101f5
LAB_001100b9:
MOVSD qword ptr [RSP],XMM0
MOVSD qword ptr [RSP + 0x8],XMM1
MOVSD qword ptr [RSP + 0x10],XMM2
MOVSD qword ptr [RSP + 0x18],XMM3
MOVSD qword ptr [RSP + 0x20],XMM4
MOVSD qword ptr [RSP + 0x28],XMM5
CMP byte ptr [0x001250ec],0x1
JNZ 0x001101ff
LEA RSI,[0x11b41c]
MOV RDX,RBX
XOR EAX,EAX
CALL 0x00118c35
MOV RDI,qword ptr [R15]
LEA RSI,[0x11be2e]
MOVSD XMM0,qword ptr [RSP]
MOV AL,0x1
CALL 0x00118c35
MOV RDI,qword ptr [R15]
LEA RSI,[0x11b429]
MOVSD XMM0,qword ptr [RSP + 0x8]
MOV AL,0x1
CALL 0x00118c35
XORPD XMM1,XMM1
MOVSD XMM0,qword ptr [RSP + 0x10]
UCOMISD XMM0,XMM1
JNZ 0x00110139
JNP 0x00110157
LAB_00110139:
MOV RDI,qword ptr [R15]
LEA RSI,[0x11b440]
MOV AL,0x1
CALL 0x00118c35
XORPD XMM1,XMM1
LEA RAX,[0x12504c]
INC dword ptr [RAX]
LAB_00110157:
MOVSD XMM0,qword ptr [RSP + 0x18]
UCOMISD XMM0,XMM1
JNZ 0x00110165
JNP 0x0011017f
LAB_00110165:
MOV RDI,qword ptr [R15]
LEA RSI,[0x11b45d]
MOV AL,0x1
CALL 0x00118c35
LEA RAX,[0x12504c]
INC dword ptr [RAX]
LAB_0011017f:
XORPD XMM1,XMM1
MOVSD XMM0,qword ptr [RSP + 0x20]
UCOMISD XMM0,XMM1
JNZ 0x00110191
JNP 0x001101af
LAB_00110191:
MOV RDI,qword ptr [R15]
LEA RSI,[0x11b47e]
MOV AL,0x1
CALL 0x00118c35
XORPD XMM1,XMM1
LEA RAX,[0x12504c]
INC dword ptr [RAX]
LAB_001101af:
MOVSD XMM0,qword ptr [RSP + 0x28]
UCOMISD XMM0,XMM1
JNZ 0x001101bd
JNP 0x001101d7
LAB_001101bd:
MOV RDI,qword ptr [R15]
LEA RSI,[0x11b4a4]
MOV AL,0x1
CALL 0x00118c35
LEA RAX,[0x12504c]
INC dword ptr [RAX]
LAB_001101d7:
MOV RDI,qword ptr [R15]
LEA RSI,[0x11b3d8]
MOV RDX,RBX
XOR EAX,EAX
CALL 0x00118c35
JMP 0x00110301
LAB_001101f0:
MOV EAX,0x1
LAB_001101f5:
ADD RSP,0x30
POP RBX
POP R14
POP R15
RET
LAB_001101ff:
LEA RSI,[0x11b41c]
MOV RDX,RBX
XOR EAX,EAX
CALL 0x001010f0
MOV RDI,qword ptr [R15]
LEA RSI,[0x11be2e]
MOVSD XMM0,qword ptr [RSP]
MOV AL,0x1
CALL 0x001010f0
MOV RDI,qword ptr [R15]
LEA RSI,[0x11b429]
MOVSD XMM0,qword ptr [RSP + 0x8]
MOV AL,0x1
CALL 0x001010f0
XORPD XMM1,XMM1
MOVSD XMM0,qword ptr [RSP + 0x10]
UCOMISD XMM0,XMM1
JNZ 0x0011024f
JNP 0x0011026d
LAB_0011024f:
MOV RDI,qword ptr [R15]
LEA RSI,[0x11b440]
MOV AL,0x1
CALL 0x001010f0
XORPD XMM1,XMM1
LEA RAX,[0x12504c]
INC dword ptr [RAX]
LAB_0011026d:
MOVSD XMM0,qword ptr [RSP + 0x18]
UCOMISD XMM0,XMM1
JNZ 0x0011027b
JNP 0x00110295
LAB_0011027b:
MOV RDI,qword ptr [R15]
LEA RSI,[0x11b45d]
MOV AL,0x1
CALL 0x001010f0
LEA RAX,[0x12504c]
INC dword ptr [RAX]
LAB_00110295:
XORPD XMM1,XMM1
MOVSD XMM0,qword ptr [RSP + 0x20]
UCOMISD XMM0,XMM1
JNZ 0x001102a7
JNP 0x001102c5
LAB_001102a7:
MOV RDI,qword ptr [R15]
LEA RSI,[0x11b47e]
MOV AL,0x1
CALL 0x001010f0
XORPD XMM1,XMM1
LEA RAX,[0x12504c]
INC dword ptr [RAX]
LAB_001102c5:
MOVSD XMM0,qword ptr [RSP + 0x28]
UCOMISD XMM0,XMM1
JNZ 0x001102d3
JNP 0x001102ed
LAB_001102d3:
MOV RDI,qword ptr [R15]
LEA RSI,[0x11b4a4]
MOV AL,0x1
CALL 0x001010f0
LEA RAX,[0x12504c]
INC dword ptr [RAX]
LAB_001102ed:
MOV RDI,qword ptr [R15]
LEA RSI,[0x11b3d8]
MOV RDX,RBX
XOR EAX,EAX
CALL 0x001010f0
LAB_00110301:
LEA RAX,[0x12504c]
ADD dword ptr [RAX],0x4
LEA RAX,[0x124e10]
MOV dword ptr [RAX + 0xec],0x1
MOV dword ptr [R14],0x3b
XOR EAX,EAX
JMP 0x001101f5
|
/* LefDefParser::lefwNonDefaultRuleLayer(char const*, double, double, double, double, double,
double) */
int8
LefDefParser::lefwNonDefaultRuleLayer
(char *param_1,double param_2,double param_3,double param_4,double param_5,double param_6,
double param_7)
{
int8 uVar1;
lefwObsoleteNum = 0x3c;
if (lefwFile == (_IO_FILE *)0x0) {
uVar1 = 1;
}
else {
uVar1 = 2;
if ((lefwDidInit != 0) &&
((((lefwState == 0x3b || (lefwState == 0xb)) && (uVar1 = 3, param_1 != (char *)0x0)) &&
(*param_1 != '\0')))) {
if (DAT_00119108 <= versionNum) {
if (param_5 != 0.0) {
lefwObsoleteNum = 0x3c;
return 7;
}
if (NAN(param_5)) {
lefwObsoleteNum = 0x3c;
return 7;
}
if (param_6 != 0.0) {
lefwObsoleteNum = 0x3c;
return 7;
}
if (NAN(param_6)) {
lefwObsoleteNum = 0x3c;
return 7;
}
if (param_7 != 0.0) {
lefwObsoleteNum = 0x3c;
return 7;
}
if (NAN(param_7)) {
lefwObsoleteNum = 0x3c;
return 7;
}
}
if (lefwWriteEncrypt == '\x01') {
encPrint(lefwFile," LAYER %s\n",param_1);
encPrint(lefwFile," WIDTH %.11g ;\n",param_2);
encPrint(lefwFile," SPACING %.11g ;\n",param_3);
if ((param_4 != 0.0) || (NAN(param_4))) {
encPrint(lefwFile," WIREEXTENSION %.11g ;\n");
lefwLines = lefwLines + 1;
}
if ((param_5 != 0.0) || (NAN(param_5))) {
encPrint(lefwFile," RESISTANCE RPERSQ %.11g ;\n");
lefwLines = lefwLines + 1;
}
if ((param_6 != 0.0) || (NAN(param_6))) {
encPrint(lefwFile," CAPACITANCE CPERSQDIST %.11g ;\n");
lefwLines = lefwLines + 1;
}
if ((param_7 != 0.0) || (NAN(param_7))) {
encPrint(lefwFile," EDGECAPACITANCE %.11g ;\n");
lefwLines = lefwLines + 1;
}
encPrint(lefwFile," END %s\n\n",param_1);
}
else {
fprintf(lefwFile," LAYER %s\n",param_1);
fprintf(lefwFile," WIDTH %.11g ;\n",param_2);
fprintf(lefwFile," SPACING %.11g ;\n",param_3);
if ((param_4 != 0.0) || (NAN(param_4))) {
fprintf(lefwFile," WIREEXTENSION %.11g ;\n");
lefwLines = lefwLines + 1;
}
if ((param_5 != 0.0) || (NAN(param_5))) {
fprintf(lefwFile," RESISTANCE RPERSQ %.11g ;\n");
lefwLines = lefwLines + 1;
}
if ((param_6 != 0.0) || (NAN(param_6))) {
fprintf(lefwFile," CAPACITANCE CPERSQDIST %.11g ;\n");
lefwLines = lefwLines + 1;
}
if ((param_7 != 0.0) || (NAN(param_7))) {
fprintf(lefwFile," EDGECAPACITANCE %.11g ;\n");
lefwLines = lefwLines + 1;
}
fprintf(lefwFile," END %s\n\n",param_1);
}
lefwLines = lefwLines + 4;
lefwSynArray._236_4_ = 1;
lefwState = 0x3b;
uVar1 = 0;
}
}
return uVar1;
}
|
|
18,499
|
w_search
|
eloqsql/storage/maria/ma_write.c
|
static int w_search(register MARIA_HA *info, uint32 comp_flag, MARIA_KEY *key,
my_off_t page_pos,
MARIA_PAGE *father_page, uchar *father_keypos,
my_bool insert_last)
{
int error,flag;
uchar *temp_buff,*keypos,*keybuff;
my_bool was_last_key, buff_alloced;
my_off_t next_page, dup_key_pos;
MARIA_SHARE *share= info->s;
MARIA_KEYDEF *keyinfo= key->keyinfo;
MARIA_PAGE page;
DBUG_ENTER("w_search");
DBUG_PRINT("enter", ("page: %lu", (ulong) (page_pos/keyinfo->block_length)));
alloc_on_stack(*info->stack_end_ptr, temp_buff, buff_alloced,
(keyinfo->block_length + keyinfo->max_store_length*3));
if (!temp_buff)
DBUG_RETURN(1);
keybuff= temp_buff + (keyinfo->block_length + keyinfo->max_store_length*2);
if (_ma_fetch_keypage(&page, info, keyinfo, page_pos, PAGECACHE_LOCK_WRITE,
DFLT_INIT_HITS, temp_buff, 0))
goto err;
flag= (*keyinfo->bin_search)(key, &page, comp_flag, &keypos,
keybuff, &was_last_key);
if (flag == 0)
{
MARIA_KEY tmp_key;
/* get position to record with duplicated key */
tmp_key.keyinfo= keyinfo;
tmp_key.data= keybuff;
if ((*keyinfo->get_key)(&tmp_key, page.flag, page.node, &keypos))
dup_key_pos= _ma_row_pos_from_key(&tmp_key);
else
dup_key_pos= HA_OFFSET_ERROR;
if (keyinfo->flag & HA_FULLTEXT)
{
uint off;
int subkeys;
get_key_full_length_rdonly(off, keybuff);
subkeys=ft_sintXkorr(keybuff+off);
comp_flag=SEARCH_SAME;
if (subkeys >= 0)
{
/* normal word, one-level tree structure */
flag=(*keyinfo->bin_search)(key, &page, comp_flag,
&keypos, keybuff, &was_last_key);
}
else
{
/* popular word. two-level tree. going down */
my_off_t root= dup_key_pos;
MARIA_KEY subkey;
get_key_full_length_rdonly(off, key->data);
subkey.keyinfo= keyinfo= &share->ft2_keyinfo;
subkey.data= key->data + off;
subkey.data_length= key->data_length - off;
subkey.ref_length= key->ref_length;
subkey.flag= key->flag;
/* we'll modify key entry 'in vivo' */
keypos-= keyinfo->keylength + page.node;
error= _ma_ck_real_write_btree(info, &subkey, &root, comp_flag);
_ma_dpointer(share, keypos+HA_FT_WLEN, root);
subkeys--; /* should there be underflow protection ? */
DBUG_ASSERT(subkeys < 0);
ft_intXstore(keypos, subkeys);
if (!error)
{
page_mark_changed(info, &page);
if (_ma_write_keypage(&page, PAGECACHE_LOCK_LEFT_WRITELOCKED,
DFLT_INIT_HITS))
goto err;
}
stack_alloc_free(temp_buff, buff_alloced);
DBUG_RETURN(error);
}
}
else /* not HA_FULLTEXT, normal HA_NOSAME key */
{
/*
TODO
When the index will support true versioning - with multiple
identical values in the UNIQUE index, invisible to each other -
the following should be changed to "continue inserting keys, at the
end (of the row or statement) wait". We need to wait on *all*
unique conflicts at once, not one-at-a-time, because we need to
know all blockers in advance, otherwise we'll have incomplete wait-for
graph.
*/
/*
transaction that has inserted the conflicting key may be in progress.
the caller will wait for it to be committed or aborted.
*/
info->dup_key_trid= _ma_trid_from_key(&tmp_key);
info->dup_key_pos= dup_key_pos;
my_errno= HA_ERR_FOUND_DUPP_KEY;
DBUG_PRINT("warning",
("Duplicate key. dup_key_trid: %lu pos %lu visible: %d",
(ulong) info->dup_key_trid,
(ulong) info->dup_key_pos,
info->trn ? trnman_can_read_from(info->trn,
info->dup_key_trid) : 2));
goto err;
}
}
if (flag == MARIA_FOUND_WRONG_KEY)
{
my_errno= HA_ERR_CRASHED;
goto err;
}
if (!was_last_key)
insert_last=0;
next_page= _ma_kpos(page.node, keypos);
if (next_page == HA_OFFSET_ERROR ||
(error= w_search(info, comp_flag, key, next_page,
&page, keypos, insert_last)) > 0)
{
error= _ma_insert(info, key, &page, keypos, keybuff,
father_page, father_keypos, insert_last);
if (error < 0)
goto err;
page_mark_changed(info, &page);
if (_ma_write_keypage(&page, PAGECACHE_LOCK_LEFT_WRITELOCKED,
DFLT_INIT_HITS))
goto err;
}
stack_alloc_free(temp_buff, buff_alloced);
DBUG_RETURN(error);
err:
stack_alloc_free(temp_buff, buff_alloced);
DBUG_PRINT("exit",("Error: %d",my_errno));
DBUG_RETURN(-1);
}
|
O3
|
c
|
w_search:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r9, -0x68(%rbp)
movq %r8, -0x60(%rbp)
movq %rcx, %r12
movl %esi, -0x48(%rbp)
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq (%rdi), %rax
movq %rax, -0x58(%rbp)
movq %rdx, -0x70(%rbp)
movq 0x8(%rdx), %r13
movzwl 0xa6(%r13), %r15d
movzwl 0xb0(%r13), %ebx
leaq (%rbx,%rbx,2), %rsi
addq %r15, %rsi
leaq -0xb0(%rbp), %rcx
movq %rsi, (%rcx)
movq 0x78(%rdi), %rax
movq (%rax), %rax
subq %rcx, %rax
subq %rsi, %rax
jbe 0x56199
cmpq $0x10000, %rax # imm = 0x10000
ja 0x56183
cmpl $0x1000, %esi # imm = 0x1000
jb 0x56199
cmpq $0x8001, %rax # imm = 0x8001
jb 0x56199
movq %rsp, %rax
addl $0xf, %esi
andl $-0x10, %esi
subq %rsi, %rax
movq %rax, %rsp
movb $0x1, %cl
movl %ecx, -0x44(%rbp)
jmp 0x561c5
movl $0x10010, %edx # imm = 0x10010
xorl %edi, %edi
callq 0x9ff21
testq %rax, %rax
je 0x5624f
movzwl 0xa6(%r13), %r15d
movzwl 0xb0(%r13), %ebx
movl $0x0, -0x44(%rbp)
leaq -0xb0(%rbp), %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
movl $0x4, %r8d
movl $0x3, %r9d
pushq $0x0
movq %rax, -0x50(%rbp)
pushq %rax
callq 0x6f32e
addq $0x10, %rsp
testb %al, %al
je 0x5620c
movl $0xffffffff, %r13d # imm = 0xFFFFFFFF
cmpb $0x0, -0x44(%rbp)
jne 0x56255
movq -0x50(%rbp), %rdi
callq 0xa014e
jmp 0x56255
leaq (%r15,%rbx,2), %r12
addq -0x50(%rbp), %r12
leaq -0xb0(%rbp), %rsi
leaq -0x40(%rbp), %rcx
leaq -0x31(%rbp), %r9
movq -0x70(%rbp), %r15
movq %r15, %rdi
movl -0x48(%rbp), %edx
movq %r12, %r8
callq *0xd8(%r13)
testl %eax, %eax
je 0x5627a
cmpl $0x7fffffff, %eax # imm = 0x7FFFFFFF
jne 0x562bb
callq 0xa1c92
movl $0x7e, (%rax)
jmp 0x561f5
movl $0x1, %r13d
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x5653f
movl %r13d, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0xd0(%rbp), %rdi
movq %r13, 0x8(%rdi)
movq %r12, (%rdi)
movl -0x88(%rbp), %edx
movl -0x84(%rbp), %esi
leaq -0x40(%rbp), %rcx
callq *0xe0(%r13)
testl %eax, %eax
je 0x56370
leaq -0xd0(%rbp), %rdi
callq 0x6d4a4
movq %rax, %rbx
jmp 0x56377
xorl %eax, %eax
cmpb $0x0, -0x31(%rbp)
movzbl 0x10(%rbp), %ebx
cmovel %eax, %ebx
movl -0x88(%rbp), %edi
movq -0x40(%rbp), %rsi
callq 0x6d33f
movsbl %bl, %ebx
cmpq $-0x1, %rax
je 0x5630d
movq -0x40(%rbp), %r9
subq $0x8, %rsp
leaq -0xb0(%rbp), %r8
movq %r14, %rdi
movl -0x48(%rbp), %esi
movq %r15, %rdx
movq %rax, %rcx
pushq %rbx
callq 0x560fa
addq $0x10, %rsp
testl %eax, %eax
jle 0x563bd
movq -0x40(%rbp), %rcx
leaq -0xb0(%rbp), %rdx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %r8
movq -0x60(%rbp), %r9
pushq %rbx
pushq -0x68(%rbp)
callq 0x5682b
addq $0x10, %rsp
testl %eax, %eax
js 0x561f5
movl %eax, %r13d
movq 0x2e8(%r14), %rax
leaq -0xb0(%rbp), %rdi
movl 0x30(%rdi), %ecx
leaq (%rcx,%rcx,2), %rcx
movb $0x1, 0x10(%rax,%rcx,8)
movl $0x2, %esi
movl $0x3, %edx
callq 0x6f46d
testb %al, %al
jne 0x561f5
jmp 0x563c0
movq $-0x1, %rbx
testb $-0x80, 0xa2(%r13)
jne 0x563ab
leaq -0xd0(%rbp), %rdi
callq 0x6d55c
movq %rax, 0x430(%r14)
movq %rbx, 0x428(%r14)
callq 0xa1c92
movl $0x79, (%rax)
jmp 0x561f5
movzbl (%r12), %eax
cmpq $0xff, %rax
je 0x563d3
incq %rax
jmp 0x563e4
movl %eax, %r13d
cmpb $0x0, -0x44(%rbp)
movq -0x50(%rbp), %rdi
je 0x56205
jmp 0x56255
movzwl 0x1(%r12), %eax
rolw $0x8, %ax
movzwl %ax, %eax
addq $0x3, %rax
movzbl (%r12,%rax), %ecx
shll $0x18, %ecx
js 0x5641b
leaq -0xb0(%rbp), %rsi
movl $0x4, -0x48(%rbp)
leaq -0x40(%rbp), %rcx
leaq -0x31(%rbp), %r9
movq %r15, %rdi
movl $0x4, %edx
movq %r12, %r8
callq *0xd8(%r13)
jmp 0x5623b
movzwl 0x2(%r12,%rax), %edx
rolw $0x8, %dx
movzwl %dx, %edx
movzbl 0x1(%r12,%rax), %r13d
shll $0x10, %r13d
orl %edx, %r13d
orl %ecx, %r13d
movq %rbx, -0x78(%rbp)
movq (%r15), %rax
movzbl (%rax), %ecx
cmpl $0xff, %ecx
je 0x5644e
incl %ecx
jmp 0x5645c
movzwl 0x1(%rax), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
addl $0x3, %ecx
movq -0x58(%rbp), %rbx
leaq 0x458(%rbx), %rdx
leaq -0xf0(%rbp), %rsi
movq %rdx, 0x8(%rsi)
movl %ecx, %edx
addq %rdx, %rax
movq %rax, (%rsi)
movl 0x10(%r15), %eax
subl %ecx, %eax
movl %eax, 0x10(%rsi)
movq 0x14(%r15), %rax
movq %rax, 0x14(%rsi)
movzwl 0x502(%rbx), %eax
addl -0x88(%rbp), %eax
subq %rax, -0x40(%rbp)
leaq -0x78(%rbp), %r12
movq %r14, %rdi
movq %r12, %rdx
movl $0x4, %ecx
callq 0x5609c
movl %eax, %r15d
movq -0x40(%rbp), %rsi
addq $0x4, %rsi
movq (%r12), %rdx
movq %rbx, %rdi
callq 0x6d688
movl %r13d, %edx
decl %edx
movq -0x40(%rbp), %rax
movb %dl, 0x3(%rax)
movq -0x40(%rbp), %rax
movb %dh, 0x2(%rax)
movl %edx, %eax
shrl $0x10, %eax
movq -0x40(%rbp), %rcx
movb %al, 0x1(%rcx)
shrl $0x18, %edx
movq -0x40(%rbp), %rax
movb %dl, (%rax)
testb %r15b, %r15b
je 0x5650c
cmpb $0x0, -0x44(%rbp)
jne 0x56503
movq -0x50(%rbp), %rdi
callq 0xa014e
movzbl %r15b, %r13d
jmp 0x56255
movq 0x2e8(%r14), %rax
leaq -0xb0(%rbp), %rdi
movl 0x30(%rdi), %ecx
leaq (%rcx,%rcx,2), %rcx
movb $0x1, 0x10(%rax,%rcx,8)
movl $0x2, %esi
movl $0x3, %edx
callq 0x6f46d
testb %al, %al
jne 0x561f5
jmp 0x564f4
callq 0x29260
|
w_search:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0C8h
mov [rbp+var_68], r9
mov [rbp+var_60], r8
mov r12, rcx
mov [rbp+var_48], esi
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov rax, [rdi]
mov [rbp+var_58], rax
mov [rbp+var_70], rdx
mov r13, [rdx+8]
movzx r15d, word ptr [r13+0A6h]
movzx ebx, word ptr [r13+0B0h]
lea rsi, [rbx+rbx*2]
add rsi, r15
lea rcx, [rbp+var_B0]
mov [rcx], rsi
mov rax, [rdi+78h]
mov rax, [rax]
sub rax, rcx
sub rax, rsi
jbe short loc_56199
cmp rax, 10000h
ja short loc_56183
cmp esi, 1000h
jb short loc_56199
cmp rax, 8001h
jb short loc_56199
loc_56183:
mov rax, rsp
add esi, 0Fh
and esi, 0FFFFFFF0h
sub rax, rsi
mov rsp, rax
mov cl, 1
mov [rbp+var_44], ecx
jmp short loc_561C5
loc_56199:
mov edx, 10010h
xor edi, edi
call my_malloc
test rax, rax
jz loc_5624F
movzx r15d, word ptr [r13+0A6h]
movzx ebx, word ptr [r13+0B0h]
mov [rbp+var_44], 0
loc_561C5:
lea rdi, [rbp+var_B0]
mov rsi, r14
mov rdx, r13
mov rcx, r12
mov r8d, 4
mov r9d, 3
push 0
mov [rbp+var_50], rax
push rax
call _ma_fetch_keypage
add rsp, 10h
test al, al
jz short loc_5620C
loc_561F5:
mov r13d, 0FFFFFFFFh
cmp byte ptr [rbp+var_44], 0
jnz short loc_56255
mov rdi, [rbp+var_50]
loc_56205:
call my_free
jmp short loc_56255
loc_5620C:
lea r12, [r15+rbx*2]
add r12, [rbp+var_50]
lea rsi, [rbp+var_B0]
lea rcx, [rbp+var_40]
lea r9, [rbp+var_31]
mov r15, [rbp+var_70]
mov rdi, r15
mov edx, [rbp+var_48]
mov r8, r12
call qword ptr [r13+0D8h]
test eax, eax
jz short loc_5627A
loc_5623B:
cmp eax, 7FFFFFFFh
jnz short loc_562BB
call _my_thread_var
mov dword ptr [rax], 7Eh ; '~'
jmp short loc_561F5
loc_5624F:
mov r13d, 1
loc_56255:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz loc_5653F
mov eax, r13d
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_5627A:
lea rdi, [rbp+var_D0]
mov [rdi+8], r13
mov [rdi], r12
mov edx, [rbp+var_88]
mov esi, [rbp+var_84]
lea rcx, [rbp+var_40]
call qword ptr [r13+0E0h]
test eax, eax
jz loc_56370
lea rdi, [rbp+var_D0]
call _ma_row_pos_from_key
mov rbx, rax
jmp loc_56377
loc_562BB:
xor eax, eax
cmp [rbp+var_31], 0
movzx ebx, [rbp+arg_0]
cmovz ebx, eax
mov edi, [rbp+var_88]
mov rsi, [rbp+var_40]
call _ma_kpos
movsx ebx, bl
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_5630D
mov r9, [rbp+var_40]
sub rsp, 8
lea r8, [rbp+var_B0]
mov rdi, r14
mov esi, [rbp+var_48]
mov rdx, r15
mov rcx, rax
push rbx
call w_search
add rsp, 10h
test eax, eax
jle loc_563BD
loc_5630D:
mov rcx, [rbp+var_40]
lea rdx, [rbp+var_B0]
mov rdi, r14
mov rsi, r15
mov r8, r12
mov r9, [rbp+var_60]
push rbx
push [rbp+var_68]
call _ma_insert
add rsp, 10h
test eax, eax
js loc_561F5
mov r13d, eax
mov rax, [r14+2E8h]
lea rdi, [rbp+var_B0]
mov ecx, [rdi+30h]
lea rcx, [rcx+rcx*2]
mov byte ptr [rax+rcx*8+10h], 1
mov esi, 2
mov edx, 3
call _ma_write_keypage
test al, al
jnz loc_561F5
jmp short loc_563C0
loc_56370:
mov rbx, 0FFFFFFFFFFFFFFFFh
loc_56377:
test byte ptr [r13+0A2h], 80h
jnz short loc_563AB
lea rdi, [rbp+var_D0]
call _ma_trid_from_key
mov [r14+430h], rax
mov [r14+428h], rbx
call _my_thread_var
mov dword ptr [rax], 79h ; 'y'
jmp loc_561F5
loc_563AB:
movzx eax, byte ptr [r12]
cmp rax, 0FFh
jz short loc_563D3
inc rax
jmp short loc_563E4
loc_563BD:
mov r13d, eax
loc_563C0:
cmp byte ptr [rbp+var_44], 0
mov rdi, [rbp+var_50]
jz loc_56205
jmp loc_56255
loc_563D3:
movzx eax, word ptr [r12+1]
rol ax, 8
movzx eax, ax
add rax, 3
loc_563E4:
movzx ecx, byte ptr [r12+rax]
shl ecx, 18h
js short loc_5641B
lea rsi, [rbp+var_B0]
mov [rbp+var_48], 4
lea rcx, [rbp+var_40]
lea r9, [rbp+var_31]
mov rdi, r15
mov edx, 4
mov r8, r12
call qword ptr [r13+0D8h]
jmp loc_5623B
loc_5641B:
movzx edx, word ptr [r12+rax+2]
rol dx, 8
movzx edx, dx
movzx r13d, byte ptr [r12+rax+1]
shl r13d, 10h
or r13d, edx
or r13d, ecx
mov [rbp+var_78], rbx
mov rax, [r15]
movzx ecx, byte ptr [rax]
cmp ecx, 0FFh
jz short loc_5644E
inc ecx
jmp short loc_5645C
loc_5644E:
movzx ecx, word ptr [rax+1]
rol cx, 8
movzx ecx, cx
add ecx, 3
loc_5645C:
mov rbx, [rbp+var_58]
lea rdx, [rbx+458h]
lea rsi, [rbp+var_F0]
mov [rsi+8], rdx
mov edx, ecx
add rax, rdx
mov [rsi], rax
mov eax, [r15+10h]
sub eax, ecx
mov [rsi+10h], eax
mov rax, [r15+14h]
mov [rsi+14h], rax
movzx eax, word ptr [rbx+502h]
add eax, [rbp+var_88]
sub [rbp+var_40], rax
lea r12, [rbp+var_78]
mov rdi, r14
mov rdx, r12
mov ecx, 4
call _ma_ck_real_write_btree
mov r15d, eax
mov rsi, [rbp+var_40]
add rsi, 4
mov rdx, [r12]
mov rdi, rbx
call _ma_dpointer
mov edx, r13d
dec edx
mov rax, [rbp+var_40]
mov [rax+3], dl
mov rax, [rbp+var_40]
mov [rax+2], dh
mov eax, edx
shr eax, 10h
mov rcx, [rbp+var_40]
mov [rcx+1], al
shr edx, 18h
mov rax, [rbp+var_40]
mov [rax], dl
test r15b, r15b
jz short loc_5650C
loc_564F4:
cmp byte ptr [rbp+var_44], 0
jnz short loc_56503
mov rdi, [rbp+var_50]
call my_free
loc_56503:
movzx r13d, r15b
jmp loc_56255
loc_5650C:
mov rax, [r14+2E8h]
lea rdi, [rbp+var_B0]
mov ecx, [rdi+30h]
lea rcx, [rcx+rcx*2]
mov byte ptr [rax+rcx*8+10h], 1
mov esi, 2
mov edx, 3
call _ma_write_keypage
test al, al
jnz loc_561F5
jmp short loc_564F4
loc_5653F:
call ___stack_chk_fail
|
long long w_search(long long a1, unsigned int a2, unsigned __int8 **a3, int a4, long long a5, long long a6, char a7)
{
unsigned __int8 *v9; // r13
long long v10; // r15
long long v11; // rbx
unsigned long long v12; // rsi
_QWORD *v13; // rcx
unsigned long long v14; // rax
bool v15; // cc
unsigned long long v16; // rax
char *v17; // rax
unsigned int v18; // r13d
char *v19; // rdi
unsigned __int8 *v20; // r12
unsigned __int8 **v21; // r15
unsigned __int8 **v22; // rdi
int v23; // eax
long long v25; // rbx
long long v27; // rax
int v28; // eax
int v29; // eax
long long v30; // rax
long long v31; // rax
int v32; // r13d
unsigned __int8 *v33; // rax
int v34; // ecx
unsigned int v35; // ecx
long long v36; // rbx
bool v37; // r15
long long v38; // rcx
_QWORD v39[2]; // [rsp+0h] [rbp-F0h] BYREF
unsigned int v40; // [rsp+10h] [rbp-E0h]
long long v41; // [rsp+14h] [rbp-DCh]
_QWORD v42[4]; // [rsp+20h] [rbp-D0h] BYREF
_QWORD v43[5]; // [rsp+40h] [rbp-B0h] BYREF
unsigned int v44; // [rsp+68h] [rbp-88h]
unsigned int v45; // [rsp+6Ch] [rbp-84h]
unsigned int v46; // [rsp+70h] [rbp-80h]
long long v47; // [rsp+78h] [rbp-78h] BYREF
unsigned __int8 **v48; // [rsp+80h] [rbp-70h]
long long v49; // [rsp+88h] [rbp-68h]
long long v50; // [rsp+90h] [rbp-60h]
long long v51; // [rsp+98h] [rbp-58h]
char *v52; // [rsp+A0h] [rbp-50h]
unsigned int v53; // [rsp+A8h] [rbp-48h]
int v54; // [rsp+ACh] [rbp-44h]
_BYTE *v55; // [rsp+B0h] [rbp-40h] BYREF
char v56; // [rsp+BFh] [rbp-31h] BYREF
unsigned long long v57; // [rsp+C0h] [rbp-30h]
v49 = a6;
v50 = a5;
v53 = a2;
v57 = __readfsqword(0x28u);
v51 = *(_QWORD *)a1;
v48 = a3;
v9 = a3[1];
v10 = *((unsigned __int16 *)v9 + 83);
v11 = *((unsigned __int16 *)v9 + 88);
v12 = v10 + 3 * v11;
v13 = v43;
v43[0] = v12;
v14 = **(_QWORD **)(a1 + 120) - (_QWORD)v43;
v15 = v14 <= v12;
v16 = v14 - v12;
if ( v15 || v16 <= 0x10000 && ((unsigned int)v12 < 0x1000 || v16 < 0x8001) )
{
v17 = (char *)my_malloc(0LL, v12, 65552LL);
if ( !v17 )
return 1;
v10 = *((unsigned __int16 *)v9 + 83);
v11 = *((unsigned __int16 *)v9 + 88);
v54 = 0;
}
else
{
v17 = (char *)v39 - (((_DWORD)v12 + 15) & 0xFFFFFFF0);
LOBYTE(v13) = 1;
v54 = (int)v13;
}
v52 = v17;
if ( (unsigned __int8)ma_fetch_keypage((unsigned int)v43, a1, (_DWORD)v9, a4, 4, 3, (long long)v17) )
goto LABEL_9;
v20 = (unsigned __int8 *)&v52[2 * v11 + v10];
v21 = v48;
v22 = v48;
v23 = (*((long long ( **)(unsigned __int8 **, _QWORD *, _QWORD, _BYTE **, unsigned __int8 *, char *))v9 + 27))(
v48,
v43,
v53,
&v55,
v20,
&v56);
if ( v23 )
{
LABEL_13:
if ( v23 == 0x7FFFFFFF )
{
*(_DWORD *)my_thread_var(v22) = 126;
goto LABEL_9;
}
if ( !v56 )
a7 = 0;
v27 = ma_kpos(v44, v55);
if ( v27 == -1 || (v28 = w_search(a1, v53, (_DWORD)v21, v27, (unsigned int)v43, (_DWORD)v55, a7), v28 > 0) )
{
v29 = ma_insert(a1, (_DWORD)v21, (unsigned int)v43, (_DWORD)v55, (_DWORD)v20, v50, v49, a7);
if ( v29 < 0 )
goto LABEL_9;
v18 = v29;
*(_BYTE *)(*(_QWORD *)(a1 + 744) + 24LL * v46 + 16) = 1;
if ( (unsigned __int8)ma_write_keypage(v43, 2LL, 3LL) )
goto LABEL_9;
}
else
{
v18 = v28;
}
v19 = v52;
if ( (_BYTE)v54 )
return v18;
goto LABEL_11;
}
v42[1] = v9;
v42[0] = v20;
if ( (*((unsigned int ( **)(_QWORD *, _QWORD, _QWORD, _BYTE **))v9 + 28))(v42, v45, v44, &v55) )
v25 = ma_row_pos_from_key(v42);
else
v25 = -1LL;
if ( (v9[162] & 0x80u) == 0 )
{
*(_QWORD *)(a1 + 1072) = ma_trid_from_key(v42);
*(_QWORD *)(a1 + 1064) = v25;
*(_DWORD *)my_thread_var(v42) = 121;
goto LABEL_9;
}
v30 = *v20;
if ( v30 == 255 )
v31 = (unsigned __int16)__ROL2__(*(_WORD *)(v20 + 1), 8) + 3LL;
else
v31 = v30 + 1;
if ( (v20[v31] & 0x80) == 0 )
{
v53 = 4;
v22 = v21;
v23 = (*((long long ( **)(unsigned __int8 **, _QWORD *, long long, _BYTE **, unsigned __int8 *, char *))v9 + 27))(
v21,
v43,
4LL,
&v55,
v20,
&v56);
goto LABEL_13;
}
v32 = (v20[v31] << 24) | (unsigned __int16)__ROL2__(*(_WORD *)&v20[v31 + 2], 8) | (v20[v31 + 1] << 16);
v47 = v25;
v33 = *v21;
v34 = **v21;
if ( v34 == 255 )
v35 = (unsigned __int16)__ROL2__(*(_WORD *)(v33 + 1), 8) + 3;
else
v35 = v34 + 1;
v36 = v51;
v39[1] = v51 + 1112;
v39[0] = &v33[v35];
v40 = *((_DWORD *)v21 + 4) - v35;
v41 = *(long long *)((char *)v21 + 20);
v55 += -v44 - *(unsigned __int16 *)(v51 + 1282);
v37 = ma_ck_real_write_btree(a1, (long long)v39, &v47, 4);
ma_dpointer(v36, v55 + 4, v47, v38);
v55[3] = v32 - 1;
v55[2] = (unsigned __int16)(v32 - 1) >> 8;
v55[1] = (unsigned int)(v32 - 1) >> 16;
*v55 = (unsigned int)(v32 - 1) >> 24;
if ( v37
|| (*(_BYTE *)(*(_QWORD *)(a1 + 744) + 24LL * v46 + 16) = 1, !(unsigned __int8)ma_write_keypage(v43, 2LL, 3LL)) )
{
if ( !(_BYTE)v54 )
my_free(v52);
return v37;
}
LABEL_9:
v18 = -1;
if ( !(_BYTE)v54 )
{
v19 = v52;
LABEL_11:
my_free(v19);
}
return v18;
}
|
w_search:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xc8
MOV qword ptr [RBP + -0x68],R9
MOV qword ptr [RBP + -0x60],R8
MOV R12,RCX
MOV dword ptr [RBP + -0x48],ESI
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RDI]
MOV qword ptr [RBP + -0x58],RAX
MOV qword ptr [RBP + -0x70],RDX
MOV R13,qword ptr [RDX + 0x8]
MOVZX R15D,word ptr [R13 + 0xa6]
MOVZX EBX,word ptr [R13 + 0xb0]
LEA RSI,[RBX + RBX*0x2]
ADD RSI,R15
LEA RCX,[RBP + -0xb0]
MOV qword ptr [RCX],RSI
MOV RAX,qword ptr [RDI + 0x78]
MOV RAX,qword ptr [RAX]
SUB RAX,RCX
SUB RAX,RSI
JBE 0x00156199
CMP RAX,0x10000
JA 0x00156183
CMP ESI,0x1000
JC 0x00156199
CMP RAX,0x8001
JC 0x00156199
LAB_00156183:
MOV RAX,RSP
ADD ESI,0xf
AND ESI,0xfffffff0
SUB RAX,RSI
MOV RSP,RAX
MOV CL,0x1
MOV dword ptr [RBP + -0x44],ECX
JMP 0x001561c5
LAB_00156199:
MOV EDX,0x10010
XOR EDI,EDI
CALL 0x0019ff21
TEST RAX,RAX
JZ 0x0015624f
MOVZX R15D,word ptr [R13 + 0xa6]
MOVZX EBX,word ptr [R13 + 0xb0]
MOV dword ptr [RBP + -0x44],0x0
LAB_001561c5:
LEA RDI,[RBP + -0xb0]
MOV RSI,R14
MOV RDX,R13
MOV RCX,R12
MOV R8D,0x4
MOV R9D,0x3
PUSH 0x0
MOV qword ptr [RBP + -0x50],RAX
PUSH RAX
CALL 0x0016f32e
ADD RSP,0x10
TEST AL,AL
JZ 0x0015620c
LAB_001561f5:
MOV R13D,0xffffffff
CMP byte ptr [RBP + -0x44],0x0
JNZ 0x00156255
MOV RDI,qword ptr [RBP + -0x50]
LAB_00156205:
CALL 0x001a014e
JMP 0x00156255
LAB_0015620c:
LEA R12,[R15 + RBX*0x2]
ADD R12,qword ptr [RBP + -0x50]
LEA RSI,[RBP + -0xb0]
LEA RCX,[RBP + -0x40]
LEA R9,[RBP + -0x31]
MOV R15,qword ptr [RBP + -0x70]
MOV RDI,R15
MOV EDX,dword ptr [RBP + -0x48]
MOV R8,R12
CALL qword ptr [R13 + 0xd8]
TEST EAX,EAX
JZ 0x0015627a
LAB_0015623b:
CMP EAX,0x7fffffff
JNZ 0x001562bb
CALL 0x001a1c92
MOV dword ptr [RAX],0x7e
JMP 0x001561f5
LAB_0015624f:
MOV R13D,0x1
LAB_00156255:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0015653f
MOV EAX,R13D
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0015627a:
LEA RDI,[RBP + -0xd0]
MOV qword ptr [RDI + 0x8],R13
MOV qword ptr [RDI],R12
MOV EDX,dword ptr [RBP + -0x88]
MOV ESI,dword ptr [RBP + -0x84]
LEA RCX,[RBP + -0x40]
CALL qword ptr [R13 + 0xe0]
TEST EAX,EAX
JZ 0x00156370
LEA RDI,[RBP + -0xd0]
CALL 0x0016d4a4
MOV RBX,RAX
JMP 0x00156377
LAB_001562bb:
XOR EAX,EAX
CMP byte ptr [RBP + -0x31],0x0
MOVZX EBX,byte ptr [RBP + 0x10]
CMOVZ EBX,EAX
MOV EDI,dword ptr [RBP + -0x88]
MOV RSI,qword ptr [RBP + -0x40]
CALL 0x0016d33f
MOVSX EBX,BL
CMP RAX,-0x1
JZ 0x0015630d
MOV R9,qword ptr [RBP + -0x40]
SUB RSP,0x8
LEA R8,[RBP + -0xb0]
MOV RDI,R14
MOV ESI,dword ptr [RBP + -0x48]
MOV RDX,R15
MOV RCX,RAX
PUSH RBX
CALL 0x001560fa
ADD RSP,0x10
TEST EAX,EAX
JLE 0x001563bd
LAB_0015630d:
MOV RCX,qword ptr [RBP + -0x40]
LEA RDX,[RBP + -0xb0]
MOV RDI,R14
MOV RSI,R15
MOV R8,R12
MOV R9,qword ptr [RBP + -0x60]
PUSH RBX
PUSH qword ptr [RBP + -0x68]
CALL 0x0015682b
ADD RSP,0x10
TEST EAX,EAX
JS 0x001561f5
MOV R13D,EAX
MOV RAX,qword ptr [R14 + 0x2e8]
LEA RDI,[RBP + -0xb0]
MOV ECX,dword ptr [RDI + 0x30]
LEA RCX,[RCX + RCX*0x2]
MOV byte ptr [RAX + RCX*0x8 + 0x10],0x1
MOV ESI,0x2
MOV EDX,0x3
CALL 0x0016f46d
TEST AL,AL
JNZ 0x001561f5
JMP 0x001563c0
LAB_00156370:
MOV RBX,-0x1
LAB_00156377:
TEST byte ptr [R13 + 0xa2],0x80
JNZ 0x001563ab
LEA RDI,[RBP + -0xd0]
CALL 0x0016d55c
MOV qword ptr [R14 + 0x430],RAX
MOV qword ptr [R14 + 0x428],RBX
CALL 0x001a1c92
MOV dword ptr [RAX],0x79
JMP 0x001561f5
LAB_001563ab:
MOVZX EAX,byte ptr [R12]
CMP RAX,0xff
JZ 0x001563d3
INC RAX
JMP 0x001563e4
LAB_001563bd:
MOV R13D,EAX
LAB_001563c0:
CMP byte ptr [RBP + -0x44],0x0
MOV RDI,qword ptr [RBP + -0x50]
JZ 0x00156205
JMP 0x00156255
LAB_001563d3:
MOVZX EAX,word ptr [R12 + 0x1]
ROL AX,0x8
MOVZX EAX,AX
ADD RAX,0x3
LAB_001563e4:
MOVZX ECX,byte ptr [R12 + RAX*0x1]
SHL ECX,0x18
JS 0x0015641b
LEA RSI,[RBP + -0xb0]
MOV dword ptr [RBP + -0x48],0x4
LEA RCX,[RBP + -0x40]
LEA R9,[RBP + -0x31]
MOV RDI,R15
MOV EDX,0x4
MOV R8,R12
CALL qword ptr [R13 + 0xd8]
JMP 0x0015623b
LAB_0015641b:
MOVZX EDX,word ptr [R12 + RAX*0x1 + 0x2]
ROL DX,0x8
MOVZX EDX,DX
MOVZX R13D,byte ptr [R12 + RAX*0x1 + 0x1]
SHL R13D,0x10
OR R13D,EDX
OR R13D,ECX
MOV qword ptr [RBP + -0x78],RBX
MOV RAX,qword ptr [R15]
MOVZX ECX,byte ptr [RAX]
CMP ECX,0xff
JZ 0x0015644e
INC ECX
JMP 0x0015645c
LAB_0015644e:
MOVZX ECX,word ptr [RAX + 0x1]
ROL CX,0x8
MOVZX ECX,CX
ADD ECX,0x3
LAB_0015645c:
MOV RBX,qword ptr [RBP + -0x58]
LEA RDX,[RBX + 0x458]
LEA RSI,[RBP + -0xf0]
MOV qword ptr [RSI + 0x8],RDX
MOV EDX,ECX
ADD RAX,RDX
MOV qword ptr [RSI],RAX
MOV EAX,dword ptr [R15 + 0x10]
SUB EAX,ECX
MOV dword ptr [RSI + 0x10],EAX
MOV RAX,qword ptr [R15 + 0x14]
MOV qword ptr [RSI + 0x14],RAX
MOVZX EAX,word ptr [RBX + 0x502]
ADD EAX,dword ptr [RBP + -0x88]
SUB qword ptr [RBP + -0x40],RAX
LEA R12,[RBP + -0x78]
MOV RDI,R14
MOV RDX,R12
MOV ECX,0x4
CALL 0x0015609c
MOV R15D,EAX
MOV RSI,qword ptr [RBP + -0x40]
ADD RSI,0x4
MOV RDX,qword ptr [R12]
MOV RDI,RBX
CALL 0x0016d688
MOV EDX,R13D
DEC EDX
MOV RAX,qword ptr [RBP + -0x40]
MOV byte ptr [RAX + 0x3],DL
MOV RAX,qword ptr [RBP + -0x40]
MOV byte ptr [RAX + 0x2],DH
MOV EAX,EDX
SHR EAX,0x10
MOV RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RCX + 0x1],AL
SHR EDX,0x18
MOV RAX,qword ptr [RBP + -0x40]
MOV byte ptr [RAX],DL
TEST R15B,R15B
JZ 0x0015650c
LAB_001564f4:
CMP byte ptr [RBP + -0x44],0x0
JNZ 0x00156503
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x001a014e
LAB_00156503:
MOVZX R13D,R15B
JMP 0x00156255
LAB_0015650c:
MOV RAX,qword ptr [R14 + 0x2e8]
LEA RDI,[RBP + -0xb0]
MOV ECX,dword ptr [RDI + 0x30]
LEA RCX,[RCX + RCX*0x2]
MOV byte ptr [RAX + RCX*0x8 + 0x10],0x1
MOV ESI,0x2
MOV EDX,0x3
CALL 0x0016f46d
TEST AL,AL
JNZ 0x001561f5
JMP 0x001564f4
LAB_0015653f:
CALL 0x00129260
|
uint w_search(long *param_1,int4 param_2,int8 *param_3,int8 param_4,
int8 param_5,int8 param_6,char param_7)
{
byte bVar1;
byte bVar2;
ushort uVar3;
code *pcVar4;
int8 *puVar5;
int8 uVar6;
long lVar7;
int4 uVar8;
char cVar9;
byte bVar10;
int iVar11;
int iVar12;
uint uVar13;
ulong uVar14;
ulong uVar15;
int4 *puVar16;
long lVar17;
long lVar18;
long lVar19;
ulong uVar20;
byte **ppbVar21;
int1 *puVar22;
byte *pbVar23;
ulong uVar24;
long in_FS_OFFSET;
byte *local_f8;
long local_f0;
int local_e8;
int8 local_e4;
byte *local_d8;
long local_d0;
ulong local_b8 [5];
int local_90;
int4 local_8c;
uint local_88;
long local_80;
int8 *local_78;
int8 local_70;
int8 local_68;
long local_60;
int1 *local_58;
int4 local_50;
int4 local_4c;
int1 *local_48;
char local_39;
long local_38;
ppbVar21 = &local_f8;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
local_60 = *param_1;
lVar18 = param_3[1];
uVar24 = (ulong)*(ushort *)(lVar18 + 0xa6);
uVar20 = (ulong)*(ushort *)(lVar18 + 0xb0);
local_b8[0] = uVar20 * 3 + uVar24;
uVar14 = *(long *)param_1[0xf] - (long)local_b8;
uVar15 = uVar14 - local_b8[0];
local_78 = param_3;
local_70 = param_6;
local_68 = param_5;
local_50 = param_2;
if ((local_b8[0] < uVar14) &&
((0x10000 < uVar15 || ((0xfff < (uint)local_b8[0] && (0x8000 < uVar15)))))) {
puVar22 = (int1 *)((long)&local_f8 - (ulong)((uint)local_b8[0] + 0xf & 0xfffffff0));
local_4c = (int4)CONCAT71((int7)((ulong)local_b8 >> 8),1);
ppbVar21 = (byte **)puVar22;
}
else {
puVar22 = (int1 *)my_malloc(0,local_b8[0],0x10010);
if (puVar22 == (int1 *)0x0) {
uVar13 = 1;
goto LAB_00156255;
}
uVar24 = (ulong)*(ushort *)(lVar18 + 0xa6);
uVar20 = (ulong)*(ushort *)(lVar18 + 0xb0);
local_4c = 0;
ppbVar21 = &local_f8;
}
*(int8 *)((long)ppbVar21 + -8) = 0;
local_58 = puVar22;
*(int1 **)((long)ppbVar21 + -0x10) = puVar22;
*(int8 *)((long)ppbVar21 + -0x18) = 0x1561ed;
cVar9 = _ma_fetch_keypage(local_b8,param_1,lVar18,param_4,4,3);
uVar8 = local_50;
puVar5 = local_78;
if (cVar9 == '\0') {
pbVar23 = local_58 + uVar24 + uVar20 * 2;
pcVar4 = *(code **)(lVar18 + 0xd8);
*(int8 *)((long)ppbVar21 + -8) = 0x156237;
iVar11 = (*pcVar4)(puVar5,local_b8,uVar8,&local_48,pbVar23,&local_39);
iVar12 = local_90;
if (iVar11 == 0) {
pcVar4 = *(code **)(lVar18 + 0xe0);
local_d8 = pbVar23;
local_d0 = lVar18;
*(int8 *)((long)ppbVar21 + -8) = 0x15629f;
iVar12 = (*pcVar4)(&local_d8,local_8c,iVar12,&local_48);
if (iVar12 == 0) {
lVar17 = -1;
}
else {
*(int8 *)((long)ppbVar21 + -8) = 0x1562b3;
lVar17 = _ma_row_pos_from_key(&local_d8);
}
lVar7 = local_60;
if ((*(byte *)(lVar18 + 0xa2) & 0x80) == 0) {
*(int8 *)((long)ppbVar21 + -8) = 0x15638d;
lVar18 = _ma_trid_from_key(&local_d8);
param_1[0x86] = lVar18;
param_1[0x85] = lVar17;
*(int8 *)((long)ppbVar21 + -8) = 0x1563a0;
puVar16 = (int4 *)_my_thread_var();
*puVar16 = 0x79;
goto LAB_001561f5;
}
if ((ulong)*pbVar23 == 0xff) {
lVar19 = (ulong)(ushort)(*(ushort *)(pbVar23 + 1) << 8 | *(ushort *)(pbVar23 + 1) >> 8) + 3;
}
else {
lVar19 = (ulong)*pbVar23 + 1;
}
bVar1 = pbVar23[lVar19];
if ((int)((uint)bVar1 << 0x18) < 0) {
uVar3 = *(ushort *)(pbVar23 + lVar19 + 2);
bVar2 = pbVar23[lVar19 + 1];
local_f8 = (byte *)*puVar5;
if (*local_f8 == 0xff) {
uVar13 = (ushort)(*(ushort *)(local_f8 + 1) << 8 | *(ushort *)(local_f8 + 1) >> 8) + 3;
}
else {
uVar13 = *local_f8 + 1;
}
local_f0 = local_60 + 0x458;
local_f8 = local_f8 + uVar13;
local_e8 = *(int *)(puVar5 + 2) - uVar13;
local_e4 = *(int8 *)((long)puVar5 + 0x14);
local_48 = local_48 + -(ulong)((uint)*(ushort *)(local_60 + 0x502) + local_90);
local_80 = lVar17;
*(int8 *)((long)ppbVar21 + -8) = 0x1564b0;
bVar10 = _ma_ck_real_write_btree(param_1,&local_f8,&local_80,4);
lVar18 = local_80;
puVar22 = local_48 + 4;
*(int8 *)((long)ppbVar21 + -8) = 0x1564c7;
_ma_dpointer(lVar7,puVar22,lVar18);
iVar12 = CONCAT13(bVar1,CONCAT12(bVar2,uVar3 << 8 | uVar3 >> 8)) + -1;
local_48[3] = (char)iVar12;
local_48[2] = (char)((uint)iVar12 >> 8);
local_48[1] = (char)((uint)iVar12 >> 0x10);
*local_48 = (char)((uint)iVar12 >> 0x18);
if (bVar10 == 0) {
*(int1 *)(param_1[0x5d] + 0x10 + (ulong)local_88 * 0x18) = 1;
*(int8 *)((long)ppbVar21 + -8) = 0x156535;
cVar9 = _ma_write_keypage(local_b8,2,3);
if (cVar9 != '\0') goto LAB_001561f5;
}
puVar22 = local_58;
if ((char)local_4c == '\0') {
*(int8 *)((long)ppbVar21 + -8) = 0x156503;
my_free(puVar22);
}
uVar13 = (uint)bVar10;
goto LAB_00156255;
}
local_50 = 4;
pcVar4 = *(code **)(lVar18 + 0xd8);
*(int8 *)((long)ppbVar21 + -8) = 0x156416;
iVar11 = (*pcVar4)(puVar5,local_b8,4,&local_48,pbVar23,&local_39);
}
puVar22 = local_48;
if (iVar11 == 0x7fffffff) {
*(int8 *)((long)ppbVar21 + -8) = 0x156247;
puVar16 = (int4 *)_my_thread_var();
*puVar16 = 0x7e;
goto LAB_001561f5;
}
if (local_39 == '\0') {
param_7 = '\0';
}
*(int8 *)((long)ppbVar21 + -8) = 0x1562d7;
lVar18 = _ma_kpos(local_90,puVar22);
puVar22 = local_48;
uVar8 = local_50;
if (lVar18 == -1) {
LAB_0015630d:
puVar22 = local_48;
uVar6 = local_68;
*(ulong *)((long)ppbVar21 + -8) = (ulong)(uint)(int)param_7;
*(int8 *)((long)ppbVar21 + -0x10) = local_70;
*(int8 *)((long)ppbVar21 + -0x18) = 0x15632e;
uVar13 = _ma_insert(param_1,puVar5,local_b8,puVar22,pbVar23,uVar6);
if (-1 < (int)uVar13) {
*(int1 *)(param_1[0x5d] + 0x10 + (ulong)local_88 * 0x18) = 1;
*(int8 *)((long)ppbVar21 + -8) = 0x156366;
cVar9 = _ma_write_keypage(local_b8,2,3);
if (cVar9 == '\0') goto LAB_001563c0;
}
goto LAB_001561f5;
}
*(ulong *)((long)ppbVar21 + -0x10) = (ulong)(uint)(int)param_7;
*(int8 *)((long)ppbVar21 + -0x18) = 0x156301;
uVar13 = w_search(param_1,uVar8,puVar5,lVar18,local_b8,puVar22);
if (0 < (int)uVar13) goto LAB_0015630d;
LAB_001563c0:
puVar22 = local_58;
}
else {
LAB_001561f5:
uVar13 = 0xffffffff;
puVar22 = local_58;
}
local_58 = puVar22;
if ((char)local_4c == '\0') {
*(int8 *)((long)ppbVar21 + -8) = 0x15620a;
my_free(puVar22);
}
LAB_00156255:
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return uVar13;
}
/* WARNING: Subroutine does not return */
*(code **)((long)ppbVar21 + -8) = _ma_enlarge_root;
__stack_chk_fail();
}
|
Subsets and Splits
C++ Functions Using STL
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ STL Function Queries
Filters C++ code examples that use standard library containers and algorithms, helping identify common programming patterns and library usage in code generation tasks.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.