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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
23,900 | maria_rtree_find_req | eloqsql/storage/maria/ma_rt_index.c | static int maria_rtree_find_req(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
uint32 search_flag,
uint nod_cmp_flag, my_off_t page_pos,
int level)
{
MARIA_SHARE *share= info->s;
uint nod_flag;
int res;
uchar *page_buf, *k, *last;
int key_data_length;
uint *saved_key= (uint*) (info->maria_rtree_recursion_state) + level;
MARIA_PAGE page;
my_bool buff_alloced;
alloc_on_stack(*info->stack_end_ptr, page_buf, buff_alloced,
keyinfo->block_length);
if (!page_buf)
{
my_errno= HA_ERR_OUT_OF_MEM;
return(-1);
}
if (_ma_fetch_keypage(&page, info, keyinfo, page_pos,
PAGECACHE_LOCK_LEFT_UNLOCKED,
DFLT_INIT_HITS, page_buf, 0))
goto err;
nod_flag= page.node;
key_data_length= keyinfo->keylength - share->base.rec_reflength;
if (info->maria_rtree_recursion_depth >= level)
{
k= page_buf + *saved_key;
}
else
{
k= rt_PAGE_FIRST_KEY(share, page_buf, nod_flag);
}
last= rt_PAGE_END(&page);
for (; k < last; k= rt_PAGE_NEXT_KEY(share, k, key_data_length, nod_flag))
{
if (nod_flag)
{
/* this is an internal node in the tree */
if (!(res= maria_rtree_key_cmp(keyinfo->seg,
info->first_mbr_key, k,
info->last_rkey_length, nod_cmp_flag)))
{
switch ((res= maria_rtree_find_req(info, keyinfo, search_flag,
nod_cmp_flag,
_ma_kpos(nod_flag, k),
level + 1)))
{
case 0: /* found - exit from recursion */
*saved_key= (uint) (k - page_buf);
goto ok;
case 1: /* not found - continue searching */
info->maria_rtree_recursion_depth= level;
break;
default: /* error */
case -1:
goto err;
}
}
}
else
{
/* this is a leaf */
if (!maria_rtree_key_cmp(keyinfo->seg, info->first_mbr_key,
k, info->last_rkey_length, search_flag))
{
uchar *after_key= rt_PAGE_NEXT_KEY(share, k, key_data_length, 0);
MARIA_KEY tmp_key;
/*
We don't need to set all MARIA_KEY elements here as
_ma_row_pos_from_key() only uses a few of them.
*/
tmp_key.keyinfo= keyinfo;
tmp_key.data= k;
tmp_key.data_length= key_data_length;
info->cur_row.lastpos= _ma_row_pos_from_key(&tmp_key);
info->last_key.data_length= key_data_length;
info->last_key.ref_length= share->base.rec_reflength;
info->last_key.flag= 0;
memcpy(info->last_key.data, k,
info->last_key.data_length + info->last_key.ref_length);
info->maria_rtree_recursion_depth= level;
*saved_key= (uint) (last - page_buf);
if (after_key < last)
{
uchar *keyread_buff= info->keyread_buff;
info->int_keypos= keyread_buff;
info->int_maxpos= keyread_buff + (last - after_key);
memcpy(keyread_buff, after_key, last - after_key);
info->keyread_buff_used= 0;
}
else
{
info->keyread_buff_used= 1;
}
res= 0;
goto ok;
}
}
}
info->cur_row.lastpos= HA_OFFSET_ERROR;
my_errno= HA_ERR_KEY_NOT_FOUND;
res= 1;
ok:
stack_alloc_free(page_buf, buff_alloced);
return res;
err:
stack_alloc_free(page_buf, buff_alloced);
info->cur_row.lastpos= HA_OFFSET_ERROR;
return -1;
} | O3 | c | maria_rtree_find_req:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, -0x58(%rbp)
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq (%rdi), %rax
movq %rax, -0x40(%rbp)
movq 0x6e0(%rdi), %r15
movzwl 0xa6(%rsi), %esi
leaq -0xa8(%rbp), %rcx
movq %rsi, (%rcx)
movq 0x78(%rdi), %rax
movq (%rax), %rax
subq %rcx, %rax
subq %rsi, %rax
jbe 0x73b3d
cmpq $0x10000, %rax # imm = 0x10000
ja 0x73b23
cmpl $0x1000, %esi # imm = 0x1000
jb 0x73b3d
cmpq $0x8001, %rax # imm = 0x8001
jb 0x73b3d
movq %r15, -0x50(%rbp)
movq %rsp, %r13
addl $0xf, %esi
andl $-0x10, %esi
subq %rsi, %r13
movq %r13, %rsp
movb $0x1, %al
movl %eax, -0x34(%rbp)
jmp 0x73b60
movl $0x10010, %edx # imm = 0x10010
xorl %edi, %edi
callq 0xc3acd
testq %rax, %rax
je 0x73bd3
movq %rax, %r13
movq %r15, -0x50(%rbp)
movl $0x0, -0x34(%rbp)
leaq -0xa8(%rbp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
movl $0x3, %r9d
pushq $0x0
pushq %r13
callq 0x40df6
addq $0x10, %rsp
testb %al, %al
je 0x73ba5
cmpb $0x0, -0x34(%rbp)
jne 0x73b98
movq %r13, %rdi
callq 0xc3cfa
movq $-0x1, 0x98(%rbx)
jmp 0x73bde
movslq -0x58(%rbp), %rcx
movl -0x80(%rbp), %r14d
cmpl %ecx, 0x6f0(%rbx)
movq %r13, -0x48(%rbp)
movq %rcx, -0x70(%rbp)
movq %r12, -0x60(%rbp)
jge 0x73c07
movq -0x40(%rbp), %rax
movl 0x744(%rax), %eax
addq %r13, %rax
movl %r14d, %ecx
jmp 0x73c11
callq 0xc5c9a
movl $0x80, (%rax)
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x73de1
movl %ebx, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x50(%rbp), %rax
movl (%rax,%rcx,4), %ecx
movq %r13, %rax
movl %ecx, %r15d
addq %rax, %r15
movl -0x88(%rbp), %r12d
addq -0x98(%rbp), %r12
cmpq %r12, %r15
jae 0x73ccd
movq -0x60(%rbp), %rax
movzwl 0xaa(%rax), %eax
movq -0x40(%rbp), %rcx
subl 0x3e0(%rcx), %eax
movq -0x58(%rbp), %rcx
incl %ecx
movl %ecx, -0x64(%rbp)
movslq %eax, %r13
movq -0x60(%rbp), %rax
movq 0xc0(%rax), %rdi
movq 0x398(%rbx), %rsi
movl 0x630(%rbx), %ecx
movq %r15, %rdx
movl $0x400, %r8d # imm = 0x400
callq 0x75c48
testl %r14d, %r14d
je 0x73cb2
movl %r14d, %ecx
testl %eax, %eax
jne 0x73cc0
movl %r14d, %edi
movq %r15, %rsi
callq 0x3ee07
movq %rbx, %rdi
movq -0x60(%rbp), %rsi
movq %rax, %rdx
movl -0x64(%rbp), %ecx
callq 0x73aaf
cmpl $0x1, %eax
jne 0x73d04
movq -0x58(%rbp), %rax
movl %eax, 0x6f0(%rbx)
movl %r14d, %ecx
jmp 0x73cc0
testl %eax, %eax
je 0x73d23
movq -0x40(%rbp), %rax
movl 0x3e0(%rax), %ecx
addq %r13, %r15
movl %ecx, %eax
addq %rax, %r15
cmpq %r12, %r15
jb 0x73c4f
movq $-0x1, 0x98(%rbx)
callq 0xc5c9a
movl $0x78, (%rax)
movl $0x1, %ebx
movq -0x48(%rbp), %r13
movl -0x34(%rbp), %eax
testb %al, %al
jne 0x73be3
movq %r13, %rdi
callq 0xc3cfa
jmp 0x73be3
testl %eax, %eax
movq -0x48(%rbp), %r13
jne 0x73b8a
subl %r13d, %r15d
movq -0x50(%rbp), %rax
movq -0x70(%rbp), %rcx
movl %r15d, (%rax,%rcx,4)
xorl %ebx, %ebx
jmp 0x73cec
movq -0x40(%rbp), %rcx
movl 0x3e0(%rcx), %r14d
addq %r15, %r14
addq %r13, %r14
leaq -0xc8(%rbp), %rdi
movq -0x60(%rbp), %rax
movq %rax, 0x8(%rdi)
movq %r15, (%rdi)
movl %r13d, 0x10(%rdi)
callq 0x3ef6c
movq %rax, 0x98(%rbx)
movl %r13d, 0x210(%rbx)
movq -0x40(%rbp), %rax
movl 0x3e0(%rax), %edx
movl %edx, 0x214(%rbx)
movl $0x0, 0x218(%rbx)
movq 0x200(%rbx), %rdi
addl %r13d, %edx
movq %r15, %rsi
callq 0x2b0b0
movq -0x58(%rbp), %rax
movl %eax, 0x6f0(%rbx)
movl %r12d, %eax
subl -0x48(%rbp), %eax
movq -0x50(%rbp), %rcx
movq -0x70(%rbp), %rdx
movl %eax, (%rcx,%rdx,4)
movb $0x1, %al
cmpq %r12, %r14
jae 0x73dd4
movq 0x380(%rbx), %rdi
movq %rdi, 0x3b0(%rbx)
subq %r14, %r12
leaq (%rdi,%r12), %rax
movq %rax, 0x3b8(%rbx)
movq %r14, %rsi
movq %r12, %rdx
callq 0x2b0b0
xorl %eax, %eax
movb %al, 0x685(%rbx)
xorl %ebx, %ebx
jmp 0x73ce8
callq 0x2b280
| maria_rtree_find_req:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0A8h
mov [rbp+var_58], rcx
mov r14, rdx
mov r12, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov rax, [rdi]
mov [rbp+var_40], rax
mov r15, [rdi+6E0h]
movzx esi, word ptr [rsi+0A6h]
lea rcx, [rbp+var_A8]
mov [rcx], rsi
mov rax, [rdi+78h]
mov rax, [rax]
sub rax, rcx
sub rax, rsi
jbe short loc_73B3D
cmp rax, 10000h
ja short loc_73B23
cmp esi, 1000h
jb short loc_73B3D
cmp rax, 8001h
jb short loc_73B3D
loc_73B23:
mov [rbp+var_50], r15
mov r13, rsp
add esi, 0Fh
and esi, 0FFFFFFF0h
sub r13, rsi
mov rsp, r13
mov al, 1
mov [rbp+var_34], eax
jmp short loc_73B60
loc_73B3D:
mov edx, offset stru_10010
xor edi, edi
call my_malloc
test rax, rax
jz loc_73BD3
mov r13, rax
mov [rbp+var_50], r15
mov [rbp+var_34], 0
loc_73B60:
lea rdi, [rbp+var_A8]
mov rsi, rbx
mov rdx, r12
mov rcx, r14
xor r8d, r8d
mov r9d, 3
push 0
push r13
call _ma_fetch_keypage
add rsp, 10h
test al, al
jz short loc_73BA5
loc_73B8A:
cmp byte ptr [rbp+var_34], 0
jnz short loc_73B98
mov rdi, r13
call my_free
loc_73B98:
mov qword ptr [rbx+98h], 0FFFFFFFFFFFFFFFFh
jmp short loc_73BDE
loc_73BA5:
movsxd rcx, dword ptr [rbp+var_58]
mov r14d, [rbp+var_80]
cmp [rbx+6F0h], ecx
mov [rbp+var_48], r13
mov [rbp+var_70], rcx
mov [rbp+var_60], r12
jge short loc_73C07
mov rax, [rbp+var_40]
mov eax, [rax+744h]
add rax, r13
mov ecx, r14d
jmp short loc_73C11
loc_73BD3:
call _my_thread_var
mov dword ptr [rax], 80h
loc_73BDE:
mov ebx, 0FFFFFFFFh
loc_73BE3:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz loc_73DE1
mov eax, ebx
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_73C07:
mov rax, [rbp+var_50]
mov ecx, [rax+rcx*4]
mov rax, r13
loc_73C11:
mov r15d, ecx
add r15, rax
mov r12d, [rbp+var_88]
add r12, [rbp+var_98]
cmp r15, r12
jnb loc_73CCD
mov rax, [rbp+var_60]
movzx eax, word ptr [rax+0AAh]
mov rcx, [rbp+var_40]
sub eax, [rcx+3E0h]
mov rcx, [rbp+var_58]
inc ecx
mov [rbp+var_64], ecx
movsxd r13, eax
loc_73C4F:
mov rax, [rbp+var_60]
mov rdi, [rax+0C0h]
mov rsi, [rbx+398h]
mov ecx, [rbx+630h]
mov rdx, r15
mov r8d, 400h
call maria_rtree_key_cmp
test r14d, r14d
jz short loc_73CB2
mov ecx, r14d
test eax, eax
jnz short loc_73CC0
mov edi, r14d
mov rsi, r15
call _ma_kpos
mov rdi, rbx
mov rsi, [rbp+var_60]
mov rdx, rax
mov ecx, [rbp+var_64]
call maria_rtree_find_req
cmp eax, 1
jnz short loc_73D04
mov rax, [rbp+var_58]
mov [rbx+6F0h], eax
mov ecx, r14d
jmp short loc_73CC0
loc_73CB2:
test eax, eax
jz short loc_73D23
mov rax, [rbp+var_40]
mov ecx, [rax+3E0h]
loc_73CC0:
add r15, r13
mov eax, ecx
add r15, rax
cmp r15, r12
jb short loc_73C4F
loc_73CCD:
mov qword ptr [rbx+98h], 0FFFFFFFFFFFFFFFFh
call _my_thread_var
mov dword ptr [rax], 78h ; 'x'
mov ebx, 1
loc_73CE8:
mov r13, [rbp+var_48]
loc_73CEC:
mov eax, [rbp+var_34]
test al, al
jnz loc_73BE3
mov rdi, r13
call my_free
jmp loc_73BE3
loc_73D04:
test eax, eax
mov r13, [rbp+var_48]
jnz loc_73B8A
sub r15d, r13d
mov rax, [rbp+var_50]
mov rcx, [rbp+var_70]
mov [rax+rcx*4], r15d
xor ebx, ebx
jmp short loc_73CEC
loc_73D23:
mov rcx, [rbp+var_40]
mov r14d, [rcx+3E0h]
add r14, r15
add r14, r13
lea rdi, [rbp+var_C8]
mov rax, [rbp+var_60]
mov [rdi+8], rax
mov [rdi], r15
mov [rdi+10h], r13d
call _ma_row_pos_from_key
mov [rbx+98h], rax
mov [rbx+210h], r13d
mov rax, [rbp+var_40]
mov edx, [rax+3E0h]
mov [rbx+214h], edx
mov dword ptr [rbx+218h], 0
mov rdi, [rbx+200h]
add edx, r13d
mov rsi, r15
call _memcpy
mov rax, [rbp+var_58]
mov [rbx+6F0h], eax
mov eax, r12d
sub eax, dword ptr [rbp+var_48]
mov rcx, [rbp+var_50]
mov rdx, [rbp+var_70]
mov [rcx+rdx*4], eax
mov al, 1
cmp r14, r12
jnb short loc_73DD4
mov rdi, [rbx+380h]
mov [rbx+3B0h], rdi
sub r12, r14
lea rax, [rdi+r12]
mov [rbx+3B8h], rax
mov rsi, r14
mov rdx, r12
call _memcpy
xor eax, eax
loc_73DD4:
mov [rbx+685h], al
xor ebx, ebx
jmp loc_73CE8
loc_73DE1:
call ___stack_chk_fail
| long long maria_rtree_find_req(long long a1, long long a2, unsigned long long a3, long long a4)
{
long long v7; // r15
unsigned long long v8; // rsi
unsigned long long v9; // rax
bool v10; // cc
unsigned long long v11; // rax
char *v12; // r13
long long v13; // rax
_QWORD *v14; // rdi
unsigned int v15; // r14d
char *v16; // rax
unsigned int v17; // ecx
unsigned int v18; // ebx
unsigned long long v20; // r15
unsigned long long v21; // r12
int v22; // eax
long long v23; // r13
int v24; // eax
unsigned int v25; // ecx
long long v26; // rax
int req; // eax
unsigned long long v28; // r14
int v29; // edx
char v30; // al
long long v31; // rdi
unsigned long long v32; // r12
long long v34[2]; // [rsp+8h] [rbp-C8h] BYREF
int v35; // [rsp+18h] [rbp-B8h]
_QWORD v36[4]; // [rsp+28h] [rbp-A8h] BYREF
unsigned int v37; // [rsp+48h] [rbp-88h]
unsigned int v38; // [rsp+50h] [rbp-80h]
long long v39; // [rsp+60h] [rbp-70h]
unsigned int v40; // [rsp+6Ch] [rbp-64h]
long long v41; // [rsp+70h] [rbp-60h]
long long v42; // [rsp+78h] [rbp-58h]
long long v43; // [rsp+80h] [rbp-50h]
char *v44; // [rsp+88h] [rbp-48h]
long long v45; // [rsp+90h] [rbp-40h]
int v46; // [rsp+9Ch] [rbp-34h]
unsigned long long v47; // [rsp+A0h] [rbp-30h]
v42 = a4;
v47 = __readfsqword(0x28u);
v45 = *(_QWORD *)a1;
v7 = *(_QWORD *)(a1 + 1760);
v8 = *(unsigned __int16 *)(a2 + 166);
v36[0] = v8;
v9 = **(_QWORD **)(a1 + 120) - (_QWORD)v36;
v10 = v9 <= v8;
v11 = v9 - v8;
if ( v10 || v11 <= 0x10000 && ((unsigned int)v8 < 0x1000 || v11 < 0x8001) )
{
v13 = my_malloc(0LL, v8, &stru_10010);
if ( !v13 )
{
*(_DWORD *)my_thread_var(0LL) = 128;
return (unsigned int)-1;
}
v12 = (char *)v13;
v43 = v7;
v46 = 0;
}
else
{
v43 = v7;
v12 = (char *)&v34[-1] - (((_DWORD)v8 + 15) & 0xFFFFFFF0);
LOBYTE(v11) = 1;
v46 = v11;
}
v14 = v36;
if ( ma_fetch_keypage((long long)v36, a1, a2, a3, 0, 3, (long long)v12) )
{
LABEL_9:
if ( !(_BYTE)v46 )
my_free(v12);
*(_QWORD *)(a1 + 152) = -1LL;
return (unsigned int)-1;
}
v15 = v38;
v10 = *(_DWORD *)(a1 + 1776) < (int)v42;
v44 = v12;
v39 = (int)v42;
v41 = a2;
if ( v10 )
{
v16 = &v12[*(unsigned int *)(v45 + 1860)];
v17 = v38;
}
else
{
v17 = *(_DWORD *)(v43 + 4LL * (int)v42);
v16 = v12;
}
v20 = (unsigned long long)&v16[v17];
v21 = v36[2] + v37;
if ( v20 < v21 )
{
v22 = *(unsigned __int16 *)(v41 + 170) - *(_DWORD *)(v45 + 992);
v40 = v42 + 1;
v23 = v22;
do
{
v14 = *(_QWORD **)(v41 + 192);
v24 = maria_rtree_key_cmp(v14, *(_QWORD *)(a1 + 920), v20, *(unsigned int *)(a1 + 1584), 1024LL);
if ( v15 )
{
v25 = v15;
if ( !v24 )
{
v26 = ma_kpos(v15, v20);
v14 = (_QWORD *)a1;
req = maria_rtree_find_req(a1, v41, v26, v40);
if ( req != 1 )
{
v12 = v44;
if ( req )
goto LABEL_9;
*(_DWORD *)(v43 + 4 * v39) = v20 - (_DWORD)v44;
v18 = 0;
goto LABEL_29;
}
*(_DWORD *)(a1 + 1776) = v42;
v25 = v15;
}
}
else
{
if ( !v24 )
{
v28 = v23 + v20 + *(unsigned int *)(v45 + 992);
v34[1] = v41;
v34[0] = v20;
v35 = v23;
*(_QWORD *)(a1 + 152) = ma_row_pos_from_key(v34);
*(_DWORD *)(a1 + 528) = v23;
v29 = *(_DWORD *)(v45 + 992);
*(_DWORD *)(a1 + 532) = v29;
*(_DWORD *)(a1 + 536) = 0;
memcpy(*(_QWORD *)(a1 + 512), v20, (unsigned int)(v23 + v29));
*(_DWORD *)(a1 + 1776) = v42;
*(_DWORD *)(v43 + 4 * v39) = v21 - (_DWORD)v44;
v30 = 1;
if ( v28 < v21 )
{
v31 = *(_QWORD *)(a1 + 896);
*(_QWORD *)(a1 + 944) = v31;
v32 = v21 - v28;
*(_QWORD *)(a1 + 952) = v31 + v32;
memcpy(v31, v28, v32);
v30 = 0;
}
*(_BYTE *)(a1 + 1669) = v30;
v18 = 0;
goto LABEL_28;
}
v25 = *(_DWORD *)(v45 + 992);
}
v20 += v25 + v23;
}
while ( v20 < v21 );
}
*(_QWORD *)(a1 + 152) = -1LL;
*(_DWORD *)my_thread_var(v14) = 120;
v18 = 1;
LABEL_28:
v12 = v44;
LABEL_29:
if ( !(_BYTE)v46 )
my_free(v12);
return v18;
}
| maria_rtree_find_req:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xa8
MOV qword ptr [RBP + -0x58],RCX
MOV R14,RDX
MOV R12,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RDI]
MOV qword ptr [RBP + -0x40],RAX
MOV R15,qword ptr [RDI + 0x6e0]
MOVZX ESI,word ptr [RSI + 0xa6]
LEA RCX,[RBP + -0xa8]
MOV qword ptr [RCX],RSI
MOV RAX,qword ptr [RDI + 0x78]
MOV RAX,qword ptr [RAX]
SUB RAX,RCX
SUB RAX,RSI
JBE 0x00173b3d
CMP RAX,0x10000
JA 0x00173b23
CMP ESI,0x1000
JC 0x00173b3d
CMP RAX,0x8001
JC 0x00173b3d
LAB_00173b23:
MOV qword ptr [RBP + -0x50],R15
MOV R13,RSP
ADD ESI,0xf
AND ESI,0xfffffff0
SUB R13,RSI
MOV RSP,R13
MOV AL,0x1
MOV dword ptr [RBP + -0x34],EAX
JMP 0x00173b60
LAB_00173b3d:
MOV EDX,0x10010
XOR EDI,EDI
CALL 0x001c3acd
TEST RAX,RAX
JZ 0x00173bd3
MOV R13,RAX
MOV qword ptr [RBP + -0x50],R15
MOV dword ptr [RBP + -0x34],0x0
LAB_00173b60:
LEA RDI,[RBP + -0xa8]
MOV RSI,RBX
MOV RDX,R12
MOV RCX,R14
XOR R8D,R8D
MOV R9D,0x3
PUSH 0x0
PUSH R13
CALL 0x00140df6
ADD RSP,0x10
TEST AL,AL
JZ 0x00173ba5
LAB_00173b8a:
CMP byte ptr [RBP + -0x34],0x0
JNZ 0x00173b98
MOV RDI,R13
CALL 0x001c3cfa
LAB_00173b98:
MOV qword ptr [RBX + 0x98],-0x1
JMP 0x00173bde
LAB_00173ba5:
MOVSXD RCX,dword ptr [RBP + -0x58]
MOV R14D,dword ptr [RBP + -0x80]
CMP dword ptr [RBX + 0x6f0],ECX
MOV qword ptr [RBP + -0x48],R13
MOV qword ptr [RBP + -0x70],RCX
MOV qword ptr [RBP + -0x60],R12
JGE 0x00173c07
MOV RAX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RAX + 0x744]
ADD RAX,R13
MOV ECX,R14D
JMP 0x00173c11
LAB_00173bd3:
CALL 0x001c5c9a
MOV dword ptr [RAX],0x80
LAB_00173bde:
MOV EBX,0xffffffff
LAB_00173be3:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00173de1
MOV EAX,EBX
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00173c07:
MOV RAX,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RAX + RCX*0x4]
MOV RAX,R13
LAB_00173c11:
MOV R15D,ECX
ADD R15,RAX
MOV R12D,dword ptr [RBP + -0x88]
ADD R12,qword ptr [RBP + -0x98]
CMP R15,R12
JNC 0x00173ccd
MOV RAX,qword ptr [RBP + -0x60]
MOVZX EAX,word ptr [RAX + 0xaa]
MOV RCX,qword ptr [RBP + -0x40]
SUB EAX,dword ptr [RCX + 0x3e0]
MOV RCX,qword ptr [RBP + -0x58]
INC ECX
MOV dword ptr [RBP + -0x64],ECX
MOVSXD R13,EAX
LAB_00173c4f:
MOV RAX,qword ptr [RBP + -0x60]
MOV RDI,qword ptr [RAX + 0xc0]
MOV RSI,qword ptr [RBX + 0x398]
MOV ECX,dword ptr [RBX + 0x630]
MOV RDX,R15
MOV R8D,0x400
CALL 0x00175c48
TEST R14D,R14D
JZ 0x00173cb2
MOV ECX,R14D
TEST EAX,EAX
JNZ 0x00173cc0
MOV EDI,R14D
MOV RSI,R15
CALL 0x0013ee07
MOV RDI,RBX
MOV RSI,qword ptr [RBP + -0x60]
MOV RDX,RAX
MOV ECX,dword ptr [RBP + -0x64]
CALL 0x00173aaf
CMP EAX,0x1
JNZ 0x00173d04
MOV RAX,qword ptr [RBP + -0x58]
MOV dword ptr [RBX + 0x6f0],EAX
MOV ECX,R14D
JMP 0x00173cc0
LAB_00173cb2:
TEST EAX,EAX
JZ 0x00173d23
MOV RAX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RAX + 0x3e0]
LAB_00173cc0:
ADD R15,R13
MOV EAX,ECX
ADD R15,RAX
CMP R15,R12
JC 0x00173c4f
LAB_00173ccd:
MOV qword ptr [RBX + 0x98],-0x1
CALL 0x001c5c9a
MOV dword ptr [RAX],0x78
MOV EBX,0x1
LAB_00173ce8:
MOV R13,qword ptr [RBP + -0x48]
LAB_00173cec:
MOV EAX,dword ptr [RBP + -0x34]
TEST AL,AL
JNZ 0x00173be3
MOV RDI,R13
CALL 0x001c3cfa
JMP 0x00173be3
LAB_00173d04:
TEST EAX,EAX
MOV R13,qword ptr [RBP + -0x48]
JNZ 0x00173b8a
SUB R15D,R13D
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RBP + -0x70]
MOV dword ptr [RAX + RCX*0x4],R15D
XOR EBX,EBX
JMP 0x00173cec
LAB_00173d23:
MOV RCX,qword ptr [RBP + -0x40]
MOV R14D,dword ptr [RCX + 0x3e0]
ADD R14,R15
ADD R14,R13
LEA RDI,[RBP + -0xc8]
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RDI + 0x8],RAX
MOV qword ptr [RDI],R15
MOV dword ptr [RDI + 0x10],R13D
CALL 0x0013ef6c
MOV qword ptr [RBX + 0x98],RAX
MOV dword ptr [RBX + 0x210],R13D
MOV RAX,qword ptr [RBP + -0x40]
MOV EDX,dword ptr [RAX + 0x3e0]
MOV dword ptr [RBX + 0x214],EDX
MOV dword ptr [RBX + 0x218],0x0
MOV RDI,qword ptr [RBX + 0x200]
ADD EDX,R13D
MOV RSI,R15
CALL 0x0012b0b0
MOV RAX,qword ptr [RBP + -0x58]
MOV dword ptr [RBX + 0x6f0],EAX
MOV EAX,R12D
SUB EAX,dword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x70]
MOV dword ptr [RCX + RDX*0x4],EAX
MOV AL,0x1
CMP R14,R12
JNC 0x00173dd4
MOV RDI,qword ptr [RBX + 0x380]
MOV qword ptr [RBX + 0x3b0],RDI
SUB R12,R14
LEA RAX,[RDI + R12*0x1]
MOV qword ptr [RBX + 0x3b8],RAX
MOV RSI,R14
MOV RDX,R12
CALL 0x0012b0b0
XOR EAX,EAX
LAB_00173dd4:
MOV byte ptr [RBX + 0x685],AL
XOR EBX,EBX
JMP 0x00173ce8
LAB_00173de1:
CALL 0x0012b280
|
int8 maria_rtree_find_req(long *param_1,long param_2,int8 param_3,int8 param_4)
{
ushort uVar1;
uint uVar2;
void *pvVar3;
long lVar4;
char cVar5;
int iVar6;
int iVar7;
ulong uVar8;
int4 *puVar9;
long lVar10;
int8 uVar11;
int1 *puVar12;
int1 *puVar13;
int1 *puVar14;
int1 *puVar15;
long in_FS_OFFSET;
int1 auStack_d8 [8];
int1 *local_d0;
long local_c8;
int local_c0;
ulong local_b0 [2];
long local_a0;
uint local_90;
uint local_88;
long local_78;
int local_6c;
long local_68;
int8 local_60;
long local_58;
int1 *local_50;
long local_48;
int4 local_3c;
long local_38;
puVar12 = auStack_d8;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
local_48 = *param_1;
lVar10 = param_1[0xdc];
uVar1 = *(ushort *)(param_2 + 0xa6);
local_b0[0] = (ulong)uVar1;
uVar8 = (*(long *)param_1[0xf] - (long)local_b0) - local_b0[0];
local_60 = param_4;
if (((ulong)(*(long *)param_1[0xf] - (long)local_b0) < local_b0[0] || uVar8 == 0) ||
((uVar8 < 0x10001 && ((uVar1 < 0x1000 || (uVar8 < 0x8001)))))) {
puVar14 = (int1 *)my_malloc(0,local_b0[0],0x10010);
if (puVar14 != (int1 *)0x0) {
local_3c = 0;
puVar12 = auStack_d8;
goto LAB_00173b60;
}
puVar9 = (int4 *)_my_thread_var();
*puVar9 = 0x80;
}
else {
puVar14 = auStack_d8 + -(ulong)(uVar1 + 0xf & 0xfffffff0);
local_3c = (int4)CONCAT71((int7)(uVar8 >> 8),1);
puVar12 = puVar14;
LAB_00173b60:
local_58 = lVar10;
*(int8 *)(puVar12 + -8) = 0;
*(int1 **)(puVar12 + -0x10) = puVar14;
*(int8 *)(puVar12 + -0x18) = 0x173b82;
cVar5 = _ma_fetch_keypage(local_b0,param_1,param_2,param_3,0,3);
if (cVar5 == '\0') {
local_78 = (long)(int)local_60;
if ((int)param_1[0xde] < (int)local_60) {
puVar15 = puVar14 + *(uint *)(local_48 + 0x744);
uVar2 = local_88;
}
else {
uVar2 = *(uint *)(local_58 + local_78 * 4);
puVar15 = puVar14;
}
puVar15 = puVar15 + uVar2;
puVar13 = (int1 *)((ulong)local_90 + local_a0);
local_68 = param_2;
local_50 = puVar14;
if (puVar15 < puVar13) {
iVar6 = (uint)*(ushort *)(param_2 + 0xaa) - *(int *)(local_48 + 0x3e0);
local_6c = (int)local_60 + 1;
do {
uVar11 = *(int8 *)(local_68 + 0xc0);
lVar10 = param_1[0x73];
lVar4 = param_1[0xc6];
*(int8 *)(puVar12 + -8) = 0x173c75;
iVar7 = maria_rtree_key_cmp(uVar11,lVar10,puVar15,(int)lVar4,0x400);
if (local_88 == 0) {
if (iVar7 == 0) {
puVar14 = puVar15 + (long)iVar6 + (ulong)*(uint *)(local_48 + 0x3e0);
local_c8 = local_68;
local_d0 = puVar15;
local_c0 = iVar6;
*(int8 *)(puVar12 + -8) = 0x173d4f;
lVar10 = _ma_row_pos_from_key();
param_1[0x13] = lVar10;
*(int *)(param_1 + 0x42) = iVar6;
iVar7 = *(int *)(local_48 + 0x3e0);
*(int *)((long)param_1 + 0x214) = iVar7;
*(int4 *)(param_1 + 0x43) = 0;
pvVar3 = (void *)param_1[0x40];
*(int8 *)(puVar12 + -8) = 0x173d89;
memcpy(pvVar3,puVar15,(ulong)(uint)(iVar7 + iVar6));
*(int *)(param_1 + 0xde) = (int)local_60;
*(int *)(local_58 + local_78 * 4) = (int)puVar13 - (int)local_50;
if (puVar13 > puVar14) {
pvVar3 = (void *)param_1[0x70];
param_1[0x76] = (long)pvVar3;
param_1[0x77] = (long)pvVar3 + ((long)puVar13 - (long)puVar14);
*(int8 *)(puVar12 + -8) = 0x173dd2;
memcpy(pvVar3,puVar14,(long)puVar13 - (long)puVar14);
}
*(bool *)((long)param_1 + 0x685) = puVar13 <= puVar14;
uVar11 = 0;
goto LAB_00173cec;
}
uVar8 = (ulong)*(uint *)(local_48 + 0x3e0);
}
else {
uVar8 = (ulong)local_88;
if (iVar7 == 0) {
*(int8 *)(puVar12 + -8) = 0x173c8c;
uVar11 = _ma_kpos(local_88,puVar15);
lVar10 = local_68;
iVar7 = local_6c;
*(int8 *)(puVar12 + -8) = 0x173c9e;
iVar7 = maria_rtree_find_req(param_1,lVar10,uVar11,iVar7);
if (iVar7 != 1) {
puVar14 = local_50;
if (iVar7 != 0) goto LAB_00173b8a;
*(int *)(local_58 + local_78 * 4) = (int)puVar15 - (int)local_50;
uVar11 = 0;
goto LAB_00173cec;
}
*(int *)(param_1 + 0xde) = (int)local_60;
uVar8 = (ulong)local_88;
}
}
puVar15 = puVar15 + uVar8 + (long)iVar6;
} while (puVar15 < puVar13);
}
param_1[0x13] = -1;
*(int8 *)(puVar12 + -8) = 0x173cdd;
puVar9 = (int4 *)_my_thread_var();
*puVar9 = 0x78;
uVar11 = 1;
LAB_00173cec:
puVar14 = local_50;
if ((char)local_3c == '\0') {
*(int8 *)(puVar12 + -8) = 0x173cff;
my_free(puVar14);
}
goto LAB_00173be3;
}
LAB_00173b8a:
if ((char)local_3c == '\0') {
*(int8 *)(puVar12 + -8) = 0x173b98;
my_free(puVar14);
}
param_1[0x13] = -1;
}
uVar11 = 0xffffffff;
LAB_00173be3:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
*(code **)(puVar12 + -8) = maria_rtree_find_next;
__stack_chk_fail();
}
return uVar11;
}
| |
23,901 | LefDefParser::lefiTrackPattern::print(_IO_FILE*) const | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiMisc.cpp | void
lefiTrackPattern::print(FILE *f) const
{
int i;
fprintf(f, " TRACK Pattern %s %g DO %d STEP %g\n",
name(),
start(),
numTracks(),
space());
if (numLayers() > 0) {
fprintf(f, " LAYER ");
for (i = 0; i < numLayers(); i++)
fprintf(f, "%s ", layerName(i));
fprintf(f, "\n");
}
} | O0 | cpp | LefDefParser::lefiTrackPattern::print(_IO_FILE*) const:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x14620
movq 0x38(%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0x14630
movq 0x38(%rsp), %rdi
movsd %xmm0, 0x30(%rsp)
callq 0x14640
movq 0x38(%rsp), %rdi
movl %eax, 0x2c(%rsp)
callq 0x14650
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rdx
movl 0x2c(%rsp), %ecx
movaps %xmm0, %xmm1
movsd 0x30(%rsp), %xmm0
leaq 0x632f0(%rip), %rsi # 0x77a82
movb $0x2, %al
callq 0x2350
movq 0x38(%rsp), %rdi
callq 0x14660
cmpl $0x0, %eax
jle 0x14831
movq 0x48(%rsp), %rdi
leaq 0x632f0(%rip), %rsi # 0x77aa8
movb $0x0, %al
callq 0x2350
movl $0x0, 0x44(%rsp)
movq 0x38(%rsp), %rdi
movl 0x44(%rsp), %eax
movl %eax, 0x14(%rsp)
callq 0x14660
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jge 0x1481e
movq 0x38(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x44(%rsp), %esi
callq 0x14670
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x6113e(%rip), %rsi # 0x75948
movb $0x0, %al
callq 0x2350
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x147c7
movq 0x48(%rsp), %rdi
leaq 0x66e9f(%rip), %rsi # 0x7b6c9
movb $0x0, %al
callq 0x2350
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
| _ZNK12LefDefParser16lefiTrackPattern5printEP8_IO_FILE:
sub rsp, 58h
mov [rsp+58h+var_8], rdi
mov [rsp+58h+var_10], rsi
mov rdi, [rsp+58h+var_8]; this
mov [rsp+58h+var_20], rdi
mov rax, [rsp+58h+var_10]
mov [rsp+58h+var_40], rax
call _ZNK12LefDefParser16lefiTrackPattern4nameEv; LefDefParser::lefiTrackPattern::name(void)
mov rdi, [rsp+58h+var_20]; this
mov [rsp+58h+var_38], rax
call _ZNK12LefDefParser16lefiTrackPattern5startEv; LefDefParser::lefiTrackPattern::start(void)
mov rdi, [rsp+58h+var_20]; this
movsd [rsp+58h+var_28], xmm0
call _ZNK12LefDefParser16lefiTrackPattern9numTracksEv; LefDefParser::lefiTrackPattern::numTracks(void)
mov rdi, [rsp+58h+var_20]; this
mov [rsp+58h+var_2C], eax
call _ZNK12LefDefParser16lefiTrackPattern5spaceEv; LefDefParser::lefiTrackPattern::space(void)
mov rdi, [rsp+58h+var_40]
mov rdx, [rsp+58h+var_38]
mov ecx, [rsp+58h+var_2C]
movaps xmm1, xmm0
movsd xmm0, [rsp+58h+var_28]
lea rsi, aTrackPatternSG; " TRACK Pattern %s %g DO %d STEP %g\n"
mov al, 2
call _fprintf
mov rdi, [rsp+58h+var_20]; this
call _ZNK12LefDefParser16lefiTrackPattern9numLayersEv; LefDefParser::lefiTrackPattern::numLayers(void)
cmp eax, 0
jle loc_14831
mov rdi, [rsp+58h+var_10]
lea rsi, aLayer; " LAYER "
mov al, 0
call _fprintf
mov [rsp+58h+var_14], 0
loc_147C7:
mov rdi, [rsp+58h+var_20]; this
mov eax, [rsp+58h+var_14]
mov [rsp+58h+var_44], eax
call _ZNK12LefDefParser16lefiTrackPattern9numLayersEv; LefDefParser::lefiTrackPattern::numLayers(void)
mov ecx, eax
mov eax, [rsp+58h+var_44]
cmp eax, ecx
jge short loc_1481E
mov rdi, [rsp+58h+var_20]; this
mov rax, [rsp+58h+var_10]
mov [rsp+58h+var_50], rax
mov esi, [rsp+58h+var_14]; int
call _ZNK12LefDefParser16lefiTrackPattern9layerNameEi; LefDefParser::lefiTrackPattern::layerName(int)
mov rdi, [rsp+58h+var_50]
mov rdx, rax
lea rsi, aIrdropTableS+0Dh; "%s "
mov al, 0
call _fprintf
mov eax, [rsp+58h+var_14]
add eax, 1
mov [rsp+58h+var_14], eax
jmp short loc_147C7
loc_1481E:
mov rdi, [rsp+58h+var_10]
lea rsi, aInfoFromFileS+14h; "\n"
mov al, 0
call _fprintf
loc_14831:
add rsp, 58h
retn
| long long LefDefParser::lefiTrackPattern::print(LefDefParser::lefiTrackPattern *a1, long long a2)
{
double v2; // xmm1_8
long long result; // rax
const char *v4; // rax
const char *v5; // [rsp+20h] [rbp-38h]
int v6; // [rsp+2Ch] [rbp-2Ch]
double v7; // [rsp+30h] [rbp-28h]
int i; // [rsp+44h] [rbp-14h]
v5 = (const char *)LefDefParser::lefiTrackPattern::name(a1);
v7 = LefDefParser::lefiTrackPattern::start(a1);
v6 = LefDefParser::lefiTrackPattern::numTracks(a1);
v2 = LefDefParser::lefiTrackPattern::space(a1);
fprintf(a2, " TRACK Pattern %s %g DO %d STEP %g\n", v5, v7, v6, v2);
result = LefDefParser::lefiTrackPattern::numLayers(a1);
if ( (int)result > 0 )
{
fprintf(a2, " LAYER ");
for ( i = 0; i < (int)LefDefParser::lefiTrackPattern::numLayers(a1); ++i )
{
v4 = (const char *)LefDefParser::lefiTrackPattern::layerName(a1, i);
fprintf(a2, "%s ", v4);
}
return fprintf(a2, "\n");
}
return result;
}
| print:
SUB RSP,0x58
MOV qword ptr [RSP + 0x50],RDI
MOV qword ptr [RSP + 0x48],RSI
MOV RDI,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x38],RDI
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x18],RAX
CALL 0x00114620
MOV RDI,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x20],RAX
CALL 0x00114630
MOV RDI,qword ptr [RSP + 0x38]
MOVSD qword ptr [RSP + 0x30],XMM0
CALL 0x00114640
MOV RDI,qword ptr [RSP + 0x38]
MOV dword ptr [RSP + 0x2c],EAX
CALL 0x00114650
MOV RDI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x20]
MOV ECX,dword ptr [RSP + 0x2c]
MOVAPS XMM1,XMM0
MOVSD XMM0,qword ptr [RSP + 0x30]
LEA RSI,[0x177a82]
MOV AL,0x2
CALL 0x00102350
MOV RDI,qword ptr [RSP + 0x38]
CALL 0x00114660
CMP EAX,0x0
JLE 0x00114831
MOV RDI,qword ptr [RSP + 0x48]
LEA RSI,[0x177aa8]
MOV AL,0x0
CALL 0x00102350
MOV dword ptr [RSP + 0x44],0x0
LAB_001147c7:
MOV RDI,qword ptr [RSP + 0x38]
MOV EAX,dword ptr [RSP + 0x44]
MOV dword ptr [RSP + 0x14],EAX
CALL 0x00114660
MOV ECX,EAX
MOV EAX,dword ptr [RSP + 0x14]
CMP EAX,ECX
JGE 0x0011481e
MOV RDI,qword ptr [RSP + 0x38]
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x8],RAX
MOV ESI,dword ptr [RSP + 0x44]
CALL 0x00114670
MOV RDI,qword ptr [RSP + 0x8]
MOV RDX,RAX
LEA RSI,[0x175948]
MOV AL,0x0
CALL 0x00102350
MOV EAX,dword ptr [RSP + 0x44]
ADD EAX,0x1
MOV dword ptr [RSP + 0x44],EAX
JMP 0x001147c7
LAB_0011481e:
MOV RDI,qword ptr [RSP + 0x48]
LEA RSI,[0x17b6c9]
MOV AL,0x0
CALL 0x00102350
LAB_00114831:
ADD RSP,0x58
RET
|
/* LefDefParser::lefiTrackPattern::print(_IO_FILE*) const */
void __thiscall LefDefParser::lefiTrackPattern::print(lefiTrackPattern *this,_IO_FILE *param_1)
{
uint uVar1;
int iVar2;
int8 uVar3;
int4 uVar4;
int8 uVar5;
int local_14;
uVar3 = name(this);
uVar5 = start(this);
uVar1 = numTracks(this);
uVar4 = space(this);
fprintf(param_1," TRACK Pattern %s %g DO %d STEP %g\n",uVar5,uVar4,uVar3,(ulong)uVar1);
iVar2 = numLayers(this);
if (0 < iVar2) {
fprintf(param_1," LAYER ");
local_14 = 0;
while( true ) {
iVar2 = numLayers(this);
if (iVar2 <= local_14) break;
uVar3 = layerName(this,local_14);
fprintf(param_1,"%s ",uVar3);
local_14 = local_14 + 1;
}
fprintf(param_1,"\n");
}
return;
}
| |
23,902 | mi_setup_functions | eloqsql/storage/myisam/mi_open.c | void mi_setup_functions(register MYISAM_SHARE *share)
{
if (share->options & HA_OPTION_COMPRESS_RECORD)
{
share->read_record=_mi_read_pack_record;
share->read_rnd=_mi_read_rnd_pack_record;
if ((share->options &
(HA_OPTION_PACK_RECORD | HA_OPTION_NULL_FIELDS)) ||
share->has_varchar_fields)
share->calc_checksum= mi_checksum;
else
share->calc_checksum= mi_static_checksum;
share->calc_check_checksum= share->calc_checksum;
if (!(share->options & HA_OPTION_TEMP_COMPRESS_RECORD))
share->calc_checksum=0; /* No checksum */
}
else if (share->options & HA_OPTION_PACK_RECORD)
{
share->read_record=_mi_read_dynamic_record;
share->read_rnd=_mi_read_rnd_dynamic_record;
share->delete_record=_mi_delete_dynamic_record;
share->compare_record=_mi_cmp_dynamic_record;
share->compare_unique=_mi_cmp_dynamic_unique;
share->calc_checksum= mi_checksum;
share->calc_check_checksum= share->calc_checksum;
/* add bits used to pack data to pack_reclength for faster allocation */
share->base.pack_reclength+= share->base.pack_bits;
if (share->base.blobs)
{
share->update_record=_mi_update_blob_record;
share->write_record=_mi_write_blob_record;
}
else
{
share->write_record=_mi_write_dynamic_record;
share->update_record=_mi_update_dynamic_record;
}
}
else
{
share->read_record=_mi_read_static_record;
share->read_rnd=_mi_read_rnd_static_record;
share->delete_record=_mi_delete_static_record;
share->compare_record=_mi_cmp_static_record;
share->update_record=_mi_update_static_record;
share->write_record=_mi_write_static_record;
share->compare_unique=_mi_cmp_static_unique;
if (share->options & HA_OPTION_NULL_FIELDS)
share->calc_checksum= mi_checksum;
else
share->calc_checksum= mi_static_checksum;
share->calc_check_checksum= share->calc_checksum;
}
share->file_read= mi_nommap_pread;
share->file_write= mi_nommap_pwrite;
if (!(share->options & HA_OPTION_CHECKSUM))
share->calc_checksum=0;
return;
} | O3 | c | mi_setup_functions:
pushq %rbp
movq %rsp, %rbp
movq 0x318(%rdi), %rax
testb $0x4, %al
jne 0x81538
testb $0x1, %al
jne 0x81598
leaq 0x76de(%rip), %rcx # 0x88ba5
movq %rcx, 0x298(%rdi)
leaq 0x77b9(%rip), %rcx # 0x88c8e
movq %rcx, 0x2b8(%rdi)
leaq 0x74e5(%rip), %rcx # 0x889c8
movq %rcx, 0x2b0(%rdi)
leaq 0x757c(%rip), %rcx # 0x88a6d
movq %rcx, 0x2c0(%rdi)
leaq 0x748f(%rip), %rcx # 0x8898e
movq %rcx, 0x2a8(%rdi)
leaq 0x71cf(%rip), %rcx # 0x886dc
movq %rcx, 0x2a0(%rdi)
leaq 0x761a(%rip), %rcx # 0x88b35
movq %rcx, 0x2d8(%rdi)
btl $0xa, %eax
jb 0x81644
leaq 0xf7bf(%rip), %rdx # 0x90cf2
jmp 0x8164b
leaq 0x1c49(%rip), %rcx # 0x83188
movq %rcx, 0x298(%rdi)
leaq 0x2126(%rip), %rcx # 0x83673
movq %rcx, 0x2b8(%rdi)
testl $0x401, %eax # imm = 0x401
jne 0x8156d
cmpb $0x0, 0x37e(%rdi)
jne 0x8156d
leaq 0xf787(%rip), %rcx # 0x90cf2
jmp 0x81574
leaq 0xf678(%rip), %rcx # 0x90bec
movq %rcx, 0x2c8(%rdi)
movq %rcx, 0x2d0(%rdi)
testw %ax, %ax
js 0x81660
movl $0x2c8, %ecx # imm = 0x2C8
xorl %r8d, %r8d
jmp 0x8165c
leaq -0x6b2f(%rip), %rcx # 0x7aa70
movq %rcx, 0x298(%rdi)
leaq -0x6326(%rip), %rcx # 0x7b287
movq %rcx, 0x2b8(%rdi)
leaq -0x80e4(%rip), %rcx # 0x794d7
movq %rcx, 0x2b0(%rdi)
leaq -0x676c(%rip), %rcx # 0x7ae5d
movq %rcx, 0x2c0(%rdi)
leaq -0x685f(%rip), %rcx # 0x7ad78
movq %rcx, 0x2d8(%rdi)
leaq 0xf607(%rip), %rcx # 0x90bec
movq %rcx, 0x2c8(%rdi)
movq %rcx, 0x2d0(%rdi)
movl 0x18c(%rdi), %ecx
addq %rcx, 0x148(%rdi)
xorl %ecx, %ecx
xorl %esi, %esi
cmpl $0x0, 0x188(%rdi)
sete %cl
setne %sil
leaq -0x81d6(%rip), %rdx # 0x79443
cmoveq 0x303977(%rip), %rdx # 0x384f98
leaq -0x82ee(%rip), %r8 # 0x7933a
cmoveq 0x303960(%rip), %r8 # 0x384f90
shll $0x3, %esi
movl $0x2a0, %r9d # imm = 0x2A0
orq %r9, %rsi
shll $0x3, %ecx
orq %r9, %rcx
jmp 0x81658
leaq 0xf5a1(%rip), %rdx # 0x90bec
movl $0x2d0, %ecx # imm = 0x2D0
movl $0x2c8, %esi # imm = 0x2C8
movq %rdx, %r8
movq %rdx, (%rdi,%rsi)
movq %r8, (%rdi,%rcx)
leaq -0x8df7(%rip), %rcx # 0x78870
movq %rcx, 0x2e0(%rdi)
leaq -0x8d2b(%rip), %rcx # 0x7894a
movq %rcx, 0x2e8(%rdi)
testb $0x20, %al
jne 0x8168b
movq $0x0, 0x2c8(%rdi)
popq %rbp
retq
| mi_setup_functions:
push rbp
mov rbp, rsp
mov rax, [rdi+318h]
test al, 4
jnz loc_81538
test al, 1
jnz loc_81598
lea rcx, _mi_read_static_record
mov [rdi+298h], rcx
lea rcx, _mi_read_rnd_static_record
mov [rdi+2B8h], rcx
lea rcx, _mi_delete_static_record
mov [rdi+2B0h], rcx
lea rcx, _mi_cmp_static_record
mov [rdi+2C0h], rcx
lea rcx, _mi_update_static_record
mov [rdi+2A8h], rcx
lea rcx, _mi_write_static_record
mov [rdi+2A0h], rcx
lea rcx, _mi_cmp_static_unique
mov [rdi+2D8h], rcx
bt eax, 0Ah
jb loc_81644
lea rdx, mi_static_checksum
jmp loc_8164B
loc_81538:
lea rcx, _mi_read_pack_record
mov [rdi+298h], rcx
lea rcx, _mi_read_rnd_pack_record
mov [rdi+2B8h], rcx
test eax, 401h
jnz short loc_8156D
cmp byte ptr [rdi+37Eh], 0
jnz short loc_8156D
lea rcx, mi_static_checksum
jmp short loc_81574
loc_8156D:
lea rcx, mi_checksum
loc_81574:
mov [rdi+2C8h], rcx
mov [rdi+2D0h], rcx
test ax, ax
js loc_81660
mov ecx, 2C8h
xor r8d, r8d
jmp loc_8165C
loc_81598:
lea rcx, _mi_read_dynamic_record
mov [rdi+298h], rcx
lea rcx, _mi_read_rnd_dynamic_record
mov [rdi+2B8h], rcx
lea rcx, _mi_delete_dynamic_record
mov [rdi+2B0h], rcx
lea rcx, _mi_cmp_dynamic_record
mov [rdi+2C0h], rcx
lea rcx, _mi_cmp_dynamic_unique
mov [rdi+2D8h], rcx
lea rcx, mi_checksum
mov [rdi+2C8h], rcx
mov [rdi+2D0h], rcx
mov ecx, [rdi+18Ch]
add [rdi+148h], rcx
xor ecx, ecx
xor esi, esi
cmp dword ptr [rdi+188h], 0
setz cl
setnz sil
lea rdx, _mi_update_blob_record
cmovz rdx, cs:_mi_write_dynamic_record_ptr
lea r8, _mi_write_blob_record
cmovz r8, cs:_mi_update_dynamic_record_ptr
shl esi, 3
mov r9d, 2A0h
or rsi, r9
shl ecx, 3
or rcx, r9
jmp short loc_81658
loc_81644:
lea rdx, mi_checksum
loc_8164B:
mov ecx, 2D0h
mov esi, 2C8h
mov r8, rdx
loc_81658:
mov [rdi+rsi], rdx
loc_8165C:
mov [rdi+rcx], r8
loc_81660:
lea rcx, mi_nommap_pread
mov [rdi+2E0h], rcx
lea rcx, mi_nommap_pwrite
mov [rdi+2E8h], rcx
test al, 20h
jnz short loc_8168B
mov qword ptr [rdi+2C8h], 0
loc_8168B:
pop rbp
retn
| long long mi_setup_functions(long long a1)
{
long long result; // rax
long long ( *v2)(); // rdx
long long ( *v3)(); // rcx
long long v4; // rcx
void *v5; // r8
long long v6; // rsi
result = *(_QWORD *)(a1 + 792);
if ( (result & 4) == 0 )
{
if ( (result & 1) != 0 )
{
*(_QWORD *)(a1 + 664) = mi_read_dynamic_record;
*(_QWORD *)(a1 + 696) = mi_read_rnd_dynamic_record;
*(_QWORD *)(a1 + 688) = mi_delete_dynamic_record;
*(_QWORD *)(a1 + 704) = mi_cmp_dynamic_record;
*(_QWORD *)(a1 + 728) = mi_cmp_dynamic_unique;
*(_QWORD *)(a1 + 712) = mi_checksum;
*(_QWORD *)(a1 + 720) = mi_checksum;
*(_QWORD *)(a1 + 328) += *(unsigned int *)(a1 + 396);
v2 = (long long ( *)())mi_update_blob_record;
if ( !*(_DWORD *)(a1 + 392) )
v2 = (long long ( *)())mi_write_dynamic_record;
v5 = mi_write_blob_record;
if ( !*(_DWORD *)(a1 + 392) )
v5 = mi_update_dynamic_record;
v6 = (8 * (unsigned int)(*(_DWORD *)(a1 + 392) != 0)) | 0x2A0LL;
v4 = (8 * (unsigned int)(*(_DWORD *)(a1 + 392) == 0)) | 0x2A0LL;
}
else
{
*(_QWORD *)(a1 + 664) = mi_read_static_record;
*(_QWORD *)(a1 + 696) = mi_read_rnd_static_record;
*(_QWORD *)(a1 + 688) = mi_delete_static_record;
*(_QWORD *)(a1 + 704) = mi_cmp_static_record;
*(_QWORD *)(a1 + 680) = mi_update_static_record;
*(_QWORD *)(a1 + 672) = mi_write_static_record;
*(_QWORD *)(a1 + 728) = mi_cmp_static_unique;
if ( (result & 0x400) != 0 )
v2 = mi_checksum;
else
v2 = mi_static_checksum;
v4 = 720LL;
v6 = 712LL;
v5 = v2;
}
*(_QWORD *)(a1 + v6) = v2;
goto LABEL_19;
}
*(_QWORD *)(a1 + 664) = mi_read_pack_record;
*(_QWORD *)(a1 + 696) = mi_read_rnd_pack_record;
if ( (result & 0x401) != 0 || *(_BYTE *)(a1 + 894) )
v3 = mi_checksum;
else
v3 = mi_static_checksum;
*(_QWORD *)(a1 + 712) = v3;
*(_QWORD *)(a1 + 720) = v3;
if ( (result & 0x8000u) == 0LL )
{
v4 = 712LL;
v5 = 0LL;
LABEL_19:
*(_QWORD *)(a1 + v4) = v5;
}
*(_QWORD *)(a1 + 736) = mi_nommap_pread;
*(_QWORD *)(a1 + 744) = mi_nommap_pwrite;
if ( (result & 0x20) == 0 )
*(_QWORD *)(a1 + 712) = 0LL;
return result;
}
| mi_setup_functions:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI + 0x318]
TEST AL,0x4
JNZ 0x00181538
TEST AL,0x1
JNZ 0x00181598
LEA RCX,[0x188ba5]
MOV qword ptr [RDI + 0x298],RCX
LEA RCX,[0x188c8e]
MOV qword ptr [RDI + 0x2b8],RCX
LEA RCX,[0x1889c8]
MOV qword ptr [RDI + 0x2b0],RCX
LEA RCX,[0x188a6d]
MOV qword ptr [RDI + 0x2c0],RCX
LEA RCX,[0x18898e]
MOV qword ptr [RDI + 0x2a8],RCX
LEA RCX,[0x1886dc]
MOV qword ptr [RDI + 0x2a0],RCX
LEA RCX,[0x188b35]
MOV qword ptr [RDI + 0x2d8],RCX
BT EAX,0xa
JC 0x00181644
LEA RDX,[0x190cf2]
JMP 0x0018164b
LAB_00181538:
LEA RCX,[0x183188]
MOV qword ptr [RDI + 0x298],RCX
LEA RCX,[0x183673]
MOV qword ptr [RDI + 0x2b8],RCX
TEST EAX,0x401
JNZ 0x0018156d
CMP byte ptr [RDI + 0x37e],0x0
JNZ 0x0018156d
LEA RCX,[0x190cf2]
JMP 0x00181574
LAB_0018156d:
LEA RCX,[0x190bec]
LAB_00181574:
MOV qword ptr [RDI + 0x2c8],RCX
MOV qword ptr [RDI + 0x2d0],RCX
TEST AX,AX
JS 0x00181660
MOV ECX,0x2c8
XOR R8D,R8D
JMP 0x0018165c
LAB_00181598:
LEA RCX,[0x17aa70]
MOV qword ptr [RDI + 0x298],RCX
LEA RCX,[0x17b287]
MOV qword ptr [RDI + 0x2b8],RCX
LEA RCX,[0x1794d7]
MOV qword ptr [RDI + 0x2b0],RCX
LEA RCX,[0x17ae5d]
MOV qword ptr [RDI + 0x2c0],RCX
LEA RCX,[0x17ad78]
MOV qword ptr [RDI + 0x2d8],RCX
LEA RCX,[0x190bec]
MOV qword ptr [RDI + 0x2c8],RCX
MOV qword ptr [RDI + 0x2d0],RCX
MOV ECX,dword ptr [RDI + 0x18c]
ADD qword ptr [RDI + 0x148],RCX
XOR ECX,ECX
XOR ESI,ESI
CMP dword ptr [RDI + 0x188],0x0
SETZ CL
SETNZ SIL
LEA RDX,[0x179443]
CMOVZ RDX,qword ptr [0x00484f98]
LEA R8,[0x17933a]
CMOVZ R8,qword ptr [0x00484f90]
SHL ESI,0x3
MOV R9D,0x2a0
OR RSI,R9
SHL ECX,0x3
OR RCX,R9
JMP 0x00181658
LAB_00181644:
LEA RDX,[0x190bec]
LAB_0018164b:
MOV ECX,0x2d0
MOV ESI,0x2c8
MOV R8,RDX
LAB_00181658:
MOV qword ptr [RDI + RSI*0x1],RDX
LAB_0018165c:
MOV qword ptr [RDI + RCX*0x1],R8
LAB_00181660:
LEA RCX,[0x178870]
MOV qword ptr [RDI + 0x2e0],RCX
LEA RCX,[0x17894a]
MOV qword ptr [RDI + 0x2e8],RCX
TEST AL,0x20
JNZ 0x0018168b
MOV qword ptr [RDI + 0x2c8],0x0
LAB_0018168b:
POP RBP
RET
|
void mi_setup_functions(long param_1)
{
ulong uVar1;
ulong uVar2;
code *pcVar3;
ulong uVar4;
code *pcVar5;
bool bVar6;
uVar1 = *(ulong *)(param_1 + 0x318);
if ((uVar1 & 4) == 0) {
if ((uVar1 & 1) == 0) {
*(code **)(param_1 + 0x298) = _mi_read_static_record;
*(code **)(param_1 + 0x2b8) = _mi_read_rnd_static_record;
*(code **)(param_1 + 0x2b0) = _mi_delete_static_record;
*(code **)(param_1 + 0x2c0) = _mi_cmp_static_record;
*(code **)(param_1 + 0x2a8) = _mi_update_static_record;
*(code **)(param_1 + 0x2a0) = _mi_write_static_record;
*(code **)(param_1 + 0x2d8) = _mi_cmp_static_unique;
if (((uint)uVar1 >> 10 & 1) == 0) {
pcVar3 = mi_static_checksum;
}
else {
pcVar3 = mi_checksum;
}
uVar2 = 0x2d0;
uVar4 = 0x2c8;
pcVar5 = pcVar3;
}
else {
*(code **)(param_1 + 0x298) = _mi_read_dynamic_record;
*(code **)(param_1 + 0x2b8) = _mi_read_rnd_dynamic_record;
*(code **)(param_1 + 0x2b0) = _mi_delete_dynamic_record;
*(code **)(param_1 + 0x2c0) = _mi_cmp_dynamic_record;
*(code **)(param_1 + 0x2d8) = _mi_cmp_dynamic_unique;
*(code **)(param_1 + 0x2c8) = mi_checksum;
*(code **)(param_1 + 0x2d0) = mi_checksum;
*(long *)(param_1 + 0x148) = *(long *)(param_1 + 0x148) + (ulong)*(uint *)(param_1 + 0x18c);
bVar6 = *(int *)(param_1 + 0x188) == 0;
pcVar3 = _mi_update_blob_record;
if (bVar6) {
pcVar3 = (code *)PTR__mi_write_dynamic_record_00484f98;
}
pcVar5 = _mi_write_blob_record;
if (bVar6) {
pcVar5 = (code *)PTR__mi_update_dynamic_record_00484f90;
}
uVar4 = (ulong)!bVar6 << 3 | 0x2a0;
uVar2 = (ulong)bVar6 << 3 | 0x2a0;
}
*(code **)(param_1 + uVar4) = pcVar3;
}
else {
*(code **)(param_1 + 0x298) = _mi_read_pack_record;
*(code **)(param_1 + 0x2b8) = _mi_read_rnd_pack_record;
if (((uVar1 & 0x401) == 0) && (*(char *)(param_1 + 0x37e) == '\0')) {
pcVar5 = mi_static_checksum;
}
else {
pcVar5 = mi_checksum;
}
*(code **)(param_1 + 0x2c8) = pcVar5;
*(code **)(param_1 + 0x2d0) = pcVar5;
if ((short)uVar1 < 0) goto LAB_00181660;
uVar2 = 0x2c8;
pcVar5 = (code *)0x0;
}
*(code **)(param_1 + uVar2) = pcVar5;
LAB_00181660:
*(code **)(param_1 + 0x2e0) = mi_nommap_pread;
*(code **)(param_1 + 0x2e8) = mi_nommap_pwrite;
if ((uVar1 & 0x20) == 0) {
*(int8 *)(param_1 + 0x2c8) = 0;
}
return;
}
| |
23,903 | my_charpos_mb | eloqsql/strings/ctype-mb.c | size_t my_charpos_mb(CHARSET_INFO *cs __attribute__((unused)),
const char *pos, const char *end, size_t length)
{
const char *start= pos;
while (length && pos < end)
{
uint mb_len;
pos+= (mb_len= my_ismbchar(cs, pos, end)) ? mb_len : 1;
length--;
}
return (size_t) (length ? end+2-start : pos-start);
} | O3 | c | my_charpos_mb:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %rbx
testq %rcx, %rcx
setne %cl
sete %al
cmpq %rdx, %rsi
setae %dl
orb %al, %dl
movq %rsi, -0x30(%rbp)
movq %rsi, %rax
jne 0xb329a
movq %rdi, %r12
decq %r15
movl $0x1, %r14d
movq -0x30(%rbp), %rax
movq %rax, %r13
movq 0xb8(%r12), %rax
movq %r12, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq *0xc0(%rax)
cmpl $0x2, %eax
cmovbl %r14d, %eax
cmovll %r14d, %eax
addq %r13, %rax
addq $-0x1, %r15
setb %cl
jae 0xb329a
cmpq %rbx, %rax
jb 0xb3264
addq $0x2, %rbx
testb %cl, %cl
cmoveq %rax, %rbx
subq -0x30(%rbp), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_charpos_mb:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rcx
mov rbx, rdx
test rcx, rcx
setnz cl
setz al
cmp rsi, rdx
setnb dl
or dl, al
mov [rbp+var_30], rsi
mov rax, rsi
jnz short loc_B329A
mov r12, rdi
dec r15
mov r14d, 1
mov rax, [rbp+var_30]
loc_B3264:
mov r13, rax
mov rax, [r12+0B8h]
mov rdi, r12
mov rsi, r13
mov rdx, rbx
call qword ptr [rax+0C0h]
cmp eax, 2
cmovb eax, r14d
cmovl eax, r14d
add rax, r13
add r15, 0FFFFFFFFFFFFFFFFh
setb cl
jnb short loc_B329A
cmp rax, rbx
jb short loc_B3264
loc_B329A:
add rbx, 2
test cl, cl
cmovz rbx, rax
sub rbx, [rbp+var_30]
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| unsigned long long my_charpos_mb(long long a1, unsigned long long a2, unsigned long long a3, long long a4)
{
long long v4; // r15
bool v6; // zf
unsigned long long v7; // rax
long long v8; // r15
unsigned long long v9; // r13
long long v10; // rax
bool v11; // cc
bool v12; // cf
unsigned long long v13; // rbx
v4 = a4;
v6 = a4 == 0;
LOBYTE(a4) = a4 != 0;
v7 = a2;
if ( !v6 && a2 < a3 )
{
v8 = v4 - 1;
v7 = a2;
do
{
v9 = v7;
v10 = (*(long long ( **)(long long, unsigned long long, unsigned long long, long long))(*(_QWORD *)(a1 + 184)
+ 192LL))(
a1,
v7,
a3,
a4);
v11 = (int)v10 < 2;
if ( (unsigned int)v10 < 2 )
v10 = 1LL;
if ( v11 )
v10 = 1LL;
v7 = v9 + v10;
v12 = v8-- != 0;
LOBYTE(a4) = v12;
}
while ( v12 && v7 < a3 );
}
v13 = a3 + 2;
if ( !(_BYTE)a4 )
v13 = v7;
return v13 - a2;
}
| my_charpos_mb:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RCX
MOV RBX,RDX
TEST RCX,RCX
SETNZ CL
SETZ AL
CMP RSI,RDX
SETNC DL
OR DL,AL
MOV qword ptr [RBP + -0x30],RSI
MOV RAX,RSI
JNZ 0x001b329a
MOV R12,RDI
DEC R15
MOV R14D,0x1
MOV RAX,qword ptr [RBP + -0x30]
LAB_001b3264:
MOV R13,RAX
MOV RAX,qword ptr [R12 + 0xb8]
MOV RDI,R12
MOV RSI,R13
MOV RDX,RBX
CALL qword ptr [RAX + 0xc0]
CMP EAX,0x2
CMOVC EAX,R14D
CMOVL EAX,R14D
ADD RAX,R13
ADD R15,-0x1
SETC CL
JNC 0x001b329a
CMP RAX,RBX
JC 0x001b3264
LAB_001b329a:
ADD RBX,0x2
TEST CL,CL
CMOVZ RBX,RAX
SUB RBX,qword ptr [RBP + -0x30]
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_charpos_mb(long param_1,ulong param_2,ulong param_3,long param_4)
{
uint uVar1;
ulong uVar2;
ulong uVar3;
bool bVar4;
bVar4 = param_4 != 0;
uVar3 = param_2;
if (param_2 < param_3 && bVar4) {
do {
param_4 = param_4 + -1;
uVar1 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))(param_1,uVar3,param_3);
uVar2 = (ulong)uVar1;
if (uVar1 < 2) {
uVar2 = 1;
}
if ((int)uVar1 < 2) {
uVar2 = 1;
}
uVar3 = uVar2 + uVar3;
bVar4 = param_4 != 0;
} while ((bVar4) && (uVar3 < param_3));
}
uVar2 = param_3 + 2;
if (!bVar4) {
uVar2 = uVar3;
}
return uVar2 - param_2;
}
| |
23,904 | minja::simple_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::function<minja::Value (std::shared_ptr<minja::Context> const&, minja::Value&)> const&) | llama.cpp/common/minja/minja.hpp | static Value simple_function(const std::string & fn_name, const std::vector<std::string> & params, const std::function<Value(const std::shared_ptr<Context> &, Value & args)> & fn) {
std::map<std::string, size_t> named_positions;
for (size_t i = 0, n = params.size(); i < n; i++) named_positions[params[i]] = i;
return Value::callable([=](const std::shared_ptr<Context> & context, ArgumentsValue & args) -> Value {
auto args_obj = Value::object();
std::vector<bool> provided_args(params.size());
for (size_t i = 0, n = args.args.size(); i < n; i++) {
auto & arg = args.args[i];
if (i < params.size()) {
args_obj.set(params[i], arg);
provided_args[i] = true;
} else {
throw std::runtime_error("Too many positional params for " + fn_name);
}
}
for (auto & [name, value] : args.kwargs) {
auto named_pos_it = named_positions.find(name);
if (named_pos_it == named_positions.end()) {
throw std::runtime_error("Unknown argument " + name + " for function " + fn_name);
}
provided_args[named_pos_it->second] = true;
args_obj.set(name, value);
}
return fn(context, args_obj);
});
} | O3 | cpp | minja::simple_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::function<minja::Value (std::shared_ptr<minja::Context> const&, minja::Value&)> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rcx, 0x28(%rsp)
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, 0x20(%rsp)
leaq 0xc0(%rsp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq 0x8(%rdx), %rbp
subq (%rdx), %rbp
je 0x54d6e
sarq $0x5, %rbp
cmpq $0x1, %rbp
adcq $0x0, %rbp
xorl %ebx, %ebx
leaq 0xb8(%rsp), %r13
xorl %r12d, %r12d
movq (%r15), %rsi
addq %rbx, %rsi
movq %r13, %rdi
callq 0x7844e
movq %r12, (%rax)
incq %r12
addq $0x20, %rbx
cmpq %r12, %rbp
jne 0x54d51
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0x393c6
leaq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x40a2c
leaq 0x68(%rsp), %r14
leaq 0xb8(%rsp), %rsi
movq %r14, %rdi
callq 0x78840
leaq 0x98(%rsp), %r15
movq %r15, %rdi
movq 0x28(%rsp), %rsi
callq 0x784e2
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0x88, %edi
callq 0x1c160
movq %rax, %r12
leaq 0x30(%rsp), %rsi
movq %rax, %rdi
callq 0x393c6
leaq 0x18(%r12), %rdi
leaq 0x28(%r12), %rbp
movq %rbp, 0x18(%r12)
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
addq %rsi, %rdx
callq 0x40a2c
leaq 0x40(%r12), %rax
movq 0x78(%rsp), %rdx
testq %rdx, %rdx
je 0x54e55
leaq 0x70(%rsp), %rdi
movl (%rdi), %ecx
movq %rdx, 0x48(%r12)
movq 0x10(%rdi), %r8
movq 0x18(%rdi), %rsi
movq %rax, 0x8(%rdx)
leaq 0x90(%rsp), %rdx
movq (%rdx), %rax
movq %rax, 0x60(%r12)
movq $0x0, -0x18(%rdx)
movq %rdi, -0x10(%rdx)
movq %rdi, -0x8(%rdx)
movq %r8, %rax
jmp 0x54e68
movq $0x0, 0x48(%r12)
leaq 0x60(%r12), %rdx
xorl %ecx, %ecx
movq %rax, %rsi
movq %rax, 0x50(%r12)
movq %rsi, 0x58(%r12)
movq $0x0, (%rdx)
movl %ecx, 0x40(%r12)
leaq 0x68(%r12), %rdi
movq %r15, %rsi
callq 0x784e2
movq %rsp, %rsi
movq %r12, (%rsi)
leaq 0x1c8(%rip), %rax # 0x55060
movq %rax, 0x18(%rsi)
leaq 0x7cb(%rip), %rax # 0x5566e
movq %rax, 0x10(%rsi)
movq 0x20(%rsp), %rdi
callq 0x72a46
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x54ec8
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0xa8(%rsp), %rax
testq %rax, %rax
je 0x54ee2
movq %r15, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq *%rax
movq %r14, %rdi
callq 0x78aa2
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x54f01
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x1c110
leaq 0x30(%rsp), %rdi
callq 0x2a79a
leaq 0xb8(%rsp), %rdi
callq 0x78aa2
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x54fa9
jmp 0x54fa9
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x54fb4
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x54fb4
jmp 0x54fa9
movq %rax, %rbx
movq %r12, %rdi
addq $0x38, %rdi
callq 0x78aa2
movq 0x18(%r12), %rdi
cmpq %rbp, %rdi
je 0x54f76
movq (%rbp), %rsi
incq %rsi
callq 0x1c110
jmp 0x54f76
movq %rax, %rbx
movq %r12, %rdi
callq 0x2a79a
jmp 0x54f83
movq %rax, %rbx
movl $0x88, %esi
movq %r12, %rdi
callq 0x1c110
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x54fb4
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x54fb4
movq %rax, %rdi
callq 0x2a81a
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x55012
jmp 0x54ffd
movq %rax, %rbx
movq %r14, %rdi
callq 0x78aa2
jmp 0x54fd0
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x54fec
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x1c110
jmp 0x54fec
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x2a79a
jmp 0x54ffd
jmp 0x54ffa
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x78aa2
movq %rbx, %rdi
callq 0x1c7d0
| _ZN5minjaL15simple_functionERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorIS5_SaIS5_EERKSt8functionIFNS_5ValueERKSt10shared_ptrINS_7ContextEERSE_EE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0E8h
mov [rsp+118h+var_F0], rcx
mov r15, rdx
mov r14, rsi
mov [rsp+118h+var_F8], rdi
lea rax, [rsp+118h+var_58]
mov dword ptr [rax], 0
xor ecx, ecx
mov [rax+8], rcx
mov [rax+10h], rax
mov [rax+18h], rax
mov [rax+20h], rcx
mov rbp, [rdx+8]
sub rbp, [rdx]
jz short loc_54D6E
sar rbp, 5
cmp rbp, 1
adc rbp, 0
xor ebx, ebx
lea r13, [rsp+118h+var_60]
xor r12d, r12d
loc_54D51:
mov rsi, [r15]
add rsi, rbx
mov rdi, r13
call _ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEmSt4lessIS5_ESaISt4pairIKS5_mEEEixERS9_; std::map<std::string,ulong>::operator[](std::string const&)
mov [rax], r12
inc r12
add rbx, 20h ; ' '
cmp rbp, r12
jnz short loc_54D51
loc_54D6E:
lea rdi, [rsp+118h+var_E8]
mov rsi, r15
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2ERKS7_; std::vector<std::string>::vector(std::vector<std::string> const&)
lea rdi, [rsp+118h+var_D0]
lea r13, [rsp+118h+var_C0]
mov [r13-10h], r13
mov rsi, [r14]
mov rdx, [r14+8]
add rdx, rsi
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea r14, [rsp+118h+var_B0]
lea rsi, [rsp+118h+var_60]
mov rdi, r14
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_mESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EEC2ERKSE_; std::_Rb_tree<std::string,std::pair<std::string const,ulong>,std::_Select1st<std::pair<std::string const,ulong>>,std::less<std::string>,std::allocator<std::pair<std::string const,ulong>>>::_Rb_tree(std::_Rb_tree<std::string,std::pair<std::string const,ulong>,std::_Select1st<std::pair<std::string const,ulong>>,std::less<std::string>,std::allocator<std::pair<std::string const,ulong>>> const&)
lea r15, [rsp+118h+var_80]
mov rdi, r15
mov rsi, [rsp+118h+var_F0]
call _ZNSt8functionIFN5minja5ValueERKSt10shared_ptrINS0_7ContextEERS1_EEC2ERKS9_; std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)>::function(std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)> const&)
xorps xmm0, xmm0
movaps [rsp+118h+var_108], xmm0
movaps [rsp+118h+var_118], xmm0
mov edi, 88h; unsigned __int64
call __Znwm; operator new(ulong)
mov r12, rax
lea rsi, [rsp+118h+var_E8]
mov rdi, rax
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2ERKS7_; std::vector<std::string>::vector(std::vector<std::string> const&)
lea rdi, [r12+18h]
lea rbp, [r12+28h]
mov [r12+18h], rbp
mov rsi, [rsp+118h+var_D0]
mov rdx, [rsp+118h+var_C8]
add rdx, rsi
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea rax, [r12+40h]
mov rdx, [rsp+118h+var_A0]
test rdx, rdx
jz short loc_54E55
lea rdi, [rsp+118h+var_A8]
mov ecx, [rdi]
mov [r12+48h], rdx
mov r8, [rdi+10h]
mov rsi, [rdi+18h]
mov [rdx+8], rax
lea rdx, [rsp+118h+var_88]
mov rax, [rdx]
mov [r12+60h], rax
mov qword ptr [rdx-18h], 0
mov [rdx-10h], rdi
mov [rdx-8], rdi
mov rax, r8
jmp short loc_54E68
loc_54E55:
mov qword ptr [r12+48h], 0
lea rdx, [r12+60h]
xor ecx, ecx
mov rsi, rax
loc_54E68:
mov [r12+50h], rax
mov [r12+58h], rsi
mov qword ptr [rdx], 0
mov [r12+40h], ecx
lea rdi, [r12+68h]
mov rsi, r15
call _ZNSt8functionIFN5minja5ValueERKSt10shared_ptrINS0_7ContextEERS1_EEC2ERKS9_; std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)>::function(std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)> const&)
mov rsi, rsp
mov [rsi], r12
lea rax, _ZNSt17_Function_handlerIFN5minja5ValueERKSt10shared_ptrINS0_7ContextEERNS0_14ArgumentsValueEEZNS0_L15simple_functionERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorISF_SaISF_EERKSt8functionIFS1_S6_RS1_EEE3$_0E9_M_invokeERKSt9_Any_dataS6_S8_; std::_Function_handler<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &),minja::simple_function(std::string const&,std::vector<std::string> const&,std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)> const&)::$_0>::_M_invoke(std::_Any_data const&,std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)
mov [rsi+18h], rax
lea rax, _ZNSt17_Function_handlerIFN5minja5ValueERKSt10shared_ptrINS0_7ContextEERNS0_14ArgumentsValueEEZNS0_L15simple_functionERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorISF_SaISF_EERKSt8functionIFS1_S6_RS1_EEE3$_0E10_M_managerERSt9_Any_dataRKSV_St18_Manager_operation; std::_Function_handler<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &),minja::simple_function(std::string const&,std::vector<std::string> const&,std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)> const&)::$_0>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rsi+10h], rax
mov rdi, [rsp+118h+var_F8]
call _ZN5minja5Value8callableERKSt8functionIFS0_RKSt10shared_ptrINS_7ContextEERNS_14ArgumentsValueEEE; minja::Value::callable(std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)> const&)
mov rax, qword ptr [rsp+118h+var_108]
test rax, rax
jz short loc_54EC8
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
loc_54EC8:
mov rax, [rsp+118h+var_70]
test rax, rax
jz short loc_54EE2
mov rdi, r15
mov rsi, r15
mov edx, 3
call rax
loc_54EE2:
mov rdi, r14
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_mESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,ulong>,std::_Select1st<std::pair<std::string const,ulong>>,std::less<std::string>,std::allocator<std::pair<std::string const,ulong>>>::~_Rb_tree()
mov rdi, [rsp+118h+var_D0]; void *
cmp rdi, r13
jz short loc_54F01
mov rsi, [rsp+118h+var_C0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_54F01:
lea rdi, [rsp+118h+var_E8]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
lea rdi, [rsp+118h+var_60]
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_mESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,ulong>,std::_Select1st<std::pair<std::string const,ulong>>,std::less<std::string>,std::allocator<std::pair<std::string const,ulong>>>::~_Rb_tree()
add rsp, 0E8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_54FA9
jmp short loc_54FA9
mov rbx, rax
mov rax, qword ptr [rsp+118h+var_108]
test rax, rax
jz short loc_54FB4
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
jmp short loc_54FB4
jmp short loc_54FA9
mov rbx, rax
mov rdi, r12
add rdi, 38h ; '8'
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_mESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,ulong>,std::_Select1st<std::pair<std::string const,ulong>>,std::less<std::string>,std::allocator<std::pair<std::string const,ulong>>>::~_Rb_tree()
mov rdi, [r12+18h]; void *
cmp rdi, rbp
jz short loc_54F76
mov rsi, [rbp+0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_54F76
mov rbx, rax
loc_54F76:
mov rdi, r12
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
jmp short loc_54F83
mov rbx, rax
loc_54F83:
mov esi, 88h; unsigned __int64
mov rdi, r12; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rax, qword ptr [rsp+118h+var_108]
test rax, rax
jz short loc_54FB4
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
jmp short loc_54FB4
loc_54FA9:
mov rdi, rax
call __clang_call_terminate
mov rbx, rax
loc_54FB4:
lea rdi, [rsp+118h+var_E8]
call _ZZN5minjaL15simple_functionERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorIS5_SaIS5_EERKSt8functionIFNS_5ValueERKSt10shared_ptrINS_7ContextEERSE_EEEN3$_0D2Ev; minja::simple_function(std::string const&,std::vector<std::string> const&,std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)> const&)::$_0::~$_0()
jmp short loc_54FFD
mov rbx, rax
mov rdi, r14
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_mESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,ulong>,std::_Select1st<std::pair<std::string const,ulong>>,std::less<std::string>,std::allocator<std::pair<std::string const,ulong>>>::~_Rb_tree()
jmp short loc_54FD0
mov rbx, rax
loc_54FD0:
mov rdi, [rsp+118h+var_D0]; void *
cmp rdi, r13
jz short loc_54FEC
mov rsi, [rsp+118h+var_C0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_54FEC
mov rbx, rax
loc_54FEC:
lea rdi, [rsp+118h+var_E8]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
jmp short loc_54FFD
jmp short $+2
loc_54FFA:
mov rbx, rax
loc_54FFD:
lea rdi, [rsp+118h+var_60]
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_mESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,ulong>,std::_Select1st<std::pair<std::string const,ulong>>,std::less<std::string>,std::allocator<std::pair<std::string const,ulong>>>::~_Rb_tree()
mov rdi, rbx
call __Unwind_Resume
| long long minja::simple_function(long long a1, long long a2, _QWORD *a3, long long a4)
{
long long v5; // rbp
long long v6; // rbp
long long v7; // rbx
long long v8; // r12
long long v9; // r12
long long v10; // rax
long long v11; // rdx
int v12; // ecx
int *v13; // r8
int *v14; // rsi
long long *v15; // rdx
__int128 v17; // [rsp+0h] [rbp-118h] BYREF
__int128 v18; // [rsp+10h] [rbp-108h]
long long v19; // [rsp+20h] [rbp-F8h]
long long v20; // [rsp+28h] [rbp-F0h]
_QWORD v21[3]; // [rsp+30h] [rbp-E8h] BYREF
void *v22[2]; // [rsp+48h] [rbp-D0h] BYREF
_QWORD v23[2]; // [rsp+58h] [rbp-C0h] BYREF
_BYTE v24[8]; // [rsp+68h] [rbp-B0h] BYREF
int v25; // [rsp+70h] [rbp-A8h] BYREF
long long v26; // [rsp+78h] [rbp-A0h]
int *v27; // [rsp+80h] [rbp-98h]
int *v28; // [rsp+88h] [rbp-90h]
long long v29; // [rsp+90h] [rbp-88h] BYREF
_BYTE v30[16]; // [rsp+98h] [rbp-80h] BYREF
void ( *v31)(_BYTE *, _BYTE *, long long); // [rsp+A8h] [rbp-70h]
_BYTE v32[8]; // [rsp+B8h] [rbp-60h] BYREF
int v33; // [rsp+C0h] [rbp-58h] BYREF
long long v34; // [rsp+C8h] [rbp-50h]
int *v35; // [rsp+D0h] [rbp-48h]
int *v36; // [rsp+D8h] [rbp-40h]
long long v37; // [rsp+E0h] [rbp-38h]
v20 = a4;
v19 = a1;
v33 = 0;
v34 = 0LL;
v35 = &v33;
v36 = &v33;
v37 = 0LL;
v5 = a3[1] - *a3;
if ( v5 )
{
v6 = (v5 >> 5 == 0) + (v5 >> 5);
v7 = 0LL;
v8 = 0LL;
do
{
*(_QWORD *)std::map<std::string,unsigned long>::operator[](v32, v7 + *a3) = v8++;
v7 += 32LL;
}
while ( v6 != v8 );
}
std::vector<std::string>::vector((long long)v21, a3);
v22[0] = v23;
std::string::_M_construct<char *>((long long)v22, *(_BYTE **)a2, *(_QWORD *)a2 + *(_QWORD *)(a2 + 8));
std::_Rb_tree<std::string,std::pair<std::string const,unsigned long>,std::_Select1st<std::pair<std::string const,unsigned long>>,std::less<std::string>,std::allocator<std::pair<std::string const,unsigned long>>>::_Rb_tree(
v24,
v32);
std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)>::function(v30, v20);
v18 = 0LL;
v17 = 0LL;
v9 = operator new(0x88uLL);
std::vector<std::string>::vector(v9, v21);
*(_QWORD *)(v9 + 24) = v9 + 40;
std::string::_M_construct<char *>(v9 + 24, (_BYTE *)v22[0], (long long)v22[0] + (unsigned long long)v22[1]);
v10 = v9 + 64;
v11 = v26;
if ( v26 )
{
v12 = v25;
*(_QWORD *)(v9 + 72) = v26;
v13 = v27;
v14 = v28;
*(_QWORD *)(v11 + 8) = v10;
v15 = &v29;
*(_QWORD *)(v9 + 96) = v29;
v26 = 0LL;
v27 = &v25;
v28 = &v25;
v10 = (long long)v13;
}
else
{
*(_QWORD *)(v9 + 72) = 0LL;
v15 = (long long *)(v9 + 96);
v12 = 0;
v14 = (int *)(v9 + 64);
}
*(_QWORD *)(v9 + 80) = v10;
*(_QWORD *)(v9 + 88) = v14;
*v15 = 0LL;
*(_DWORD *)(v9 + 64) = v12;
std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)>::function(v9 + 104, v30);
*(_QWORD *)&v17 = v9;
*((_QWORD *)&v18 + 1) = std::_Function_handler<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &),minja::simple_function(std::string const&,std::vector<std::string> const&,std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)> const&)::$_0>::_M_invoke;
*(_QWORD *)&v18 = std::_Function_handler<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &),minja::simple_function(std::string const&,std::vector<std::string> const&,std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)> const&)::$_0>::_M_manager;
minja::Value::callable(v19);
if ( std::_Function_handler<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &),minja::simple_function(std::string const&,std::vector<std::string> const&,std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)> const&)::$_0>::_M_manager )
((void ( *)(__int128 *, __int128 *, long long))v18)(&v17, &v17, 3LL);
if ( v31 )
v31(v30, v30, 3LL);
std::_Rb_tree<std::string,std::pair<std::string const,unsigned long>,std::_Select1st<std::pair<std::string const,unsigned long>>,std::less<std::string>,std::allocator<std::pair<std::string const,unsigned long>>>::~_Rb_tree(v24);
if ( v22[0] != v23 )
operator delete(v22[0], v23[0] + 1LL);
std::vector<std::string>::~vector((long long)v21);
return std::_Rb_tree<std::string,std::pair<std::string const,unsigned long>,std::_Select1st<std::pair<std::string const,unsigned long>>,std::less<std::string>,std::allocator<std::pair<std::string const,unsigned long>>>::~_Rb_tree(v32);
}
| simple_function:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xe8
MOV qword ptr [RSP + 0x28],RCX
MOV R15,RDX
MOV R14,RSI
MOV qword ptr [RSP + 0x20],RDI
LEA RAX,[RSP + 0xc0]
MOV dword ptr [RAX],0x0
XOR ECX,ECX
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [RAX + 0x10],RAX
MOV qword ptr [RAX + 0x18],RAX
MOV qword ptr [RAX + 0x20],RCX
MOV RBP,qword ptr [RDX + 0x8]
SUB RBP,qword ptr [RDX]
JZ 0x00154d6e
SAR RBP,0x5
CMP RBP,0x1
ADC RBP,0x0
XOR EBX,EBX
LEA R13,[RSP + 0xb8]
XOR R12D,R12D
LAB_00154d51:
MOV RSI,qword ptr [R15]
ADD RSI,RBX
LAB_00154d57:
MOV RDI,R13
CALL 0x0017844e
MOV qword ptr [RAX],R12
INC R12
ADD RBX,0x20
CMP RBP,R12
JNZ 0x00154d51
LAB_00154d6e:
LEA RDI,[RSP + 0x30]
MOV RSI,R15
CALL 0x001393c6
LEA RDI,[RSP + 0x48]
LEA R13,[RSP + 0x58]
MOV qword ptr [R13 + -0x10],R13
MOV RSI,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
ADD RDX,RSI
LAB_00154d93:
CALL 0x00140a2c
LEA R14,[RSP + 0x68]
LAB_00154d9d:
LEA RSI,[RSP + 0xb8]
MOV RDI,R14
CALL 0x00178840
LEA R15,[RSP + 0x98]
LAB_00154db5:
MOV RDI,R15
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x001784e2
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVAPS xmmword ptr [RSP],XMM0
LAB_00154dce:
MOV EDI,0x88
CALL 0x0011c160
LAB_00154dd8:
MOV R12,RAX
LEA RSI,[RSP + 0x30]
MOV RDI,RAX
CALL 0x001393c6
LEA RDI,[R12 + 0x18]
LEA RBP,[R12 + 0x28]
MOV qword ptr [R12 + 0x18],RBP
MOV RSI,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RSP + 0x50]
ADD RDX,RSI
LAB_00154e04:
CALL 0x00140a2c
LEA RAX,[R12 + 0x40]
MOV RDX,qword ptr [RSP + 0x78]
TEST RDX,RDX
JZ 0x00154e55
LEA RDI,[RSP + 0x70]
MOV ECX,dword ptr [RDI]
MOV qword ptr [R12 + 0x48],RDX
MOV R8,qword ptr [RDI + 0x10]
MOV RSI,qword ptr [RDI + 0x18]
MOV qword ptr [RDX + 0x8],RAX
LEA RDX,[RSP + 0x90]
MOV RAX,qword ptr [RDX]
MOV qword ptr [R12 + 0x60],RAX
MOV qword ptr [RDX + -0x18],0x0
MOV qword ptr [RDX + -0x10],RDI
MOV qword ptr [RDX + -0x8],RDI
MOV RAX,R8
JMP 0x00154e68
LAB_00154e55:
MOV qword ptr [R12 + 0x48],0x0
LEA RDX,[R12 + 0x60]
XOR ECX,ECX
MOV RSI,RAX
LAB_00154e68:
MOV qword ptr [R12 + 0x50],RAX
MOV qword ptr [R12 + 0x58],RSI
MOV qword ptr [RDX],0x0
MOV dword ptr [R12 + 0x40],ECX
LEA RDI,[R12 + 0x68]
LAB_00154e83:
MOV RSI,R15
CALL 0x001784e2
MOV RSI,RSP
MOV qword ptr [RSI],R12
LEA RAX,[0x155060]
MOV qword ptr [RSI + 0x18],RAX
LEA RAX,[0x15566e]
MOV qword ptr [RSI + 0x10],RAX
LAB_00154ea7:
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x00172a46
MOV RAX,qword ptr [RSP + 0x10]
TEST RAX,RAX
JZ 0x00154ec8
LAB_00154ebb:
MOV RDI,RSP
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_00154ec8:
MOV RAX,qword ptr [RSP + 0xa8]
TEST RAX,RAX
JZ 0x00154ee2
LAB_00154ed5:
MOV RDI,R15
MOV RSI,R15
MOV EDX,0x3
CALL RAX
LAB_00154ee2:
MOV RDI,R14
CALL 0x00178aa2
MOV RDI,qword ptr [RSP + 0x48]
CMP RDI,R13
JZ 0x00154f01
MOV RSI,qword ptr [RSP + 0x58]
INC RSI
CALL 0x0011c110
LAB_00154f01:
LEA RDI,[RSP + 0x30]
CALL 0x0012a79a
LEA RDI,[RSP + 0xb8]
CALL 0x00178aa2
ADD RSP,0xe8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* minja::simple_function(std::__cxx11::string const&, std::vector<std::__cxx11::string,
std::allocator<std::__cxx11::string > > const&, std::function<minja::Value
(std::shared_ptr<minja::Context> const&, minja::Value&)> const&) */
void __thiscall
minja::simple_function(minja *this,string *param_1,vector *param_2,function *param_3)
{
long *plVar1;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *this_00;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *pvVar2;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *pvVar3;
long lVar4;
long lVar5;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *pvVar6;
long lVar7;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *local_118;
int8 uStack_110;
code *local_108;
code *pcStack_100;
minja *local_f8;
function *local_f0;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> local_e8 [24];
long *local_d0;
long local_c8;
long local_c0 [2];
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,unsigned_long>,std::_Select1st<std::pair<std::__cxx11::string_const,unsigned_long>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
local_b0 [8];
int4 local_a8 [2];
long local_a0;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *local_98;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *local_90;
int8 local_88;
function<minja::Value(std::shared_ptr<minja::Context>const&,minja::Value&)> local_80 [16];
code *local_70;
map<std::__cxx11::string,unsigned_long,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
local_60 [8];
int4 local_58 [2];
int8 local_50;
int4 *local_48;
int4 *local_40;
int8 local_38;
local_48 = local_58;
local_58[0] = 0;
local_50 = 0;
local_38 = 0;
local_f8 = this;
local_f0 = param_3;
local_40 = local_48;
if (*(long *)(param_2 + 8) - *(long *)param_2 != 0) {
lVar5 = *(long *)(param_2 + 8) - *(long *)param_2 >> 5;
lVar4 = 0;
lVar7 = 0;
do {
/* try { // try from 00154d57 to 00154d5e has its CatchHandler @ 00154ffa */
plVar1 = (long *)std::
map<std::__cxx11::string,unsigned_long,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
::operator[](local_60,(string *)(*(long *)param_2 + lVar4));
*plVar1 = lVar7;
lVar7 = lVar7 + 1;
lVar4 = lVar4 + 0x20;
} while (lVar5 + (ulong)(lVar5 == 0) != lVar7);
}
/* try { // try from 00154d6e to 00154d7a has its CatchHandler @ 00154ff8 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::vector(local_e8,param_2);
local_d0 = local_c0;
/* try { // try from 00154d93 to 00154d97 has its CatchHandler @ 00154fe9 */
std::__cxx11::string::_M_construct<char*>
(&local_d0,*(long *)param_1,*(long *)(param_1 + 8) + *(long *)param_1);
/* try { // try from 00154d9d to 00154dac has its CatchHandler @ 00154fcd */
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,unsigned_long>,std::_Select1st<std::pair<std::__cxx11::string_const,unsigned_long>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
::_Rb_tree(local_b0,(_Rb_tree *)local_60);
/* try { // try from 00154db5 to 00154dc1 has its CatchHandler @ 00154fc0 */
std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::Value&)>::function
(local_80,local_f0);
local_108 = (code *)0x0;
pcStack_100 = (code *)0x0;
local_118 = (vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)0x0;
uStack_110 = 0;
/* try { // try from 00154dce to 00154dd7 has its CatchHandler @ 00154fb1 */
this_00 = (vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)operator_new(0x88);
/* try { // try from 00154dd8 to 00154de7 has its CatchHandler @ 00154f80 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::vector
(this_00,(vector *)local_e8);
*(vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> **)(this_00 + 0x18) =
this_00 + 0x28;
/* try { // try from 00154e04 to 00154e08 has its CatchHandler @ 00154f73 */
std::__cxx11::string::_M_construct<char*>(this_00 + 0x18,local_d0,local_c8 + (long)local_d0);
pvVar2 = this_00 + 0x40;
if (local_a0 == 0) {
*(int8 *)(this_00 + 0x48) = 0;
pvVar3 = this_00 + 0x60;
local_a8[0] = 0;
pvVar6 = pvVar2;
}
else {
*(long *)(this_00 + 0x48) = local_a0;
*(vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> **)(local_a0 + 8) = pvVar2;
pvVar3 = (vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_88;
*(int8 *)(this_00 + 0x60) = local_88;
local_a0 = 0;
pvVar2 = local_98;
pvVar6 = local_90;
local_98 = (vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)local_a8;
local_90 = (vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)local_a8;
}
*(vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> **)(this_00 + 0x50) = pvVar2;
*(vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> **)(this_00 + 0x58) = pvVar6;
*(int8 *)pvVar3 = 0;
*(int4 *)(this_00 + 0x40) = local_a8[0];
/* try { // try from 00154e83 to 00154e8a has its CatchHandler @ 00154f4c */
std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::Value&)>::function
((function<minja::Value(std::shared_ptr<minja::Context>const&,minja::Value&)> *)
(this_00 + 0x68),local_80);
pcStack_100 = std::
_Function_handler<minja::Value(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&),minja::simple_function(std::__cxx11::string_const&,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&,std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::Value&)>const&)::$_0>
::_M_invoke;
local_108 = std::
_Function_handler<minja::Value(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&),minja::simple_function(std::__cxx11::string_const&,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&,std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::Value&)>const&)::$_0>
::_M_manager;
local_118 = this_00;
/* try { // try from 00154ea7 to 00154eb0 has its CatchHandler @ 00154f2e */
Value::callable((Value *)local_f8,(function *)&local_118);
if (local_108 != (code *)0x0) {
/* try { // try from 00154ebb to 00154ec7 has its CatchHandler @ 00154f2c */
(*local_108)(&local_118,&local_118,3);
}
if (local_70 != (code *)0x0) {
/* try { // try from 00154ed5 to 00154ee1 has its CatchHandler @ 00154f2a */
(*local_70)(local_80,local_80,3);
}
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,unsigned_long>,std::_Select1st<std::pair<std::__cxx11::string_const,unsigned_long>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
::~_Rb_tree(local_b0);
if (local_d0 != local_c0) {
operator_delete(local_d0,local_c0[0] + 1);
}
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector(local_e8);
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,unsigned_long>,std::_Select1st<std::pair<std::__cxx11::string_const,unsigned_long>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
::~_Rb_tree((_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,unsigned_long>,std::_Select1st<std::pair<std::__cxx11::string_const,unsigned_long>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
*)local_60);
return;
}
| |
23,905 | Rows_log_event::print_verbose_one_row(st_io_cache*, table_def*, st_print_event_info*, st_bitmap*, unsigned char const*, unsigned char const*, char) | eloqsql/sql/log_event_client.cc | size_t
Rows_log_event::print_verbose_one_row(IO_CACHE *file, table_def *td,
PRINT_EVENT_INFO *print_event_info,
MY_BITMAP *cols_bitmap,
const uchar *value, const uchar *prefix,
const my_bool no_fill_output)
{
const uchar *value0= value;
const uchar *null_bits= value;
uint null_bit_index= 0;
char typestr[64]= "";
#ifdef WHEN_FLASHBACK_REVIEW_READY
/* Storing the review SQL */
IO_CACHE *review_sql= &print_event_info->review_sql_cache;
LEX_STRING review_str;
#endif
/*
Skip metadata bytes which gives the information about nullabity of master
columns. Master writes one bit for each affected column.
*/
value+= (bitmap_bits_set(cols_bitmap) + 7) / 8;
if (!no_fill_output)
if (my_b_printf(file, "%s", prefix))
goto err;
for (uint i= 0; i < (uint)td->size(); i ++)
{
size_t size;
int is_null= (null_bits[null_bit_index / 8]
>> (null_bit_index % 8)) & 0x01;
if (bitmap_is_set(cols_bitmap, i) == 0)
continue;
if (!no_fill_output)
if (my_b_printf(file, "### @%d=", static_cast<int>(i + 1)))
goto err;
if (!is_null)
{
size_t fsize= td->calc_field_size((uint)i, (uchar*) value);
if (value + fsize > m_rows_end)
{
if (!no_fill_output)
if (my_b_printf(file, "***Corrupted replication event was detected."
" Not printing the value***\n"))
goto err;
value+= fsize;
return 0;
}
}
if (!no_fill_output)
{
size= log_event_print_value(file, print_event_info, is_null? NULL: value,
td->type(i), td->field_metadata(i),
typestr, sizeof(typestr));
#ifdef WHEN_FLASHBACK_REVIEW_READY
if (need_flashback_review)
{
String tmp_str, hex_str;
IO_CACHE tmp_cache;
// Using a tmp IO_CACHE to get the value output
open_cached_file(&tmp_cache, NULL, NULL, 0, MYF(MY_WME | MY_NABP));
size= log_event_print_value(&tmp_cache, print_event_info,
is_null ? NULL: value,
td->type(i), td->field_metadata(i),
typestr, sizeof(typestr));
error= copy_event_cache_to_string_and_reinit(&tmp_cache, &review_str);
close_cached_file(&tmp_cache);
if (unlikely(error))
return 0;
switch (td->type(i)) // Converting a string to HEX format
{
case MYSQL_TYPE_VARCHAR:
case MYSQL_TYPE_VAR_STRING:
case MYSQL_TYPE_STRING:
case MYSQL_TYPE_BLOB:
// Avoid write_pos changed to a new area
// tmp_str.free();
tmp_str.append(review_str.str + 1, review_str.length - 2); // Removing quotation marks
if (hex_str.alloc(tmp_str.length()*2+1)) // If out of memory
{
fprintf(stderr, "\nError: Out of memory. "
"Could not print correct binlog event.\n");
exit(1);
}
octet2hex((char*) hex_str.ptr(), tmp_str.ptr(), tmp_str.length());
if (my_b_printf(review_sql, ", UNHEX('%s')", hex_str.ptr()))
goto err;
break;
default:
tmp_str.free();
if (tmp_str.append(review_str.str, review_str.length) ||
my_b_printf(review_sql, ", %s", tmp_str.ptr()))
goto err;
break;
}
my_free(revieww_str.str);
}
#endif
}
else
{
IO_CACHE tmp_cache;
open_cached_file(&tmp_cache, NULL, NULL, 0, MYF(MY_WME | MY_NABP));
size= log_event_print_value(&tmp_cache, print_event_info,
is_null ? NULL: value,
td->type(i), td->field_metadata(i),
typestr, sizeof(typestr));
close_cached_file(&tmp_cache);
}
if (!size)
goto err;
if (!is_null)
value+= size;
if (print_event_info->verbose > 1 && !no_fill_output)
{
if (my_b_write(file, (uchar*)" /* ", 4) ||
my_b_printf(file, "%s ", typestr) ||
my_b_printf(file, "meta=%d nullable=%d is_null=%d ",
td->field_metadata(i),
td->maybe_null(i), is_null) ||
my_b_write(file, (uchar*)"*/", 2))
goto err;
}
if (!no_fill_output)
if (my_b_write_byte(file, '\n'))
goto err;
null_bit_index++;
}
return value - value0;
err:
return 0;
} | O3 | cpp | Rows_log_event::print_verbose_one_row(st_io_cache*, table_def*, st_print_event_info*, st_bitmap*, unsigned char const*, unsigned char const*, char):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %r9, %r14
movq %rcx, -0xa8(%rbp)
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, -0xb0(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x60(%rbp)
movaps %xmm0, -0x70(%rbp)
movq %r8, -0xb8(%rbp)
movq %r8, %rdi
callq 0x804f8
movl %eax, %ebx
cmpb $0x0, 0x18(%rbp)
je 0x4c579
addl $0x7, %ebx
shrl $0x3, %ebx
addq %r14, %rbx
movq %rbx, -0xa0(%rbp)
movq %r12, -0x98(%rbp)
movl (%r12), %eax
testq %rax, %rax
je 0x4c56d
xorl %r12d, %r12d
xorl %edx, %edx
movq %r14, -0x90(%rbp)
movq %r15, -0x80(%rbp)
movl %edx, %ecx
shrl $0x3, %ecx
movzbl (%r14,%rcx), %ecx
movl %edx, -0x84(%rbp)
andl $0x7, %edx
xorl %r14d, %r14d
btl %edx, %ecx
setb %bl
movq -0xb8(%rbp), %rcx
movq (%rcx), %rcx
movq %r12, %r13
shrq $0x3, %r13
movzbl (%rcx,%r13), %ecx
movl %r12d, %r15d
andl $0x7, %r15d
btl %r15d, %ecx
jae 0x4c2d0
cmpb $0x0, 0x18(%rbp)
jne 0x4c28e
leal 0x1(%r12), %edx
movq -0x80(%rbp), %rdi
leaq 0x6da49(%rip), %rsi # 0xb9cc8
xorl %eax, %eax
callq 0x7dd8d
testb %al, %al
jne 0x4c596
movb %bl, %r14b
movl %r14d, -0x74(%rbp)
testl %r14d, %r14d
jne 0x4c2e2
movq -0x98(%rbp), %r14
movq %r14, %rdi
movl %r12d, %esi
movq -0xa0(%rbp), %rbx
movq %rbx, %rdx
callq 0x4c5de
movl %eax, %eax
addq %rbx, %rax
movq -0xb0(%rbp), %rcx
cmpq 0x118(%rcx), %rax
jbe 0x4c2eb
jmp 0x4c5bc
movq -0x90(%rbp), %r14
movl -0x84(%rbp), %edx
jmp 0x4c55f
xorl %ebx, %ebx
movq -0x98(%rbp), %r14
cmpb $0x0, 0x18(%rbp)
je 0x4c33d
movl $0x14, %r8d
leaq -0x1c0(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x7abe0
movq 0x8(%r14), %rax
movzbl (%rax,%r12), %ecx
cmpl $0xa, %ecx
je 0x4c371
cmpl $0xfe, %ecx
jne 0x4c376
movq 0x18(%r14), %rax
movzbl 0x1(%rax,%r12,2), %ecx
leal -0xf7(%rcx), %eax
cmpw $0x2, %ax
movl $0xfe, %eax
cmovael %eax, %ecx
jmp 0x4c376
movq 0x8(%r14), %rax
movzbl (%rax,%r12), %ecx
cmpl $0xa, %ecx
je 0x4c3b9
cmpl $0xfe, %ecx
jne 0x4c3be
movq 0x18(%r14), %rax
movzbl 0x1(%rax,%r12,2), %ecx
leal -0xf7(%rcx), %eax
cmpw $0x2, %ax
movl $0xfe, %eax
cmovael %eax, %ecx
jmp 0x4c3be
movl $0xe, %ecx
cmpl $0x0, 0x10(%r14)
je 0x4c388
movq 0x18(%r14), %rax
movzwl (%rax,%r12,2), %r8d
jmp 0x4c38b
xorl %r8d, %r8d
leaq -0x1c0(%rbp), %r14
movq %r14, %rdi
movq -0xa8(%rbp), %rsi
movq %rbx, %rdx
leaq -0x70(%rbp), %r9
callq 0x4c7e2
movq %rax, %rbx
movq %r14, %rdi
callq 0x7acb8
movl -0x74(%rbp), %r14d
jmp 0x4c3f1
movl $0xe, %ecx
cmpl $0x0, 0x10(%r14)
je 0x4c3d0
movq 0x18(%r14), %rax
movzwl (%rax,%r12,2), %r8d
jmp 0x4c3d3
xorl %r8d, %r8d
movl -0x74(%rbp), %r14d
movq -0x80(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movq %rbx, %rdx
leaq -0x70(%rbp), %r9
callq 0x4c7e2
movq %rax, %rbx
testq %rbx, %rbx
je 0x4c596
testl %r14d, %r14d
movl $0x0, %eax
cmovneq %rax, %rbx
cmpb $0x0, 0x18(%rbp)
jne 0x4c44b
movq -0xa8(%rbp), %rax
cmpl $0x2, 0x348(%rax)
jb 0x4c44b
movq -0x80(%rbp), %r14
movq 0x40(%r14), %rax
leaq 0x4(%rax), %rcx
cmpq 0x48(%r14), %rcx
jbe 0x4c465
movl $0x4, %edx
movq %r14, %rdi
leaq 0x6d8de(%rip), %rsi # 0xb9d1b
callq 0x7bc9b
testl %eax, %eax
je 0x4c470
jmp 0x4c596
cmpb $0x0, 0x18(%rbp)
movq -0x90(%rbp), %r14
movq -0x80(%rbp), %r15
jne 0x4c547
jmp 0x4c51d
movl $0x202a2f20, (%rax) # imm = 0x202A2F20
addq $0x4, 0x40(%r14)
movq %r14, %rdi
leaq 0x6d82c(%rip), %rsi # 0xb9ca6
leaq -0x70(%rbp), %rdx
xorl %eax, %eax
callq 0x7dd8d
testb %al, %al
jne 0x4c596
movq -0x98(%rbp), %rcx
cmpl $0x0, 0x10(%rcx)
je 0x4c4a5
movq 0x18(%rcx), %rax
movzwl (%rax,%r12,2), %edx
jmp 0x4c4a7
xorl %edx, %edx
movl -0x74(%rbp), %r8d
movq 0x20(%rcx), %rax
movzbl (%rax,%r13), %eax
xorl %ecx, %ecx
btl %r15d, %eax
setb %cl
movq -0x80(%rbp), %r15
movq %r15, %rdi
leaq 0x6d855(%rip), %rsi # 0xb9d20
xorl %eax, %eax
callq 0x7dd8d
testb %al, %al
jne 0x4c596
movq 0x40(%r15), %rax
leaq 0x2(%rax), %rcx
cmpq 0x48(%r15), %rcx
jbe 0x4c50c
movl $0x2, %edx
movq %r15, %rdi
leaq 0x6d849(%rip), %rsi # 0xb9d40
callq 0x7bc9b
testl %eax, %eax
movq -0x90(%rbp), %r14
je 0x4c51d
jmp 0x4c596
movw $0x2f2a, (%rax) # imm = 0x2F2A
addq $0x2, 0x40(%r15)
movq -0x90(%rbp), %r14
movq 0x40(%r15), %rax
cmpq 0x48(%r15), %rax
jb 0x4c53c
movq %r15, %rdi
movl $0x1, %esi
callq 0x7b9d9
testl %eax, %eax
jne 0x4c596
movq 0x40(%r15), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x40(%r15)
movb $0xa, (%rax)
addq %rbx, -0xa0(%rbp)
movl -0x84(%rbp), %edx
incl %edx
movq -0x98(%rbp), %rax
movl (%rax), %eax
incq %r12
movl %eax, %ecx
cmpq %rcx, %r12
jb 0x4c22a
movq -0xa0(%rbp), %rbx
subq %r14, %rbx
jmp 0x4c598
movq 0x10(%rbp), %rdx
leaq 0x75d14(%rip), %rsi # 0xc2298
movq %r15, %rdi
xorl %eax, %eax
callq 0x7dd8d
testb %al, %al
je 0x4c1f6
xorl %ebx, %ebx
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x4c5d8
movq %rbx, %rax
addq $0x198, %rsp # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x0, 0x18(%rbp)
jne 0x4c596
leaq 0x6d70a(%rip), %rsi # 0xb9cd3
xorl %ebx, %ebx
movq -0x80(%rbp), %rdi
xorl %eax, %eax
callq 0x7dd8d
jmp 0x4c598
callq 0x3a340
nop
| _ZN14Rows_log_event21print_verbose_one_rowEP11st_io_cacheP9table_defP19st_print_event_infoP9st_bitmapPKhS9_c:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 198h
mov r14, r9
mov [rbp+var_A8], rcx
mov r12, rdx
mov r15, rsi
mov [rbp+var_B0], rdi
mov rax, fs:28h
mov [rbp+var_30], rax
xorps xmm0, xmm0
movaps [rbp+var_40], xmm0
movaps [rbp+var_50], xmm0
movaps [rbp+var_60], xmm0
movaps [rbp+var_70], xmm0
mov [rbp+var_B8], r8
mov rdi, r8
call bitmap_bits_set
mov ebx, eax
cmp [rbp+arg_8], 0
jz loc_4C579
loc_4C1F6:
add ebx, 7
shr ebx, 3
add rbx, r14
mov [rbp+var_A0], rbx
mov [rbp+var_98], r12
mov eax, [r12]
test rax, rax
jz loc_4C56D
xor r12d, r12d
xor edx, edx
mov [rbp+var_90], r14
mov [rbp+var_80], r15
loc_4C22A:
mov ecx, edx
shr ecx, 3
movzx ecx, byte ptr [r14+rcx]
mov [rbp+var_84], edx
and edx, 7
xor r14d, r14d
bt ecx, edx
setb bl
mov rcx, [rbp+var_B8]
mov rcx, [rcx]
mov r13, r12
shr r13, 3
movzx ecx, byte ptr [rcx+r13]
mov r15d, r12d
and r15d, 7
bt ecx, r15d
jnb short loc_4C2D0
cmp [rbp+arg_8], 0
jnz short loc_4C28E
lea edx, [r12+1]
mov rdi, [rbp+var_80]
lea rsi, aD; "### @%d="
xor eax, eax
call my_b_printf
test al, al
jnz loc_4C596
loc_4C28E:
mov r14b, bl
mov [rbp+var_74], r14d
test r14d, r14d
jnz short loc_4C2E2
mov r14, [rbp+var_98]
mov rdi, r14; this
mov esi, r12d; unsigned int
mov rbx, [rbp+var_A0]
mov rdx, rbx; unsigned __int8 *
call _ZNK9table_def15calc_field_sizeEjPh; table_def::calc_field_size(uint,uchar *)
mov eax, eax
add rax, rbx
mov rcx, [rbp+var_B0]
cmp rax, [rcx+118h]
jbe short loc_4C2EB
jmp loc_4C5BC
loc_4C2D0:
mov r14, [rbp+var_90]
mov edx, [rbp+var_84]
jmp loc_4C55F
loc_4C2E2:
xor ebx, ebx
mov r14, [rbp+var_98]
loc_4C2EB:
cmp [rbp+arg_8], 0
jz short loc_4C33D
mov r8d, 14h
lea rdi, [rbp+var_1C0]
xor esi, esi
xor edx, edx
xor ecx, ecx
call open_cached_file
mov rax, [r14+8]
movzx ecx, byte ptr [rax+r12]
cmp ecx, 0Ah
jz short loc_4C371
cmp ecx, 0FEh
jnz short loc_4C376
mov rax, [r14+18h]
movzx ecx, byte ptr [rax+r12*2+1]
lea eax, [rcx-0F7h]
cmp ax, 2
mov eax, 0FEh
cmovnb ecx, eax
jmp short loc_4C376
loc_4C33D:
mov rax, [r14+8]
movzx ecx, byte ptr [rax+r12]
cmp ecx, 0Ah
jz short loc_4C3B9
cmp ecx, 0FEh
jnz short loc_4C3BE
mov rax, [r14+18h]
movzx ecx, byte ptr [rax+r12*2+1]
lea eax, [rcx-0F7h]
cmp ax, 2
mov eax, 0FEh
cmovnb ecx, eax
jmp short loc_4C3BE
loc_4C371:
mov ecx, 0Eh
loc_4C376:
cmp dword ptr [r14+10h], 0
jz short loc_4C388
mov rax, [r14+18h]
movzx r8d, word ptr [rax+r12*2]
jmp short loc_4C38B
loc_4C388:
xor r8d, r8d
loc_4C38B:
lea r14, [rbp+var_1C0]
mov rdi, r14
mov rsi, [rbp+var_A8]
mov rdx, rbx
lea r9, [rbp+var_70]
call _ZL21log_event_print_valueP11st_io_cacheP19st_print_event_infoPKhjjPcm; log_event_print_value(st_io_cache *,st_print_event_info *,uchar const*,uint,uint,char *,ulong)
mov rbx, rax
mov rdi, r14
call close_cached_file
mov r14d, [rbp+var_74]
jmp short loc_4C3F1
loc_4C3B9:
mov ecx, 0Eh
loc_4C3BE:
cmp dword ptr [r14+10h], 0
jz short loc_4C3D0
mov rax, [r14+18h]
movzx r8d, word ptr [rax+r12*2]
jmp short loc_4C3D3
loc_4C3D0:
xor r8d, r8d
loc_4C3D3:
mov r14d, [rbp+var_74]
mov rdi, [rbp+var_80]
mov rsi, [rbp+var_A8]
mov rdx, rbx
lea r9, [rbp+var_70]
call _ZL21log_event_print_valueP11st_io_cacheP19st_print_event_infoPKhjjPcm; log_event_print_value(st_io_cache *,st_print_event_info *,uchar const*,uint,uint,char *,ulong)
mov rbx, rax
loc_4C3F1:
test rbx, rbx
jz loc_4C596
test r14d, r14d
mov eax, 0
cmovnz rbx, rax
cmp [rbp+arg_8], 0
jnz short loc_4C44B
mov rax, [rbp+var_A8]
cmp dword ptr [rax+348h], 2
jb short loc_4C44B
mov r14, [rbp+var_80]
mov rax, [r14+40h]
lea rcx, [rax+4]
cmp rcx, [r14+48h]
jbe short loc_4C465
mov edx, 4
mov rdi, r14
lea rsi, asc_B9D1B; " /* "
call _my_b_write
test eax, eax
jz short loc_4C470
jmp loc_4C596
loc_4C44B:
cmp [rbp+arg_8], 0
mov r14, [rbp+var_90]
mov r15, [rbp+var_80]
jnz loc_4C547
jmp loc_4C51D
loc_4C465:
mov dword ptr [rax], 202A2F20h
add qword ptr [r14+40h], 4
loc_4C470:
mov rdi, r14
lea rsi, aServerIdLuEndL+1Ch; "%s "
lea rdx, [rbp+var_70]
xor eax, eax
call my_b_printf
test al, al
jnz loc_4C596
mov rcx, [rbp+var_98]
cmp dword ptr [rcx+10h], 0
jz short loc_4C4A5
mov rax, [rcx+18h]
movzx edx, word ptr [rax+r12*2]
jmp short loc_4C4A7
loc_4C4A5:
xor edx, edx
loc_4C4A7:
mov r8d, [rbp+var_74]
mov rax, [rcx+20h]
movzx eax, byte ptr [rax+r13]
xor ecx, ecx
bt eax, r15d
setb cl
mov r15, [rbp+var_80]
mov rdi, r15
lea rsi, aMetaDNullableD; "meta=%d nullable=%d is_null=%d "
xor eax, eax
call my_b_printf
test al, al
jnz loc_4C596
mov rax, [r15+40h]
lea rcx, [rax+2]
cmp rcx, [r15+48h]
jbe short loc_4C50C
mov edx, 2
mov rdi, r15
lea rsi, asc_B9D40; "*/"
call _my_b_write
test eax, eax
mov r14, [rbp+var_90]
jz short loc_4C51D
jmp loc_4C596
loc_4C50C:
mov word ptr [rax], 2F2Ah
add qword ptr [r15+40h], 2
mov r14, [rbp+var_90]
loc_4C51D:
mov rax, [r15+40h]
cmp rax, [r15+48h]
jb short loc_4C53C
mov rdi, r15
mov esi, 1
call my_b_flush_io_cache
test eax, eax
jnz short loc_4C596
mov rax, [r15+40h]
loc_4C53C:
lea rcx, [rax+1]
mov [r15+40h], rcx
mov byte ptr [rax], 0Ah
loc_4C547:
add [rbp+var_A0], rbx
mov edx, [rbp+var_84]
inc edx
mov rax, [rbp+var_98]
mov eax, [rax]
loc_4C55F:
inc r12
mov ecx, eax
cmp r12, rcx
jb loc_4C22A
loc_4C56D:
mov rbx, [rbp+var_A0]
sub rbx, r14
jmp short loc_4C598
loc_4C579:
mov rdx, [rbp+arg_0]
lea rsi, aAtLineDPosDS+13h; "%s"
mov rdi, r15
xor eax, eax
call my_b_printf
test al, al
jz loc_4C1F6
loc_4C596:
xor ebx, ebx
loc_4C598:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_4C5D8
mov rax, rbx
add rsp, 198h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4C5BC:
cmp [rbp+arg_8], 0
jnz short loc_4C596
lea rsi, aCorruptedRepli; "***Corrupted replication event was dete"...
xor ebx, ebx
mov rdi, [rbp+var_80]
xor eax, eax
call my_b_printf
jmp short loc_4C598
loc_4C5D8:
call ___stack_chk_fail
| unsigned __int8 * Rows_log_event::print_verbose_one_row(
long long a1,
long long a2,
table_def *a3,
long long a4,
_QWORD *a5,
long long a6,
long long a7,
char a8)
{
int v10; // ecx
int v11; // ebx
int v12; // r8d
int v13; // r9d
unsigned int v14; // eax
unsigned long long v15; // r12
unsigned int v16; // edx
int v17; // ecx
int v18; // r14d
unsigned __int8 v19; // bl
int v20; // ecx
unsigned int v21; // r15d
table_def *v22; // r14
unsigned __int8 *v23; // rbx
int v24; // eax
int v25; // edx
int v26; // r8d
int v27; // r9d
long long v28; // rcx
long long v29; // rcx
long long v30; // r8
long long v31; // rbx
int v32; // r14d
long long v33; // r8
long long v34; // r14
_DWORD *v35; // rax
int v36; // ecx
long long v37; // r15
int v38; // r9d
int v39; // edx
int v40; // eax
int v41; // ecx
_WORD *v42; // rax
int v43; // eax
_BYTE *v44; // rax
long long v45; // rbx
_BYTE v47[264]; // [rsp+0h] [rbp-1C0h] BYREF
_QWORD *v48; // [rsp+108h] [rbp-B8h]
long long v49; // [rsp+110h] [rbp-B0h]
long long v50; // [rsp+118h] [rbp-A8h]
unsigned __int8 *v51; // [rsp+120h] [rbp-A0h]
table_def *v52; // [rsp+128h] [rbp-98h]
long long v53; // [rsp+130h] [rbp-90h]
unsigned int v54; // [rsp+13Ch] [rbp-84h]
long long v55; // [rsp+140h] [rbp-80h]
int v56; // [rsp+14Ch] [rbp-74h]
_OWORD v57[4]; // [rsp+150h] [rbp-70h] BYREF
unsigned long long v58; // [rsp+190h] [rbp-30h]
v50 = a4;
v49 = a1;
v58 = __readfsqword(0x28u);
memset(v57, 0, sizeof(v57));
v48 = a5;
v11 = bitmap_bits_set(a5);
if ( !a8 && (unsigned __int8)my_b_printf(a2, (unsigned int)"%s", a7, v10, v12, v13) )
return 0LL;
v51 = (unsigned __int8 *)(a6 + ((unsigned int)(v11 + 7) >> 3));
v52 = a3;
v14 = *(_DWORD *)a3;
if ( !*(_DWORD *)a3 )
return &v51[-a6];
v15 = 0LL;
v16 = 0;
v53 = a6;
v55 = a2;
while ( 1 )
{
v17 = *(unsigned __int8 *)(a6 + (v16 >> 3));
v54 = v16;
v18 = 0;
v19 = _bittest(&v17, v16 & 7);
v20 = *(unsigned __int8 *)(*v48 + (v15 >> 3));
v21 = v15 & 7;
if ( _bittest(&v20, v21) )
break;
a6 = v53;
v16 = v54;
LABEL_58:
if ( ++v15 >= v14 )
return &v51[-a6];
}
if ( !a8 && (unsigned __int8)my_b_printf(v55, (unsigned int)"### @%d=", (int)v15 + 1, v20, v12, v13) )
return 0LL;
LOBYTE(v18) = v19;
v56 = v18;
if ( v18 )
{
v23 = 0LL;
v22 = v52;
LABEL_12:
if ( a8 )
{
open_cached_file(v47, 0LL, 0LL, 0LL, 20LL);
v28 = *(unsigned __int8 *)(*((_QWORD *)v22 + 1) + v15);
if ( (_DWORD)v28 == 10 )
{
v28 = 14LL;
}
else if ( (_DWORD)v28 == 254 )
{
v28 = *(unsigned __int8 *)(*((_QWORD *)v22 + 3) + 2 * v15 + 1);
if ( (unsigned __int16)(v28 - 247) >= 2u )
v28 = 254LL;
}
if ( *((_DWORD *)v22 + 4) )
v30 = *(unsigned __int16 *)(*((_QWORD *)v22 + 3) + 2 * v15);
else
v30 = 0LL;
v31 = log_event_print_value(v47, v50, v23, v28, v30, v57);
close_cached_file(v47);
v32 = v56;
}
else
{
v29 = *(unsigned __int8 *)(*((_QWORD *)v22 + 1) + v15);
if ( (_DWORD)v29 == 10 )
{
v29 = 14LL;
}
else if ( (_DWORD)v29 == 254 )
{
v29 = *(unsigned __int8 *)(*((_QWORD *)v22 + 3) + 2 * v15 + 1);
if ( (unsigned __int16)(v29 - 247) >= 2u )
v29 = 254LL;
}
if ( *((_DWORD *)v22 + 4) )
v33 = *(unsigned __int16 *)(*((_QWORD *)v22 + 3) + 2 * v15);
else
v33 = 0LL;
v32 = v56;
v31 = log_event_print_value(v55, v50, v23, v29, v33, v57);
}
if ( !v31 )
return 0LL;
if ( v32 )
v31 = 0LL;
if ( a8 || *(_DWORD *)(v50 + 840) < 2u )
{
a6 = v53;
v37 = v55;
if ( a8 )
{
LABEL_57:
v51 += v31;
v16 = v54 + 1;
v14 = *(_DWORD *)v52;
goto LABEL_58;
}
}
else
{
v34 = v55;
v35 = *(_DWORD **)(v55 + 64);
v36 = (_DWORD)v35 + 4;
if ( (unsigned long long)(v35 + 1) <= *(_QWORD *)(v55 + 72) )
{
*v35 = 539635488;
*(_QWORD *)(v34 + 64) += 4LL;
}
else if ( (unsigned int)my_b_write(v55, " /* ", 4LL) )
{
return 0LL;
}
if ( (unsigned __int8)my_b_printf(v34, (unsigned int)"%s ", (unsigned int)v57, v36, v12, v13) )
return 0LL;
v39 = *((_DWORD *)v52 + 4) ? *(unsigned __int16 *)(*((_QWORD *)v52 + 3) + 2 * v15) : 0;
v40 = *(unsigned __int8 *)(*((_QWORD *)v52 + 4) + (v15 >> 3));
v41 = _bittest(&v40, v21);
v37 = v55;
if ( (unsigned __int8)my_b_printf(v55, (unsigned int)"meta=%d nullable=%d is_null=%d ", v39, v41, v56, v38) )
return 0LL;
v42 = *(_WORD **)(v37 + 64);
if ( (unsigned long long)(v42 + 1) <= *(_QWORD *)(v37 + 72) )
{
*v42 = 12074;
*(_QWORD *)(v37 + 64) += 2LL;
a6 = v53;
}
else
{
v43 = my_b_write(v37, "*/", 2LL);
a6 = v53;
if ( v43 )
return 0LL;
}
}
v44 = *(_BYTE **)(v37 + 64);
if ( (unsigned long long)v44 >= *(_QWORD *)(v37 + 72) )
{
if ( (unsigned int)my_b_flush_io_cache(v37, 1LL) )
return 0LL;
v44 = *(_BYTE **)(v37 + 64);
}
*(_QWORD *)(v37 + 64) = v44 + 1;
*v44 = 10;
goto LABEL_57;
}
v22 = v52;
v23 = v51;
v24 = table_def::calc_field_size(v52, v15, v51);
if ( (unsigned long long)&v23[v24] <= *(_QWORD *)(v49 + 280) )
goto LABEL_12;
if ( !a8 )
{
v45 = 0LL;
my_b_printf(
v55,
(unsigned int)"***Corrupted replication event was detected. Not printing the value***\n",
v25,
v49,
v26,
v27);
return (unsigned __int8 *)v45;
}
return 0LL;
}
| print_verbose_one_row:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x198
MOV R14,R9
MOV qword ptr [RBP + -0xa8],RCX
MOV R12,RDX
MOV R15,RSI
MOV qword ptr [RBP + -0xb0],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RBP + -0x40],XMM0
MOVAPS xmmword ptr [RBP + -0x50],XMM0
MOVAPS xmmword ptr [RBP + -0x60],XMM0
MOVAPS xmmword ptr [RBP + -0x70],XMM0
MOV qword ptr [RBP + -0xb8],R8
MOV RDI,R8
CALL 0x001804f8
MOV EBX,EAX
CMP byte ptr [RBP + 0x18],0x0
JZ 0x0014c579
LAB_0014c1f6:
ADD EBX,0x7
SHR EBX,0x3
ADD RBX,R14
MOV qword ptr [RBP + -0xa0],RBX
MOV qword ptr [RBP + -0x98],R12
MOV EAX,dword ptr [R12]
TEST RAX,RAX
JZ 0x0014c56d
XOR R12D,R12D
XOR EDX,EDX
MOV qword ptr [RBP + -0x90],R14
MOV qword ptr [RBP + -0x80],R15
LAB_0014c22a:
MOV ECX,EDX
SHR ECX,0x3
MOVZX ECX,byte ptr [R14 + RCX*0x1]
MOV dword ptr [RBP + -0x84],EDX
AND EDX,0x7
XOR R14D,R14D
BT ECX,EDX
SETC BL
MOV RCX,qword ptr [RBP + -0xb8]
MOV RCX,qword ptr [RCX]
MOV R13,R12
SHR R13,0x3
MOVZX ECX,byte ptr [RCX + R13*0x1]
MOV R15D,R12D
AND R15D,0x7
BT ECX,R15D
JNC 0x0014c2d0
CMP byte ptr [RBP + 0x18],0x0
JNZ 0x0014c28e
LEA EDX,[R12 + 0x1]
MOV RDI,qword ptr [RBP + -0x80]
LEA RSI,[0x1b9cc8]
XOR EAX,EAX
CALL 0x0017dd8d
TEST AL,AL
JNZ 0x0014c596
LAB_0014c28e:
MOV R14B,BL
MOV dword ptr [RBP + -0x74],R14D
TEST R14D,R14D
JNZ 0x0014c2e2
MOV R14,qword ptr [RBP + -0x98]
MOV RDI,R14
MOV ESI,R12D
MOV RBX,qword ptr [RBP + -0xa0]
MOV RDX,RBX
CALL 0x0014c5de
MOV EAX,EAX
ADD RAX,RBX
MOV RCX,qword ptr [RBP + -0xb0]
CMP RAX,qword ptr [RCX + 0x118]
JBE 0x0014c2eb
JMP 0x0014c5bc
LAB_0014c2d0:
MOV R14,qword ptr [RBP + -0x90]
MOV EDX,dword ptr [RBP + -0x84]
JMP 0x0014c55f
LAB_0014c2e2:
XOR EBX,EBX
MOV R14,qword ptr [RBP + -0x98]
LAB_0014c2eb:
CMP byte ptr [RBP + 0x18],0x0
JZ 0x0014c33d
MOV R8D,0x14
LEA RDI,[RBP + -0x1c0]
XOR ESI,ESI
XOR EDX,EDX
XOR ECX,ECX
CALL 0x0017abe0
MOV RAX,qword ptr [R14 + 0x8]
MOVZX ECX,byte ptr [RAX + R12*0x1]
CMP ECX,0xa
JZ 0x0014c371
CMP ECX,0xfe
JNZ 0x0014c376
MOV RAX,qword ptr [R14 + 0x18]
MOVZX ECX,byte ptr [RAX + R12*0x2 + 0x1]
LEA EAX,[RCX + -0xf7]
CMP AX,0x2
MOV EAX,0xfe
CMOVNC ECX,EAX
JMP 0x0014c376
LAB_0014c33d:
MOV RAX,qword ptr [R14 + 0x8]
MOVZX ECX,byte ptr [RAX + R12*0x1]
CMP ECX,0xa
JZ 0x0014c3b9
CMP ECX,0xfe
JNZ 0x0014c3be
MOV RAX,qword ptr [R14 + 0x18]
MOVZX ECX,byte ptr [RAX + R12*0x2 + 0x1]
LEA EAX,[RCX + -0xf7]
CMP AX,0x2
MOV EAX,0xfe
CMOVNC ECX,EAX
JMP 0x0014c3be
LAB_0014c371:
MOV ECX,0xe
LAB_0014c376:
CMP dword ptr [R14 + 0x10],0x0
JZ 0x0014c388
MOV RAX,qword ptr [R14 + 0x18]
MOVZX R8D,word ptr [RAX + R12*0x2]
JMP 0x0014c38b
LAB_0014c388:
XOR R8D,R8D
LAB_0014c38b:
LEA R14,[RBP + -0x1c0]
MOV RDI,R14
MOV RSI,qword ptr [RBP + -0xa8]
MOV RDX,RBX
LEA R9,[RBP + -0x70]
CALL 0x0014c7e2
MOV RBX,RAX
MOV RDI,R14
CALL 0x0017acb8
MOV R14D,dword ptr [RBP + -0x74]
JMP 0x0014c3f1
LAB_0014c3b9:
MOV ECX,0xe
LAB_0014c3be:
CMP dword ptr [R14 + 0x10],0x0
JZ 0x0014c3d0
MOV RAX,qword ptr [R14 + 0x18]
MOVZX R8D,word ptr [RAX + R12*0x2]
JMP 0x0014c3d3
LAB_0014c3d0:
XOR R8D,R8D
LAB_0014c3d3:
MOV R14D,dword ptr [RBP + -0x74]
MOV RDI,qword ptr [RBP + -0x80]
MOV RSI,qword ptr [RBP + -0xa8]
MOV RDX,RBX
LEA R9,[RBP + -0x70]
CALL 0x0014c7e2
MOV RBX,RAX
LAB_0014c3f1:
TEST RBX,RBX
JZ 0x0014c596
TEST R14D,R14D
MOV EAX,0x0
CMOVNZ RBX,RAX
CMP byte ptr [RBP + 0x18],0x0
JNZ 0x0014c44b
MOV RAX,qword ptr [RBP + -0xa8]
CMP dword ptr [RAX + 0x348],0x2
JC 0x0014c44b
MOV R14,qword ptr [RBP + -0x80]
MOV RAX,qword ptr [R14 + 0x40]
LEA RCX,[RAX + 0x4]
CMP RCX,qword ptr [R14 + 0x48]
JBE 0x0014c465
MOV EDX,0x4
MOV RDI,R14
LEA RSI,[0x1b9d1b]
CALL 0x0017bc9b
TEST EAX,EAX
JZ 0x0014c470
JMP 0x0014c596
LAB_0014c44b:
CMP byte ptr [RBP + 0x18],0x0
MOV R14,qword ptr [RBP + -0x90]
MOV R15,qword ptr [RBP + -0x80]
JNZ 0x0014c547
JMP 0x0014c51d
LAB_0014c465:
MOV dword ptr [RAX],0x202a2f20
ADD qword ptr [R14 + 0x40],0x4
LAB_0014c470:
MOV RDI,R14
LEA RSI,[0x1b9ca6]
LEA RDX,[RBP + -0x70]
XOR EAX,EAX
CALL 0x0017dd8d
TEST AL,AL
JNZ 0x0014c596
MOV RCX,qword ptr [RBP + -0x98]
CMP dword ptr [RCX + 0x10],0x0
JZ 0x0014c4a5
MOV RAX,qword ptr [RCX + 0x18]
MOVZX EDX,word ptr [RAX + R12*0x2]
JMP 0x0014c4a7
LAB_0014c4a5:
XOR EDX,EDX
LAB_0014c4a7:
MOV R8D,dword ptr [RBP + -0x74]
MOV RAX,qword ptr [RCX + 0x20]
MOVZX EAX,byte ptr [RAX + R13*0x1]
XOR ECX,ECX
BT EAX,R15D
SETC CL
MOV R15,qword ptr [RBP + -0x80]
MOV RDI,R15
LEA RSI,[0x1b9d20]
XOR EAX,EAX
CALL 0x0017dd8d
TEST AL,AL
JNZ 0x0014c596
MOV RAX,qword ptr [R15 + 0x40]
LEA RCX,[RAX + 0x2]
CMP RCX,qword ptr [R15 + 0x48]
JBE 0x0014c50c
MOV EDX,0x2
MOV RDI,R15
LEA RSI,[0x1b9d40]
CALL 0x0017bc9b
TEST EAX,EAX
MOV R14,qword ptr [RBP + -0x90]
JZ 0x0014c51d
JMP 0x0014c596
LAB_0014c50c:
MOV word ptr [RAX],0x2f2a
ADD qword ptr [R15 + 0x40],0x2
MOV R14,qword ptr [RBP + -0x90]
LAB_0014c51d:
MOV RAX,qword ptr [R15 + 0x40]
CMP RAX,qword ptr [R15 + 0x48]
JC 0x0014c53c
MOV RDI,R15
MOV ESI,0x1
CALL 0x0017b9d9
TEST EAX,EAX
JNZ 0x0014c596
MOV RAX,qword ptr [R15 + 0x40]
LAB_0014c53c:
LEA RCX,[RAX + 0x1]
MOV qword ptr [R15 + 0x40],RCX
MOV byte ptr [RAX],0xa
LAB_0014c547:
ADD qword ptr [RBP + -0xa0],RBX
MOV EDX,dword ptr [RBP + -0x84]
INC EDX
MOV RAX,qword ptr [RBP + -0x98]
MOV EAX,dword ptr [RAX]
LAB_0014c55f:
INC R12
MOV ECX,EAX
CMP R12,RCX
JC 0x0014c22a
LAB_0014c56d:
MOV RBX,qword ptr [RBP + -0xa0]
SUB RBX,R14
JMP 0x0014c598
LAB_0014c579:
MOV RDX,qword ptr [RBP + 0x10]
LEA RSI,[0x1c2298]
MOV RDI,R15
XOR EAX,EAX
CALL 0x0017dd8d
TEST AL,AL
JZ 0x0014c1f6
LAB_0014c596:
XOR EBX,EBX
LAB_0014c598:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0014c5d8
MOV RAX,RBX
ADD RSP,0x198
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0014c5bc:
CMP byte ptr [RBP + 0x18],0x0
JNZ 0x0014c596
LEA RSI,[0x1b9cd3]
XOR EBX,EBX
MOV RDI,qword ptr [RBP + -0x80]
XOR EAX,EAX
CALL 0x0017dd8d
JMP 0x0014c598
LAB_0014c5d8:
CALL 0x0013a340
|
/* Rows_log_event::print_verbose_one_row(st_io_cache*, table_def*, st_print_event_info*, st_bitmap*,
unsigned char const*, unsigned char const*, char) */
long __thiscall
Rows_log_event::print_verbose_one_row
(Rows_log_event *this,st_io_cache *param_1,table_def *param_2,st_print_event_info *param_3
,st_bitmap *param_4,uchar *param_5,uchar *param_6,char param_7)
{
byte bVar1;
char cVar2;
int iVar3;
uint uVar4;
ulong uVar5;
long lVar6;
int1 *puVar7;
int2 uVar8;
uint uVar9;
ulong uVar10;
uchar *puVar11;
uint uVar12;
uint uVar13;
ulong uVar14;
long in_FS_OFFSET;
bool bVar15;
ulong in_stack_fffffffffffffe38;
uchar *local_a8;
char local_78 [64];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
local_78[0x30] = '\0';
local_78[0x31] = '\0';
local_78[0x32] = '\0';
local_78[0x33] = '\0';
local_78[0x34] = '\0';
local_78[0x35] = '\0';
local_78[0x36] = '\0';
local_78[0x37] = '\0';
local_78[0x38] = '\0';
local_78[0x39] = '\0';
local_78[0x3a] = '\0';
local_78[0x3b] = '\0';
local_78[0x3c] = '\0';
local_78[0x3d] = '\0';
local_78[0x3e] = '\0';
local_78[0x3f] = '\0';
local_78[0x20] = '\0';
local_78[0x21] = '\0';
local_78[0x22] = '\0';
local_78[0x23] = '\0';
local_78[0x24] = '\0';
local_78[0x25] = '\0';
local_78[0x26] = '\0';
local_78[0x27] = '\0';
local_78[0x28] = '\0';
local_78[0x29] = '\0';
local_78[0x2a] = '\0';
local_78[0x2b] = '\0';
local_78[0x2c] = '\0';
local_78[0x2d] = '\0';
local_78[0x2e] = '\0';
local_78[0x2f] = '\0';
local_78[0x10] = '\0';
local_78[0x11] = '\0';
local_78[0x12] = '\0';
local_78[0x13] = '\0';
local_78[0x14] = '\0';
local_78[0x15] = '\0';
local_78[0x16] = '\0';
local_78[0x17] = '\0';
local_78[0x18] = '\0';
local_78[0x19] = '\0';
local_78[0x1a] = '\0';
local_78[0x1b] = '\0';
local_78[0x1c] = '\0';
local_78[0x1d] = '\0';
local_78[0x1e] = '\0';
local_78[0x1f] = '\0';
local_78[0] = '\0';
local_78[1] = '\0';
local_78[2] = '\0';
local_78[3] = '\0';
local_78[4] = '\0';
local_78[5] = '\0';
local_78[6] = '\0';
local_78[7] = '\0';
local_78[8] = '\0';
local_78[9] = '\0';
local_78[10] = '\0';
local_78[0xb] = '\0';
local_78[0xc] = '\0';
local_78[0xd] = '\0';
local_78[0xe] = '\0';
local_78[0xf] = '\0';
iVar3 = bitmap_bits_set(param_4);
if ((param_7 == '\0') && (cVar2 = my_b_printf(param_1,"%s",param_6), cVar2 != '\0')) {
LAB_0014c596:
lVar6 = 0;
}
else {
local_a8 = param_5 + (iVar3 + 7U >> 3);
uVar5 = (ulong)*(uint *)param_2;
if (uVar5 != 0) {
uVar14 = 0;
uVar10 = 0;
do {
uVar9 = (uint)uVar10;
bVar15 = (param_5[uVar10 >> 3] >> (uVar9 & 7) & 1) != 0;
uVar13 = (uint)uVar14;
if ((*(byte *)(*(long *)param_4 + (uVar14 >> 3)) >> (uVar13 & 7) & 1) != 0) {
if ((param_7 == '\0') &&
(cVar2 = my_b_printf(param_1,"### @%d=",uVar13 + 1), cVar2 != '\0'))
goto LAB_0014c596;
if (bVar15) {
puVar11 = (uchar *)0x0;
}
else {
uVar4 = table_def::calc_field_size(param_2,uVar13,local_a8);
puVar11 = local_a8;
if (*(uchar **)(this + 0x118) < local_a8 + uVar4) {
if (param_7 != '\0') goto LAB_0014c596;
lVar6 = 0;
my_b_printf(param_1,
"***Corrupted replication event was detected. Not printing the value***\n"
);
goto LAB_0014c598;
}
}
if (param_7 == '\0') {
bVar1 = *(byte *)(*(long *)(param_2 + 8) + uVar14);
uVar4 = (uint)bVar1;
if (bVar1 == 10) {
uVar4 = 0xe;
}
else if ((bVar1 == 0xfe) &&
(bVar1 = *(byte *)(*(long *)(param_2 + 0x18) + 1 + uVar14 * 2),
uVar4 = (uint)bVar1, 1 < (ushort)(bVar1 - 0xf7))) {
uVar4 = 0xfe;
}
if (*(int *)(param_2 + 0x10) == 0) {
uVar12 = 0;
}
else {
uVar12 = (uint)*(ushort *)(*(long *)(param_2 + 0x18) + uVar14 * 2);
}
lVar6 = log_event_print_value
(param_1,param_3,puVar11,uVar4,uVar12,local_78,
in_stack_fffffffffffffe38);
}
else {
open_cached_file(&stack0xfffffffffffffe38,0,0,0);
bVar1 = *(byte *)(*(long *)(param_2 + 8) + uVar14);
uVar4 = (uint)bVar1;
if (bVar1 == 10) {
uVar4 = 0xe;
}
else if ((bVar1 == 0xfe) &&
(bVar1 = *(byte *)(*(long *)(param_2 + 0x18) + 1 + uVar14 * 2),
uVar4 = (uint)bVar1, 1 < (ushort)(bVar1 - 0xf7))) {
uVar4 = 0xfe;
}
if (*(int *)(param_2 + 0x10) == 0) {
uVar12 = 0;
}
else {
uVar12 = (uint)*(ushort *)(*(long *)(param_2 + 0x18) + uVar14 * 2);
}
lVar6 = log_event_print_value
((st_io_cache *)&stack0xfffffffffffffe38,param_3,puVar11,uVar4,uVar12,
local_78,in_stack_fffffffffffffe38);
close_cached_file((st_io_cache *)&stack0xfffffffffffffe38);
}
if (lVar6 == 0) goto LAB_0014c596;
if (bVar15) {
lVar6 = 0;
}
if ((param_7 == '\0') && (1 < *(uint *)(param_3 + 0x348))) {
if (*(int4 **)(param_1 + 0x48) < *(int4 **)(param_1 + 0x40) + 1) {
iVar3 = _my_b_write(param_1,&DAT_001b9d1b,4);
if (iVar3 != 0) goto LAB_0014c596;
}
else {
**(int4 **)(param_1 + 0x40) = 0x202a2f20;
*(long *)(param_1 + 0x40) = *(long *)(param_1 + 0x40) + 4;
}
cVar2 = my_b_printf(param_1,"%s ",local_78);
if (cVar2 != '\0') goto LAB_0014c596;
if (*(int *)(param_2 + 0x10) == 0) {
uVar8 = 0;
}
else {
uVar8 = *(int2 *)(*(long *)(param_2 + 0x18) + uVar14 * 2);
}
cVar2 = my_b_printf(param_1,"meta=%d nullable=%d is_null=%d ",uVar8,
(*(byte *)(*(long *)(param_2 + 0x20) + (uVar14 >> 3)) >>
(uVar13 & 7) & 1) != 0);
if (cVar2 != '\0') goto LAB_0014c596;
if (*(int2 **)(param_1 + 0x48) < *(int2 **)(param_1 + 0x40) + 1) {
iVar3 = _my_b_write(param_1,&DAT_001b9d40,2);
if (iVar3 != 0) goto LAB_0014c596;
}
else {
**(int2 **)(param_1 + 0x40) = 0x2f2a;
*(long *)(param_1 + 0x40) = *(long *)(param_1 + 0x40) + 2;
}
LAB_0014c51d:
puVar7 = *(int1 **)(param_1 + 0x40);
if (*(int1 **)(param_1 + 0x48) <= puVar7) {
iVar3 = my_b_flush_io_cache(param_1);
if (iVar3 != 0) goto LAB_0014c596;
puVar7 = *(int1 **)(param_1 + 0x40);
}
*(int1 **)(param_1 + 0x40) = puVar7 + 1;
*puVar7 = 10;
}
else if (param_7 == '\0') goto LAB_0014c51d;
local_a8 = local_a8 + lVar6;
uVar9 = uVar9 + 1;
uVar5 = (ulong)*(uint *)param_2;
}
uVar10 = (ulong)uVar9;
uVar14 = uVar14 + 1;
} while (uVar14 < uVar5);
}
lVar6 = (long)local_a8 - (long)param_5;
}
LAB_0014c598:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return lVar6;
}
| |
23,906 | LefDefParser::lefiNonDefault::propIsString(int) const | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiNonDefault.cpp | int
lefiNonDefault::propIsString(int index) const
{
char msg[160];
if (index < 0 || index >= numProps_) {
sprintf(msg, "ERROR (LEFPARS-1408): The index number %d given for the NONDEFAULT PROPERTY is invalid.\nValid index is from 0 to %d", index, numProps_);
lefiError(0, 1408, msg);
return 0;
}
return dvalues_[index] ? 0 : 1;
} | O3 | cpp | LefDefParser::lefiNonDefault::propIsString(int) const:
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movl %esi, %edx
testl %esi, %esi
setns %al
movl 0xf0(%rdi), %ecx
cmpl %esi, %ecx
setg %sil
testb %sil, %al
je 0x20d6f
movq 0x108(%rdi), %rax
movl %edx, %ecx
xorpd %xmm0, %xmm0
cmpeqsd (%rax,%rcx,8), %xmm0
movq %xmm0, %rbx
andl $0x1, %ebx
jmp 0x20d94
leaq 0x2ef13(%rip), %rsi # 0x4fc89
xorl %ebx, %ebx
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
xorl %edi, %edi
movl $0x580, %esi # imm = 0x580
movq %r14, %rdx
callq 0x27ae8
movl %ebx, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
| _ZNK12LefDefParser14lefiNonDefault12propIsStringEi:
push r14
push rbx
sub rsp, 0A8h
mov edx, esi
test esi, esi
setns al
mov ecx, [rdi+0F0h]
cmp ecx, esi
setnle sil
test al, sil
jz short loc_20D6F
mov rax, [rdi+108h]
mov ecx, edx
xorpd xmm0, xmm0
cmpeqsd xmm0, qword ptr [rax+rcx*8]
movq rbx, xmm0
and ebx, 1
jmp short loc_20D94
loc_20D6F:
lea rsi, aErrorLefpars14_9; "ERROR (LEFPARS-1408): The index number "...
xor ebx, ebx
mov r14, rsp
mov rdi, r14
xor eax, eax
call _sprintf
xor edi, edi; this
mov esi, 580h; int
mov rdx, r14; int
call _ZN12LefDefParser9lefiErrorEiiPKc; LefDefParser::lefiError(int,int,char const*)
loc_20D94:
mov eax, ebx
add rsp, 0A8h
pop rbx
pop r14
retn
| long long LefDefParser::lefiNonDefault::propIsString(LefDefParser::lefiNonDefault *this, signed int a2)
{
int v2; // ecx
__m128d v3; // rt1
unsigned int v4; // ebx
const char *v5; // rcx
_BYTE v7[184]; // [rsp+0h] [rbp-B8h] BYREF
v2 = *((_DWORD *)this + 60);
if ( v2 > a2 && a2 >= 0 )
{
v3.m128d_f64[0] = *(double *)(*((_QWORD *)this + 33) + 8LL * (unsigned int)a2);
return *(_OWORD *)&_mm_cmpeq_sd((__m128d)0LL, v3) & 1;
}
else
{
v4 = 0;
sprintf(
v7,
"ERROR (LEFPARS-1408): The index number %d given for the NONDEFAULT PROPERTY is invalid.\n"
"Valid index is from 0 to %d",
a2,
v2);
LefDefParser::lefiError(0LL, 1408, (int)v7, v5);
}
return v4;
}
| propIsString:
PUSH R14
PUSH RBX
SUB RSP,0xa8
MOV EDX,ESI
TEST ESI,ESI
SETNS AL
MOV ECX,dword ptr [RDI + 0xf0]
CMP ECX,ESI
SETG SIL
TEST AL,SIL
JZ 0x00120d6f
MOV RAX,qword ptr [RDI + 0x108]
MOV ECX,EDX
XORPD XMM0,XMM0
CMPEQSD XMM0,qword ptr [RAX + RCX*0x8]
MOVQ RBX,XMM0
AND EBX,0x1
JMP 0x00120d94
LAB_00120d6f:
LEA RSI,[0x14fc89]
XOR EBX,EBX
MOV R14,RSP
MOV RDI,R14
XOR EAX,EAX
CALL 0x00102050
XOR EDI,EDI
MOV ESI,0x580
MOV RDX,R14
CALL 0x00127ae8
LAB_00120d94:
MOV EAX,EBX
ADD RSP,0xa8
POP RBX
POP R14
RET
|
/* LefDefParser::lefiNonDefault::propIsString(int) const */
byte __thiscall LefDefParser::lefiNonDefault::propIsString(lefiNonDefault *this,int param_1)
{
byte bVar1;
char acStack_b8 [168];
if (param_1 < 0 || *(int *)(this + 0xf0) <= param_1) {
bVar1 = 0;
sprintf(acStack_b8,
"ERROR (LEFPARS-1408): The index number %d given for the NONDEFAULT PROPERTY is invalid.\nValid index is from 0 to %d"
);
lefiError(0,0x580,acStack_b8);
}
else {
bVar1 = -(*(double *)(*(long *)(this + 0x108) + (ulong)(uint)param_1 * 8) == 0.0) & 1;
}
return bVar1;
}
| |
23,907 | R3D_GetLightColorV | r3d/src/r3d_lighting.c | Vector3 R3D_GetLightColorV(R3D_Light id)
{
r3d_get_and_check_light(light, id, (Vector3) { 0 });
return light->color;
} | O3 | c | R3D_GetLightColorV:
movl %edi, %edx
testl %edi, %edi
je 0xbda5d
leaq 0xf21cd(%rip), %rax # 0x1afbf0
cmpl %edx, 0x168(%rax)
jbe 0xbda5d
movq 0x128(%rax), %rsi
leal -0x1(%rdx), %ecx
cmpb $0x1, (%rsi,%rcx)
jne 0xbda5d
movq 0x108(%rax), %rsi
cmpq %rcx, 0x110(%rax)
setbe %dil
testq %rsi, %rsi
sete %r8b
orb %dil, %r8b
cmpb $0x1, %r8b
jne 0xbda7c
pushq %rbp
movq %rsp, %rbp
leaq 0x54375(%rip), %rsi # 0x111ddd
movl $0x5, %edi
xorl %eax, %eax
callq 0xa9b51
xorps %xmm1, %xmm1
xorps %xmm0, %xmm0
popq %rbp
retq
imulq 0x120(%rax), %rcx
movsd 0x68(%rsi,%rcx), %xmm0
movss 0x70(%rsi,%rcx), %xmm1
retq
| R3D_GetLightColorV:
mov edx, edi
test edi, edi
jz short loc_BDA5D
lea rax, R3D
cmp [rax+168h], edx
jbe short loc_BDA5D
mov rsi, [rax+128h]
lea ecx, [rdx-1]
cmp byte ptr [rsi+rcx], 1
jnz short loc_BDA5D
mov rsi, [rax+108h]
cmp [rax+110h], rcx
setbe dil
test rsi, rsi
setz r8b
or r8b, dil
cmp r8b, 1
jnz short loc_BDA7C
loc_BDA5D:
push rbp
mov rbp, rsp
lea rsi, aLightIdIIsNotV; "Light [ID %i] is not valid"
mov edi, 5
xor eax, eax
call TraceLog
xorps xmm1, xmm1
xorps xmm0, xmm0
pop rbp
retn
loc_BDA7C:
imul rcx, [rax+120h]
movsd xmm0, qword ptr [rsi+rcx+68h]
movss xmm1, dword ptr [rsi+rcx+70h]
retn
| double R3D_GetLightColorV(unsigned int a1)
{
unsigned long long v1; // rcx
long long v2; // rsi
if ( a1 )
{
if ( *((_DWORD *)&R3D + 90) > a1 )
{
v1 = a1 - 1;
if ( *(_BYTE *)(*((_QWORD *)&R3D + 37) + v1) == 1 )
{
v2 = *((_QWORD *)&R3D + 33);
if ( *((_QWORD *)&R3D + 34) > v1 && v2 != 0 )
return *(double *)(v2 + *((_QWORD *)&R3D + 36) * v1 + 104);
}
}
}
TraceLog(5, (long long)"Light [ID %i] is not valid", a1);
return 0.0;
}
| R3D_GetLightColorV:
MOV EDX,EDI
TEST EDI,EDI
JZ 0x001bda5d
LEA RAX,[0x2afbf0]
CMP dword ptr [RAX + 0x168],EDX
JBE 0x001bda5d
MOV RSI,qword ptr [RAX + 0x128]
LEA ECX,[RDX + -0x1]
CMP byte ptr [RSI + RCX*0x1],0x1
JNZ 0x001bda5d
MOV RSI,qword ptr [RAX + 0x108]
CMP qword ptr [RAX + 0x110],RCX
SETBE DIL
TEST RSI,RSI
SETZ R8B
OR R8B,DIL
CMP R8B,0x1
JNZ 0x001bda7c
LAB_001bda5d:
PUSH RBP
MOV RBP,RSP
LEA RSI,[0x211ddd]
MOV EDI,0x5
XOR EAX,EAX
CALL 0x001a9b51
XORPS XMM1,XMM1
XORPS XMM0,XMM0
POP RBP
RET
LAB_001bda7c:
IMUL RCX,qword ptr [RAX + 0x120]
MOVSD XMM0,qword ptr [RSI + RCX*0x1 + 0x68]
MOVSS XMM1,dword ptr [RSI + RCX*0x1 + 0x70]
RET
|
int8 R3D_GetLightColorV(uint param_1)
{
ulong uVar1;
if (((param_1 != 0) && (param_1 < DAT_002afd58)) &&
(uVar1 = (ulong)(param_1 - 1), *(char *)(DAT_002afd18 + uVar1) == '\x01')) {
if (DAT_002afcf8 != 0 && uVar1 < DAT_002afd00) {
return *(int8 *)(DAT_002afcf8 + 0x68 + uVar1 * DAT_002afd10);
}
}
TraceLog(5,"Light [ID %i] is not valid");
return 0;
}
| |
23,908 | my_copy_fix_mb | eloqsql/strings/ctype-mb.c | size_t
my_copy_fix_mb(CHARSET_INFO *cs,
char *dst, size_t dst_length,
const char *src, size_t src_length,
size_t nchars, MY_STRCOPY_STATUS *status)
{
size_t well_formed_nchars;
size_t well_formed_length;
size_t fixed_length;
size_t min_length= MY_MIN(src_length, dst_length);
well_formed_nchars= my_ci_well_formed_char_length(cs, src, src + min_length,
nchars, status);
DBUG_ASSERT(well_formed_nchars <= nchars);
well_formed_length= status->m_source_end_pos - src;
if (well_formed_length)
memmove(dst, src, well_formed_length);
if (!status->m_well_formed_error_pos)
return well_formed_length;
fixed_length= my_append_fix_badly_formed_tail(cs,
dst + well_formed_length,
dst + dst_length,
src + well_formed_length,
src + src_length,
nchars - well_formed_nchars,
status);
return well_formed_length + fixed_length;
} | O0 | c | my_copy_fix_mb:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x3ee98
movq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x3eea0
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x28(%rbp), %rdx
addq -0x58(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0x3ef60
movq %rax, -0x40(%rbp)
jmp 0x3eecb
movq 0x10(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x3eef5
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x24490
movq 0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x3ef0a
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3ef53
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq -0x48(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
addq -0x48(%rbp), %rcx
movq -0x28(%rbp), %r8
addq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
subq -0x40(%rbp), %r9
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x3efb0
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
addq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
| my_copy_fix_mb:
push rbp
mov rbp, rsp
sub rsp, 70h
mov rax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
mov rax, [rbp+var_30]
cmp rax, [rbp+var_20]
jnb short loc_3EE98
mov rax, [rbp+var_30]
mov [rbp+var_60], rax
jmp short loc_3EEA0
loc_3EE98:
mov rax, [rbp+var_20]
mov [rbp+var_60], rax
loc_3EEA0:
mov rax, [rbp+var_60]
mov [rbp+var_58], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_28]
add rdx, [rbp+var_58]
mov rcx, [rbp+var_38]
mov r8, [rbp+arg_0]
call my_ci_well_formed_char_length
mov [rbp+var_40], rax
jmp short $+2
loc_3EECB:
mov rax, [rbp+arg_0]
mov rax, [rax]
mov rcx, [rbp+var_28]
sub rax, rcx
mov [rbp+var_48], rax
cmp [rbp+var_48], 0
jz short loc_3EEF5
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_48]
call _memmove
loc_3EEF5:
mov rax, [rbp+arg_0]
cmp qword ptr [rax+8], 0
jnz short loc_3EF0A
mov rax, [rbp+var_48]
mov [rbp+var_8], rax
jmp short loc_3EF53
loc_3EF0A:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
add rsi, [rbp+var_48]
mov rdx, [rbp+var_18]
add rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
add rcx, [rbp+var_48]
mov r8, [rbp+var_28]
add r8, [rbp+var_30]
mov r9, [rbp+var_38]
sub r9, [rbp+var_40]
mov rax, [rbp+arg_0]
mov [rsp+70h+var_70], rax
call my_append_fix_badly_formed_tail
mov [rbp+var_50], rax
mov rax, [rbp+var_48]
add rax, [rbp+var_50]
mov [rbp+var_8], rax
loc_3EF53:
mov rax, [rbp+var_8]
add rsp, 70h
pop rbp
retn
| long long my_copy_fix_mb(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
unsigned long long a5,
long long a6,
_QWORD *a7)
{
unsigned long long v8; // [rsp+10h] [rbp-60h]
long long v9; // [rsp+28h] [rbp-48h]
int v10; // [rsp+30h] [rbp-40h]
int v11; // [rsp+38h] [rbp-38h]
int v12; // [rsp+40h] [rbp-30h]
int v14; // [rsp+50h] [rbp-20h]
v14 = a3;
v12 = a5;
v11 = a6;
if ( a5 >= a3 )
v8 = a3;
else
v8 = a5;
v10 = my_ci_well_formed_char_length(a1, a4, v8 + a4, a6, a7);
v9 = *a7 - a4;
if ( v9 )
memmove(a2, a4, v9);
if ( a7[1] )
return my_append_fix_badly_formed_tail(
a1,
(int)v9 + (int)a2,
v14 + (int)a2,
(int)v9 + (int)a4,
v12 + (int)a4,
v11 - v10,
(long long)a7)
+ v9;
else
return v9;
}
| my_copy_fix_mb:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x0013ee98
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x60],RAX
JMP 0x0013eea0
LAB_0013ee98:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x60],RAX
LAB_0013eea0:
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x58],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x28]
ADD RDX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x38]
MOV R8,qword ptr [RBP + 0x10]
CALL 0x0013ef60
MOV qword ptr [RBP + -0x40],RAX
JMP 0x0013eecb
LAB_0013eecb:
MOV RAX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x28]
SUB RAX,RCX
MOV qword ptr [RBP + -0x48],RAX
CMP qword ptr [RBP + -0x48],0x0
JZ 0x0013eef5
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x48]
CALL 0x00124490
LAB_0013eef5:
MOV RAX,qword ptr [RBP + 0x10]
CMP qword ptr [RAX + 0x8],0x0
JNZ 0x0013ef0a
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0013ef53
LAB_0013ef0a:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
ADD RSI,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
ADD RCX,qword ptr [RBP + -0x48]
MOV R8,qword ptr [RBP + -0x28]
ADD R8,qword ptr [RBP + -0x30]
MOV R9,qword ptr [RBP + -0x38]
SUB R9,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RSP],RAX
CALL 0x0013efb0
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x8],RAX
LAB_0013ef53:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x70
POP RBP
RET
|
size_t my_copy_fix_mb(int8 param_1,void *param_2,ulong param_3,void *param_4,ulong param_5,
long param_6,long *param_7)
{
long lVar1;
ulong local_68;
size_t local_10;
local_68 = param_3;
if (param_5 < param_3) {
local_68 = param_5;
}
lVar1 = my_ci_well_formed_char_length(param_1,param_4,(long)param_4 + local_68,param_6,param_7);
local_10 = *param_7 - (long)param_4;
if (local_10 != 0) {
memmove(param_2,param_4,local_10);
}
if (param_7[1] != 0) {
lVar1 = my_append_fix_badly_formed_tail
(param_1,(long)param_2 + local_10,(long)param_2 + param_3,
(long)param_4 + local_10,(long)param_4 + param_5,param_6 - lVar1,param_7);
local_10 = local_10 + lVar1;
}
return local_10;
}
| |
23,909 | LoraModel::alloc_compute_buffer(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ggml_tensor*, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, ggml_tensor*>>>) | 7CodeWizard[P]stablediffusion/lora.hpp | void alloc_compute_buffer(std::map<std::string, struct ggml_tensor*> model_tensors) {
auto get_graph = [&]() -> struct ggml_cgraph* {
return build_graph(model_tensors);
};
GGMLModule::alloc_compute_buffer(get_graph);
} | O2 | cpp | LoraModel::alloc_compute_buffer(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ggml_tensor*, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, ggml_tensor*>>>):
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq (%rdi), %rbx
movq 0x8(%rdi), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x31282
movq %rbx, %rdi
movq %r14, %rsi
callq 0x30994
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x25e24
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x25e24
movq %rbx, %rdi
callq 0xaab0
nop
| _ZZN9LoraModel20alloc_compute_bufferESt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEP11ggml_tensorSt4lessIS6_ESaISt4pairIKS6_S8_EEEENKUlvE_clEv:
push r14
push rbx
sub rsp, 38h
mov rbx, [rdi]
mov rsi, [rdi+8]
lea r14, [rsp+48h+var_40]
mov rdi, r14
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_P11ggml_tensorESt10_Select1stISA_ESt4lessIS5_ESaISA_EEC2ERKSG_; std::_Rb_tree<std::string,std::pair<std::string const,ggml_tensor *>,std::_Select1st<std::pair<std::string const,ggml_tensor *>>,std::less<std::string>,std::allocator<std::pair<std::string const,ggml_tensor *>>>::_Rb_tree(std::_Rb_tree<std::string,std::pair<std::string const,ggml_tensor *>,std::_Select1st<std::pair<std::string const,ggml_tensor *>>,std::less<std::string>,std::allocator<std::pair<std::string const,ggml_tensor *>>> const&)
mov rdi, rbx
mov rsi, r14
call _ZN9LoraModel11build_graphESt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEP11ggml_tensorSt4lessIS6_ESaISt4pairIKS6_S8_EEE; LoraModel::build_graph(std::map<std::string,ggml_tensor *>)
mov rbx, rax
lea rdi, [rsp+48h+var_40]
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_P11ggml_tensorESt10_Select1stISA_ESt4lessIS5_ESaISA_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,ggml_tensor *>,std::_Select1st<std::pair<std::string const,ggml_tensor *>>,std::less<std::string>,std::allocator<std::pair<std::string const,ggml_tensor *>>>::~_Rb_tree()
mov rax, rbx
add rsp, 38h
pop rbx
pop r14
retn
mov rbx, rax
lea rdi, [rsp+arg_0]
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_P11ggml_tensorESt10_Select1stISA_ESt4lessIS5_ESaISA_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,ggml_tensor *>,std::_Select1st<std::pair<std::string const,ggml_tensor *>>,std::less<std::string>,std::allocator<std::pair<std::string const,ggml_tensor *>>>::~_Rb_tree()
mov rdi, rbx
call __Unwind_Resume
| operator():
PUSH R14
PUSH RBX
SUB RSP,0x38
MOV RBX,qword ptr [RDI]
MOV RSI,qword ptr [RDI + 0x8]
LEA R14,[RSP + 0x8]
MOV RDI,R14
CALL 0x00131282
LAB_0013095b:
MOV RDI,RBX
MOV RSI,R14
CALL 0x00130994
LAB_00130966:
MOV RBX,RAX
LEA RDI,[RSP + 0x8]
CALL 0x00125e24
MOV RAX,RBX
ADD RSP,0x38
POP RBX
POP R14
RET
|
/* LoraModel::alloc_compute_buffer(std::map<std::__cxx11::string, ggml_tensor*,
std::less<std::__cxx11::string >, std::allocator<std::pair<std::__cxx11::string const,
ggml_tensor*> > >)::{lambda()#1}::TEMPNAMEPLACEHOLDERVALUE() const */
int8 __thiscall
LoraModel::
alloc_compute_buffer(std::map<std::__cxx11::string,ggml_tensor*,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,ggml_tensor*>>>)
::{lambda()#1}::operator()(_lambda___1_ *this)
{
LoraModel *pLVar1;
int8 uVar2;
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,ggml_tensor*>,std::_Select1st<std::pair<std::__cxx11::string_const,ggml_tensor*>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,ggml_tensor*>>>
local_40 [48];
pLVar1 = *(LoraModel **)this;
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,ggml_tensor*>,std::_Select1st<std::pair<std::__cxx11::string_const,ggml_tensor*>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,ggml_tensor*>>>
::_Rb_tree(local_40,*(_Rb_tree **)(this + 8));
/* try { // try from 0013095b to 00130965 has its CatchHandler @ 0013097e */
uVar2 = build_graph(pLVar1,local_40);
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,ggml_tensor*>,std::_Select1st<std::pair<std::__cxx11::string_const,ggml_tensor*>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,ggml_tensor*>>>
::~_Rb_tree(local_40);
return uVar2;
}
| ||
23,910 | LoraModel::alloc_compute_buffer(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ggml_tensor*, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, ggml_tensor*>>>) | 7CodeWizard[P]stablediffusion/lora.hpp | void alloc_compute_buffer(std::map<std::string, struct ggml_tensor*> model_tensors) {
auto get_graph = [&]() -> struct ggml_cgraph* {
return build_graph(model_tensors);
};
GGMLModule::alloc_compute_buffer(get_graph);
} | O3 | cpp | LoraModel::alloc_compute_buffer(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ggml_tensor*, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, ggml_tensor*>>>):
pushq %rbx
subq $0x20, %rsp
movq %rsp, %rax
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
leaq 0x60(%rip), %rcx # 0x4b83a
movq %rcx, 0x18(%rax)
leaq 0x5b(%rip), %rcx # 0x4b840
movq %rcx, 0x10(%rax)
movq %rax, %rsi
callq 0x46fb8
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x4b808
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
retq
jmp 0x4b832
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x4b82a
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0xaad0
movq %rax, %rdi
callq 0x36331
| _ZN9LoraModel20alloc_compute_bufferESt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEP11ggml_tensorSt4lessIS6_ESaISt4pairIKS6_S8_EEE:
push rbx
sub rsp, 20h
mov rax, rsp
mov [rax], rdi
mov [rax+8], rsi
lea rcx, _ZNSt17_Function_handlerIFP11ggml_cgraphvEZN9LoraModel20alloc_compute_bufferESt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEP11ggml_tensorSt4lessISA_ESaISt4pairIKSA_SC_EEEEUlvE_E9_M_invokeERKSt9_Any_data; std::_Function_handler<ggml_cgraph * ()(void),LoraModel::alloc_compute_buffer(std::map<std::string,ggml_tensor *>)::{lambda(void)#1}>::_M_invoke(std::_Any_data const&)
mov [rax+18h], rcx
lea rcx, _ZNSt17_Function_handlerIFP11ggml_cgraphvEZN9LoraModel20alloc_compute_bufferESt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEP11ggml_tensorSt4lessISA_ESaISt4pairIKSA_SC_EEEEUlvE_E10_M_managerERSt9_Any_dataRKSM_St18_Manager_operation; std::_Function_handler<ggml_cgraph * ()(void),LoraModel::alloc_compute_buffer(std::map<std::string,ggml_tensor *>)::{lambda(void)#1}>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rax+10h], rcx
mov rsi, rax
call _ZN10GGMLModule20alloc_compute_bufferESt8functionIFP11ggml_cgraphvEE; GGMLModule::alloc_compute_buffer(std::function<ggml_cgraph * ()(void)>)
mov rax, [rsp+28h+var_18]
test rax, rax
jz short loc_4B808
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
loc_4B808:
add rsp, 20h
pop rbx
retn
jmp short loc_4B832
mov rbx, rax
mov rax, [rsp+28h+var_18]
test rax, rax
jz short loc_4B82A
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
loc_4B82A:
mov rdi, rbx
call __Unwind_Resume
loc_4B832:
mov rdi, rax
call __clang_call_terminate
| long long LoraModel::alloc_compute_buffer(_QWORD *a1, long long a2)
{
long long result; // rax
_QWORD v3[2]; // [rsp+0h] [rbp-28h] BYREF
long long ( *v4)(); // [rsp+10h] [rbp-18h]
long long ( *v5)(); // [rsp+18h] [rbp-10h]
v3[0] = a1;
v3[1] = a2;
v5 = std::_Function_handler<ggml_cgraph * ()(void),LoraModel::alloc_compute_buffer(std::map<std::string,ggml_tensor *>)::{lambda(void)#1}>::_M_invoke;
v4 = std::_Function_handler<ggml_cgraph * ()(void),LoraModel::alloc_compute_buffer(std::map<std::string,ggml_tensor *>)::{lambda(void)#1}>::_M_manager;
GGMLModule::alloc_compute_buffer(a1, (long long)v3);
result = (long long)v4;
if ( v4 )
return ((long long ( *)(_QWORD *, _QWORD *, long long))v4)(v3, v3, 3LL);
return result;
}
| |||
23,911 | nglog::SetVLOGLevel(char const*, int) | ng-log[P]ng-log/src/vlog_is_on.cc | int SetVLOGLevel(const char* module_pattern, int log_level) {
int result = FLAGS_v;
size_t const pattern_len = strlen(module_pattern);
bool found = false;
{
std::lock_guard<std::mutex> l(
vmodule_mutex); // protect whole read-modify-write
for (const VModuleInfo* info = vmodule_list; info != nullptr;
info = info->next) {
if (info->module_pattern == module_pattern) {
if (!found) {
result = info->vlog_level;
found = true;
}
info->vlog_level = log_level;
} else if (!found && SafeFNMatch_(info->module_pattern.c_str(),
info->module_pattern.size(),
module_pattern, pattern_len)) {
result = info->vlog_level;
found = true;
}
}
if (!found) {
auto* info = new VModuleInfo;
info->module_pattern = module_pattern;
info->vlog_level = log_level;
info->next = vmodule_list;
vmodule_list = info;
SiteFlag** item_ptr = &cached_site_list;
SiteFlag* item = cached_site_list;
// We traverse the list fully because the pattern can match several items
// from the list.
while (item) {
if (SafeFNMatch_(module_pattern, pattern_len, item->base_name,
item->base_len)) {
// Redirect the cached value to its module override.
item->level = &info->vlog_level;
*item_ptr = item->next; // Remove the item from the list.
} else {
item_ptr = &item->next;
}
item = *item_ptr;
}
}
}
RAW_VLOG(1, "Set VLOG level for \"%s\" to %d", module_pattern, log_level);
return result;
} | O3 | cpp | nglog::SetVLOGLevel(char const*, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0xfb2b(%rip), %rax # 0x32b54
movl (%rax), %ebp
callq 0x71e0
movq %rax, %r15
leaq 0x1fb16(%rip), %rdi # 0x42b50
callq 0x77d0
testl %eax, %eax
jne 0x231d3
movq 0x1faca(%rip), %r12 # 0x42b18
testq %r12, %r12
je 0x230b4
xorl %r13d, %r13d
movq %r12, %rdi
movq %r14, %rsi
callq 0x70f0
testl %eax, %eax
je 0x2308d
testb $0x1, %r13b
jne 0x230a0
movq (%r12), %rdi
movq 0x8(%r12), %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x22f60
testb %al, %al
je 0x230a0
movl 0x20(%r12), %ebp
movb $0x1, %r13b
jmp 0x230a0
testb $0x1, %r13b
jne 0x2309b
movl 0x20(%r12), %ebp
movb $0x1, %r13b
movl %ebx, 0x20(%r12)
movq 0x28(%r12), %r12
testq %r12, %r12
jne 0x23056
testb $0x1, %r13b
jne 0x2315e
movl $0x30, %edi
callq 0x8e90
movq %rax, %r12
addq $0x10, %rax
movq %rax, (%r12)
movq $0x0, 0x8(%r12)
movb $0x0, 0x10(%r12)
movq %r14, %rdi
callq 0x71e0
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
callq 0x7830
movl %ebx, 0x20(%r12)
movq 0x1fa1a(%rip), %rax # 0x42b18
movq %rax, 0x28(%r12)
movq %r12, 0x1fa0e(%rip) # 0x42b18
movq 0x1fa0f(%rip), %r13 # 0x42b20
testq %r13, %r13
je 0x2315e
movl %ebp, 0x4(%rsp)
addq $0x20, %r12
leaq 0x1f9fb(%rip), %rbp # 0x42b20
movq 0x8(%r13), %rdx
movq 0x10(%r13), %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0x22f60
testb %al, %al
je 0x2314a
movq %r12, (%r13)
movq 0x18(%r13), %r13
movq %r13, (%rbp)
jmp 0x23155
movq %r13, %rbp
movq 0x18(%r13), %r13
addq $0x18, %rbp
testq %r13, %r13
jne 0x23125
movl 0x4(%rsp), %ebp
leaq 0x1f9eb(%rip), %rdi # 0x42b50
callq 0x73c0
movq 0x1f9b7(%rip), %rax # 0x42b28
testq %rax, %rax
je 0x231ae
cmpl $0x0, (%rax)
jle 0x2319d
leaq 0x2f37(%rip), %rsi # 0x260b9
leaq 0x2f7a(%rip), %rcx # 0x26103
xorl %edi, %edi
movl $0xc5, %edx
movq %r14, %r8
movl %ebx, %r9d
xorl %eax, %eax
callq 0x20dd8
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f973(%rip), %rdi # 0x42b28
leaq 0xf998(%rip), %rsi # 0x32b54
leaq 0x2ef6(%rip), %rdx # 0x260b9
movl $0x1, %ecx
callq 0x231f1
testb %al, %al
jne 0x2317b
jmp 0x2319d
movl %eax, %edi
callq 0x7330
movq %rax, %rbx
leaq 0x1f96c(%rip), %rdi # 0x42b50
callq 0x73c0
movq %rbx, %rdi
callq 0x7930
| _ZN5nglog12SetVLOGLevelEPKci:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebx, esi
mov r14, rdi
lea rax, _ZN3fLI7FLAGS_vE; fLI::FLAGS_v
mov ebp, [rax]
call _strlen
mov r15, rax
lea rdi, _ZN5nglogL13vmodule_mutexE; nglog::vmodule_mutex
call _pthread_mutex_lock
test eax, eax
jnz loc_231D3
mov r12, cs:_ZN5nglogL12vmodule_listE; nglog::vmodule_list
test r12, r12
jz short loc_230B4
xor r13d, r13d
loc_23056:
mov rdi, r12
mov rsi, r14
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_2308D
test r13b, 1
jnz short loc_230A0
mov rdi, [r12]; this
mov rsi, [r12+8]; char *
mov rdx, r14; unsigned __int64
mov rcx, r15; char *
call _ZN5nglog5tools12SafeFNMatch_EPKcmS2_m; nglog::tools::SafeFNMatch_(char const*,ulong,char const*,ulong)
test al, al
jz short loc_230A0
mov ebp, [r12+20h]
mov r13b, 1
jmp short loc_230A0
loc_2308D:
test r13b, 1
jnz short loc_2309B
mov ebp, [r12+20h]
mov r13b, 1
loc_2309B:
mov [r12+20h], ebx
loc_230A0:
mov r12, [r12+28h]
test r12, r12
jnz short loc_23056
test r13b, 1
jnz loc_2315E
loc_230B4:
mov edi, 30h ; '0'; unsigned __int64
call _Znwm; operator new(ulong)
mov r12, rax
add rax, 10h
mov [r12], rax
mov qword ptr [r12+8], 0
mov byte ptr [r12+10h], 0
mov rdi, r14
call _strlen
mov rdi, r12
xor esi, esi
xor edx, edx
mov rcx, r14
mov r8, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
mov [r12+20h], ebx
mov rax, cs:_ZN5nglogL12vmodule_listE; nglog::vmodule_list
mov [r12+28h], rax
mov cs:_ZN5nglogL12vmodule_listE, r12; nglog::vmodule_list
mov r13, cs:_ZN5nglogL16cached_site_listE; nglog::cached_site_list
test r13, r13
jz short loc_2315E
mov [rsp+38h+var_34], ebp
add r12, 20h ; ' '
lea rbp, _ZN5nglogL16cached_site_listE; nglog::cached_site_list
loc_23125:
mov rdx, [r13+8]; unsigned __int64
mov rcx, [r13+10h]; char *
mov rdi, r14; this
mov rsi, r15; char *
call _ZN5nglog5tools12SafeFNMatch_EPKcmS2_m; nglog::tools::SafeFNMatch_(char const*,ulong,char const*,ulong)
test al, al
jz short loc_2314A
mov [r13+0], r12
mov r13, [r13+18h]
mov [rbp+0], r13
jmp short loc_23155
loc_2314A:
mov rbp, r13
mov r13, [r13+18h]
add rbp, 18h
loc_23155:
test r13, r13
jnz short loc_23125
mov ebp, [rsp+38h+var_34]
loc_2315E:
lea rdi, _ZN5nglogL13vmodule_mutexE; nglog::vmodule_mutex
call _pthread_mutex_unlock
mov rax, cs:_ZZN5nglog12SetVLOGLevelEPKciE8vlocal__; nglog::SetVLOGLevel(char const*,int)::vlocal__
test rax, rax
jz short loc_231AE
cmp dword ptr [rax], 0
jle short loc_2319D
loc_2317B:
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aSetVlogLevelFo; "Set VLOG level for \"%s\" to %d"
xor edi, edi
mov edx, 0C5h
mov r8, r14
mov r9d, ebx
xor eax, eax
call _ZN5nglog6RawLogENS_11LogSeverityEPKciS2_z; nglog::RawLog(nglog::LogSeverity,char const*,int,char const*,...)
loc_2319D:
mov eax, ebp
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_231AE:
lea rdi, _ZZN5nglog12SetVLOGLevelEPKciE8vlocal__; nglog::SetVLOGLevel(char const*,int)::vlocal__
lea rsi, _ZN3fLI7FLAGS_vE; fLI::FLAGS_v
lea rdx, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
mov ecx, 1
call _ZN5nglog15InitializeVLOG3EPNS_8SiteFlagEPiPKci; nglog::InitializeVLOG3(nglog::SiteFlag *,int *,char const*,int)
test al, al
jnz short loc_2317B
jmp short loc_2319D
loc_231D3:
mov edi, eax; int
call __ZSt20__throw_system_errori; std::__throw_system_error(int)
mov rbx, rax
lea rdi, _ZN5nglogL13vmodule_mutexE; nglog::vmodule_mutex
call _pthread_mutex_unlock
mov rdi, rbx
call __Unwind_Resume
| long long nglog::SetVLOGLevel(
nglog *this,
const char *a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
char v10; // al
unsigned int v11; // ebp
const char *v12; // r15
int v13; // eax
long long v14; // r12
char v15; // r13
unsigned long long v16; // r8
long long v17; // r12
long long v18; // rax
unsigned long long v19; // r8
long long v20; // r13
long long v21; // r12
long long *v22; // rbp
long long v23; // rbp
__m128 v24; // xmm4
__m128 v25; // xmm5
char v27; // [rsp-4h] [rbp-38h]
unsigned int v28; // [rsp+0h] [rbp-34h]
v27 = v10;
v11 = fLI::FLAGS_v;
v12 = (const char *)strlen(this);
v13 = pthread_mutex_lock(&nglog::vmodule_mutex);
if ( v13 )
std::__throw_system_error(v13);
v14 = nglog::vmodule_list;
if ( !nglog::vmodule_list )
goto LABEL_13;
v15 = 0;
do
{
if ( !(unsigned int)std::string::compare(v14, this) )
{
if ( (v15 & 1) == 0 )
{
v11 = *(_DWORD *)(v14 + 32);
v15 = 1;
}
*(_DWORD *)(v14 + 32) = (_DWORD)a2;
}
else if ( (v15 & 1) == 0
&& nglog::tools::SafeFNMatch_(*(nglog::tools **)v14, *(const char **)(v14 + 8), (long long)this, v12, v16) )
{
v11 = *(_DWORD *)(v14 + 32);
v15 = 1;
}
v14 = *(_QWORD *)(v14 + 40);
}
while ( v14 );
if ( (v15 & 1) == 0 )
{
LABEL_13:
v17 = operator new(48LL);
*(_QWORD *)v17 = v17 + 16;
*(_QWORD *)(v17 + 8) = 0LL;
*(_BYTE *)(v17 + 16) = 0;
v18 = strlen(this);
std::string::_M_replace(v17, 0LL, 0LL, this, v18);
*(_DWORD *)(v17 + 32) = (_DWORD)a2;
*(_QWORD *)(v17 + 40) = nglog::vmodule_list;
nglog::vmodule_list = v17;
v20 = nglog::cached_site_list;
if ( nglog::cached_site_list )
{
v28 = v11;
v21 = v17 + 32;
v22 = &nglog::cached_site_list;
do
{
if ( nglog::tools::SafeFNMatch_(this, v12, *(_QWORD *)(v20 + 8), *(const char **)(v20 + 16), v19) )
{
*(_QWORD *)v20 = v21;
v20 = *(_QWORD *)(v20 + 24);
*v22 = v20;
}
else
{
v23 = v20;
v20 = *(_QWORD *)(v20 + 24);
v22 = (long long *)(v23 + 24);
}
}
while ( v20 );
v11 = v28;
}
}
pthread_mutex_unlock(&nglog::vmodule_mutex);
if ( !nglog::SetVLOGLevel(char const*,int)::vlocal__ )
{
if ( !(unsigned __int8)nglog::InitializeVLOG3(
&nglog::SetVLOGLevel(char const*,int)::vlocal__,
&fLI::FLAGS_v,
"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/vlog_is_on.cc",
1LL) )
return v11;
goto LABEL_22;
}
if ( *(int *)nglog::SetVLOGLevel(char const*,int)::vlocal__ > 0 )
LABEL_22:
nglog::RawLog(
0LL,
(nglog::tools *)"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/vlog_is_on.cc",
197,
(long long)"Set VLOG level for \"%s\" to %d",
(long long)this,
(unsigned int)a2,
a3,
a4,
a5,
a6,
v24,
v25,
a9,
a10,
v27);
return v11;
}
| SetVLOGLevel:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EBX,ESI
MOV R14,RDI
LEA RAX,[0x132b54]
MOV EBP,dword ptr [RAX]
CALL 0x001071e0
MOV R15,RAX
LEA RDI,[0x142b50]
CALL 0x001077d0
TEST EAX,EAX
JNZ 0x001231d3
MOV R12,qword ptr [0x00142b18]
TEST R12,R12
JZ 0x001230b4
XOR R13D,R13D
LAB_00123056:
MOV RDI,R12
MOV RSI,R14
CALL 0x001070f0
TEST EAX,EAX
JZ 0x0012308d
TEST R13B,0x1
JNZ 0x001230a0
MOV RDI,qword ptr [R12]
MOV RSI,qword ptr [R12 + 0x8]
MOV RDX,R14
MOV RCX,R15
CALL 0x00122f60
TEST AL,AL
JZ 0x001230a0
MOV EBP,dword ptr [R12 + 0x20]
MOV R13B,0x1
JMP 0x001230a0
LAB_0012308d:
TEST R13B,0x1
JNZ 0x0012309b
MOV EBP,dword ptr [R12 + 0x20]
MOV R13B,0x1
LAB_0012309b:
MOV dword ptr [R12 + 0x20],EBX
LAB_001230a0:
MOV R12,qword ptr [R12 + 0x28]
TEST R12,R12
JNZ 0x00123056
TEST R13B,0x1
JNZ 0x0012315e
LAB_001230b4:
MOV EDI,0x30
CALL 0x00108e90
MOV R12,RAX
ADD RAX,0x10
MOV qword ptr [R12],RAX
MOV qword ptr [R12 + 0x8],0x0
MOV byte ptr [R12 + 0x10],0x0
MOV RDI,R14
CALL 0x001071e0
MOV RDI,R12
XOR ESI,ESI
XOR EDX,EDX
MOV RCX,R14
MOV R8,RAX
CALL 0x00107830
LAB_001230f2:
MOV dword ptr [R12 + 0x20],EBX
MOV RAX,qword ptr [0x00142b18]
MOV qword ptr [R12 + 0x28],RAX
MOV qword ptr [0x00142b18],R12
MOV R13,qword ptr [0x00142b20]
TEST R13,R13
JZ 0x0012315e
MOV dword ptr [RSP + 0x4],EBP
ADD R12,0x20
LEA RBP,[0x142b20]
LAB_00123125:
MOV RDX,qword ptr [R13 + 0x8]
MOV RCX,qword ptr [R13 + 0x10]
MOV RDI,R14
MOV RSI,R15
CALL 0x00122f60
TEST AL,AL
JZ 0x0012314a
MOV qword ptr [R13],R12
MOV R13,qword ptr [R13 + 0x18]
MOV qword ptr [RBP],R13
JMP 0x00123155
LAB_0012314a:
MOV RBP,R13
MOV R13,qword ptr [R13 + 0x18]
ADD RBP,0x18
LAB_00123155:
TEST R13,R13
JNZ 0x00123125
MOV EBP,dword ptr [RSP + 0x4]
LAB_0012315e:
LEA RDI,[0x142b50]
CALL 0x001073c0
MOV RAX,qword ptr [0x00142b28]
TEST RAX,RAX
JZ 0x001231ae
CMP dword ptr [RAX],0x0
JLE 0x0012319d
LAB_0012317b:
LEA RSI,[0x1260b9]
LEA RCX,[0x126103]
XOR EDI,EDI
MOV EDX,0xc5
MOV R8,R14
MOV R9D,EBX
XOR EAX,EAX
CALL 0x00120dd8
LAB_0012319d:
MOV EAX,EBP
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001231ae:
LEA RDI,[0x142b28]
LEA RSI,[0x132b54]
LEA RDX,[0x1260b9]
MOV ECX,0x1
CALL 0x001231f1
TEST AL,AL
JNZ 0x0012317b
JMP 0x0012319d
LAB_001231d3:
MOV EDI,EAX
CALL 0x00107330
|
/* nglog::SetVLOGLevel(char const*, int) */
int4 nglog::SetVLOGLevel(char *param_1,int param_2)
{
bool bVar1;
char cVar2;
int iVar3;
size_t sVar4;
long *plVar5;
int4 uVar6;
int8 *puVar7;
int8 *puVar8;
int8 *puVar9;
uVar6 = fLI::FLAGS_v;
sVar4 = strlen(param_1);
iVar3 = pthread_mutex_lock((pthread_mutex_t *)vmodule_mutex);
if (iVar3 != 0) {
/* WARNING: Subroutine does not return */
std::__throw_system_error(iVar3);
}
if (vmodule_list != (long *)0x0) {
bVar1 = false;
plVar5 = vmodule_list;
do {
iVar3 = std::__cxx11::string::compare((char *)plVar5);
if (iVar3 == 0) {
if (!bVar1) {
uVar6 = (int4)plVar5[4];
bVar1 = true;
}
*(int *)(plVar5 + 4) = param_2;
}
else if ((!bVar1) &&
(cVar2 = tools::SafeFNMatch_((char *)*plVar5,plVar5[1],param_1,sVar4), cVar2 != '\0'))
{
uVar6 = (int4)plVar5[4];
bVar1 = true;
}
plVar5 = (long *)plVar5[5];
} while (plVar5 != (long *)0x0);
if (bVar1) goto LAB_0012315e;
}
/* try { // try from 001230b4 to 001230f1 has its CatchHandler @ 001231da */
plVar5 = (long *)operator_new(0x30);
*plVar5 = (long)(plVar5 + 2);
plVar5[1] = 0;
*(int1 *)(plVar5 + 2) = 0;
strlen(param_1);
std::__cxx11::string::_M_replace((ulong)plVar5,0,(char *)0x0,(ulong)param_1);
*(int *)(plVar5 + 4) = param_2;
plVar5[5] = (long)vmodule_list;
vmodule_list = plVar5;
if (cached_site_list != (int8 *)0x0) {
puVar7 = &cached_site_list;
puVar8 = cached_site_list;
do {
cVar2 = tools::SafeFNMatch_(param_1,sVar4,(char *)puVar8[1],puVar8[2]);
if (cVar2 == '\0') {
puVar9 = (int8 *)puVar8[3];
puVar7 = puVar8 + 3;
}
else {
*puVar8 = plVar5 + 4;
puVar9 = (int8 *)puVar8[3];
*puVar7 = puVar9;
}
puVar8 = puVar9;
} while (puVar9 != (int8 *)0x0);
}
LAB_0012315e:
pthread_mutex_unlock((pthread_mutex_t *)vmodule_mutex);
if (SetVLOGLevel(char_const*,int)::vlocal__ == (int *)0x0) {
cVar2 = InitializeVLOG3((SiteFlag *)&SetVLOGLevel(char_const*,int)::vlocal__,&fLI::FLAGS_v,
"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/vlog_is_on.cc"
,1);
if (cVar2 == '\0') {
return uVar6;
}
}
else if (*SetVLOGLevel(char_const*,int)::vlocal__ < 1) {
return uVar6;
}
RawLog(0,"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/vlog_is_on.cc",0xc5,
"Set VLOG level for \"%s\" to %d",param_1,param_2);
return uVar6;
}
| |
23,912 | Field_longstr::make_packed_sort_key_part(unsigned char*, SORT_FIELD_ATTR const*) | eloqsql/sql/field.cc | uint
Field_longstr::make_packed_sort_key_part(uchar *buff,
const SORT_FIELD_ATTR *sort_field)
{
if (maybe_null())
{
if (is_null())
{
*buff++= 0;
return 0; // For NULL values don't write any data
}
*buff++=1;
}
uchar *end= pack_sort_string(buff, sort_field);
return (uint) (end-buff);
} | O0 | cpp | Field_longstr::make_packed_sort_key_part(unsigned char*, SORT_FIELD_ATTR const*):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x87faa0
testb $0x1, %al
jne 0xcd6a67
jmp 0xcd6aa7
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x880200
testb $0x1, %al
jne 0xcd6a7a
jmp 0xcd6a95
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0xcd6aca
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x1, (%rax)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xcd6ae0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZN13Field_longstr25make_packed_sort_key_partEPhPK15SORT_FIELD_ATTR:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rdi, [rbp+var_10]; this
mov [rbp+var_30], rdi
call _ZNK5Field10maybe_nullEv; Field::maybe_null(void)
test al, 1
jnz short loc_CD6A67
jmp short loc_CD6AA7
loc_CD6A67:
mov rdi, [rbp+var_30]; this
xor eax, eax
mov esi, eax; __int64
call _ZNK5Field7is_nullEx; Field::is_null(long long)
test al, 1
jnz short loc_CD6A7A
jmp short loc_CD6A95
loc_CD6A7A:
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
mov byte ptr [rax], 0
mov [rbp+var_4], 0
jmp short loc_CD6ACA
loc_CD6A95:
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
mov byte ptr [rax], 1
loc_CD6AA7:
mov rdi, [rbp+var_30]; this
mov rsi, [rbp+var_18]; unsigned __int8 *
mov rdx, [rbp+var_20]; SORT_FIELD_ATTR *
call _ZN13Field_longstr16pack_sort_stringEPhPK15SORT_FIELD_ATTR; Field_longstr::pack_sort_string(uchar *,SORT_FIELD_ATTR const*)
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov rcx, [rbp+var_18]
sub rax, rcx
mov [rbp+var_4], eax
loc_CD6ACA:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long Field_longstr::make_packed_sort_key_part(
Field_longstr *this,
unsigned __int8 *a2,
const SORT_FIELD_ATTR *a3)
{
unsigned __int8 *v5; // [rsp+18h] [rbp-18h]
v5 = a2;
if ( !Field::maybe_null(this) )
return (unsigned int)(Field_longstr::pack_sort_string(this, v5, a3) - (_DWORD)v5);
if ( !Field::is_null(this, 0LL) )
{
v5 = a2 + 1;
*a2 = 1;
return (unsigned int)(Field_longstr::pack_sort_string(this, v5, a3) - (_DWORD)v5);
}
*a2 = 0;
return 0;
}
| is_group_ending:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
CMP dword ptr [RBP + -0x14],0x10
JZ 0x00cd6a5b
CMP dword ptr [RBP + -0x14],0x26
JNZ 0x00cd6a67
LAB_00cd6a5b:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00cd6afa
LAB_00cd6a67:
CMP dword ptr [RBP + -0x14],0x2
JNZ 0x00cd6af3
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x98]
TEST AL,0x1
JNZ 0x00cd6acc
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,qword ptr [RAX + 0x98]
LEA RSI,[0x153efd1]
MOV EDX,0x9
CALL 0x00876620
CMP EAX,0x0
JZ 0x00cd6acc
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,qword ptr [RAX + 0x98]
LEA RSI,[0x153efdb]
MOV EDX,0xb
CALL 0x00876620
CMP EAX,0x0
JNZ 0x00cd6ad5
LAB_00cd6acc:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00cd6afa
LAB_00cd6ad5:
MOV RDI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0xa0]
TEST AL,0x1
JNZ 0x00cd6ae8
JMP 0x00cd6af1
LAB_00cd6ae8:
MOV dword ptr [RBP + -0x4],0x2
JMP 0x00cd6afa
LAB_00cd6af1:
JMP 0x00cd6af3
LAB_00cd6af3:
MOV dword ptr [RBP + -0x4],0x0
LAB_00cd6afa:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
/* is_group_ending(Log_event*, Log_event_type) */
int4 is_group_ending(long *param_1,int param_2)
{
int iVar1;
ulong uVar2;
if ((param_2 == 0x10) || (param_2 == 0x26)) {
return 1;
}
if (param_2 == 2) {
uVar2 = (**(code **)(*param_1 + 0x98))();
if ((((uVar2 & 1) != 0) || (iVar1 = strncmp((char *)param_1[0x13],"XA COMMIT",9), iVar1 == 0))
|| (iVar1 = strncmp((char *)param_1[0x13],"XA ROLLBACK",0xb), iVar1 == 0)) {
return 1;
}
uVar2 = (**(code **)(*param_1 + 0xa0))();
if ((uVar2 & 1) != 0) {
return 2;
}
}
return 0;
}
| |
23,913 | lzr_pop3_handle_response | xtate/src/probe-modules/lzr-probes/lzr-pop3.c | static unsigned lzr_pop3_handle_response(unsigned th_idx, ProbeTarget *target,
const unsigned char *px,
unsigned sizeof_px, OutItem *item) {
/**
* ref to nmap.
* must be compatible with lzr-imap
*/
if (safe_memismem(px, sizeof_px, "pop3", strlen("pop3"))) {
item->level = OUT_SUCCESS;
safe_strcpy(item->classification, OUT_CLS_SIZE, "pop3");
safe_strcpy(item->reason, OUT_RSN_SIZE, "matched");
return 0;
}
item->level = OUT_FAILURE;
safe_strcpy(item->classification, OUT_CLS_SIZE, "not pop3");
safe_strcpy(item->reason, OUT_RSN_SIZE, "not matched");
return 0;
} | O3 | c | lzr_pop3_handle_response:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %rbx
movq %rdx, %rdi
movl %ecx, %esi
leaq 0x3c39b(%rip), %r14 # 0x687a7
movl $0x4, %ecx
movq %r14, %rdx
callq 0x512e2
leaq 0x50(%rbx), %rdi
leaq 0x6e(%rbx), %r15
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
leaq 0x3c373(%rip), %rdx # 0x687a3
cmovneq %r14, %rdx
leaq 0x3dccf(%rip), %rax # 0x6a10a
leaq 0x3dd1e(%rip), %r14 # 0x6a160
cmoveq %rax, %r14
incl %ecx
movl %ecx, 0x8(%rbx)
movl $0x1e, %esi
callq 0x51195
movl $0x1e, %esi
movq %r15, %rdi
movq %r14, %rdx
callq 0x51195
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
| lzr_pop3_handle_response:
push r15
push r14
push rbx
mov rbx, r8
mov rdi, rdx
mov esi, ecx
lea r14, aNotPop3+4; "pop3"
mov ecx, 4
mov rdx, r14
call safe_memismem
lea rdi, [rbx+50h]
lea r15, [rbx+6Eh]
xor ecx, ecx
test rax, rax
setnz cl
lea rdx, aNotPop3; "not pop3"
cmovnz rdx, r14
lea rax, aProtocolNotMat+9; "not matched"
lea r14, aProtocolMatche_0+9; "matched"
cmovz r14, rax
inc ecx
mov [rbx+8], ecx
mov esi, 1Eh
call safe_strcpy
mov esi, 1Eh
mov rdi, r15
mov rdx, r14
call safe_strcpy
xor eax, eax
pop rbx
pop r14
pop r15
retn
| long long lzr_pop3_handle_response(long long a1, long long a2, long long a3, unsigned int a4, long long a5)
{
*(_DWORD *)(a5 + 8) = (safe_memismem(a3, a4, "pop3", 4LL) != 0) + 1;
safe_strcpy(a5 + 80, 30LL);
safe_strcpy(a5 + 110, 30LL);
return 0LL;
}
| lzr_pop3_handle_response:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,R8
MOV RDI,RDX
MOV ESI,ECX
LEA R14,[0x1687a7]
MOV ECX,0x4
MOV RDX,R14
CALL 0x001512e2
LEA RDI,[RBX + 0x50]
LEA R15,[RBX + 0x6e]
XOR ECX,ECX
TEST RAX,RAX
SETNZ CL
LEA RDX,[0x1687a3]
CMOVNZ RDX,R14
LEA RAX,[0x16a10a]
LEA R14,[0x16a160]
CMOVZ R14,RAX
INC ECX
MOV dword ptr [RBX + 0x8],ECX
MOV ESI,0x1e
CALL 0x00151195
MOV ESI,0x1e
MOV RDI,R15
MOV RDX,R14
CALL 0x00151195
XOR EAX,EAX
POP RBX
POP R14
POP R15
RET
|
int8
lzr_pop3_handle_response
(int8 param_1,int8 param_2,int8 param_3,int4 param_4,long param_5)
{
char *pcVar1;
long lVar2;
char *pcVar3;
bool bVar4;
lVar2 = safe_memismem(param_3,param_4,"pop3",4);
bVar4 = lVar2 != 0;
pcVar3 = "not pop3";
if (bVar4) {
pcVar3 = "pop3";
}
pcVar1 = "protocol matched";
if (!bVar4) {
pcVar1 = "protocol not matched";
}
*(uint *)(param_5 + 8) = bVar4 + 1;
safe_strcpy(param_5 + 0x50,0x1e,pcVar3);
safe_strcpy(param_5 + 0x6e,0x1e,pcVar1 + 9);
return 0;
}
| |
23,914 | hashcmp | eloqsql/mysys/hash.c | static int hashcmp(const HASH *hash, HASH_LINK *pos, const uchar *key,
size_t length)
{
size_t rec_keylength;
uchar *rec_key= (uchar*) my_hash_key(hash, pos->data, &rec_keylength, 1);
return ((length && length != rec_keylength) ||
my_strnncoll(hash->charset, (uchar*) rec_key, rec_keylength,
(uchar*) key, rec_keylength));
} | O3 | c | hashcmp:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movq %rdi, %r14
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x4eca8
leaq -0x28(%rbp), %r12
movq %rsi, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq *%rax
movq %rax, %rsi
movq (%r12), %rdx
jmp 0x4ecb3
movq 0x8(%r14), %rdx
movq %rdx, -0x28(%rbp)
addq (%r14), %rsi
testq %r15, %r15
sete %al
cmpq %r15, %rdx
sete %cl
orb %al, %cl
movl $0x1, %eax
cmpb $0x1, %cl
jne 0x4eceb
movq 0x68(%r14), %rdi
movq 0xc0(%rdi), %rax
movq %rbx, %rcx
movq %rdx, %r8
xorl %r9d, %r9d
callq *0x8(%rax)
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| hashcmp:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov r15, rcx
mov rbx, rdx
mov r14, rdi
mov rax, [rdi+50h]
test rax, rax
jz short loc_4ECA8
lea r12, [rbp+var_28]
mov rdi, rsi
mov rsi, r12
mov edx, 1
call rax
mov rsi, rax
mov rdx, [r12]
jmp short loc_4ECB3
loc_4ECA8:
mov rdx, [r14+8]
mov [rbp+var_28], rdx
add rsi, [r14]
loc_4ECB3:
test r15, r15
setz al
cmp rdx, r15
setz cl
or cl, al
mov eax, 1
cmp cl, 1
jnz short loc_4ECEB
mov rdi, [r14+68h]
mov rax, [rdi+0C0h]
mov rcx, rbx
mov r8, rdx
xor r9d, r9d
call qword ptr [rax+8]
mov ecx, eax
xor eax, eax
test ecx, ecx
setnz al
loc_4ECEB:
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| _BOOL8 hashcmp(_QWORD *a1, long long a2, long long a3, long long a4)
{
long long ( *v6)(long long, _QWORD *, long long); // rax
long long v7; // rsi
long long v8; // rdx
_BOOL8 result; // rax
_QWORD v10[5]; // [rsp+8h] [rbp-28h] BYREF
v6 = (long long ( *)(long long, _QWORD *, long long))a1[10];
if ( v6 )
{
v7 = v6(a2, v10, 1LL);
v8 = v10[0];
}
else
{
v8 = a1[1];
v10[0] = v8;
v7 = *a1 + a2;
}
result = 1LL;
if ( a4 == 0 || v8 == a4 )
return (*(unsigned int ( **)(_QWORD, long long, long long, long long, long long, _QWORD))(*(_QWORD *)(a1[13] + 192LL)
+ 8LL))(
a1[13],
v7,
v8,
a3,
v8,
0LL) != 0;
return result;
}
| hashcmp:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R15,RCX
MOV RBX,RDX
MOV R14,RDI
MOV RAX,qword ptr [RDI + 0x50]
TEST RAX,RAX
JZ 0x0014eca8
LEA R12,[RBP + -0x28]
MOV RDI,RSI
MOV RSI,R12
MOV EDX,0x1
CALL RAX
MOV RSI,RAX
MOV RDX,qword ptr [R12]
JMP 0x0014ecb3
LAB_0014eca8:
MOV RDX,qword ptr [R14 + 0x8]
MOV qword ptr [RBP + -0x28],RDX
ADD RSI,qword ptr [R14]
LAB_0014ecb3:
TEST R15,R15
SETZ AL
CMP RDX,R15
SETZ CL
OR CL,AL
MOV EAX,0x1
CMP CL,0x1
JNZ 0x0014eceb
MOV RDI,qword ptr [R14 + 0x68]
MOV RAX,qword ptr [RDI + 0xc0]
MOV RCX,RBX
MOV R8,RDX
XOR R9D,R9D
CALL qword ptr [RAX + 0x8]
MOV ECX,EAX
XOR EAX,EAX
TEST ECX,ECX
SETNZ AL
LAB_0014eceb:
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
bool hashcmp(long *param_1,long param_2,int8 param_3,long param_4)
{
int iVar1;
bool bVar2;
long local_30;
if ((code *)param_1[10] == (code *)0x0) {
local_30 = param_1[1];
param_2 = param_2 + *param_1;
}
else {
param_2 = (*(code *)param_1[10])(param_2,&local_30,1);
}
bVar2 = true;
if (local_30 == param_4 || param_4 == 0) {
iVar1 = (**(code **)(*(long *)(param_1[0xd] + 0xc0) + 8))
(param_1[0xd],param_2,local_30,param_3,local_30,0);
bVar2 = iVar1 != 0;
}
return bVar2;
}
| |
23,915 | mysql_server_end | eloqsql/libmariadb/libmariadb/mariadb_lib.c | void STDCALL mysql_server_end(void)
{
if (!mysql_client_init)
return;
release_configuration_dirs();
mysql_client_plugin_deinit();
list_free(pvio_callback, 0);
if (ma_init_done)
ma_end(0);
#ifdef HAVE_TLS
ma_pvio_tls_end();
#endif
mysql_client_init= 0;
ma_init_done= 0;
#ifdef WIN32
init_once = (INIT_ONCE)INIT_ONCE_STATIC_INIT;
#else
init_once = (pthread_once_t)PTHREAD_ONCE_INIT;
#endif
} | O0 | c | mysql_server_end:
pushq %rbp
movq %rsp, %rbp
cmpb $0x0, 0x40469(%rip) # 0x68a14
jne 0x285af
jmp 0x28603
movb $0x0, %al
callq 0x4d580
movb $0x0, %al
callq 0x3c1d0
leaq 0x40454(%rip), %rax # 0x68a18
movq (%rax), %rdi
xorl %esi, %esi
callq 0x294f0
leaq 0x4044c(%rip), %rax # 0x68a21
cmpb $0x0, (%rax)
je 0x285e1
xorl %edi, %edi
callq 0x2bac0
movb $0x0, %al
callq 0x2aab0
movb $0x0, 0x40425(%rip) # 0x68a14
leaq 0x4042b(%rip), %rax # 0x68a21
movb $0x0, (%rax)
movl $0x0, 0x4040d(%rip) # 0x68a10
popq %rbp
retq
nopw %cs:(%rax,%rax)
| mysql_server_end:
push rbp
mov rbp, rsp
cmp cs:mysql_client_init, 0
jnz short loc_285AF
jmp short loc_28603
loc_285AF:
mov al, 0
call release_configuration_dirs
mov al, 0
call mysql_client_plugin_deinit
lea rax, pvio_callback
mov rdi, [rax]
xor esi, esi
call list_free
lea rax, ma_init_done
cmp byte ptr [rax], 0
jz short loc_285E1
xor edi, edi
call ma_end
loc_285E1:
mov al, 0
call ma_pvio_tls_end
mov cs:mysql_client_init, 0
lea rax, ma_init_done
mov byte ptr [rax], 0
mov cs:init_once, 0
loc_28603:
pop rbp
retn
| void *mysql_server_end()
{
void *result; // rax
if ( mysql_client_init )
{
release_configuration_dirs();
mysql_client_plugin_deinit();
list_free(pvio_callback, 0LL);
if ( ma_init_done )
ma_end(0LL);
ma_pvio_tls_end();
mysql_client_init = 0;
result = &ma_init_done;
ma_init_done = 0;
init_once = 0;
}
return result;
}
| mysql_server_end:
PUSH RBP
MOV RBP,RSP
CMP byte ptr [0x00168a14],0x0
JNZ 0x001285af
JMP 0x00128603
LAB_001285af:
MOV AL,0x0
CALL 0x0014d580
MOV AL,0x0
CALL 0x0013c1d0
LEA RAX,[0x168a18]
MOV RDI,qword ptr [RAX]
XOR ESI,ESI
CALL 0x001294f0
LEA RAX,[0x168a21]
CMP byte ptr [RAX],0x0
JZ 0x001285e1
XOR EDI,EDI
CALL 0x0012bac0
LAB_001285e1:
MOV AL,0x0
CALL 0x0012aab0
MOV byte ptr [0x00168a14],0x0
LEA RAX,[0x168a21]
MOV byte ptr [RAX],0x0
MOV dword ptr [0x00168a10],0x0
LAB_00128603:
POP RBP
RET
|
void mysql_server_end(void)
{
if (mysql_client_init != '\0') {
release_configuration_dirs();
mysql_client_plugin_deinit();
list_free(pvio_callback,0);
if (ma_init_done != '\0') {
ma_end(0);
}
ma_pvio_tls_end();
mysql_client_init = '\0';
ma_init_done = '\0';
init_once = 0;
}
return;
}
| |
23,916 | ftxui::InputOption::Default() | Andrewchistyakov[P]flashcards_lyc/build_O2/_deps/ftxui-src/src/ftxui/component/component_options.cpp | InputOption InputOption::Default() {
InputOption option;
option.transform = [](InputState state) {
state.element |= color(Color::White);
if (state.is_placeholder) {
state.element |= dim;
}
if (state.focused) {
state.element |= inverted;
} else if (state.hovered) {
state.element |= bgcolor(Color::GrayDark);
}
return state.element;
};
return option;
} | O2 | cpp | ftxui::InputOption::Default():
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x2d3be
movups 0x50(%rbx), %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movups 0x60(%rbx), %xmm0
leaq 0x109b(%rip), %rax # 0x2cff4
movq %rax, 0x60(%rbx)
movaps %xmm0, 0x10(%rdi)
leaq 0xf10(%rip), %rax # 0x2ce78
movq %rax, 0x68(%rbx)
callq 0x13b10
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
| _ZN5ftxui11InputOption7DefaultEv:
push rbx
sub rsp, 20h
mov rbx, rdi
call _ZN5ftxui11InputOptionC2Ev; ftxui::InputOption::InputOption(void)
movups xmm0, xmmword ptr [rbx+50h]
mov rdi, rsp; this
movaps xmmword ptr [rdi], xmm0
xorps xmm0, xmm0
movups xmmword ptr [rbx+50h], xmm0
movups xmm0, xmmword ptr [rbx+60h]
lea rax, _ZNSt17_Function_handlerIFSt10shared_ptrIN5ftxui4NodeEENS1_10InputStateEEZNS1_11InputOption7DefaultEvE3$_0E10_M_managerERSt9_Any_dataRKS9_St18_Manager_operation; std::_Function_handler<std::shared_ptr<ftxui::Node> ()(ftxui::InputState),ftxui::InputOption::Default(void)::$_0>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rbx+60h], rax
movaps xmmword ptr [rdi+10h], xmm0
lea rax, _ZNSt17_Function_handlerIFSt10shared_ptrIN5ftxui4NodeEENS1_10InputStateEEZNS1_11InputOption7DefaultEvE3$_0E9_M_invokeERKSt9_Any_dataOS4_; std::_Function_handler<std::shared_ptr<ftxui::Node> ()(ftxui::InputState),ftxui::InputOption::Default(void)::$_0>::_M_invoke(std::_Any_data const&,ftxui::InputState&&)
mov [rbx+68h], rax
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
mov rax, rbx
add rsp, 20h
pop rbx
retn
| ftxui::InputOption * ftxui::InputOption::Default(ftxui::InputOption *this)
{
__int128 v1; // xmm0
_OWORD v3[2]; // [rsp+0h] [rbp-28h] BYREF
ftxui::InputOption::InputOption(this);
v3[0] = *((_OWORD *)this + 5);
*((_OWORD *)this + 5) = 0LL;
v1 = *((_OWORD *)this + 6);
*((_QWORD *)this + 12) = std::_Function_handler<std::shared_ptr<ftxui::Node> ()(ftxui::InputState),ftxui::InputOption::Default(void)::$_0>::_M_manager;
v3[1] = v1;
*((_QWORD *)this + 13) = std::_Function_handler<std::shared_ptr<ftxui::Node> ()(ftxui::InputState),ftxui::InputOption::Default(void)::$_0>::_M_invoke;
std::_Function_base::~_Function_base((std::_Function_base *)v3);
return this;
}
| Default:
PUSH RBX
SUB RSP,0x20
MOV RBX,RDI
CALL 0x0012d3be
MOVUPS XMM0,xmmword ptr [RBX + 0x50]
MOV RDI,RSP
MOVAPS xmmword ptr [RDI],XMM0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x50],XMM0
MOVUPS XMM0,xmmword ptr [RBX + 0x60]
LEA RAX,[0x12cff4]
MOV qword ptr [RBX + 0x60],RAX
MOVAPS xmmword ptr [RDI + 0x10],XMM0
LEA RAX,[0x12ce78]
MOV qword ptr [RBX + 0x68],RAX
CALL 0x00113b10
MOV RAX,RBX
ADD RSP,0x20
POP RBX
RET
|
/* ftxui::InputOption::Default() */
InputOption * __thiscall ftxui::InputOption::Default(InputOption *this)
{
int8 local_28;
int8 uStack_20;
int8 local_18;
int8 uStack_10;
InputOption(this);
local_28 = *(int8 *)(this + 0x50);
uStack_20 = *(int8 *)(this + 0x58);
*(int8 *)(this + 0x50) = 0;
*(int8 *)(this + 0x58) = 0;
local_18 = *(int8 *)(this + 0x60);
uStack_10 = *(int8 *)(this + 0x68);
*(code **)(this + 0x60) =
std::
_Function_handler<std::shared_ptr<ftxui::Node>(ftxui::InputState),ftxui::InputOption::Default()::$_0>
::_M_manager;
*(code **)(this + 0x68) =
std::
_Function_handler<std::shared_ptr<ftxui::Node>(ftxui::InputState),ftxui::InputOption::Default()::$_0>
::_M_invoke;
std::_Function_base::~_Function_base((_Function_base *)&local_28);
return this;
}
| |
23,917 | string_parse_kv_override(char const*, std::vector<llama_model_kv_override, std::allocator<llama_model_kv_override>>&) | monkey531[P]llama/common/common.cpp | bool string_parse_kv_override(const char * data, std::vector<llama_model_kv_override> & overrides) {
const char * sep = strchr(data, '=');
if (sep == nullptr || sep - data >= 128) {
LOG_ERR("%s: malformed KV override '%s'\n", __func__, data);
return false;
}
llama_model_kv_override kvo;
std::strncpy(kvo.key, data, sep - data);
kvo.key[sep - data] = 0;
sep++;
if (strncmp(sep, "int:", 4) == 0) {
sep += 4;
kvo.tag = LLAMA_KV_OVERRIDE_TYPE_INT;
kvo.val_i64 = std::atol(sep);
} else if (strncmp(sep, "float:", 6) == 0) {
sep += 6;
kvo.tag = LLAMA_KV_OVERRIDE_TYPE_FLOAT;
kvo.val_f64 = std::atof(sep);
} else if (strncmp(sep, "bool:", 5) == 0) {
sep += 5;
kvo.tag = LLAMA_KV_OVERRIDE_TYPE_BOOL;
if (std::strcmp(sep, "true") == 0) {
kvo.val_bool = true;
} else if (std::strcmp(sep, "false") == 0) {
kvo.val_bool = false;
} else {
LOG_ERR("%s: invalid boolean value for KV override '%s'\n", __func__, data);
return false;
}
} else if (strncmp(sep, "str:", 4) == 0) {
sep += 4;
kvo.tag = LLAMA_KV_OVERRIDE_TYPE_STR;
if (strlen(sep) > 127) {
LOG_ERR("%s: malformed KV override '%s', value cannot exceed 127 chars\n", __func__, data);
return false;
}
strncpy(kvo.val_str, sep, 127);
kvo.val_str[127] = '\0';
} else {
LOG_ERR("%s: invalid type for KV override '%s'\n", __func__, data);
return false;
}
overrides.emplace_back(std::move(kvo));
return true;
} | O0 | cpp | string_parse_kv_override(char const*, std::vector<llama_model_kv_override, std::allocator<llama_model_kv_override>>&):
subq $0x128, %rsp # imm = 0x128
movq %rdi, 0x118(%rsp)
movq %rsi, 0x110(%rsp)
movq 0x118(%rsp), %rdi
movl $0x3d, %esi
callq 0x5a9b0
movq %rax, 0x108(%rsp)
cmpq $0x0, 0x108(%rsp)
je 0xeec47
movq 0x108(%rsp), %rax
movq 0x118(%rsp), %rcx
subq %rcx, %rax
cmpq $0x80, %rax
jl 0xeec8f
jmp 0xeec49
xorl %eax, %eax
leaq 0x1b59c6(%rip), %rcx # 0x2a4618
cmpl (%rcx), %eax
jg 0xeec80
callq 0x1bf360
movq %rax, %rdi
movq 0x118(%rsp), %r8
movl $0x4, %esi
leaq 0x121a38(%rip), %rdx # 0x2106aa
leaq 0x121a51(%rip), %rcx # 0x2106ca
movb $0x0, %al
callq 0x1bf450
jmp 0xeec82
movb $0x0, 0x127(%rsp)
jmp 0xeef7c
movq %rsp, %rdi
addq $0x4, %rdi
movq 0x118(%rsp), %rsi
movq 0x108(%rsp), %rdx
movq 0x118(%rsp), %rax
subq %rax, %rdx
callq 0x5a280
movq 0x108(%rsp), %rax
movq 0x118(%rsp), %rcx
subq %rcx, %rax
movb $0x0, 0x4(%rsp,%rax)
movq 0x108(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x108(%rsp)
movq 0x108(%rsp), %rdi
leaq 0x1219f2(%rip), %rsi # 0x2106e3
movl $0x4, %edx
callq 0x5a400
cmpl $0x0, %eax
jne 0xeed35
movq 0x108(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x108(%rsp)
movl $0x0, (%rsp)
movq 0x108(%rsp), %rdi
callq 0x5aad0
movq %rax, 0x88(%rsp)
jmp 0xeef64
movq 0x108(%rsp), %rdi
leaq 0x1219a4(%rip), %rsi # 0x2106e8
movl $0x6, %edx
callq 0x5a400
cmpl $0x0, %eax
jne 0xeed89
movq 0x108(%rsp), %rax
addq $0x6, %rax
movq %rax, 0x108(%rsp)
movl $0x1, (%rsp)
movq 0x108(%rsp), %rdi
callq 0x5aed0
movsd %xmm0, 0x88(%rsp)
jmp 0xeef62
movq 0x108(%rsp), %rdi
leaq 0x121957(%rip), %rsi # 0x2106ef
movl $0x5, %edx
callq 0x5a400
cmpl $0x0, %eax
jne 0xeee5b
movq 0x108(%rsp), %rax
addq $0x5, %rax
movq %rax, 0x108(%rsp)
movl $0x2, (%rsp)
movq 0x108(%rsp), %rdi
leaq 0x119301(%rip), %rsi # 0x2080d6
callq 0x5aee0
cmpl $0x0, %eax
jne 0xeede9
movb $0x1, 0x88(%rsp)
jmp 0xeee56
movq 0x108(%rsp), %rdi
leaq 0x11bfc7(%rip), %rsi # 0x20adbf
callq 0x5aee0
cmpl $0x0, %eax
jne 0xeee0c
movb $0x0, 0x88(%rsp)
jmp 0xeee54
jmp 0xeee0e
xorl %eax, %eax
leaq 0x1b5801(%rip), %rcx # 0x2a4618
cmpl (%rcx), %eax
jg 0xeee45
callq 0x1bf360
movq %rax, %rdi
movq 0x118(%rsp), %r8
movl $0x4, %esi
leaq 0x1218be(%rip), %rdx # 0x2106f5
leaq 0x12188c(%rip), %rcx # 0x2106ca
movb $0x0, %al
callq 0x1bf450
jmp 0xeee47
movb $0x0, 0x127(%rsp)
jmp 0xeef7c
jmp 0xeee56
jmp 0xeef60
movq 0x108(%rsp), %rdi
leaq 0x1218bb(%rip), %rsi # 0x210725
movl $0x4, %edx
callq 0x5a400
cmpl $0x0, %eax
jne 0xeef19
movq 0x108(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x108(%rsp)
movl $0x3, (%rsp)
movq 0x108(%rsp), %rdi
callq 0x5a6d0
cmpq $0x7f, %rax
jbe 0xeeef3
jmp 0xeeead
xorl %eax, %eax
leaq 0x1b5762(%rip), %rcx # 0x2a4618
cmpl (%rcx), %eax
jg 0xeeee4
callq 0x1bf360
movq %rax, %rdi
movq 0x118(%rsp), %r8
movl $0x4, %esi
leaq 0x121854(%rip), %rdx # 0x21072a
leaq 0x1217ed(%rip), %rcx # 0x2106ca
movb $0x0, %al
callq 0x1bf450
jmp 0xeeee6
movb $0x0, 0x127(%rsp)
jmp 0xeef7c
movq %rsp, %rdi
addq $0x88, %rdi
movq 0x108(%rsp), %rsi
movl $0x7f, %edx
callq 0x5a280
movb $0x0, 0x107(%rsp)
jmp 0xeef5e
jmp 0xeef1b
xorl %eax, %eax
leaq 0x1b56f4(%rip), %rcx # 0x2a4618
cmpl (%rcx), %eax
jg 0xeef52
callq 0x1bf360
movq %rax, %rdi
movq 0x118(%rsp), %r8
movl $0x4, %esi
leaq 0x121825(%rip), %rdx # 0x210769
leaq 0x12177f(%rip), %rcx # 0x2106ca
movb $0x0, %al
callq 0x1bf450
jmp 0xeef54
movb $0x0, 0x127(%rsp)
jmp 0xeef7c
jmp 0xeef60
jmp 0xeef62
jmp 0xeef64
movq 0x110(%rsp), %rdi
movq %rsp, %rsi
callq 0xf8920
movb $0x1, 0x127(%rsp)
movb 0x127(%rsp), %al
andb $0x1, %al
addq $0x128, %rsp # imm = 0x128
retq
nopl (%rax)
| _Z24string_parse_kv_overridePKcRSt6vectorI23llama_model_kv_overrideSaIS2_EE:
sub rsp, 128h
mov [rsp+128h+var_10], rdi
mov [rsp+128h+var_18], rsi
mov rdi, [rsp+128h+var_10]
mov esi, 3Dh ; '='
call _strchr
mov [rsp+128h+var_20], rax
cmp [rsp+128h+var_20], 0
jz short loc_EEC47
mov rax, [rsp+128h+var_20]
mov rcx, [rsp+128h+var_10]
sub rax, rcx
cmp rax, 80h
jl short loc_EEC8F
loc_EEC47:
jmp short $+2
loc_EEC49:
xor eax, eax
lea rcx, common_log_verbosity_thold
cmp eax, [rcx]
jg short loc_EEC80
call _Z15common_log_mainv; common_log_main(void)
mov rdi, rax
mov r8, [rsp+128h+var_10]
mov esi, 4
lea rdx, aSMalformedKvOv; "%s: malformed KV override '%s'\n"
lea rcx, aStringParseKvO; "string_parse_kv_override"
mov al, 0
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
loc_EEC80:
jmp short $+2
loc_EEC82:
mov [rsp+128h+var_1], 0
jmp loc_EEF7C
loc_EEC8F:
mov rdi, rsp
add rdi, 4
mov rsi, [rsp+128h+var_10]
mov rdx, [rsp+128h+var_20]
mov rax, [rsp+128h+var_10]
sub rdx, rax
call _strncpy
mov rax, [rsp+128h+var_20]
mov rcx, [rsp+128h+var_10]
sub rax, rcx
mov [rsp+rax+128h+var_124], 0
mov rax, [rsp+128h+var_20]
add rax, 1
mov [rsp+128h+var_20], rax
mov rdi, [rsp+128h+var_20]
lea rsi, aInt; "int:"
mov edx, 4
call _strncmp
cmp eax, 0
jnz short loc_EED35
mov rax, [rsp+128h+var_20]
add rax, 4
mov [rsp+128h+var_20], rax
mov [rsp+128h+var_128], 0
mov rdi, [rsp+128h+var_20]
call _atol
mov [rsp+128h+var_A0], rax
jmp loc_EEF64
loc_EED35:
mov rdi, [rsp+128h+var_20]
lea rsi, aFloat; "float:"
mov edx, 6
call _strncmp
cmp eax, 0
jnz short loc_EED89
mov rax, [rsp+128h+var_20]
add rax, 6
mov [rsp+128h+var_20], rax
mov [rsp+128h+var_128], 1
mov rdi, [rsp+128h+var_20]
call _atof
movsd [rsp+128h+var_A0], xmm0
jmp loc_EEF62
loc_EED89:
mov rdi, [rsp+128h+var_20]
lea rsi, aBool; "bool:"
mov edx, 5
call _strncmp
cmp eax, 0
jnz loc_EEE5B
mov rax, [rsp+128h+var_20]
add rax, 5
mov [rsp+128h+var_20], rax
mov [rsp+128h+var_128], 2
mov rdi, [rsp+128h+var_20]
lea rsi, aTrue; "true"
call _strcmp
cmp eax, 0
jnz short loc_EEDE9
mov byte ptr [rsp+128h+var_A0], 1
jmp short loc_EEE56
loc_EEDE9:
mov rdi, [rsp+128h+var_20]
lea rsi, aAdvancedOption+0ABh; "false"
call _strcmp
cmp eax, 0
jnz short loc_EEE0C
mov byte ptr [rsp+128h+var_A0], 0
jmp short loc_EEE54
loc_EEE0C:
jmp short $+2
loc_EEE0E:
xor eax, eax
lea rcx, common_log_verbosity_thold
cmp eax, [rcx]
jg short loc_EEE45
call _Z15common_log_mainv; common_log_main(void)
mov rdi, rax
mov r8, [rsp+128h+var_10]
mov esi, 4
lea rdx, aSInvalidBoolea; "%s: invalid boolean value for KV overri"...
lea rcx, aStringParseKvO; "string_parse_kv_override"
mov al, 0
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
loc_EEE45:
jmp short $+2
loc_EEE47:
mov [rsp+128h+var_1], 0
jmp loc_EEF7C
loc_EEE54:
jmp short $+2
loc_EEE56:
jmp loc_EEF60
loc_EEE5B:
mov rdi, [rsp+128h+var_20]
lea rsi, aStr; "str:"
mov edx, 4
call _strncmp
cmp eax, 0
jnz loc_EEF19
mov rax, [rsp+128h+var_20]
add rax, 4
mov [rsp+128h+var_20], rax
mov [rsp+128h+var_128], 3
mov rdi, [rsp+128h+var_20]
call _strlen
cmp rax, 7Fh
jbe short loc_EEEF3
jmp short $+2
loc_EEEAD:
xor eax, eax
lea rcx, common_log_verbosity_thold
cmp eax, [rcx]
jg short loc_EEEE4
call _Z15common_log_mainv; common_log_main(void)
mov rdi, rax
mov r8, [rsp+128h+var_10]
mov esi, 4
lea rdx, aSMalformedKvOv_0; "%s: malformed KV override '%s', value c"...
lea rcx, aStringParseKvO; "string_parse_kv_override"
mov al, 0
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
loc_EEEE4:
jmp short $+2
loc_EEEE6:
mov [rsp+128h+var_1], 0
jmp loc_EEF7C
loc_EEEF3:
mov rdi, rsp
add rdi, 88h
mov rsi, [rsp+128h+var_20]
mov edx, 7Fh
call _strncpy
mov [rsp+128h+var_21], 0
jmp short loc_EEF5E
loc_EEF19:
jmp short $+2
loc_EEF1B:
xor eax, eax
lea rcx, common_log_verbosity_thold
cmp eax, [rcx]
jg short loc_EEF52
call _Z15common_log_mainv; common_log_main(void)
mov rdi, rax
mov r8, [rsp+128h+var_10]
mov esi, 4
lea rdx, aSInvalidTypeFo; "%s: invalid type for KV override '%s'\n"
lea rcx, aStringParseKvO; "string_parse_kv_override"
mov al, 0
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
loc_EEF52:
jmp short $+2
loc_EEF54:
mov [rsp+128h+var_1], 0
jmp short loc_EEF7C
loc_EEF5E:
jmp short $+2
loc_EEF60:
jmp short $+2
loc_EEF62:
jmp short $+2
loc_EEF64:
mov rdi, [rsp+128h+var_18]
mov rsi, rsp
call _ZNSt6vectorI23llama_model_kv_overrideSaIS0_EE12emplace_backIJS0_EEERS0_DpOT_; std::vector<llama_model_kv_override>::emplace_back<llama_model_kv_override>(llama_model_kv_override &&)
mov [rsp+128h+var_1], 1
loc_EEF7C:
mov al, [rsp+128h+var_1]
and al, 1
add rsp, 128h
retn
| char string_parse_kv_override(long long a1, long long a2)
{
int v2; // eax
int v3; // r9d
int v4; // eax
int v5; // r9d
int v6; // eax
int v7; // r9d
int v8; // eax
int v9; // r9d
int v11; // [rsp+0h] [rbp-128h] BYREF
_BYTE v12[132]; // [rsp+4h] [rbp-124h] BYREF
long long v13[15]; // [rsp+88h] [rbp-A0h] BYREF
char v14; // [rsp+107h] [rbp-21h]
long long v15; // [rsp+108h] [rbp-20h]
long long v16; // [rsp+110h] [rbp-18h]
long long v17; // [rsp+118h] [rbp-10h]
v17 = a1;
v16 = a2;
v15 = strchr(a1, 61LL);
if ( !v15 || v15 - v17 >= 128 )
{
if ( common_log_verbosity_thold >= 0 )
{
v2 = common_log_main();
common_log_add(
v2,
4,
(unsigned int)"%s: malformed KV override '%s'\n",
(unsigned int)"string_parse_kv_override",
v17,
v3);
}
return 0;
}
strncpy(v12, v17, v15 - v17);
v12[v15 - v17] = 0;
if ( !(unsigned int)strncmp(++v15, "int:", 4LL) )
{
v15 += 4LL;
v11 = 0;
v13[0] = atol(v15);
LABEL_27:
std::vector<llama_model_kv_override>::emplace_back<llama_model_kv_override>(v16, &v11);
return 1;
}
if ( !(unsigned int)strncmp(v15, "float:", 6LL) )
{
v15 += 6LL;
v11 = 1;
v13[0] = atof(v15);
goto LABEL_27;
}
if ( !(unsigned int)strncmp(v15, "bool:", 5LL) )
{
v15 += 5LL;
v11 = 2;
if ( !(unsigned int)strcmp(v15, "true") )
{
LOBYTE(v13[0]) = 1;
goto LABEL_27;
}
if ( !(unsigned int)strcmp(v15, "false") )
{
LOBYTE(v13[0]) = 0;
goto LABEL_27;
}
if ( common_log_verbosity_thold >= 0 )
{
v4 = common_log_main();
common_log_add(
v4,
4,
(unsigned int)"%s: invalid boolean value for KV override '%s'\n",
(unsigned int)"string_parse_kv_override",
v17,
v5);
}
return 0;
}
else if ( !(unsigned int)strncmp(v15, "str:", 4LL) )
{
v15 += 4LL;
v11 = 3;
if ( (unsigned long long)strlen(v15) <= 0x7F )
{
strncpy(v13, v15, 127LL);
v14 = 0;
goto LABEL_27;
}
if ( common_log_verbosity_thold >= 0 )
{
v6 = common_log_main();
common_log_add(
v6,
4,
(unsigned int)"%s: malformed KV override '%s', value cannot exceed 127 chars\n",
(unsigned int)"string_parse_kv_override",
v17,
v7);
}
return 0;
}
else
{
if ( common_log_verbosity_thold >= 0 )
{
v8 = common_log_main();
common_log_add(
v8,
4,
(unsigned int)"%s: invalid type for KV override '%s'\n",
(unsigned int)"string_parse_kv_override",
v17,
v9);
}
return 0;
}
}
| string_parse_kv_override:
SUB RSP,0x128
MOV qword ptr [RSP + 0x118],RDI
MOV qword ptr [RSP + 0x110],RSI
MOV RDI,qword ptr [RSP + 0x118]
MOV ESI,0x3d
CALL 0x0015a9b0
MOV qword ptr [RSP + 0x108],RAX
CMP qword ptr [RSP + 0x108],0x0
JZ 0x001eec47
MOV RAX,qword ptr [RSP + 0x108]
MOV RCX,qword ptr [RSP + 0x118]
SUB RAX,RCX
CMP RAX,0x80
JL 0x001eec8f
LAB_001eec47:
JMP 0x001eec49
LAB_001eec49:
XOR EAX,EAX
LEA RCX,[0x3a4618]
CMP EAX,dword ptr [RCX]
JG 0x001eec80
CALL 0x002bf360
MOV RDI,RAX
MOV R8,qword ptr [RSP + 0x118]
MOV ESI,0x4
LEA RDX,[0x3106aa]
LEA RCX,[0x3106ca]
MOV AL,0x0
CALL 0x002bf450
LAB_001eec80:
JMP 0x001eec82
LAB_001eec82:
MOV byte ptr [RSP + 0x127],0x0
JMP 0x001eef7c
LAB_001eec8f:
MOV RDI,RSP
ADD RDI,0x4
MOV RSI,qword ptr [RSP + 0x118]
MOV RDX,qword ptr [RSP + 0x108]
MOV RAX,qword ptr [RSP + 0x118]
SUB RDX,RAX
CALL 0x0015a280
MOV RAX,qword ptr [RSP + 0x108]
MOV RCX,qword ptr [RSP + 0x118]
SUB RAX,RCX
MOV byte ptr [RSP + RAX*0x1 + 0x4],0x0
MOV RAX,qword ptr [RSP + 0x108]
ADD RAX,0x1
MOV qword ptr [RSP + 0x108],RAX
MOV RDI,qword ptr [RSP + 0x108]
LEA RSI,[0x3106e3]
MOV EDX,0x4
CALL 0x0015a400
CMP EAX,0x0
JNZ 0x001eed35
MOV RAX,qword ptr [RSP + 0x108]
ADD RAX,0x4
MOV qword ptr [RSP + 0x108],RAX
MOV dword ptr [RSP],0x0
MOV RDI,qword ptr [RSP + 0x108]
CALL 0x0015aad0
MOV qword ptr [RSP + 0x88],RAX
JMP 0x001eef64
LAB_001eed35:
MOV RDI,qword ptr [RSP + 0x108]
LEA RSI,[0x3106e8]
MOV EDX,0x6
CALL 0x0015a400
CMP EAX,0x0
JNZ 0x001eed89
MOV RAX,qword ptr [RSP + 0x108]
ADD RAX,0x6
MOV qword ptr [RSP + 0x108],RAX
MOV dword ptr [RSP],0x1
MOV RDI,qword ptr [RSP + 0x108]
CALL 0x0015aed0
MOVSD qword ptr [RSP + 0x88],XMM0
JMP 0x001eef62
LAB_001eed89:
MOV RDI,qword ptr [RSP + 0x108]
LEA RSI,[0x3106ef]
MOV EDX,0x5
CALL 0x0015a400
CMP EAX,0x0
JNZ 0x001eee5b
MOV RAX,qword ptr [RSP + 0x108]
ADD RAX,0x5
MOV qword ptr [RSP + 0x108],RAX
MOV dword ptr [RSP],0x2
MOV RDI,qword ptr [RSP + 0x108]
LEA RSI,[0x3080d6]
CALL 0x0015aee0
CMP EAX,0x0
JNZ 0x001eede9
MOV byte ptr [RSP + 0x88],0x1
JMP 0x001eee56
LAB_001eede9:
MOV RDI,qword ptr [RSP + 0x108]
LEA RSI,[0x30adbf]
CALL 0x0015aee0
CMP EAX,0x0
JNZ 0x001eee0c
MOV byte ptr [RSP + 0x88],0x0
JMP 0x001eee54
LAB_001eee0c:
JMP 0x001eee0e
LAB_001eee0e:
XOR EAX,EAX
LEA RCX,[0x3a4618]
CMP EAX,dword ptr [RCX]
JG 0x001eee45
CALL 0x002bf360
MOV RDI,RAX
MOV R8,qword ptr [RSP + 0x118]
MOV ESI,0x4
LEA RDX,[0x3106f5]
LEA RCX,[0x3106ca]
MOV AL,0x0
CALL 0x002bf450
LAB_001eee45:
JMP 0x001eee47
LAB_001eee47:
MOV byte ptr [RSP + 0x127],0x0
JMP 0x001eef7c
LAB_001eee54:
JMP 0x001eee56
LAB_001eee56:
JMP 0x001eef60
LAB_001eee5b:
MOV RDI,qword ptr [RSP + 0x108]
LEA RSI,[0x310725]
MOV EDX,0x4
CALL 0x0015a400
CMP EAX,0x0
JNZ 0x001eef19
MOV RAX,qword ptr [RSP + 0x108]
ADD RAX,0x4
MOV qword ptr [RSP + 0x108],RAX
MOV dword ptr [RSP],0x3
MOV RDI,qword ptr [RSP + 0x108]
CALL 0x0015a6d0
CMP RAX,0x7f
JBE 0x001eeef3
JMP 0x001eeead
LAB_001eeead:
XOR EAX,EAX
LEA RCX,[0x3a4618]
CMP EAX,dword ptr [RCX]
JG 0x001eeee4
CALL 0x002bf360
MOV RDI,RAX
MOV R8,qword ptr [RSP + 0x118]
MOV ESI,0x4
LEA RDX,[0x31072a]
LEA RCX,[0x3106ca]
MOV AL,0x0
CALL 0x002bf450
LAB_001eeee4:
JMP 0x001eeee6
LAB_001eeee6:
MOV byte ptr [RSP + 0x127],0x0
JMP 0x001eef7c
LAB_001eeef3:
MOV RDI,RSP
ADD RDI,0x88
MOV RSI,qword ptr [RSP + 0x108]
MOV EDX,0x7f
CALL 0x0015a280
MOV byte ptr [RSP + 0x107],0x0
JMP 0x001eef5e
LAB_001eef19:
JMP 0x001eef1b
LAB_001eef1b:
XOR EAX,EAX
LEA RCX,[0x3a4618]
CMP EAX,dword ptr [RCX]
JG 0x001eef52
CALL 0x002bf360
MOV RDI,RAX
MOV R8,qword ptr [RSP + 0x118]
MOV ESI,0x4
LEA RDX,[0x310769]
LEA RCX,[0x3106ca]
MOV AL,0x0
CALL 0x002bf450
LAB_001eef52:
JMP 0x001eef54
LAB_001eef54:
MOV byte ptr [RSP + 0x127],0x0
JMP 0x001eef7c
LAB_001eef5e:
JMP 0x001eef60
LAB_001eef60:
JMP 0x001eef62
LAB_001eef62:
JMP 0x001eef64
LAB_001eef64:
MOV RDI,qword ptr [RSP + 0x110]
MOV RSI,RSP
CALL 0x001f8920
MOV byte ptr [RSP + 0x127],0x1
LAB_001eef7c:
MOV AL,byte ptr [RSP + 0x127]
AND AL,0x1
ADD RSP,0x128
RET
|
/* string_parse_kv_override(char const*, std::vector<llama_model_kv_override,
std::allocator<llama_model_kv_override> >&) */
int1 string_parse_kv_override(char *param_1,vector *param_2)
{
int iVar1;
int8 uVar2;
size_t sVar3;
int4 local_128;
char acStack_124 [132];
double local_a0 [15];
int1 local_21;
char *local_20;
vector<llama_model_kv_override,std::allocator<llama_model_kv_override>> *local_18;
char *local_10;
local_18 = (vector<llama_model_kv_override,std::allocator<llama_model_kv_override>> *)param_2;
local_10 = param_1;
local_20 = strchr(param_1,0x3d);
if ((local_20 == (char *)0x0) || (0x7f < (long)local_20 - (long)local_10)) {
if (-1 < common_log_verbosity_thold) {
uVar2 = common_log_main();
common_log_add(uVar2,4,"%s: malformed KV override \'%s\'\n","string_parse_kv_override",
local_10);
}
return 0;
}
strncpy(acStack_124,local_10,(long)local_20 - (long)local_10);
local_20[(long)(acStack_124 + -(long)local_10)] = '\0';
local_20 = local_20 + 1;
iVar1 = strncmp(local_20,"int:",4);
if (iVar1 == 0) {
local_20 = local_20 + 4;
local_128 = 0;
local_a0[0] = (double)atol(local_20);
}
else {
iVar1 = strncmp(local_20,"float:",6);
if (iVar1 == 0) {
local_20 = local_20 + 6;
local_128 = 1;
local_a0[0] = atof(local_20);
}
else {
iVar1 = strncmp(local_20,"bool:",5);
if (iVar1 == 0) {
local_20 = local_20 + 5;
local_128 = 2;
iVar1 = strcmp(local_20,"true");
if (iVar1 == 0) {
local_a0[0] = (double)CONCAT71(local_a0[0]._1_7_,1);
}
else {
iVar1 = strcmp(local_20,"false");
if (iVar1 != 0) {
if (-1 < common_log_verbosity_thold) {
uVar2 = common_log_main();
common_log_add(uVar2,4,"%s: invalid boolean value for KV override \'%s\'\n",
"string_parse_kv_override",local_10);
}
return 0;
}
local_a0[0] = (double)((ulong)local_a0[0] & 0xffffffffffffff00);
}
}
else {
iVar1 = strncmp(local_20,"str:",4);
if (iVar1 != 0) {
if (-1 < common_log_verbosity_thold) {
uVar2 = common_log_main();
common_log_add(uVar2,4,"%s: invalid type for KV override \'%s\'\n",
"string_parse_kv_override",local_10);
}
return 0;
}
local_20 = local_20 + 4;
local_128 = 3;
sVar3 = strlen(local_20);
if (0x7f < sVar3) {
if (-1 < common_log_verbosity_thold) {
uVar2 = common_log_main();
common_log_add(uVar2,4,
"%s: malformed KV override \'%s\', value cannot exceed 127 chars\n",
"string_parse_kv_override",local_10);
}
return 0;
}
strncpy((char *)local_a0,local_20,0x7f);
local_21 = 0;
}
}
}
std::vector<llama_model_kv_override,std::allocator<llama_model_kv_override>>::
emplace_back<llama_model_kv_override>(local_18,(llama_model_kv_override *)&local_128);
return 1;
}
| |
23,918 | string_parse_kv_override(char const*, std::vector<llama_model_kv_override, std::allocator<llama_model_kv_override>>&) | monkey531[P]llama/common/common.cpp | bool string_parse_kv_override(const char * data, std::vector<llama_model_kv_override> & overrides) {
const char * sep = strchr(data, '=');
if (sep == nullptr || sep - data >= 128) {
LOG_ERR("%s: malformed KV override '%s'\n", __func__, data);
return false;
}
llama_model_kv_override kvo;
std::strncpy(kvo.key, data, sep - data);
kvo.key[sep - data] = 0;
sep++;
if (strncmp(sep, "int:", 4) == 0) {
sep += 4;
kvo.tag = LLAMA_KV_OVERRIDE_TYPE_INT;
kvo.val_i64 = std::atol(sep);
} else if (strncmp(sep, "float:", 6) == 0) {
sep += 6;
kvo.tag = LLAMA_KV_OVERRIDE_TYPE_FLOAT;
kvo.val_f64 = std::atof(sep);
} else if (strncmp(sep, "bool:", 5) == 0) {
sep += 5;
kvo.tag = LLAMA_KV_OVERRIDE_TYPE_BOOL;
if (std::strcmp(sep, "true") == 0) {
kvo.val_bool = true;
} else if (std::strcmp(sep, "false") == 0) {
kvo.val_bool = false;
} else {
LOG_ERR("%s: invalid boolean value for KV override '%s'\n", __func__, data);
return false;
}
} else if (strncmp(sep, "str:", 4) == 0) {
sep += 4;
kvo.tag = LLAMA_KV_OVERRIDE_TYPE_STR;
if (strlen(sep) > 127) {
LOG_ERR("%s: malformed KV override '%s', value cannot exceed 127 chars\n", __func__, data);
return false;
}
strncpy(kvo.val_str, sep, 127);
kvo.val_str[127] = '\0';
} else {
LOG_ERR("%s: invalid type for KV override '%s'\n", __func__, data);
return false;
}
overrides.emplace_back(std::move(kvo));
return true;
} | O2 | cpp | string_parse_kv_override(char const*, std::vector<llama_model_kv_override, std::allocator<llama_model_kv_override>>&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x3d
popq %rsi
callq 0x23310
testq %rax, %rax
je 0x5495b
movq %rax, %r15
movq %rax, %r12
subq %rbx, %r12
cmpq $0x80, %r12
jl 0x54995
leaq 0xaaaf6(%rip), %rax # 0xff458
cmpl $0x0, (%rax)
js 0x54b0d
callq 0x96692
leaq 0x5e36f(%rip), %rdx # 0xb2ce6
leaq 0x5e388(%rip), %rcx # 0xb2d06
xorl %ebp, %ebp
pushq $0x4
popq %rsi
movq %rax, %rdi
movq %rbx, %r8
xorl %eax, %eax
callq 0x9672a
jmp 0x54b0f
leaq 0xc(%rsp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x234a0
movb $0x0, 0xc(%rsp,%r12)
leaq 0x1(%r15), %r12
leaq 0x5e369(%rip), %rsi # 0xb2d1f
pushq $0x4
popq %rdx
movq %r12, %rdi
callq 0x23450
testl %eax, %eax
je 0x54a30
leaq 0x5e358(%rip), %rsi # 0xb2d24
pushq $0x6
popq %rdx
movq %r12, %rdi
callq 0x23450
testl %eax, %eax
je 0x54a4b
leaq 0x5e349(%rip), %rsi # 0xb2d2b
pushq $0x5
popq %rdx
movq %r12, %rdi
callq 0x23450
testl %eax, %eax
je 0x54a7d
leaq 0x5e365(%rip), %rsi # 0xb2d61
pushq $0x4
popq %rdx
movq %r12, %rdi
callq 0x23450
testl %eax, %eax
je 0x54ad4
leaq 0xaaa42(%rip), %rax # 0xff458
cmpl $0x0, (%rax)
js 0x54b0d
callq 0x96692
leaq 0x5e37a(%rip), %rdx # 0xb2da5
jmp 0x54977
addq $0x5, %r15
andl $0x0, 0x8(%rsp)
movq %r15, %rdi
callq 0x23a90
movq %rax, 0x90(%rsp)
jmp 0x54a68
addq $0x7, %r15
movl $0x1, 0x8(%rsp)
movq %r15, %rdi
callq 0x23af0
movsd %xmm0, 0x90(%rsp)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x58958
movb $0x1, %bpl
jmp 0x54b0f
addq $0x6, %r15
movl $0x2, 0x8(%rsp)
leaq 0x5614a(%rip), %rsi # 0xaabda
movq %r15, %rdi
callq 0x23c80
testl %eax, %eax
je 0x54b21
leaq 0x58e1c(%rip), %rsi # 0xad8c3
movq %r15, %rdi
callq 0x23c80
testl %eax, %eax
je 0x54b4d
leaq 0xaa99a(%rip), %rax # 0xff458
cmpl $0x0, (%rax)
js 0x54b0d
callq 0x96692
leaq 0x5e262(%rip), %rdx # 0xb2d31
jmp 0x54977
addq $0x5, %r15
movl $0x3, 0x8(%rsp)
movq %r15, %rdi
callq 0x233f0
cmpq $0x80, %rax
jb 0x54b2e
leaq 0xaa961(%rip), %rax # 0xff458
cmpl $0x0, (%rax)
js 0x54b0d
callq 0x96692
leaq 0x5e25e(%rip), %rdx # 0xb2d66
jmp 0x54977
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, 0x90(%rsp)
jmp 0x54a68
leaq 0x90(%rsp), %rbx
pushq $0x7f
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x234a0
movb $0x0, 0x7f(%rbx)
jmp 0x54a68
movb $0x0, 0x90(%rsp)
jmp 0x54a68
| _Z24string_parse_kv_overridePKcRSt6vectorI23llama_model_kv_overrideSaIS2_EE:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 110h
mov r14, rsi
mov rbx, rdi
push 3Dh ; '='
pop rsi
call _strchr
test rax, rax
jz short loc_5495B
mov r15, rax
mov r12, rax
sub r12, rbx
cmp r12, 80h
jl short loc_54995
loc_5495B:
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js loc_54B0D
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aSMalformedKvOv; "%s: malformed KV override '%s'\n"
loc_54977:
lea rcx, aStringParseKvO; "string_parse_kv_override"
xor ebp, ebp
push 4
pop rsi
mov rdi, rax
mov r8, rbx
xor eax, eax
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
jmp loc_54B0F
loc_54995:
lea rdi, [rsp+138h+var_12C]
mov rsi, rbx
mov rdx, r12
call _strncpy
mov [rsp+r12+138h+var_12C], 0
lea r12, [r15+1]
lea rsi, aInt; "int:"
push 4
pop rdx
mov rdi, r12
call _strncmp
test eax, eax
jz short loc_54A30
lea rsi, aFloat; "float:"
push 6
pop rdx
mov rdi, r12
call _strncmp
test eax, eax
jz short loc_54A4B
lea rsi, aBool; "bool:"
push 5
pop rdx
mov rdi, r12
call _strncmp
test eax, eax
jz loc_54A7D
lea rsi, aStr; "str:"
push 4
pop rdx
mov rdi, r12
call _strncmp
test eax, eax
jz loc_54AD4
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js loc_54B0D
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aSInvalidTypeFo; "%s: invalid type for KV override '%s'\n"
jmp loc_54977
loc_54A30:
add r15, 5
and [rsp+138h+var_130], 0
mov rdi, r15
call _atol
mov [rsp+138h+var_A8], rax
jmp short loc_54A68
loc_54A4B:
add r15, 7
mov [rsp+138h+var_130], 1
mov rdi, r15
call _atof
movsd [rsp+138h+var_A8], xmm0
loc_54A68:
lea rsi, [rsp+138h+var_130]
mov rdi, r14
call _ZNSt6vectorI23llama_model_kv_overrideSaIS0_EE12emplace_backIJS0_EEERS0_DpOT_; std::vector<llama_model_kv_override>::emplace_back<llama_model_kv_override>(llama_model_kv_override &&)
mov bpl, 1
jmp loc_54B0F
loc_54A7D:
add r15, 6
mov [rsp+138h+var_130], 2
lea rsi, aTrue; "true"
mov rdi, r15
call _strcmp
test eax, eax
jz loc_54B21
lea rsi, aAdvancedOption+0ABh; "false"
mov rdi, r15
call _strcmp
test eax, eax
jz loc_54B4D
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js short loc_54B0D
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aSInvalidBoolea; "%s: invalid boolean value for KV overri"...
jmp loc_54977
loc_54AD4:
add r15, 5
mov [rsp+138h+var_130], 3
mov rdi, r15
call _strlen
cmp rax, 80h
jb short loc_54B2E
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js short loc_54B0D
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aSMalformedKvOv_0; "%s: malformed KV override '%s', value c"...
jmp loc_54977
loc_54B0D:
xor ebp, ebp
loc_54B0F:
mov eax, ebp
add rsp, 110h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_54B21:
mov byte ptr [rsp+138h+var_A8], 1
jmp loc_54A68
loc_54B2E:
lea rbx, [rsp+138h+var_A8]
push 7Fh
pop rdx
mov rdi, rbx
mov rsi, r15
call _strncpy
mov byte ptr [rbx+7Fh], 0
jmp loc_54A68
loc_54B4D:
mov byte ptr [rsp+138h+var_A8], 0
jmp loc_54A68
| long long string_parse_kv_override(long long a1, long long a2)
{
unsigned int v2; // ebp
long long v3; // rax
long long v4; // r15
long long v5; // r12
int v6; // eax
int v7; // r9d
const char *v8; // rdx
long long v9; // r15
long long v10; // r15
int v12; // [rsp+8h] [rbp-130h] BYREF
_BYTE v13[132]; // [rsp+Ch] [rbp-12Ch] BYREF
long long v14[15]; // [rsp+90h] [rbp-A8h] BYREF
char v15; // [rsp+10Fh] [rbp-29h]
v3 = strchr(a1, 61LL);
if ( v3 )
{
v4 = v3;
v5 = v3 - a1;
if ( v3 - a1 < 128 )
{
strncpy(v13, a1, v3 - a1);
v13[v5] = 0;
if ( !(unsigned int)strncmp(v4 + 1, "int:", 4LL) )
{
v12 = 0;
v14[0] = atol(v4 + 5);
}
else if ( !(unsigned int)strncmp(v4 + 1, "float:", 6LL) )
{
v12 = 1;
v14[0] = atof(v4 + 7);
}
else if ( !(unsigned int)strncmp(v4 + 1, "bool:", 5LL) )
{
v9 = v4 + 6;
v12 = 2;
if ( !(unsigned int)strcmp(v9) )
{
LOBYTE(v14[0]) = 1;
}
else
{
if ( (unsigned int)strcmp(v9) )
{
if ( common_log_verbosity_thold >= 0 )
{
v6 = common_log_main();
v8 = "%s: invalid boolean value for KV override '%s'\n";
goto LABEL_5;
}
return 0;
}
LOBYTE(v14[0]) = 0;
}
}
else
{
if ( (unsigned int)strncmp(v4 + 1, "str:", 4LL) )
{
if ( common_log_verbosity_thold >= 0 )
{
v6 = common_log_main();
v8 = "%s: invalid type for KV override '%s'\n";
goto LABEL_5;
}
return 0;
}
v10 = v4 + 5;
v12 = 3;
if ( (unsigned long long)strlen(v10) >= 0x80 )
{
if ( common_log_verbosity_thold >= 0 )
{
v6 = common_log_main();
v8 = "%s: malformed KV override '%s', value cannot exceed 127 chars\n";
goto LABEL_5;
}
return 0;
}
strncpy(v14, v10, 127LL);
v15 = 0;
}
std::vector<llama_model_kv_override>::emplace_back<llama_model_kv_override>(a2, &v12);
LOBYTE(v2) = 1;
return v2;
}
}
if ( common_log_verbosity_thold < 0 )
return 0;
v6 = common_log_main();
v8 = "%s: malformed KV override '%s'\n";
LABEL_5:
v2 = 0;
common_log_add(v6, 4, (_DWORD)v8, (unsigned int)"string_parse_kv_override", a1, v7);
return v2;
}
| string_parse_kv_override:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x110
MOV R14,RSI
MOV RBX,RDI
PUSH 0x3d
POP RSI
CALL 0x00123310
TEST RAX,RAX
JZ 0x0015495b
MOV R15,RAX
MOV R12,RAX
SUB R12,RBX
CMP R12,0x80
JL 0x00154995
LAB_0015495b:
LEA RAX,[0x1ff458]
CMP dword ptr [RAX],0x0
JS 0x00154b0d
CALL 0x00196692
LEA RDX,[0x1b2ce6]
LAB_00154977:
LEA RCX,[0x1b2d06]
XOR EBP,EBP
PUSH 0x4
POP RSI
MOV RDI,RAX
MOV R8,RBX
XOR EAX,EAX
CALL 0x0019672a
JMP 0x00154b0f
LAB_00154995:
LEA RDI,[RSP + 0xc]
MOV RSI,RBX
MOV RDX,R12
CALL 0x001234a0
MOV byte ptr [RSP + R12*0x1 + 0xc],0x0
LEA R12,[R15 + 0x1]
LEA RSI,[0x1b2d1f]
PUSH 0x4
POP RDX
MOV RDI,R12
CALL 0x00123450
TEST EAX,EAX
JZ 0x00154a30
LEA RSI,[0x1b2d24]
PUSH 0x6
POP RDX
MOV RDI,R12
CALL 0x00123450
TEST EAX,EAX
JZ 0x00154a4b
LEA RSI,[0x1b2d2b]
PUSH 0x5
POP RDX
MOV RDI,R12
CALL 0x00123450
TEST EAX,EAX
JZ 0x00154a7d
LEA RSI,[0x1b2d61]
PUSH 0x4
POP RDX
MOV RDI,R12
CALL 0x00123450
TEST EAX,EAX
JZ 0x00154ad4
LEA RAX,[0x1ff458]
CMP dword ptr [RAX],0x0
JS 0x00154b0d
CALL 0x00196692
LEA RDX,[0x1b2da5]
JMP 0x00154977
LAB_00154a30:
ADD R15,0x5
AND dword ptr [RSP + 0x8],0x0
MOV RDI,R15
CALL 0x00123a90
MOV qword ptr [RSP + 0x90],RAX
JMP 0x00154a68
LAB_00154a4b:
ADD R15,0x7
MOV dword ptr [RSP + 0x8],0x1
MOV RDI,R15
CALL 0x00123af0
MOVSD qword ptr [RSP + 0x90],XMM0
LAB_00154a68:
LEA RSI,[RSP + 0x8]
MOV RDI,R14
CALL 0x00158958
MOV BPL,0x1
JMP 0x00154b0f
LAB_00154a7d:
ADD R15,0x6
MOV dword ptr [RSP + 0x8],0x2
LEA RSI,[0x1aabda]
MOV RDI,R15
CALL 0x00123c80
TEST EAX,EAX
JZ 0x00154b21
LEA RSI,[0x1ad8c3]
MOV RDI,R15
CALL 0x00123c80
TEST EAX,EAX
JZ 0x00154b4d
LEA RAX,[0x1ff458]
CMP dword ptr [RAX],0x0
JS 0x00154b0d
CALL 0x00196692
LEA RDX,[0x1b2d31]
JMP 0x00154977
LAB_00154ad4:
ADD R15,0x5
MOV dword ptr [RSP + 0x8],0x3
MOV RDI,R15
CALL 0x001233f0
CMP RAX,0x80
JC 0x00154b2e
LEA RAX,[0x1ff458]
CMP dword ptr [RAX],0x0
JS 0x00154b0d
CALL 0x00196692
LEA RDX,[0x1b2d66]
JMP 0x00154977
LAB_00154b0d:
XOR EBP,EBP
LAB_00154b0f:
MOV EAX,EBP
ADD RSP,0x110
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00154b21:
MOV byte ptr [RSP + 0x90],0x1
JMP 0x00154a68
LAB_00154b2e:
LEA RBX,[RSP + 0x90]
PUSH 0x7f
POP RDX
MOV RDI,RBX
MOV RSI,R15
CALL 0x001234a0
MOV byte ptr [RBX + 0x7f],0x0
JMP 0x00154a68
LAB_00154b4d:
MOV byte ptr [RSP + 0x90],0x0
JMP 0x00154a68
|
/* string_parse_kv_override(char const*, std::vector<llama_model_kv_override,
std::allocator<llama_model_kv_override> >&) */
ulong string_parse_kv_override(char *param_1,vector *param_2)
{
char *__s1;
int iVar1;
char *pcVar2;
int8 uVar3;
int8 unaff_RBP;
ulong uVar4;
size_t sVar5;
int4 local_130;
char local_12c [132];
double local_a8 [15];
int1 local_29;
pcVar2 = strchr(param_1,0x3d);
if ((pcVar2 == (char *)0x0) || (sVar5 = (long)pcVar2 - (long)param_1, 0x7f < (long)sVar5)) {
if (common_log_verbosity_thold < 0) goto LAB_00154b0d;
uVar3 = common_log_main();
pcVar2 = "%s: malformed KV override \'%s\'\n";
goto LAB_00154977;
}
strncpy(local_12c,param_1,sVar5);
local_12c[sVar5] = '\0';
__s1 = pcVar2 + 1;
iVar1 = strncmp(__s1,"int:",4);
if (iVar1 == 0) {
local_130 = 0;
local_a8[0] = (double)atol(pcVar2 + 5);
}
else {
iVar1 = strncmp(__s1,"float:",6);
if (iVar1 == 0) {
local_130 = 1;
local_a8[0] = atof(pcVar2 + 7);
}
else {
iVar1 = strncmp(__s1,"bool:",5);
if (iVar1 != 0) {
iVar1 = strncmp(__s1,"str:",4);
if (iVar1 == 0) {
local_130 = 3;
sVar5 = strlen(pcVar2 + 5);
if (sVar5 < 0x80) {
strncpy((char *)local_a8,pcVar2 + 5,0x7f);
local_29 = 0;
goto LAB_00154a68;
}
if (common_log_verbosity_thold < 0) goto LAB_00154b0d;
uVar3 = common_log_main();
pcVar2 = "%s: malformed KV override \'%s\', value cannot exceed 127 chars\n";
}
else {
if (common_log_verbosity_thold < 0) {
LAB_00154b0d:
uVar4 = 0;
goto LAB_00154b0f;
}
uVar3 = common_log_main();
pcVar2 = "%s: invalid type for KV override \'%s\'\n";
}
LAB_00154977:
uVar4 = 0;
common_log_add(uVar3,4,pcVar2,"string_parse_kv_override",param_1);
goto LAB_00154b0f;
}
local_130 = 2;
iVar1 = strcmp(pcVar2 + 6,"true");
if (iVar1 == 0) {
local_a8[0] = (double)CONCAT71(local_a8[0]._1_7_,1);
}
else {
iVar1 = strcmp(pcVar2 + 6,"false");
if (iVar1 != 0) {
if (common_log_verbosity_thold < 0) goto LAB_00154b0d;
uVar3 = common_log_main();
pcVar2 = "%s: invalid boolean value for KV override \'%s\'\n";
goto LAB_00154977;
}
local_a8[0] = (double)((ulong)local_a8[0] & 0xffffffffffffff00);
}
}
}
LAB_00154a68:
std::vector<llama_model_kv_override,std::allocator<llama_model_kv_override>>::
emplace_back<llama_model_kv_override>
((vector<llama_model_kv_override,std::allocator<llama_model_kv_override>> *)param_2,
(llama_model_kv_override *)&local_130);
uVar4 = CONCAT71((int7)((ulong)unaff_RBP >> 8),1);
LAB_00154b0f:
return uVar4 & 0xffffffff;
}
| |
23,919 | do_outer_field_null(Copy_field*) | eloqsql/sql/field_conv.cc | static void do_outer_field_null(Copy_field *copy)
{
if (*copy->null_row ||
(copy->from_null_ptr && (*copy->from_null_ptr & copy->from_bit)))
{
*copy->to_null_ptr|=copy->to_bit;
copy->to_field->reset();
}
else
{
*copy->to_null_ptr&= ~copy->to_bit;
(copy->do_copy2)(copy);
}
} | O0 | cpp | do_outer_field_null(Copy_field*):
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
testb $0x1, (%rax)
jne 0x8ce42b
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x8ce454
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
movq -0x8(%rbp), %rcx
andl 0x28(%rcx), %eax
cmpl $0x0, %eax
je 0x8ce454
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movzbl (%rax), %ecx
orl %edx, %ecx
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
movq (%rdi), %rax
callq *0x160(%rax)
jmp 0x8ce47b
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %edx
xorl $-0x1, %edx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movzbl (%rax), %ecx
andl %edx, %ecx
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZL19do_outer_field_nullP10Copy_field:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax+20h]
test byte ptr [rax], 1
jnz short loc_8CE42B
mov rax, [rbp+var_8]
cmp qword ptr [rax+10h], 0
jz short loc_8CE454
mov rax, [rbp+var_8]
mov rax, [rax+10h]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_8]
and eax, [rcx+28h]
cmp eax, 0
jz short loc_8CE454
loc_8CE42B:
mov rax, [rbp+var_8]
mov edx, [rax+2Ch]
mov rax, [rbp+var_8]
mov rax, [rax+18h]
movzx ecx, byte ptr [rax]
or ecx, edx
mov [rax], cl
mov rax, [rbp+var_8]
mov rdi, [rax+40h]
mov rax, [rdi]
call qword ptr [rax+160h]
jmp short loc_8CE47B
loc_8CE454:
mov rax, [rbp+var_8]
mov edx, [rax+2Ch]
xor edx, 0FFFFFFFFh
mov rax, [rbp+var_8]
mov rax, [rax+18h]
movzx ecx, byte ptr [rax]
and ecx, edx
mov [rax], cl
mov rax, [rbp+var_8]
mov rax, [rax+70h]
mov rdi, [rbp+var_8]
call rax
loc_8CE47B:
add rsp, 10h
pop rbp
retn
| long long do_outer_field_null(Copy_field *a1)
{
if ( (**((_BYTE **)a1 + 4) & 1) != 0
|| *((_QWORD *)a1 + 2) && (*((_DWORD *)a1 + 10) & **((unsigned __int8 **)a1 + 2)) != 0 )
{
**((_BYTE **)a1 + 3) |= *((_DWORD *)a1 + 11);
return (*(long long ( **)(_QWORD))(**((_QWORD **)a1 + 8) + 352LL))(*((_QWORD *)a1 + 8));
}
else
{
**((_BYTE **)a1 + 3) &= ~*((_BYTE *)a1 + 44);
return (*((long long ( **)(Copy_field *))a1 + 14))(a1);
}
}
| ~Item_cache_year:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x008ceaa0
ADD RSP,0x10
POP RBP
RET
|
/* Item_cache_year::~Item_cache_year() */
void __thiscall Item_cache_year::~Item_cache_year(Item_cache_year *this)
{
Item_cache_int::~Item_cache_int((Item_cache_int *)this);
return;
}
| |
23,920 | host_get_block_hash | corpus-core[P]colibri-stateless/src/chains/eth/verifier/call_evmone.c | static evmc_bytes32 host_get_block_hash(void* context, int64_t number) {
evmone_context_t* ctx = (evmone_context_t*) context;
EVM_LOG("get_block_hash for block number: %zu", (size_t) number);
evmc_bytes32 result = {0};
// TODO: Implement block hash retrieval logic
debug_print_bytes32("get_block_hash result", &result);
return result;
} | O0 | c | host_get_block_hash:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x2bc12
movq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x23140
movq -0x28(%rbp), %rsi
leaq 0xaf8ba(%rip), %rdi # 0xdb4e7
callq 0x2b2b0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| host_get_block_hash:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov [rbp+var_20], rdi
mov [rbp+var_8], rsi
mov [rbp+var_10], rdx
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
jmp short $+2
loc_2BC12:
mov rdi, [rbp+var_28]
xor esi, esi
mov edx, 20h ; ' '
call _memset
mov rsi, [rbp+var_28]
lea rdi, aGetBlockHashRe; "get_block_hash result"
call debug_print_bytes32
mov rax, [rbp+var_20]
add rsp, 30h
pop rbp
retn
| long long host_get_block_hash(long long a1)
{
memset(a1, 0LL, 32LL);
debug_print_bytes32();
return a1;
}
| host_get_block_hash:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x20],RDI
MOV qword ptr [RBP + -0x8],RSI
MOV qword ptr [RBP + -0x10],RDX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0012bc12
LAB_0012bc12:
MOV RDI,qword ptr [RBP + -0x28]
XOR ESI,ESI
MOV EDX,0x20
CALL 0x00123140
MOV RSI,qword ptr [RBP + -0x28]
LEA RDI,[0x1db4e7]
CALL 0x0012b2b0
MOV RAX,qword ptr [RBP + -0x20]
ADD RSP,0x30
POP RBP
RET
|
void * host_get_block_hash(void *param_1)
{
memset(param_1,0,0x20);
debug_print_bytes32("get_block_hash result",param_1);
return param_1;
}
| |
23,921 | host_get_block_hash | corpus-core[P]colibri-stateless/src/chains/eth/verifier/call_evmone.c | static evmc_bytes32 host_get_block_hash(void* context, int64_t number) {
evmone_context_t* ctx = (evmone_context_t*) context;
EVM_LOG("get_block_hash for block number: %zu", (size_t) number);
evmc_bytes32 result = {0};
// TODO: Implement block hash retrieval logic
debug_print_bytes32("get_block_hash result", &result);
return result;
} | O3 | c | host_get_block_hash:
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
retq
| host_get_block_hash:
mov rax, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi+10h], xmm0
movups xmmword ptr [rdi], xmm0
retn
| _OWORD * host_get_block_hash(_OWORD *a1)
{
_OWORD *result; // rax
result = a1;
a1[1] = 0LL;
*a1 = 0LL;
return result;
}
| host_get_block_hash:
MOV RAX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOVUPS xmmword ptr [RDI],XMM0
RET
|
int8 * host_get_block_hash(int8 *param_1)
{
param_1[2] = 0;
param_1[3] = 0;
*param_1 = 0;
param_1[1] = 0;
return param_1;
}
| |
23,922 | minja::MacroTemplateToken::MacroTemplateToken(minja::Location const&, minja::SpaceHandling, minja::SpaceHandling, std::shared_ptr<minja::VariableExpr>&&, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<minja::Expression>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<minja::Expression>>>>&&) | monkey531[P]llama/common/minja.hpp | TemplateToken(Type type, const Location & location, SpaceHandling pre, SpaceHandling post) : type(type), location(location), pre_space(pre), post_space(post) {} | O1 | cpp | minja::MacroTemplateToken::MacroTemplateToken(minja::Location const&, minja::SpaceHandling, minja::SpaceHandling, std::shared_ptr<minja::VariableExpr>&&, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<minja::Expression>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<minja::Expression>>>>&&):
leaq 0x836af(%rip), %rax # 0xe31c8
addq $0x10, %rax
movq %rax, (%rdi)
movl $0xd, 0x8(%rdi)
movq (%rsi), %rax
movq %rax, 0x10(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x18(%rdi)
testq %rax, %rax
je 0x5fb51
movq 0x85456(%rip), %r10 # 0xe4f98
cmpb $0x0, (%r10)
je 0x5fb4d
incl 0x8(%rax)
jmp 0x5fb51
lock
incl 0x8(%rax)
movq 0x10(%rsi), %rax
movq %rax, 0x20(%rdi)
movl %edx, 0x28(%rdi)
movl %ecx, 0x2c(%rdi)
leaq 0x84292(%rip), %rax # 0xe3df8
addq $0x10, %rax
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x38(%rdi)
movups (%r8), %xmm0
movq %rax, 0x8(%r8)
movups %xmm0, 0x30(%rdi)
movq %rax, (%r8)
movups (%r9), %xmm0
movups %xmm0, 0x40(%rdi)
movq 0x10(%r9), %rcx
movq %rcx, 0x50(%rdi)
movq %rax, 0x10(%r9)
xorps %xmm0, %xmm0
movups %xmm0, (%r9)
retq
| _ZN5minja18MacroTemplateTokenC2ERKNS_8LocationENS_13SpaceHandlingES4_OSt10shared_ptrINS_12VariableExprEEOSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_INS_10ExpressionEEESaISJ_EE:
lea rax, _ZTVN5minja13TemplateTokenE; `vtable for'minja::TemplateToken
add rax, 10h
mov [rdi], rax
mov dword ptr [rdi+8], 0Dh
mov rax, [rsi]
mov [rdi+10h], rax
mov rax, [rsi+8]
mov [rdi+18h], rax
test rax, rax
jz short loc_5FB51
mov r10, cs:__libc_single_threaded_ptr
cmp byte ptr [r10], 0
jz short loc_5FB4D
inc dword ptr [rax+8]
jmp short loc_5FB51
loc_5FB4D:
lock inc dword ptr [rax+8]
loc_5FB51:
mov rax, [rsi+10h]
mov [rdi+20h], rax
mov [rdi+28h], edx
mov [rdi+2Ch], ecx
lea rax, _ZTVN5minja18MacroTemplateTokenE; `vtable for'minja::MacroTemplateToken
add rax, 10h
mov [rdi], rax
xor eax, eax
mov [rdi+38h], rax
movups xmm0, xmmword ptr [r8]
mov [r8+8], rax
movups xmmword ptr [rdi+30h], xmm0
mov [r8], rax
movups xmm0, xmmword ptr [r9]
movups xmmword ptr [rdi+40h], xmm0
mov rcx, [r9+10h]
mov [rdi+50h], rcx
mov [r9+10h], rax
xorps xmm0, xmm0
movups xmmword ptr [r9], xmm0
retn
| long long minja::MacroTemplateToken::MacroTemplateToken(
long long a1,
_QWORD *a2,
int a3,
int a4,
__int128 *a5,
long long a6)
{
long long v6; // rax
long long result; // rax
__int128 v8; // xmm0
*(_QWORD *)a1 = &`vtable for'minja::TemplateToken + 2;
*(_DWORD *)(a1 + 8) = 13;
*(_QWORD *)(a1 + 16) = *a2;
v6 = a2[1];
*(_QWORD *)(a1 + 24) = v6;
if ( v6 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v6 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v6 + 8));
}
*(_QWORD *)(a1 + 32) = a2[2];
*(_DWORD *)(a1 + 40) = a3;
*(_DWORD *)(a1 + 44) = a4;
*(_QWORD *)a1 = &`vtable for'minja::MacroTemplateToken + 2;
result = 0LL;
*(_QWORD *)(a1 + 56) = 0LL;
v8 = *a5;
*((_QWORD *)a5 + 1) = 0LL;
*(_OWORD *)(a1 + 48) = v8;
*(_QWORD *)a5 = 0LL;
*(_OWORD *)(a1 + 64) = *(_OWORD *)a6;
*(_QWORD *)(a1 + 80) = *(_QWORD *)(a6 + 16);
*(_QWORD *)(a6 + 16) = 0LL;
*(_OWORD *)a6 = 0LL;
return result;
}
| MacroTemplateToken:
LEA RAX,[0x1e31c8]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV dword ptr [RDI + 0x8],0xd
MOV RAX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],RAX
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x18],RAX
TEST RAX,RAX
JZ 0x0015fb51
MOV R10,qword ptr [0x001e4f98]
CMP byte ptr [R10],0x0
JZ 0x0015fb4d
INC dword ptr [RAX + 0x8]
JMP 0x0015fb51
LAB_0015fb4d:
INC.LOCK dword ptr [RAX + 0x8]
LAB_0015fb51:
MOV RAX,qword ptr [RSI + 0x10]
MOV qword ptr [RDI + 0x20],RAX
MOV dword ptr [RDI + 0x28],EDX
MOV dword ptr [RDI + 0x2c],ECX
LEA RAX,[0x1e3df8]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x38],RAX
MOVUPS XMM0,xmmword ptr [R8]
MOV qword ptr [R8 + 0x8],RAX
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOV qword ptr [R8],RAX
MOVUPS XMM0,xmmword ptr [R9]
MOVUPS xmmword ptr [RDI + 0x40],XMM0
MOV RCX,qword ptr [R9 + 0x10]
MOV qword ptr [RDI + 0x50],RCX
MOV qword ptr [R9 + 0x10],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R9],XMM0
RET
|
/* minja::MacroTemplateToken::MacroTemplateToken(minja::Location const&, minja::SpaceHandling,
minja::SpaceHandling, std::shared_ptr<minja::VariableExpr>&&,
std::vector<std::pair<std::__cxx11::string, std::shared_ptr<minja::Expression> >,
std::allocator<std::pair<std::__cxx11::string, std::shared_ptr<minja::Expression> > > >&&) */
void __thiscall
minja::MacroTemplateToken::MacroTemplateToken
(MacroTemplateToken *this,int8 *param_1,int4 param_3,int4 param_4,
int8 *param_5,int8 *param_6)
{
long lVar1;
int8 uVar2;
*(int ***)this = &PTR__TemplateToken_001e31d8;
*(int4 *)(this + 8) = 0xd;
*(int8 *)(this + 0x10) = *param_1;
lVar1 = param_1[1];
*(long *)(this + 0x18) = lVar1;
if (lVar1 != 0) {
if (*PTR___libc_single_threaded_001e4f98 == '\0') {
LOCK();
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
UNLOCK();
}
else {
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
}
}
*(int8 *)(this + 0x20) = param_1[2];
*(int4 *)(this + 0x28) = param_3;
*(int4 *)(this + 0x2c) = param_4;
*(int ***)this = &PTR__MacroTemplateToken_001e3e08;
*(int8 *)(this + 0x38) = 0;
uVar2 = param_5[1];
param_5[1] = 0;
*(int8 *)(this + 0x30) = *param_5;
*(int8 *)(this + 0x38) = uVar2;
*param_5 = 0;
uVar2 = param_6[1];
*(int8 *)(this + 0x40) = *param_6;
*(int8 *)(this + 0x48) = uVar2;
*(int8 *)(this + 0x50) = param_6[2];
param_6[2] = 0;
*param_6 = 0;
param_6[1] = 0;
return;
}
| |
23,923 | minja::MacroTemplateToken::MacroTemplateToken(minja::Location const&, minja::SpaceHandling, minja::SpaceHandling, std::shared_ptr<minja::VariableExpr>&&, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<minja::Expression>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<minja::Expression>>>>&&) | monkey531[P]llama/common/minja.hpp | TemplateToken(Type type, const Location & location, SpaceHandling pre, SpaceHandling post) : type(type), location(location), pre_space(pre), post_space(post) {} | O3 | cpp | minja::MacroTemplateToken::MacroTemplateToken(minja::Location const&, minja::SpaceHandling, minja::SpaceHandling, std::shared_ptr<minja::VariableExpr>&&, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<minja::Expression>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<minja::Expression>>>>&&):
leaq 0x81e01(%rip), %rax # 0xdf1c8
addq $0x10, %rax
movq %rax, (%rdi)
movl $0xd, 0x8(%rdi)
movq (%rsi), %rax
movq %rax, 0x10(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x18(%rdi)
testq %rax, %rax
je 0x5d3ff
movq 0x83ba8(%rip), %r10 # 0xe0f98
cmpb $0x0, (%r10)
je 0x5d3fb
incl 0x8(%rax)
jmp 0x5d3ff
lock
incl 0x8(%rax)
movq 0x10(%rsi), %rax
movq %rax, 0x20(%rdi)
movl %edx, 0x28(%rdi)
movl %ecx, 0x2c(%rdi)
leaq 0x829e4(%rip), %rax # 0xdfdf8
addq $0x10, %rax
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x38(%rdi)
movups (%r8), %xmm0
movq %rax, 0x8(%r8)
movups %xmm0, 0x30(%rdi)
movq %rax, (%r8)
movups (%r9), %xmm0
movups %xmm0, 0x40(%rdi)
movq 0x10(%r9), %rcx
movq %rcx, 0x50(%rdi)
movq %rax, 0x10(%r9)
xorps %xmm0, %xmm0
movups %xmm0, (%r9)
retq
| _ZN5minja18MacroTemplateTokenC2ERKNS_8LocationENS_13SpaceHandlingES4_OSt10shared_ptrINS_12VariableExprEEOSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_INS_10ExpressionEEESaISJ_EE:
lea rax, _ZTVN5minja13TemplateTokenE; `vtable for'minja::TemplateToken
add rax, 10h
mov [rdi], rax
mov dword ptr [rdi+8], 0Dh
mov rax, [rsi]
mov [rdi+10h], rax
mov rax, [rsi+8]
mov [rdi+18h], rax
test rax, rax
jz short loc_5D3FF
mov r10, cs:__libc_single_threaded_ptr
cmp byte ptr [r10], 0
jz short loc_5D3FB
inc dword ptr [rax+8]
jmp short loc_5D3FF
loc_5D3FB:
lock inc dword ptr [rax+8]
loc_5D3FF:
mov rax, [rsi+10h]
mov [rdi+20h], rax
mov [rdi+28h], edx
mov [rdi+2Ch], ecx
lea rax, _ZTVN5minja18MacroTemplateTokenE; `vtable for'minja::MacroTemplateToken
add rax, 10h
mov [rdi], rax
xor eax, eax
mov [rdi+38h], rax
movups xmm0, xmmword ptr [r8]
mov [r8+8], rax
movups xmmword ptr [rdi+30h], xmm0
mov [r8], rax
movups xmm0, xmmword ptr [r9]
movups xmmword ptr [rdi+40h], xmm0
mov rcx, [r9+10h]
mov [rdi+50h], rcx
mov [r9+10h], rax
xorps xmm0, xmm0
movups xmmword ptr [r9], xmm0
retn
| long long minja::MacroTemplateToken::MacroTemplateToken(
long long a1,
_QWORD *a2,
int a3,
int a4,
__int128 *a5,
long long a6)
{
long long v6; // rax
long long result; // rax
__int128 v8; // xmm0
*(_QWORD *)a1 = &`vtable for'minja::TemplateToken + 2;
*(_DWORD *)(a1 + 8) = 13;
*(_QWORD *)(a1 + 16) = *a2;
v6 = a2[1];
*(_QWORD *)(a1 + 24) = v6;
if ( v6 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v6 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v6 + 8));
}
*(_QWORD *)(a1 + 32) = a2[2];
*(_DWORD *)(a1 + 40) = a3;
*(_DWORD *)(a1 + 44) = a4;
*(_QWORD *)a1 = &`vtable for'minja::MacroTemplateToken + 2;
result = 0LL;
*(_QWORD *)(a1 + 56) = 0LL;
v8 = *a5;
*((_QWORD *)a5 + 1) = 0LL;
*(_OWORD *)(a1 + 48) = v8;
*(_QWORD *)a5 = 0LL;
*(_OWORD *)(a1 + 64) = *(_OWORD *)a6;
*(_QWORD *)(a1 + 80) = *(_QWORD *)(a6 + 16);
*(_QWORD *)(a6 + 16) = 0LL;
*(_OWORD *)a6 = 0LL;
return result;
}
| MacroTemplateToken:
LEA RAX,[0x1df1c8]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV dword ptr [RDI + 0x8],0xd
MOV RAX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],RAX
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x18],RAX
TEST RAX,RAX
JZ 0x0015d3ff
MOV R10,qword ptr [0x001e0f98]
CMP byte ptr [R10],0x0
JZ 0x0015d3fb
INC dword ptr [RAX + 0x8]
JMP 0x0015d3ff
LAB_0015d3fb:
INC.LOCK dword ptr [RAX + 0x8]
LAB_0015d3ff:
MOV RAX,qword ptr [RSI + 0x10]
MOV qword ptr [RDI + 0x20],RAX
MOV dword ptr [RDI + 0x28],EDX
MOV dword ptr [RDI + 0x2c],ECX
LEA RAX,[0x1dfdf8]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x38],RAX
MOVUPS XMM0,xmmword ptr [R8]
MOV qword ptr [R8 + 0x8],RAX
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOV qword ptr [R8],RAX
MOVUPS XMM0,xmmword ptr [R9]
MOVUPS xmmword ptr [RDI + 0x40],XMM0
MOV RCX,qword ptr [R9 + 0x10]
MOV qword ptr [RDI + 0x50],RCX
MOV qword ptr [R9 + 0x10],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R9],XMM0
RET
|
/* minja::MacroTemplateToken::MacroTemplateToken(minja::Location const&, minja::SpaceHandling,
minja::SpaceHandling, std::shared_ptr<minja::VariableExpr>&&,
std::vector<std::pair<std::__cxx11::string, std::shared_ptr<minja::Expression> >,
std::allocator<std::pair<std::__cxx11::string, std::shared_ptr<minja::Expression> > > >&&) */
void __thiscall
minja::MacroTemplateToken::MacroTemplateToken
(MacroTemplateToken *this,int8 *param_1,int4 param_3,int4 param_4,
int8 *param_5,int8 *param_6)
{
long lVar1;
int8 uVar2;
*(int ***)this = &PTR__TemplateToken_001df1d8;
*(int4 *)(this + 8) = 0xd;
*(int8 *)(this + 0x10) = *param_1;
lVar1 = param_1[1];
*(long *)(this + 0x18) = lVar1;
if (lVar1 != 0) {
if (*PTR___libc_single_threaded_001e0f98 == '\0') {
LOCK();
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
UNLOCK();
}
else {
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
}
}
*(int8 *)(this + 0x20) = param_1[2];
*(int4 *)(this + 0x28) = param_3;
*(int4 *)(this + 0x2c) = param_4;
*(int ***)this = &PTR__MacroTemplateToken_001dfe08;
*(int8 *)(this + 0x38) = 0;
uVar2 = param_5[1];
param_5[1] = 0;
*(int8 *)(this + 0x30) = *param_5;
*(int8 *)(this + 0x38) = uVar2;
*param_5 = 0;
uVar2 = param_6[1];
*(int8 *)(this + 0x40) = *param_6;
*(int8 *)(this + 0x48) = uVar2;
*(int8 *)(this + 0x50) = param_6[2];
param_6[2] = 0;
*param_6 = 0;
param_6[1] = 0;
return;
}
| |
23,924 | my_uca_scanner_contraction_find | eloqsql/strings/ctype-uca.c | static const MY_CONTRACTION *
my_uca_scanner_contraction_find(my_uca_scanner *scanner, my_wc_t *wc,
size_t max_char_length)
{
size_t clen= 1;
int flag;
const uchar *s, *beg[MY_UCA_MAX_CONTRACTION];
memset((void*) beg, 0, sizeof(beg));
/* Scan all contraction candidates */
for (s= scanner->sbeg, flag= MY_UCA_CNT_MID1;
clen < max_char_length;
flag<<= 1)
{
int mblen;
if ((mblen= my_ci_mb_wc(scanner->cs, &wc[clen], s, scanner->send)) <= 0)
break;
beg[clen]= s= s + mblen;
if (!my_uca_can_be_contraction_part(&scanner->level->contractions,
wc[clen++], flag))
break;
}
/* Find among candidates the longest real contraction */
for ( ; clen > 1; clen--)
{
const MY_CONTRACTION *cnt;
if (my_uca_can_be_contraction_tail(&scanner->level->contractions,
wc[clen - 1]) &&
(cnt= my_uca_contraction_find(&scanner->level->contractions,
wc, clen)))
{
scanner->wbeg= cnt->weight + 1;
scanner->sbeg= beg[clen - 1];
return cnt;
}
}
return NULL; /* No contractions were found */
} | O0 | c | my_uca_scanner_contraction_find:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x1, -0x28(%rbp)
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x24190
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movl $0x4, -0x2c(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x5193a
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0xb8(%rax), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rsi
movq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
callq *%rax
movl %eax, -0x74(%rbp)
cmpl $0x0, %eax
jg 0x518e2
jmp 0x5193a
movq -0x38(%rbp), %rcx
movslq -0x74(%rbp), %rax
addq %rax, %rcx
movq %rcx, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rcx, -0x70(%rbp,%rax,8)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movq (%rax,%rcx,8), %rsi
movl -0x2c(%rbp), %edx
callq 0x519f0
cmpb $0x0, %al
jne 0x5192b
jmp 0x5193a
jmp 0x5192d
movl -0x2c(%rbp), %eax
shll %eax
movl %eax, -0x2c(%rbp)
jmp 0x51892
jmp 0x5193c
cmpq $0x1, -0x28(%rbp)
jbe 0x519d8
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rsi
callq 0x48be0
movsbl %al, %eax
cmpl $0x0, %eax
je 0x519c5
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x51010
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0x519c5
movq -0x80(%rbp), %rcx
addq $0x30, %rcx
addq $0x2, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
subq $0x1, %rax
movq -0x70(%rbp,%rax,8), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x80(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x519e0
jmp 0x519c7
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x5193c
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
| my_uca_scanner_contraction_find:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], 1
lea rdi, [rbp+var_70]
xor esi, esi
mov edx, 30h ; '0'
call _memset
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_38], rax
mov [rbp+var_2C], 4
loc_51892:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_20]
jnb loc_5193A
mov rax, [rbp+var_10]
mov rax, [rax+30h]
mov rax, [rax+0B8h]
mov rax, [rax+28h]
mov rcx, [rbp+var_10]
mov rdi, [rcx+30h]
mov rsi, [rbp+var_18]
mov rcx, [rbp+var_28]
shl rcx, 3
add rsi, rcx
mov rdx, [rbp+var_38]
mov rcx, [rbp+var_10]
mov rcx, [rcx+10h]
call rax
mov [rbp+var_74], eax
cmp eax, 0
jg short loc_518E2
jmp short loc_5193A
loc_518E2:
mov rcx, [rbp+var_38]
movsxd rax, [rbp+var_74]
add rcx, rax
mov [rbp+var_38], rcx
mov rax, [rbp+var_28]
mov [rbp+rax*8+var_70], rcx
mov rax, [rbp+var_10]
mov rdi, [rax+18h]
add rdi, 18h
mov rax, [rbp+var_18]
mov rcx, [rbp+var_28]
mov rdx, rcx
add rdx, 1
mov [rbp+var_28], rdx
mov rsi, [rax+rcx*8]
mov edx, [rbp+var_2C]
call my_uca_can_be_contraction_part
cmp al, 0
jnz short loc_5192B
jmp short loc_5193A
loc_5192B:
jmp short $+2
loc_5192D:
mov eax, [rbp+var_2C]
shl eax, 1
mov [rbp+var_2C], eax
jmp loc_51892
loc_5193A:
jmp short $+2
loc_5193C:
cmp [rbp+var_28], 1
jbe loc_519D8
mov rax, [rbp+var_10]
mov rdi, [rax+18h]
add rdi, 18h
mov rax, [rbp+var_18]
mov rcx, [rbp+var_28]
sub rcx, 1
mov rsi, [rax+rcx*8]
call my_uca_can_be_contraction_tail
movsx eax, al
cmp eax, 0
jz short loc_519C5
mov rax, [rbp+var_10]
mov rdi, [rax+18h]
add rdi, 18h
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_28]
call my_uca_contraction_find
mov [rbp+var_80], rax
cmp rax, 0
jz short loc_519C5
mov rcx, [rbp+var_80]
add rcx, 30h ; '0'
add rcx, 2
mov rax, [rbp+var_10]
mov [rax], rcx
mov rax, [rbp+var_28]
sub rax, 1
mov rcx, [rbp+rax*8+var_70]
mov rax, [rbp+var_10]
mov [rax+8], rcx
mov rax, [rbp+var_80]
mov [rbp+var_8], rax
jmp short loc_519E0
loc_519C5:
jmp short $+2
loc_519C7:
mov rax, [rbp+var_28]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_28], rax
jmp loc_5193C
loc_519D8:
mov [rbp+var_8], 0
loc_519E0:
mov rax, [rbp+var_8]
add rsp, 80h
pop rbp
retn
| unsigned long long my_uca_scanner_contraction_find(_QWORD *a1, long long a2, unsigned long long a3)
{
long long v3; // rdi
unsigned long long v4; // rcx
unsigned long long v6; // [rsp+0h] [rbp-80h]
int v7; // [rsp+Ch] [rbp-74h]
_QWORD v8[7]; // [rsp+10h] [rbp-70h] BYREF
long long v9; // [rsp+48h] [rbp-38h]
unsigned int i; // [rsp+54h] [rbp-2Ch]
unsigned long long v11; // [rsp+58h] [rbp-28h]
unsigned long long v12; // [rsp+60h] [rbp-20h]
long long v13; // [rsp+68h] [rbp-18h]
_QWORD *v14; // [rsp+70h] [rbp-10h]
v14 = a1;
v13 = a2;
v12 = a3;
v11 = 1LL;
memset(v8, 0LL, 48LL);
v9 = v14[1];
for ( i = 4; v11 < v12; i *= 2 )
{
v7 = (*(long long ( **)(_QWORD, unsigned long long, long long, _QWORD))(*(_QWORD *)(v14[6] + 184LL) + 40LL))(
v14[6],
8 * v11 + v13,
v9,
v14[2]);
if ( v7 <= 0 )
break;
v9 += v7;
v8[v11] = v9;
v3 = v14[3] + 24LL;
v4 = v11++;
if ( !(unsigned __int8)my_uca_can_be_contraction_part(v3, *(_QWORD *)(v13 + 8 * v4), i) )
break;
}
while ( v11 > 1 )
{
if ( (unsigned __int8)my_uca_can_be_contraction_tail(v14[3] + 24LL, *(_QWORD *)(v13 + 8 * (v11 - 1))) )
{
v6 = my_uca_contraction_find((_QWORD *)(v14[3] + 24LL), v13, v11);
if ( v6 )
{
*v14 = v6 + 50;
v14[1] = v8[v11 - 1];
return v6;
}
}
--v11;
}
return 0LL;
}
| my_uca_scanner_contraction_find:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],0x1
LEA RDI,[RBP + -0x70]
XOR ESI,ESI
MOV EDX,0x30
CALL 0x00124190
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x38],RAX
MOV dword ptr [RBP + -0x2c],0x4
LAB_00151892:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x0015193a
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x30]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x28]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RCX + 0x30]
MOV RSI,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x28]
SHL RCX,0x3
ADD RSI,RCX
MOV RDX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x10]
CALL RAX
MOV dword ptr [RBP + -0x74],EAX
CMP EAX,0x0
JG 0x001518e2
JMP 0x0015193a
LAB_001518e2:
MOV RCX,qword ptr [RBP + -0x38]
MOVSXD RAX,dword ptr [RBP + -0x74]
ADD RCX,RAX
MOV qword ptr [RBP + -0x38],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + RAX*0x8 + -0x70],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x18]
ADD RDI,0x18
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x28]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x28],RDX
MOV RSI,qword ptr [RAX + RCX*0x8]
MOV EDX,dword ptr [RBP + -0x2c]
CALL 0x001519f0
CMP AL,0x0
JNZ 0x0015192b
JMP 0x0015193a
LAB_0015192b:
JMP 0x0015192d
LAB_0015192d:
MOV EAX,dword ptr [RBP + -0x2c]
SHL EAX,0x1
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x00151892
LAB_0015193a:
JMP 0x0015193c
LAB_0015193c:
CMP qword ptr [RBP + -0x28],0x1
JBE 0x001519d8
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x18]
ADD RDI,0x18
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x28]
SUB RCX,0x1
MOV RSI,qword ptr [RAX + RCX*0x8]
CALL 0x00148be0
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x001519c5
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x18]
ADD RDI,0x18
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x00151010
MOV qword ptr [RBP + -0x80],RAX
CMP RAX,0x0
JZ 0x001519c5
MOV RCX,qword ptr [RBP + -0x80]
ADD RCX,0x30
ADD RCX,0x2
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,0x1
MOV RCX,qword ptr [RBP + RAX*0x8 + -0x70]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x80]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001519e0
LAB_001519c5:
JMP 0x001519c7
LAB_001519c7:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0015193c
LAB_001519d8:
MOV qword ptr [RBP + -0x8],0x0
LAB_001519e0:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x80
POP RBP
RET
|
long my_uca_scanner_contraction_find(long *param_1,long param_2,ulong param_3)
{
char cVar1;
int iVar2;
long lVar3;
long local_78 [7];
long local_40;
int local_34;
ulong local_30;
ulong local_28;
long local_20;
long *local_18;
local_30 = 1;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
memset(local_78,0,0x30);
local_40 = local_18[1];
local_34 = 4;
while ((local_30 < local_28 &&
(iVar2 = (**(code **)(*(long *)(local_18[6] + 0xb8) + 0x28))
(local_18[6],local_20 + local_30 * 8,local_40,local_18[2]), 0 < iVar2)))
{
local_40 = local_40 + iVar2;
local_78[local_30] = local_40;
lVar3 = local_30 * 8;
local_30 = local_30 + 1;
cVar1 = my_uca_can_be_contraction_part
(local_18[3] + 0x18,*(int8 *)(local_20 + lVar3),local_34);
if (cVar1 == '\0') break;
local_34 = local_34 << 1;
}
while( true ) {
if (local_30 < 2) {
return 0;
}
cVar1 = my_uca_can_be_contraction_tail
(local_18[3] + 0x18,*(int8 *)(local_20 + (local_30 - 1) * 8));
if ((cVar1 != '\0') &&
(lVar3 = my_uca_contraction_find(local_18[3] + 0x18,local_20,local_30), lVar3 != 0)) break;
local_30 = local_30 - 1;
}
*local_18 = lVar3 + 0x32;
local_18[1] = local_78[local_30 - 1];
return lVar3;
}
| |
23,925 | delete_map_weak_ref | bluesky950520[P]quickjs/quickjs.c | static void delete_map_weak_ref(JSRuntime *rt, JSMapRecord *mr)
{
JSWeakRefRecord **pwr, *wr;
pwr = get_first_weak_ref(mr->key);
for(;;) {
wr = *pwr;
assert(wr != NULL);
if (wr->kind == JS_WEAK_REF_KIND_MAP && wr->u.map_record == mr)
break;
pwr = &wr->next_weak_ref;
}
*pwr = wr->next_weak_ref;
js_free_rt(rt, wr);
} | O1 | c | delete_map_weak_ref:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd 0x30(%rsi), %xmm0
movl 0x38(%rsi), %eax
movsd %xmm0, (%rsp)
cmpl $-0x8, %eax
je 0x3b41e
cmpl $-0x1, %eax
jne 0x3b472
movq (%rsp), %rax
addq $0x28, %rax
jmp 0x3b42f
movq (%rsp), %rax
addq $0x10, %rax
jmp 0x3b42f
addq $0x8, %r14
movq %r14, %rax
movq (%rax), %r14
cmpl $0x0, (%r14)
jne 0x3b428
cmpq %rsi, 0x10(%r14)
jne 0x3b428
movq 0x8(%r14), %rcx
movq %rcx, (%rax)
decq 0x28(%rbx)
movq %r14, %rdi
callq *0x20(%rbx)
movq 0x10(%rbx), %rcx
movq 0x30(%rbx), %rdx
subq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x30(%rbx)
movq 0x40(%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
callq 0xe090
| delete_map_weak_ref:
push r14
push rbx
push rax
mov rbx, rdi
movsd xmm0, qword ptr [rsi+30h]
mov eax, [rsi+38h]
movsd [rsp+18h+var_18], xmm0
cmp eax, 0FFFFFFF8h
jz short loc_3B41E
cmp eax, 0FFFFFFFFh
jnz short loc_3B472
mov rax, [rsp+18h+var_18]
add rax, 28h ; '('
jmp short loc_3B42F
loc_3B41E:
mov rax, [rsp+18h+var_18]
add rax, 10h
jmp short loc_3B42F
loc_3B428:
add r14, 8
mov rax, r14
loc_3B42F:
mov r14, [rax]
cmp dword ptr [r14], 0
jnz short loc_3B428
cmp [r14+10h], rsi
jnz short loc_3B428
mov rcx, [r14+8]
mov [rax], rcx
dec qword ptr [rbx+28h]
mov rdi, r14
call qword ptr [rbx+20h]
mov rcx, [rbx+10h]
mov rdx, [rbx+30h]
sub rdx, rax
add rdx, 0FFFFFFFFFFFFFFF8h
mov [rbx+30h], rdx
mov rdi, [rbx+40h]
mov rsi, r14
add rsp, 8
pop rbx
pop r14
jmp rcx
loc_3B472:
call _abort
| long long delete_map_weak_ref(long long a1, long long a2)
{
int v2; // eax
_QWORD *v3; // rax
_DWORD *v4; // r14
long long v5; // rax
long long ( *v6)(_QWORD, _DWORD *); // rcx
long long v8; // [rsp+0h] [rbp-18h]
v2 = *(_DWORD *)(a2 + 56);
v8 = *(_QWORD *)(a2 + 48);
if ( v2 == -8 )
{
v3 = (_QWORD *)(v8 + 16);
}
else
{
if ( v2 != -1 )
abort((const char *)a1);
v3 = (_QWORD *)(v8 + 40);
}
while ( 1 )
{
v4 = (_DWORD *)*v3;
if ( !*(_DWORD *)*v3 && *((_QWORD *)v4 + 2) == a2 )
break;
v3 = v4 + 2;
}
*v3 = *((_QWORD *)v4 + 1);
--*(_QWORD *)(a1 + 40);
v5 = (*(long long ( **)(_DWORD *))(a1 + 32))(v4);
v6 = *(long long ( **)(_QWORD, _DWORD *))(a1 + 16);
*(_QWORD *)(a1 + 48) = *(_QWORD *)(a1 + 48) - v5 - 8;
return v6(*(_QWORD *)(a1 + 64), v4);
}
| delete_map_weak_ref:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOVSD XMM0,qword ptr [RSI + 0x30]
MOV EAX,dword ptr [RSI + 0x38]
MOVSD qword ptr [RSP],XMM0
CMP EAX,-0x8
JZ 0x0013b41e
CMP EAX,-0x1
JNZ 0x0013b472
MOV RAX,qword ptr [RSP]
ADD RAX,0x28
JMP 0x0013b42f
LAB_0013b41e:
MOV RAX,qword ptr [RSP]
ADD RAX,0x10
JMP 0x0013b42f
LAB_0013b428:
ADD R14,0x8
MOV RAX,R14
LAB_0013b42f:
MOV R14,qword ptr [RAX]
CMP dword ptr [R14],0x0
JNZ 0x0013b428
CMP qword ptr [R14 + 0x10],RSI
JNZ 0x0013b428
MOV RCX,qword ptr [R14 + 0x8]
MOV qword ptr [RAX],RCX
DEC qword ptr [RBX + 0x28]
MOV RDI,R14
CALL qword ptr [RBX + 0x20]
MOV RCX,qword ptr [RBX + 0x10]
MOV RDX,qword ptr [RBX + 0x30]
SUB RDX,RAX
ADD RDX,-0x8
MOV qword ptr [RBX + 0x30],RDX
MOV RDI,qword ptr [RBX + 0x40]
MOV RSI,R14
ADD RSP,0x8
POP RBX
POP R14
JMP RCX
LAB_0013b472:
CALL 0x0010e090
|
void delete_map_weak_ref(long param_1,long param_2)
{
int *piVar1;
int *piVar2;
long lVar3;
if (*(int *)(param_2 + 0x38) == -8) {
piVar2 = (int *)(*(long *)(param_2 + 0x30) + 0x10);
}
else {
if (*(int *)(param_2 + 0x38) != -1) {
/* WARNING: Subroutine does not return */
abort();
}
piVar2 = (int *)(*(long *)(param_2 + 0x30) + 0x28);
}
while ((piVar1 = *(int **)piVar2, *piVar1 != 0 || (*(long *)(piVar1 + 4) != param_2))) {
piVar2 = piVar1 + 2;
}
*(int8 *)piVar2 = *(int8 *)(piVar1 + 2);
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + -1;
lVar3 = (**(code **)(param_1 + 0x20))(piVar1);
lVar3 = (*(long *)(param_1 + 0x30) - lVar3) + -8;
*(long *)(param_1 + 0x30) = lVar3;
/* WARNING: Could not recover jumptable at 0x0013b470. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(param_1 + 0x10))
(*(int8 *)(param_1 + 0x40),piVar1,lVar3,*(code **)(param_1 + 0x10));
return;
}
| |
23,926 | ma_log_suffix | eloqsql/storage/maria/ma_key_recover.c | my_bool _ma_log_suffix(MARIA_PAGE *ma_page, uint org_length, uint new_length)
{
LSN lsn;
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 4];
uchar log_data[FILEID_STORE_SIZE + PAGE_STORE_SIZE + 10 + 7 + 2], *log_pos;
uchar *buff= ma_page->buff;
int diff;
uint translog_parts, extra_length;
MARIA_HA *info= ma_page->info;
pgcache_page_no_t page= ma_page->pos / info->s->block_size;
DBUG_ENTER("_ma_log_suffix");
DBUG_PRINT("enter", ("page: %lu org_length: %u new_length: %u",
(ulong) page, org_length, new_length));
DBUG_ASSERT(ma_page->size == new_length);
DBUG_ASSERT(ma_page->org_size == org_length);
log_pos= log_data + FILEID_STORE_SIZE;
page_store(log_pos, page);
log_pos+= PAGE_STORE_SIZE;
/* Store keypage_flag */
*log_pos++= KEY_OP_SET_PAGEFLAG;
*log_pos++= _ma_get_keypage_flag(info->s, buff);
if ((diff= (int) (new_length - org_length)) < 0)
{
log_pos[0]= KEY_OP_DEL_SUFFIX;
int2store(log_pos+1, -diff);
log_pos+= 3;
translog_parts= 1;
extra_length= 0;
}
else
{
log_pos[0]= KEY_OP_ADD_SUFFIX;
int2store(log_pos+1, diff);
log_pos+= 3;
log_array[TRANSLOG_INTERNAL_PARTS + 1].str= buff + org_length;
log_array[TRANSLOG_INTERNAL_PARTS + 1].length= (uint) diff;
translog_parts= 2;
extra_length= (uint) diff;
}
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= (uint) (log_pos -
log_data);
_ma_log_key_changes(ma_page,
log_array + TRANSLOG_INTERNAL_PARTS + translog_parts,
log_pos, &extra_length, &translog_parts);
/* Remember new page length for future log entires for same page */
ma_page->org_size= ma_page->size;
DBUG_RETURN(translog_write_record(&lsn, LOGREC_REDO_INDEX,
info->trn, info,
(translog_size_t)
log_array[TRANSLOG_INTERNAL_PARTS +
0].length + extra_length,
TRANSLOG_INTERNAL_PARTS + translog_parts,
log_array, log_data, NULL));
} | O0 | c | ma_log_suffix:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x38(%rbp)
movl %esi, -0x3c(%rbp)
movl %edx, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0xc0(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xd8(%rbp)
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
movq -0xd8(%rbp), %rcx
movq (%rcx), %rcx
movl 0x7bc(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0xe0(%rbp)
jmp 0x71de5
jmp 0x71de7
jmp 0x71de9
jmp 0x71deb
jmp 0x71ded
leaq -0x30(%rbp), %rax
addq $0x2, %rax
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0xe0(%rbp), %rax
movl %eax, %ecx
movq -0xe8(%rbp), %rax
movl %ecx, (%rax)
movq -0xe0(%rbp), %rax
shrq $0x20, %rax
movb %al, %cl
movq -0xe8(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0xb8(%rbp), %rax
addq $0x5, %rax
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xb8(%rbp)
movb $0xa, (%rax)
movq -0xc0(%rbp), %rax
movq -0xd8(%rbp), %rcx
movq (%rcx), %rcx
movl 0x744(%rcx), %ecx
subl $0x2, %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %cl
movq -0xb8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0xb8(%rbp)
movb %cl, (%rax)
movl -0x40(%rbp), %eax
subl -0x3c(%rbp), %eax
movl %eax, -0xc4(%rbp)
cmpl $0x0, %eax
jge 0x71f00
movq -0xb8(%rbp), %rax
movb $0x7, (%rax)
movq -0xb8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xf0(%rbp)
xorl %eax, %eax
subl -0xc4(%rbp), %eax
movw %ax, %cx
movq -0xf0(%rbp), %rax
movw %cx, (%rax)
movq -0xb8(%rbp), %rax
addq $0x3, %rax
movq %rax, -0xb8(%rbp)
movl $0x1, -0xc8(%rbp)
movl $0x0, -0xcc(%rbp)
jmp 0x71f72
movq -0xb8(%rbp), %rax
movb $0x6, (%rax)
movq -0xb8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xf8(%rbp)
movl -0xc4(%rbp), %eax
movw %ax, %cx
movq -0xf8(%rbp), %rax
movw %cx, (%rax)
movq -0xb8(%rbp), %rax
addq $0x3, %rax
movq %rax, -0xb8(%rbp)
movq -0xc0(%rbp), %rax
movl -0x3c(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x80(%rbp)
movl -0xc4(%rbp), %eax
movq %rax, -0x78(%rbp)
movl $0x2, -0xc8(%rbp)
movl -0xc4(%rbp), %eax
movl %eax, -0xcc(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0xb8(%rbp), %rax
leaq -0x30(%rbp), %rcx
subq %rcx, %rax
movl %eax, %eax
movq %rax, -0x88(%rbp)
movq -0x38(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0xd8(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0xd8(%rbp), %rcx
movq -0x88(%rbp), %rax
movl %eax, %r8d
addl -0xcc(%rbp), %r8d
movl -0xc8(%rbp), %r9d
addl $0x2, %r9d
leaq -0xb0(%rbp), %r10
leaq -0x30(%rbp), %rax
leaq -0x48(%rbp), %rdi
movl $0xc, %esi
xorl %r11d, %r11d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
callq 0x55370
movb %al, -0xf9(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x72025
movb -0xf9(%rbp), %al
addq $0x120, %rsp # imm = 0x120
popq %rbp
retq
callq 0x2a270
nopw (%rax,%rax)
| _ma_log_suffix:
push rbp
mov rbp, rsp
sub rsp, 120h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov [rbp+var_40], edx
mov rax, [rbp+var_38]
mov rax, [rax+10h]
mov [rbp+var_C0], rax
mov rax, [rbp+var_38]
mov rax, [rax]
mov [rbp+var_D8], rax
mov rax, [rbp+var_38]
mov rax, [rax+18h]
mov rcx, [rbp+var_D8]
mov rcx, [rcx]
mov ecx, [rcx+7BCh]
xor edx, edx
div rcx
mov [rbp+var_E0], rax
jmp short $+2
loc_71DE5:
jmp short $+2
loc_71DE7:
jmp short $+2
loc_71DE9:
jmp short $+2
loc_71DEB:
jmp short $+2
loc_71DED:
lea rax, [rbp+var_30]
add rax, 2
mov [rbp+var_B8], rax
mov rax, [rbp+var_B8]
mov [rbp+var_E8], rax
mov rax, [rbp+var_E0]
mov ecx, eax
mov rax, [rbp+var_E8]
mov [rax], ecx
mov rax, [rbp+var_E0]
shr rax, 20h
mov cl, al
mov rax, [rbp+var_E8]
mov [rax+4], cl
mov rax, [rbp+var_B8]
add rax, 5
mov [rbp+var_B8], rax
mov rax, [rbp+var_B8]
mov rcx, rax
add rcx, 1
mov [rbp+var_B8], rcx
mov byte ptr [rax], 0Ah
mov rax, [rbp+var_C0]
mov rcx, [rbp+var_D8]
mov rcx, [rcx]
mov ecx, [rcx+744h]
sub ecx, 2
sub ecx, 1
mov ecx, ecx
mov cl, [rax+rcx]
mov rax, [rbp+var_B8]
mov rdx, rax
add rdx, 1
mov [rbp+var_B8], rdx
mov [rax], cl
mov eax, [rbp+var_40]
sub eax, [rbp+var_3C]
mov [rbp+var_C4], eax
cmp eax, 0
jge short loc_71F00
mov rax, [rbp+var_B8]
mov byte ptr [rax], 7
mov rax, [rbp+var_B8]
add rax, 1
mov [rbp+var_F0], rax
xor eax, eax
sub eax, [rbp+var_C4]
mov cx, ax
mov rax, [rbp+var_F0]
mov [rax], cx
mov rax, [rbp+var_B8]
add rax, 3
mov [rbp+var_B8], rax
mov [rbp+var_C8], 1
mov [rbp+var_CC], 0
jmp short loc_71F72
loc_71F00:
mov rax, [rbp+var_B8]
mov byte ptr [rax], 6
mov rax, [rbp+var_B8]
add rax, 1
mov [rbp+var_F8], rax
mov eax, [rbp+var_C4]
mov cx, ax
mov rax, [rbp+var_F8]
mov [rax], cx
mov rax, [rbp+var_B8]
add rax, 3
mov [rbp+var_B8], rax
mov rax, [rbp+var_C0]
mov ecx, [rbp+var_3C]
add rax, rcx
mov [rbp+var_80], rax
mov eax, [rbp+var_C4]
mov [rbp+var_78], rax
mov [rbp+var_C8], 2
mov eax, [rbp+var_C4]
mov [rbp+var_CC], eax
loc_71F72:
lea rax, [rbp+var_30]
mov [rbp+var_90], rax
mov rax, [rbp+var_B8]
lea rcx, [rbp+var_30]
sub rax, rcx
mov eax, eax
mov [rbp+var_88], rax
mov rax, [rbp+var_38]
mov ecx, [rax+20h]
mov rax, [rbp+var_38]
mov [rax+24h], ecx
mov rax, [rbp+var_D8]
mov rdx, [rax+8]
mov rcx, [rbp+var_D8]
mov rax, [rbp+var_88]
mov r8d, eax
add r8d, [rbp+var_CC]
mov r9d, [rbp+var_C8]
add r9d, 2
lea r10, [rbp+var_B0]
lea rax, [rbp+var_30]
lea rdi, [rbp+var_48]
mov esi, 0Ch
xor r11d, r11d
mov [rsp+120h+var_120], r10
mov [rsp+120h+var_118], rax
mov [rsp+120h+var_110], 0
call translog_write_record
mov [rbp+var_F9], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_72025
mov al, [rbp+var_F9]
add rsp, 120h
pop rbp
retn
loc_72025:
call ___stack_chk_fail
| char ma_log_suffix(long long **a1, unsigned int a2, int a3)
{
unsigned long long v4; // [rsp+40h] [rbp-E0h]
long long *v5; // [rsp+48h] [rbp-D8h]
int v6; // [rsp+54h] [rbp-CCh]
int v7; // [rsp+58h] [rbp-C8h]
long long *v8; // [rsp+60h] [rbp-C0h]
_QWORD v9[5]; // [rsp+70h] [rbp-B0h] BYREF
long long v10; // [rsp+98h] [rbp-88h]
long long v11; // [rsp+A0h] [rbp-80h]
long long v12; // [rsp+A8h] [rbp-78h]
char v13[8]; // [rsp+D8h] [rbp-48h] BYREF
int v14; // [rsp+E0h] [rbp-40h]
unsigned int v15; // [rsp+E4h] [rbp-3Ch]
long long **v16; // [rsp+E8h] [rbp-38h]
__int16 v17; // [rsp+F0h] [rbp-30h] BYREF
int v18; // [rsp+F2h] [rbp-2Eh]
char v19; // [rsp+F6h] [rbp-2Ah]
char v20; // [rsp+F7h] [rbp-29h]
char v21; // [rsp+F8h] [rbp-28h]
char v22; // [rsp+F9h] [rbp-27h]
__int16 v23; // [rsp+FAh] [rbp-26h]
_BYTE v24[36]; // [rsp+FCh] [rbp-24h] BYREF
long long savedregs; // [rsp+120h] [rbp+0h] BYREF
*(_QWORD *)&v24[28] = __readfsqword(0x28u);
v16 = a1;
v15 = a2;
v14 = a3;
v8 = a1[2];
v5 = *a1;
v4 = (unsigned long long)a1[3] / *(unsigned int *)(**a1 + 1980);
v18 = v4;
v19 = BYTE4(v4);
v20 = 10;
v21 = *((_BYTE *)v8 + (unsigned int)(*(_DWORD *)(*v5 + 1860) - 3));
if ( (int)(a3 - a2) >= 0 )
{
v22 = 6;
v23 = a3 - a2;
v11 = (long long)v8 + v15;
v12 = a3 - a2;
v7 = 2;
v6 = a3 - a2;
}
else
{
v22 = 7;
v23 = a2 - a3;
v7 = 1;
v6 = 0;
}
v9[4] = &v17;
v10 = (unsigned int)v24 - ((unsigned int)&savedregs - 48);
*((_DWORD *)v16 + 9) = *((_DWORD *)v16 + 8);
return translog_write_record((long long)v13, 0xCu, v5[1], v5, v6 + v10, v7 + 2, v9, &v17, 0LL);
}
| _ma_log_suffix:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x120
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV dword ptr [RBP + -0x40],EDX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0xc0],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0xd8],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RBP + -0xd8]
MOV RCX,qword ptr [RCX]
MOV ECX,dword ptr [RCX + 0x7bc]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0xe0],RAX
JMP 0x00171de5
LAB_00171de5:
JMP 0x00171de7
LAB_00171de7:
JMP 0x00171de9
LAB_00171de9:
JMP 0x00171deb
LAB_00171deb:
JMP 0x00171ded
LAB_00171ded:
LEA RAX,[RBP + -0x30]
ADD RAX,0x2
MOV qword ptr [RBP + -0xb8],RAX
MOV RAX,qword ptr [RBP + -0xb8]
MOV qword ptr [RBP + -0xe8],RAX
MOV RAX,qword ptr [RBP + -0xe0]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0xe8]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0xe0]
SHR RAX,0x20
MOV CL,AL
MOV RAX,qword ptr [RBP + -0xe8]
MOV byte ptr [RAX + 0x4],CL
MOV RAX,qword ptr [RBP + -0xb8]
ADD RAX,0x5
MOV qword ptr [RBP + -0xb8],RAX
MOV RAX,qword ptr [RBP + -0xb8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0xb8],RCX
MOV byte ptr [RAX],0xa
MOV RAX,qword ptr [RBP + -0xc0]
MOV RCX,qword ptr [RBP + -0xd8]
MOV RCX,qword ptr [RCX]
MOV ECX,dword ptr [RCX + 0x744]
SUB ECX,0x2
SUB ECX,0x1
MOV ECX,ECX
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0xb8]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0xb8],RDX
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RBP + -0x40]
SUB EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0xc4],EAX
CMP EAX,0x0
JGE 0x00171f00
MOV RAX,qword ptr [RBP + -0xb8]
MOV byte ptr [RAX],0x7
MOV RAX,qword ptr [RBP + -0xb8]
ADD RAX,0x1
MOV qword ptr [RBP + -0xf0],RAX
XOR EAX,EAX
SUB EAX,dword ptr [RBP + -0xc4]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0xf0]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RBP + -0xb8]
ADD RAX,0x3
MOV qword ptr [RBP + -0xb8],RAX
MOV dword ptr [RBP + -0xc8],0x1
MOV dword ptr [RBP + -0xcc],0x0
JMP 0x00171f72
LAB_00171f00:
MOV RAX,qword ptr [RBP + -0xb8]
MOV byte ptr [RAX],0x6
MOV RAX,qword ptr [RBP + -0xb8]
ADD RAX,0x1
MOV qword ptr [RBP + -0xf8],RAX
MOV EAX,dword ptr [RBP + -0xc4]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0xf8]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RBP + -0xb8]
ADD RAX,0x3
MOV qword ptr [RBP + -0xb8],RAX
MOV RAX,qword ptr [RBP + -0xc0]
MOV ECX,dword ptr [RBP + -0x3c]
ADD RAX,RCX
MOV qword ptr [RBP + -0x80],RAX
MOV EAX,dword ptr [RBP + -0xc4]
MOV qword ptr [RBP + -0x78],RAX
MOV dword ptr [RBP + -0xc8],0x2
MOV EAX,dword ptr [RBP + -0xc4]
MOV dword ptr [RBP + -0xcc],EAX
LAB_00171f72:
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x90],RAX
MOV RAX,qword ptr [RBP + -0xb8]
LEA RCX,[RBP + -0x30]
SUB RAX,RCX
MOV EAX,EAX
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x24],ECX
MOV RAX,qword ptr [RBP + -0xd8]
MOV RDX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0xd8]
MOV RAX,qword ptr [RBP + -0x88]
MOV R8D,EAX
ADD R8D,dword ptr [RBP + -0xcc]
MOV R9D,dword ptr [RBP + -0xc8]
ADD R9D,0x2
LEA R10,[RBP + -0xb0]
LEA RAX,[RBP + -0x30]
LEA RDI,[RBP + -0x48]
MOV ESI,0xc
XOR R11D,R11D
MOV qword ptr [RSP],R10
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],0x0
CALL 0x00155370
MOV byte ptr [RBP + -0xf9],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00172025
MOV AL,byte ptr [RBP + -0xf9]
ADD RSP,0x120
POP RBP
RET
LAB_00172025:
CALL 0x0012a270
|
int8 _ma_log_suffix(long *param_1,uint param_2,int param_3)
{
long *plVar1;
int1 uVar2;
uint uVar3;
ulong uVar4;
long in_FS_OFFSET;
uint local_d4;
int local_d0;
int1 *local_c0;
int1 local_b8 [32];
int1 *local_98;
ulong local_90;
long local_88;
ulong local_80;
int1 local_50 [8];
int local_48;
uint local_44;
long *local_40;
int1 local_38 [2];
int4 local_36;
int1 local_32;
int1 local_31;
int1 local_30;
int1 local_2f;
short local_2e;
int1 auStack_2c [28];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
plVar1 = (long *)*param_1;
uVar4 = (ulong)param_1[3] / (ulong)*(uint *)(*plVar1 + 0x7bc);
local_36 = (int4)uVar4;
local_32 = (int1)(uVar4 >> 0x20);
local_31 = 10;
local_30 = *(int1 *)(param_1[2] + (ulong)(*(int *)(*plVar1 + 0x744) - 3));
local_d4 = param_3 - param_2;
local_2e = (short)local_d4;
if ((int)local_d4 < 0) {
local_2f = 7;
local_2e = -local_2e;
local_d0 = 1;
local_d4 = 0;
}
else {
local_2f = 6;
local_88 = param_1[2] + (ulong)param_2;
local_80 = (ulong)local_d4;
local_d0 = 2;
}
local_c0 = auStack_2c;
local_98 = local_38;
uVar3 = (int)local_c0 - (int)local_38;
local_90 = (ulong)uVar3;
*(int *)((long)param_1 + 0x24) = (int)param_1[4];
local_48 = param_3;
local_44 = param_2;
local_40 = param_1;
uVar2 = translog_write_record
(local_50,0xc,plVar1[1],plVar1,uVar3 + local_d4,local_d0 + 2,local_b8,local_38,0
);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),uVar2);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
23,927 | PFS_statement_stat::delayed_reset() | eloqsql/storage/perfschema/pfs_stat.h | inline void delayed_reset(void)
{
if (m_timer1_stat.m_count == 0)
{
m_timer1_stat.reset();
m_error_count= 0;
m_warning_count= 0;
m_rows_affected= 0;
m_lock_time= 0;
m_rows_sent= 0;
m_rows_examined= 0;
m_created_tmp_disk_tables= 0;
m_created_tmp_tables= 0;
m_select_full_join= 0;
m_select_full_range_join= 0;
m_select_range= 0;
m_select_range_check= 0;
m_select_scan= 0;
m_sort_merge_passes= 0;
m_sort_range= 0;
m_sort_rows= 0;
m_sort_scan= 0;
m_no_index_used= 0;
m_no_good_index_used= 0;
}
} | O0 | c | PFS_statement_stat::delayed_reset():
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, (%rax)
jne 0x37038
movq -0x10(%rbp), %rdi
callq 0x2d880
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
movq $0x0, 0x38(%rax)
movq $0x0, 0x40(%rax)
movq $0x0, 0x48(%rax)
movq $0x0, 0x50(%rax)
movq $0x0, 0x58(%rax)
movq $0x0, 0x60(%rax)
movq $0x0, 0x68(%rax)
movq $0x0, 0x70(%rax)
movq $0x0, 0x78(%rax)
movq $0x0, 0x80(%rax)
movq $0x0, 0x88(%rax)
movq $0x0, 0x90(%rax)
movq $0x0, 0x98(%rax)
movq $0x0, 0xa0(%rax)
movq $0x0, 0xa8(%rax)
movq $0x0, 0xb0(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
| _ZN18PFS_statement_stat13delayed_resetEv:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
cmp qword ptr [rax], 0
jnz loc_37038
mov rdi, [rbp+var_10]; this
call _ZN15PFS_single_stat5resetEv; PFS_single_stat::reset(void)
mov rax, [rbp+var_10]
mov qword ptr [rax+20h], 0
mov qword ptr [rax+28h], 0
mov qword ptr [rax+30h], 0
mov qword ptr [rax+38h], 0
mov qword ptr [rax+40h], 0
mov qword ptr [rax+48h], 0
mov qword ptr [rax+50h], 0
mov qword ptr [rax+58h], 0
mov qword ptr [rax+60h], 0
mov qword ptr [rax+68h], 0
mov qword ptr [rax+70h], 0
mov qword ptr [rax+78h], 0
mov qword ptr [rax+80h], 0
mov qword ptr [rax+88h], 0
mov qword ptr [rax+90h], 0
mov qword ptr [rax+98h], 0
mov qword ptr [rax+0A0h], 0
mov qword ptr [rax+0A8h], 0
mov qword ptr [rax+0B0h], 0
loc_37038:
add rsp, 10h
pop rbp
retn
| PFS_statement_stat * PFS_statement_stat::delayed_reset(PFS_statement_stat *this)
{
PFS_statement_stat *result; // rax
result = this;
if ( !*(_QWORD *)this )
{
PFS_single_stat::reset(this);
result = this;
*((_QWORD *)this + 4) = 0LL;
*((_QWORD *)this + 5) = 0LL;
*((_QWORD *)this + 6) = 0LL;
*((_QWORD *)this + 7) = 0LL;
*((_QWORD *)this + 8) = 0LL;
*((_QWORD *)this + 9) = 0LL;
*((_QWORD *)this + 10) = 0LL;
*((_QWORD *)this + 11) = 0LL;
*((_QWORD *)this + 12) = 0LL;
*((_QWORD *)this + 13) = 0LL;
*((_QWORD *)this + 14) = 0LL;
*((_QWORD *)this + 15) = 0LL;
*((_QWORD *)this + 16) = 0LL;
*((_QWORD *)this + 17) = 0LL;
*((_QWORD *)this + 18) = 0LL;
*((_QWORD *)this + 19) = 0LL;
*((_QWORD *)this + 20) = 0LL;
*((_QWORD *)this + 21) = 0LL;
*((_QWORD *)this + 22) = 0LL;
}
return result;
}
| delayed_reset:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
CMP qword ptr [RAX],0x0
JNZ 0x00137038
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0012d880
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x20],0x0
MOV qword ptr [RAX + 0x28],0x0
MOV qword ptr [RAX + 0x30],0x0
MOV qword ptr [RAX + 0x38],0x0
MOV qword ptr [RAX + 0x40],0x0
MOV qword ptr [RAX + 0x48],0x0
MOV qword ptr [RAX + 0x50],0x0
MOV qword ptr [RAX + 0x58],0x0
MOV qword ptr [RAX + 0x60],0x0
MOV qword ptr [RAX + 0x68],0x0
MOV qword ptr [RAX + 0x70],0x0
MOV qword ptr [RAX + 0x78],0x0
MOV qword ptr [RAX + 0x80],0x0
MOV qword ptr [RAX + 0x88],0x0
MOV qword ptr [RAX + 0x90],0x0
MOV qword ptr [RAX + 0x98],0x0
MOV qword ptr [RAX + 0xa0],0x0
MOV qword ptr [RAX + 0xa8],0x0
MOV qword ptr [RAX + 0xb0],0x0
LAB_00137038:
ADD RSP,0x10
POP RBP
RET
|
/* PFS_statement_stat::delayed_reset() */
void __thiscall PFS_statement_stat::delayed_reset(PFS_statement_stat *this)
{
if (*(long *)this == 0) {
PFS_single_stat::reset((PFS_single_stat *)this);
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 0x50) = 0;
*(int8 *)(this + 0x58) = 0;
*(int8 *)(this + 0x60) = 0;
*(int8 *)(this + 0x68) = 0;
*(int8 *)(this + 0x70) = 0;
*(int8 *)(this + 0x78) = 0;
*(int8 *)(this + 0x80) = 0;
*(int8 *)(this + 0x88) = 0;
*(int8 *)(this + 0x90) = 0;
*(int8 *)(this + 0x98) = 0;
*(int8 *)(this + 0xa0) = 0;
*(int8 *)(this + 0xa8) = 0;
*(int8 *)(this + 0xb0) = 0;
}
return;
}
| |
23,928 | char const* fmt::v10::detail::parse_format_specs<char>(char const*, char const*, fmt::v10::detail::dynamic_format_specs<char>&, fmt::v10::basic_format_parse_context<char>&, fmt::v10::detail::type)::'unnamed0'::operator()(fmt::v10::presentation_type, int) | AlayaLite/build_O0/_deps/spdlog-src/include/spdlog/fmt/bundled/core.h | FMT_CONSTEXPR auto operator()(pres pres_type, int set) -> const Char* {
if (!in(arg_type, set)) {
if (arg_type == type::none_type) return begin;
throw_format_error("invalid format specifier");
}
specs.type = pres_type;
return begin + 1;
} | O0 | c | char const* fmt::v10::detail::parse_format_specs<char>(char const*, char const*, fmt::v10::detail::dynamic_format_specs<char>&, fmt::v10::basic_format_parse_context<char>&, fmt::v10::detail::type)::'unnamed0'::operator()(fmt::v10::presentation_type, int):
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x18(%rsp)
movb %al, 0x17(%rsp)
movl %edx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x10(%rax), %edi
movl 0x10(%rsp), %esi
callq 0xa3100
testb $0x1, %al
jne 0xa33f7
movq 0x8(%rsp), %rax
cmpl $0x0, 0x10(%rax)
jne 0xa33eb
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0xa3416
leaq 0x6cc30(%rip), %rdi # 0x110022
callq 0x86600
movq 0x8(%rsp), %rax
movb 0x17(%rsp), %dl
movq 0x8(%rax), %rcx
movb %dl, 0x8(%rcx)
movq (%rax), %rax
movq (%rax), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
| _ZZN3fmt3v106detail18parse_format_specsIcEEPKT_S5_S5_RNS1_20dynamic_format_specsIS3_EERNS0_26basic_format_parse_contextIS3_EENS1_4typeEENUt0_clENS0_17presentation_typeEi:
sub rsp, 28h
mov al, sil
mov [rsp+28h+var_10], rdi
mov byte ptr [rsp+28h+var_18+7], al
mov dword ptr [rsp+28h+var_18], edx
mov rax, [rsp+28h+var_10]
mov [rsp+28h+var_20], rax
mov edi, [rax+10h]
mov esi, dword ptr [rsp+28h+var_18]; char *
call _ZN3fmt3v106detail2inENS1_4typeEi; fmt::v10::detail::in(fmt::v10::detail::type,int)
test al, 1
jnz short loc_A33F7
mov rax, [rsp+28h+var_20]
cmp dword ptr [rax+10h], 0
jnz short loc_A33EB
mov rax, [rsp+28h+var_20]
mov rax, [rax]
mov rax, [rax]
mov [rsp+28h+var_8], rax
jmp short loc_A3416
loc_A33EB:
lea rdi, aInvalidFormatS; "invalid format specifier"
call _ZN3fmt3v106detail18throw_format_errorEPKc; fmt::v10::detail::throw_format_error(char const*)
loc_A33F7:
mov rax, [rsp+28h+var_20]
mov dl, byte ptr [rsp+28h+var_18+7]
mov rcx, [rax+8]
mov [rcx+8], dl
mov rax, [rax]
mov rax, [rax]
add rax, 1
mov [rsp+28h+var_8], rax
loc_A3416:
mov rax, [rsp+28h+var_8]
add rsp, 28h
retn
| long long fmt::v10::detail::parse_format_specs<char>(char const*,char const*,fmt::v10::detail::dynamic_format_specs<char> &,fmt::v10::basic_format_parse_context<char> &,fmt::v10::detail::type)::{unnamed type#2}::operator()(
long long a1,
char a2,
unsigned int a3)
{
const char *v3; // rsi
v3 = (const char *)a3;
if ( fmt::v10::detail::in(*(_DWORD *)(a1 + 16), a3) )
{
*(_BYTE *)(*(_QWORD *)(a1 + 8) + 8LL) = a2;
return **(_QWORD **)a1 + 1LL;
}
else
{
if ( *(_DWORD *)(a1 + 16) )
fmt::v10::detail::throw_format_error((fmt::v10::detail *)"invalid format specifier", v3);
return **(_QWORD **)a1;
}
}
| operator():
SUB RSP,0x28
MOV AL,SIL
MOV qword ptr [RSP + 0x18],RDI
MOV byte ptr [RSP + 0x17],AL
MOV dword ptr [RSP + 0x10],EDX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x8],RAX
MOV EDI,dword ptr [RAX + 0x10]
MOV ESI,dword ptr [RSP + 0x10]
CALL 0x001a3100
TEST AL,0x1
JNZ 0x001a33f7
MOV RAX,qword ptr [RSP + 0x8]
CMP dword ptr [RAX + 0x10],0x0
JNZ 0x001a33eb
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0x20],RAX
JMP 0x001a3416
LAB_001a33eb:
LEA RDI,[0x210022]
CALL 0x00186600
LAB_001a33f7:
MOV RAX,qword ptr [RSP + 0x8]
MOV DL,byte ptr [RSP + 0x17]
MOV RCX,qword ptr [RAX + 0x8]
MOV byte ptr [RCX + 0x8],DL
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX]
ADD RAX,0x1
MOV qword ptr [RSP + 0x20],RAX
LAB_001a3416:
MOV RAX,qword ptr [RSP + 0x20]
ADD RSP,0x28
RET
|
/* fmt::v10::detail::parse_format_specs<char>(char const*, char const*,
fmt::v10::detail::dynamic_format_specs<char>&, fmt::v10::basic_format_parse_context<char>&,
fmt::v10::detail::type)::{unnamed type#2}::TEMPNAMEPLACEHOLDERVALUE(fmt::v10::presentation_type,
int) */
long __thiscall
fmt::v10::detail::
parse_format_specs<char>(char_const*,char_const*,fmt::v10::detail::dynamic_format_specs<char>&,fmt::v10::basic_format_parse_context<char>&,fmt::v10::detail::type)
::{unnamed_type#2}::operator()(_unnamed_type_2_ *this,int1 param_2,int4 param_3)
{
ulong uVar1;
long local_8;
uVar1 = in(*(int4 *)(this + 0x10),param_3);
if ((uVar1 & 1) == 0) {
if (*(int *)(this + 0x10) != 0) {
/* WARNING: Subroutine does not return */
throw_format_error("invalid format specifier");
}
local_8 = **(long **)this;
}
else {
*(int1 *)(*(long *)(this + 8) + 8) = param_2;
local_8 = **(long **)this + 1;
}
return local_8;
}
| |
23,929 | ma_alloc_root | eloqsql/libmariadb/libmariadb/ma_alloc.c | void * ma_alloc_root(MA_MEM_ROOT *mem_root, size_t Size)
{
#if defined(HAVE_purify) && defined(EXTRA_DEBUG)
reg1 MA_USED_MEM *next;
Size+=ALIGN_SIZE(sizeof(MA_USED_MEM));
if (!(next = (MA_USED_MEM*) malloc(Size)))
{
if (mem_root->error_handler)
(*mem_root->error_handler)();
return((void *) 0); /* purecov: inspected */
}
next->next=mem_root->used;
mem_root->used=next;
return (void *) (((char*) next)+ALIGN_SIZE(sizeof(MA_USED_MEM)));
#else
size_t get_size;
void * point;
reg1 MA_USED_MEM *next= 0;
reg2 MA_USED_MEM **prev;
Size= ALIGN_SIZE(Size);
if ((*(prev= &mem_root->free)))
{
if ((*prev)->left < Size &&
mem_root->first_block_usage++ >= 16 &&
(*prev)->left < 4096)
{
next= *prev;
*prev= next->next;
next->next= mem_root->used;
mem_root->used= next;
mem_root->first_block_usage= 0;
}
for (next= *prev; next && next->left < Size; next= next->next)
prev= &next->next;
}
if (! next)
{ /* Time to alloc new block */
get_size= MAX(Size+ALIGN_SIZE(sizeof(MA_USED_MEM)),
(mem_root->block_size & ~1) * (mem_root->block_num >> 2));
if (!(next = (MA_USED_MEM*) malloc(get_size)))
{
if (mem_root->error_handler)
(*mem_root->error_handler)();
return((void *) 0); /* purecov: inspected */
}
mem_root->block_num++;
next->next= *prev;
next->size= get_size;
next->left= get_size-ALIGN_SIZE(sizeof(MA_USED_MEM));
*prev=next;
}
point= (void *) ((char*) next+ (next->size-next->left));
if ((next->left-= Size) < mem_root->min_malloc)
{ /* Full block */
*prev=next->next; /* Remove block from list */
next->next=mem_root->used;
mem_root->used=next;
mem_root->first_block_usage= 0;
}
return(point);
#endif
} | O0 | c | ma_alloc_root:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
subq $0x1, %rax
andq $-0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, (%rax)
je 0x24bdc
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jae 0x24b93
movq -0x10(%rbp), %rcx
movl 0x2c(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x2c(%rcx)
cmpl $0x10, %eax
jb 0x24b93
movq -0x38(%rbp), %rax
movq (%rax), %rax
cmpq $0x1000, 0x8(%rax) # imm = 0x1000
jae 0x24b93
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x30(%rbp)
movb %al, -0x39(%rbp)
je 0x24bbc
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
setb %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x24bc5
jmp 0x24bda
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x24b9e
jmp 0x24bdc
cmpq $0x0, -0x30(%rbp)
jne 0x24cba
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
andq $-0x2, %rcx
movq -0x10(%rbp), %rdx
movl 0x28(%rdx), %edx
shrl $0x2, %edx
movl %edx, %edx
imulq %rdx, %rcx
cmpq %rcx, %rax
jbe 0x24c1e
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x48(%rbp)
jmp 0x24c3e
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
andq $-0x2, %rax
movq -0x10(%rbp), %rcx
movl 0x28(%rcx), %ecx
shrl $0x2, %ecx
movl %ecx, %ecx
imulq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x135b0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x24c78
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x24c6b
movq -0x10(%rbp), %rax
callq *0x30(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x24d2e
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
subq $0x18, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq -0x30(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x30(%rbp), %rdx
subq 0x8(%rdx), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rax
subq %rdx, %rax
movq %rax, 0x8(%rcx)
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x24d26
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| ma_alloc_root:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_30], 0
mov rax, [rbp+var_18]
add rax, 8
sub rax, 1
and rax, 0FFFFFFFFFFFFFFF8h
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
mov [rbp+var_38], rax
cmp qword ptr [rax], 0
jz loc_24BDC
mov rax, [rbp+var_38]
mov rax, [rax]
mov rax, [rax+8]
cmp rax, [rbp+var_18]
jnb short loc_24B93
mov rcx, [rbp+var_10]
mov eax, [rcx+2Ch]
mov edx, eax
add edx, 1
mov [rcx+2Ch], edx
cmp eax, 10h
jb short loc_24B93
mov rax, [rbp+var_38]
mov rax, [rax]
cmp qword ptr [rax+8], 1000h
jnb short loc_24B93
mov rax, [rbp+var_38]
mov rax, [rax]
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
mov rcx, [rax]
mov rax, [rbp+var_38]
mov [rax], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+8]
mov rax, [rbp+var_30]
mov [rax], rcx
mov rcx, [rbp+var_30]
mov rax, [rbp+var_10]
mov [rax+8], rcx
mov rax, [rbp+var_10]
mov dword ptr [rax+2Ch], 0
loc_24B93:
mov rax, [rbp+var_38]
mov rax, [rax]
mov [rbp+var_30], rax
loc_24B9E:
xor eax, eax
cmp [rbp+var_30], 0
mov [rbp+var_39], al
jz short loc_24BBC
mov rax, [rbp+var_30]
mov rax, [rax+8]
cmp rax, [rbp+var_18]
setb al
mov [rbp+var_39], al
loc_24BBC:
mov al, [rbp+var_39]
test al, 1
jnz short loc_24BC5
jmp short loc_24BDA
loc_24BC5:
mov rax, [rbp+var_30]
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
mov rax, [rax]
mov [rbp+var_30], rax
jmp short loc_24B9E
loc_24BDA:
jmp short $+2
loc_24BDC:
cmp [rbp+var_30], 0
jnz loc_24CBA
mov rax, [rbp+var_18]
add rax, 18h
mov rcx, [rbp+var_10]
mov rcx, [rcx+20h]
and rcx, 0FFFFFFFFFFFFFFFEh
mov rdx, [rbp+var_10]
mov edx, [rdx+28h]
shr edx, 2
mov edx, edx
imul rcx, rdx
cmp rax, rcx
jbe short loc_24C1E
mov rax, [rbp+var_18]
add rax, 18h
mov [rbp+var_48], rax
jmp short loc_24C3E
loc_24C1E:
mov rax, [rbp+var_10]
mov rax, [rax+20h]
and rax, 0FFFFFFFFFFFFFFFEh
mov rcx, [rbp+var_10]
mov ecx, [rcx+28h]
shr ecx, 2
mov ecx, ecx
imul rax, rcx
mov [rbp+var_48], rax
loc_24C3E:
mov rax, [rbp+var_48]
mov [rbp+var_20], rax
mov rdi, [rbp+var_20]
call _malloc
mov [rbp+var_30], rax
cmp rax, 0
jnz short loc_24C78
mov rax, [rbp+var_10]
cmp qword ptr [rax+30h], 0
jz short loc_24C6B
mov rax, [rbp+var_10]
call qword ptr [rax+30h]
loc_24C6B:
mov [rbp+var_8], 0
jmp loc_24D2E
loc_24C78:
mov rax, [rbp+var_10]
mov ecx, [rax+28h]
add ecx, 1
mov [rax+28h], ecx
mov rax, [rbp+var_38]
mov rcx, [rax]
mov rax, [rbp+var_30]
mov [rax], rcx
mov rcx, [rbp+var_20]
mov rax, [rbp+var_30]
mov [rax+10h], rcx
mov rcx, [rbp+var_20]
sub rcx, 18h
mov rax, [rbp+var_30]
mov [rax+8], rcx
mov rcx, [rbp+var_30]
mov rax, [rbp+var_38]
mov [rax], rcx
loc_24CBA:
mov rax, [rbp+var_30]
mov rcx, [rbp+var_30]
mov rcx, [rcx+10h]
mov rdx, [rbp+var_30]
sub rcx, [rdx+8]
add rax, rcx
mov [rbp+var_28], rax
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_30]
mov rax, [rcx+8]
sub rax, rdx
mov [rcx+8], rax
mov rcx, [rbp+var_10]
cmp rax, [rcx+18h]
jnb short loc_24D26
mov rax, [rbp+var_30]
mov rcx, [rax]
mov rax, [rbp+var_38]
mov [rax], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+8]
mov rax, [rbp+var_30]
mov [rax], rcx
mov rcx, [rbp+var_30]
mov rax, [rbp+var_10]
mov [rax+8], rcx
mov rax, [rbp+var_10]
mov dword ptr [rax+2Ch], 0
loc_24D26:
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
loc_24D2E:
mov rax, [rbp+var_8]
add rsp, 50h
pop rbp
retn
| char * ma_alloc_root(_QWORD **a1, long long a2)
{
unsigned int v2; // eax
unsigned long long v3; // rax
unsigned long long v5; // [rsp+8h] [rbp-48h]
bool v6; // [rsp+17h] [rbp-39h]
_QWORD *v7; // [rsp+18h] [rbp-38h]
_QWORD *i; // [rsp+20h] [rbp-30h]
_QWORD *v9; // [rsp+20h] [rbp-30h]
char *v10; // [rsp+28h] [rbp-28h]
unsigned long long v11; // [rsp+38h] [rbp-18h]
i = 0LL;
v11 = (a2 + 7) & 0xFFFFFFFFFFFFFFF8LL;
v7 = a1;
if ( *a1 )
{
if ( (*a1)[1] < v11 )
{
v2 = *((_DWORD *)a1 + 11);
*((_DWORD *)a1 + 11) = v2 + 1;
if ( v2 >= 0x10 && (*a1)[1] < 0x1000uLL )
{
v9 = *a1;
*a1 = (_QWORD *)**a1;
*v9 = a1[1];
a1[1] = v9;
*((_DWORD *)a1 + 11) = 0;
}
}
for ( i = *a1; ; i = (_QWORD *)*i )
{
v6 = 0;
if ( i )
v6 = i[1] < v11;
if ( !v6 )
break;
v7 = i;
}
}
if ( !i )
{
if ( v11 + 24 <= (*((_DWORD *)a1 + 10) >> 2) * ((unsigned long long)a1[4] & 0xFFFFFFFFFFFFFFFELL) )
v5 = (*((_DWORD *)a1 + 10) >> 2) * ((unsigned long long)a1[4] & 0xFFFFFFFFFFFFFFFELL);
else
v5 = v11 + 24;
i = (_QWORD *)malloc(v5);
if ( !i )
{
if ( a1[6] )
((void (*)(void))a1[6])();
return 0LL;
}
++*((_DWORD *)a1 + 10);
*i = *v7;
i[2] = v5;
i[1] = v5 - 24;
*v7 = i;
}
v10 = (char *)i + i[2] - i[1];
v3 = i[1] - v11;
i[1] = v3;
if ( v3 < (unsigned long long)a1[3] )
{
*v7 = *i;
*i = a1[1];
a1[1] = i;
*((_DWORD *)a1 + 11) = 0;
}
return v10;
}
| ma_alloc_root:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x30],0x0
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x8
SUB RAX,0x1
AND RAX,-0x8
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RAX],0x0
JZ 0x00124bdc
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x8]
CMP RAX,qword ptr [RBP + -0x18]
JNC 0x00124b93
MOV RCX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RCX + 0x2c]
MOV EDX,EAX
ADD EDX,0x1
MOV dword ptr [RCX + 0x2c],EDX
CMP EAX,0x10
JC 0x00124b93
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
CMP qword ptr [RAX + 0x8],0x1000
JNC 0x00124b93
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x2c],0x0
LAB_00124b93:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x30],RAX
LAB_00124b9e:
XOR EAX,EAX
CMP qword ptr [RBP + -0x30],0x0
MOV byte ptr [RBP + -0x39],AL
JZ 0x00124bbc
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x8]
CMP RAX,qword ptr [RBP + -0x18]
SETC AL
MOV byte ptr [RBP + -0x39],AL
LAB_00124bbc:
MOV AL,byte ptr [RBP + -0x39]
TEST AL,0x1
JNZ 0x00124bc5
JMP 0x00124bda
LAB_00124bc5:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00124b9e
LAB_00124bda:
JMP 0x00124bdc
LAB_00124bdc:
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x00124cba
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x18
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x20]
AND RCX,-0x2
MOV RDX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RDX + 0x28]
SHR EDX,0x2
MOV EDX,EDX
IMUL RCX,RDX
CMP RAX,RCX
JBE 0x00124c1e
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x18
MOV qword ptr [RBP + -0x48],RAX
JMP 0x00124c3e
LAB_00124c1e:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
AND RAX,-0x2
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x28]
SHR ECX,0x2
MOV ECX,ECX
IMUL RAX,RCX
MOV qword ptr [RBP + -0x48],RAX
LAB_00124c3e:
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001135b0
MOV qword ptr [RBP + -0x30],RAX
CMP RAX,0x0
JNZ 0x00124c78
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x30],0x0
JZ 0x00124c6b
MOV RAX,qword ptr [RBP + -0x10]
CALL qword ptr [RAX + 0x30]
LAB_00124c6b:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00124d2e
LAB_00124c78:
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x28]
ADD ECX,0x1
MOV dword ptr [RAX + 0x28],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RBP + -0x20]
SUB RCX,0x18
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RCX
LAB_00124cba:
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RCX + 0x10]
MOV RDX,qword ptr [RBP + -0x30]
SUB RCX,qword ptr [RDX + 0x8]
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RCX + 0x8]
SUB RAX,RDX
MOV qword ptr [RCX + 0x8],RAX
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x18]
JNC 0x00124d26
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x2c],0x0
LAB_00124d26:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
LAB_00124d2e:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x50
POP RBP
RET
|
long ma_alloc_root(long *param_1,long param_2)
{
uint uVar1;
long *plVar2;
long lVar3;
long lVar4;
long lVar5;
ulong uVar6;
bool bVar7;
size_t local_50;
long *local_40;
long *local_38;
local_38 = (long *)0x0;
uVar6 = param_2 + 7U & 0xfffffffffffffff8;
local_40 = param_1;
if (*param_1 != 0) {
if (((*(ulong *)(*param_1 + 8) < uVar6) &&
(uVar1 = *(uint *)((long)param_1 + 0x2c), *(uint *)((long)param_1 + 0x2c) = uVar1 + 1,
0xf < uVar1)) && (*(ulong *)(*param_1 + 8) < 0x1000)) {
plVar2 = (long *)*param_1;
*param_1 = *plVar2;
*plVar2 = param_1[1];
param_1[1] = (long)plVar2;
*(int4 *)((long)param_1 + 0x2c) = 0;
}
local_38 = (long *)*param_1;
while( true ) {
bVar7 = false;
if (local_38 != (long *)0x0) {
bVar7 = (ulong)local_38[1] < uVar6;
}
if (!bVar7) break;
local_40 = local_38;
local_38 = (long *)*local_38;
}
}
if (local_38 == (long *)0x0) {
if ((param_1[4] & 0xfffffffffffffffeU) * (ulong)(*(uint *)(param_1 + 5) >> 2) < uVar6 + 0x18) {
local_50 = uVar6 + 0x18;
}
else {
local_50 = (param_1[4] & 0xfffffffffffffffeU) * (ulong)(*(uint *)(param_1 + 5) >> 2);
}
local_38 = (long *)malloc(local_50);
if (local_38 == (long *)0x0) {
if (param_1[6] != 0) {
(*(code *)param_1[6])();
}
return 0;
}
*(int *)(param_1 + 5) = (int)param_1[5] + 1;
*local_38 = *local_40;
local_38[2] = local_50;
local_38[1] = local_50 - 0x18;
*local_40 = (long)local_38;
}
lVar3 = local_38[2];
lVar4 = local_38[1];
lVar5 = local_38[1];
local_38[1] = lVar5 - uVar6;
if (lVar5 - uVar6 < (ulong)param_1[3]) {
*local_40 = *local_38;
*local_38 = param_1[1];
param_1[1] = (long)local_38;
*(int4 *)((long)param_1 + 0x2c) = 0;
}
return (long)local_38 + (lVar3 - lVar4);
}
| |
23,930 | ftxui::ScreenInteractive::PostMain() | Andrewchistyakov[P]flashcards_lyc/build_O1/_deps/ftxui-src/src/ftxui/component/screen_interactive.cpp | void ScreenInteractive::PostMain() {
// Put cursor position at the end of the drawing.
ResetCursorPosition();
g_active_screen = nullptr;
// Restore suspended screen.
if (suspended_screen_) {
// Clear screen, and put the cursor at the beginning of the drawing.
std::cout << ResetPosition(/*clear=*/true);
dimx_ = 0;
dimy_ = 0;
Uninstall();
std::swap(g_active_screen, suspended_screen_);
g_active_screen->Install();
} else {
Uninstall();
std::cout << '\r';
// On final exit, keep the current drawing and reset cursor position one
// line after it.
if (!use_alternative_screen_) {
std::cout << std::endl;
}
}
} | O1 | cpp | ftxui::ScreenInteractive::PostMain():
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x2e03e
movq $0x0, 0x2cace(%rip) # 0x5b2c0
cmpq $0x0, 0x58(%rbx)
je 0x2e869
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x3a618
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x2b79c(%rip), %rdi # 0x59fb8
callq 0xb490
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e83c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb400
movq $0x0, 0x10(%rbx)
movq %rbx, %rdi
callq 0x2e088
movq 0x2ca6d(%rip), %rax # 0x5b2c0
movq 0x58(%rbx), %rdi
movq %rdi, 0x2ca62(%rip) # 0x5b2c0
movq %rax, 0x58(%rbx)
callq 0x2e0c0
jmp 0x2e8ba
movq %rbx, %rdi
callq 0x2e088
leaq 0x8(%rsp), %rsi
movb $0xd, (%rsi)
movq 0x2b738(%rip), %r14 # 0x59fb8
movl $0x1, %edx
movq %r14, %rdi
callq 0xb490
cmpb $0x0, 0x64(%rbx)
jne 0x2e8ba
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xb3c0
movsbl %al, %esi
movq %r14, %rdi
callq 0xb030
movq %rax, %rdi
callq 0xb280
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e8e0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb400
movq %rbx, %rdi
callq 0xb780
| _ZN5ftxui17ScreenInteractive8PostMainEv:
push r14
push rbx
sub rsp, 28h
mov rbx, rdi
call _ZN5ftxui17ScreenInteractive19ResetCursorPositionEv; ftxui::ScreenInteractive::ResetCursorPosition(void)
mov cs:_ZN5ftxui12_GLOBAL__N_115g_active_screenE, 0; ftxui::`anonymous namespace'::g_active_screen
cmp qword ptr [rbx+58h], 0
jz short loc_2E869
lea r14, [rsp+38h+var_30]
mov rdi, r14
mov rsi, rbx
mov edx, 1
call _ZNK5ftxui6Screen13ResetPositionB5cxx11Eb; ftxui::Screen::ResetPosition(bool)
mov rsi, [r14]
mov rdx, [r14+8]
mov rdi, cs:_ZSt4cout_ptr
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rax, [rsp+38h+var_20]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_2E83C
mov rsi, [rsp+38h+var_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2E83C:
mov qword ptr [rbx+10h], 0
mov rdi, rbx; this
call _ZN5ftxui17ScreenInteractive9UninstallEv; ftxui::ScreenInteractive::Uninstall(void)
mov rax, cs:_ZN5ftxui12_GLOBAL__N_115g_active_screenE; ftxui::`anonymous namespace'::g_active_screen
mov rdi, [rbx+58h]; this
mov cs:_ZN5ftxui12_GLOBAL__N_115g_active_screenE, rdi; ftxui::`anonymous namespace'::g_active_screen
mov [rbx+58h], rax
call _ZN5ftxui17ScreenInteractive7InstallEv; ftxui::ScreenInteractive::Install(void)
jmp short loc_2E8BA
loc_2E869:
mov rdi, rbx; this
call _ZN5ftxui17ScreenInteractive9UninstallEv; ftxui::ScreenInteractive::Uninstall(void)
lea rsi, [rsp+38h+var_30]
mov byte ptr [rsi], 0Dh
mov r14, cs:_ZSt4cout_ptr
mov edx, 1
mov rdi, r14
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
cmp byte ptr [rbx+64h], 0
jnz short loc_2E8BA
mov rax, [r14]
mov rdi, [rax-18h]
add rdi, r14
mov esi, 0Ah
call __ZNKSt9basic_iosIcSt11char_traitsIcEE5widenEc; std::ios::widen(char)
movsx esi, al; char
mov rdi, r14; this
call __ZNSo3putEc; std::ostream::put(char)
mov rdi, rax; this
call __ZNSo5flushEv; std::ostream::flush(void)
loc_2E8BA:
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_2E8E0
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2E8E0:
mov rdi, rbx
call __Unwind_Resume
| PostMain:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
CALL 0x0012e03e
MOV qword ptr [0x0015b2c0],0x0
CMP qword ptr [RBX + 0x58],0x0
JZ 0x0012e869
LEA R14,[RSP + 0x8]
MOV RDI,R14
MOV RSI,RBX
MOV EDX,0x1
CALL 0x0013a618
MOV RSI,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
LAB_0012e815:
MOV RDI,qword ptr [0x00159fb8]
CALL 0x0010b490
LAB_0012e821:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0012e83c
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0010b400
LAB_0012e83c:
MOV qword ptr [RBX + 0x10],0x0
MOV RDI,RBX
CALL 0x0012e088
MOV RAX,qword ptr [0x0015b2c0]
MOV RDI,qword ptr [RBX + 0x58]
MOV qword ptr [0x0015b2c0],RDI
MOV qword ptr [RBX + 0x58],RAX
CALL 0x0012e0c0
JMP 0x0012e8ba
LAB_0012e869:
MOV RDI,RBX
CALL 0x0012e088
LEA RSI,[RSP + 0x8]
MOV byte ptr [RSI],0xd
MOV R14,qword ptr [0x00159fb8]
MOV EDX,0x1
MOV RDI,R14
CALL 0x0010b490
CMP byte ptr [RBX + 0x64],0x0
JNZ 0x0012e8ba
MOV RAX,qword ptr [R14]
MOV RDI,qword ptr [RAX + -0x18]
ADD RDI,R14
MOV ESI,0xa
CALL 0x0010b3c0
MOVSX ESI,AL
MOV RDI,R14
CALL 0x0010b030
MOV RDI,RAX
CALL 0x0010b280
LAB_0012e8ba:
ADD RSP,0x28
POP RBX
POP R14
RET
|
/* ftxui::ScreenInteractive::PostMain() */
void __thiscall ftxui::ScreenInteractive::PostMain(ScreenInteractive *this)
{
ScreenInteractive *this_00;
char cVar1;
int *puVar2;
ScreenInteractive *pSVar3;
char local_30;
int7 uStack_2f;
long local_28;
long local_20 [2];
ResetCursorPosition(this);
(anonymous_namespace)::g_active_screen = (ScreenInteractive *)0x0;
if (*(long *)(this + 0x58) == 0) {
Uninstall(this);
puVar2 = PTR_cout_00159fb8;
local_30 = '\r';
std::__ostream_insert<char,std::char_traits<char>>((ostream *)PTR_cout_00159fb8,&local_30,1);
if (this[100] == (ScreenInteractive)0x0) {
cVar1 = (char)puVar2;
std::ios::widen((char)*(int8 *)(*(long *)puVar2 + -0x18) + cVar1);
std::ostream::put(cVar1);
std::ostream::flush();
}
}
else {
Screen::ResetPosition_abi_cxx11_(SUB81(&local_30,0));
/* try { // try from 0012e815 to 0012e820 has its CatchHandler @ 0012e8c2 */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cout_00159fb8,(char *)CONCAT71(uStack_2f,local_30),local_28);
if ((long *)CONCAT71(uStack_2f,local_30) != local_20) {
operator_delete((long *)CONCAT71(uStack_2f,local_30),local_20[0] + 1);
}
*(int8 *)(this + 0x10) = 0;
Uninstall(this);
this_00 = *(ScreenInteractive **)(this + 0x58);
pSVar3 = this_00;
*(ScreenInteractive **)(this + 0x58) = (anonymous_namespace)::g_active_screen;
(anonymous_namespace)::g_active_screen = pSVar3;
Install(this_00);
}
return;
}
| ||
23,931 | testing::internal::PrintTo(wchar_t const*, std::ostream*) | AlayaLite/build_O3/_deps/googletest-src/googletest/src/gtest-printers.cc | void PrintTo(const wchar_t* s, ostream* os) { PrintCStringTo(s, os); } | O3 | cpp | testing::internal::PrintTo(wchar_t const*, std::ostream*):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x5941a
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11590
leaq 0x2f495(%rip), %rsi # 0x88885
movl $0xd, %edx
movq %rax, %rdi
callq 0x11b90
movq %r14, %rdi
callq 0x117a0
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x59a07
leaq 0x2f381(%rip), %rsi # 0x887a2
movl $0x4, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11b90
| _ZN7testing8internal7PrintToEPKwPSo:
push r14
push rbx
push rax
mov rbx, rsi
test rdi, rdi
jz short loc_5941A
mov r14, rdi
mov rdi, rbx
mov rsi, r14
call __ZNSo9_M_insertIPKvEERSoT_; std::ostream::_M_insert<void const*>(void const*)
lea rsi, aPointingTo; " pointing to "
mov edx, 0Dh
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, r14
call _wcslen
mov rdi, r14
mov rsi, rax
mov rdx, rbx
add rsp, 8
pop rbx
pop r14
jmp _ZN7testing8internalL20PrintCharsAsStringToIwEENS0_10CharFormatEPKT_mPSo; testing::internal::PrintCharsAsStringTo<wchar_t>(wchar_t const*,ulong,std::ostream *)
loc_5941A:
lea rsi, aNull_0; "NULL"
mov edx, 4
mov rdi, rbx
add rsp, 8
pop rbx
pop r14
jmp __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
| long long testing::internal::PrintTo(long long a1, long long a2, long long a3)
{
long long v3; // rax
long long v4; // rax
if ( !a1 )
return std::__ostream_insert<char,std::char_traits<char>>(a2, "NULL", 4LL);
v3 = std::ostream::_M_insert<void const*>(a2, a1, a3);
std::__ostream_insert<char,std::char_traits<char>>(v3, " pointing to ", 13LL);
v4 = wcslen(a1);
return testing::internal::PrintCharsAsStringTo<wchar_t>(a1, v4, a2);
}
| PrintTo:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
TEST RDI,RDI
JZ 0x0015941a
MOV R14,RDI
MOV RDI,RBX
MOV RSI,R14
CALL 0x00111590
LEA RSI,[0x188885]
MOV EDX,0xd
MOV RDI,RAX
CALL 0x00111b90
MOV RDI,R14
CALL 0x001117a0
MOV RDI,R14
MOV RSI,RAX
MOV RDX,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x00159a07
LAB_0015941a:
LEA RSI,[0x1887a2]
MOV EDX,0x4
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x00111b90
|
/* testing::internal::PrintTo(wchar_t const*, std::ostream*) */
void testing::internal::PrintTo(wchar_t *param_1,ostream *param_2)
{
ostream *poVar1;
size_t sVar2;
if (param_1 != (wchar_t *)0x0) {
poVar1 = std::ostream::_M_insert<void_const*>(param_2);
std::__ostream_insert<char,std::char_traits<char>>(poVar1," pointing to ",0xd);
sVar2 = wcslen(param_1);
PrintCharsAsStringTo<wchar_t>(param_1,sVar2,param_2);
return;
}
std::__ostream_insert<char,std::char_traits<char>>(param_2,"NULL",4);
return;
}
| |
23,932 | usage | eloqsql/client/mysqlcheck.c | static void usage(void)
{
DBUG_ENTER("usage");
print_version();
puts(ORACLE_WELCOME_COPYRIGHT_NOTICE("2000"));
puts("This program can be used to CHECK (-c, -m, -C), REPAIR (-r), ANALYZE (-a),");
puts("or OPTIMIZE (-o) tables. Some of the options (like -e or -q) can be");
puts("used at the same time. Not all options are supported by all storage engines.");
puts("The options -c, -r, -a, and -o are exclusive to each other, which");
puts("means that the last option will be used, if several was specified.\n");
puts("The option -c (--check) will be used by default, if none was specified.");
puts("You can change the default behavior by making a symbolic link, or");
puts("copying this file somewhere with another name, the alternatives are:");
puts("mysqlrepair: The default option will be -r");
puts("mysqlanalyze: The default option will be -a");
puts("mysqloptimize: The default option will be -o\n");
printf("Usage: %s [OPTIONS] database [tables]\n", my_progname);
printf("OR %s [OPTIONS] --databases DB1 [DB2 DB3...]\n",
my_progname);
puts("Please consult the MariaDB Knowledge Base at");
puts("https://mariadb.com/kb/en/mysqlcheck for latest information about");
puts("this program.");
print_defaults("my", load_default_groups);
puts("");
my_print_help(my_long_options);
my_print_variables(my_long_options);
DBUG_VOID_RETURN;
} | O0 | c | usage:
pushq %rbp
movq %rsp, %rbp
callq 0x38970
leaq 0x90dce(%rip), %rdi # 0xc91fe
callq 0x369b0
leaq 0x90e08(%rip), %rdi # 0xc9244
callq 0x369b0
leaq 0x90e47(%rip), %rdi # 0xc928f
callq 0x369b0
leaq 0x90e7f(%rip), %rdi # 0xc92d3
callq 0x369b0
leaq 0x90ec0(%rip), %rdi # 0xc9320
callq 0x369b0
leaq 0x90ef6(%rip), %rdi # 0xc9362
callq 0x369b0
leaq 0x90f2e(%rip), %rdi # 0xc93a6
callq 0x369b0
leaq 0x90f6a(%rip), %rdi # 0xc93ee
callq 0x369b0
leaq 0x90fa0(%rip), %rdi # 0xc9430
callq 0x369b0
leaq 0x90fd9(%rip), %rdi # 0xc9475
callq 0x369b0
leaq 0x90ffa(%rip), %rdi # 0xc94a2
callq 0x369b0
leaq 0x9101b(%rip), %rdi # 0xc94cf
callq 0x369b0
leaq 0x3bd400(%rip), %rax # 0x3f58c0
movq (%rax), %rsi
leaq 0x91033(%rip), %rdi # 0xc94fd
movb $0x0, %al
callq 0x36070
leaq 0x3bd3e8(%rip), %rax # 0x3f58c0
movq (%rax), %rsi
leaq 0x91042(%rip), %rdi # 0xc9524
movb $0x0, %al
callq 0x36070
leaq 0x91066(%rip), %rdi # 0xc9556
callq 0x369b0
leaq 0x91087(%rip), %rdi # 0xc9583
callq 0x369b0
leaq 0x910bd(%rip), %rdi # 0xc95c5
callq 0x369b0
leaq 0x90b38(%rip), %rdi # 0xc904c
leaq 0x1f7b65(%rip), %rsi # 0x230080
callq 0x728e0
leaq 0x9886c(%rip), %rdi # 0xd0d93
callq 0x369b0
leaq 0x1f7b8d(%rip), %rdi # 0x2300c0
callq 0x7adc0
leaq 0x1f7b81(%rip), %rdi # 0x2300c0
callq 0x7b470
jmp 0x38546
popq %rbp
retq
nopl (%rax,%rax)
| usage:
push rbp
mov rbp, rsp
call print_version
lea rdi, aCopyrightC2000; "Copyright (c) 2000, 2018, Oracle, Maria"...
call _puts
lea rdi, aThisProgramCan; "This program can be used to CHECK (-c, "...
call _puts
lea rdi, aOrOptimizeOTab; "or OPTIMIZE (-o) tables. Some of the op"...
call _puts
lea rdi, aUsedAtTheSameT; "used at the same time. Not all options "...
call _puts
lea rdi, aTheOptionsCRAA; "The options -c, -r, -a, and -o are excl"...
call _puts
lea rdi, aMeansThatTheLa; "means that the last option will be used"...
call _puts
lea rdi, aTheOptionCChec; "The option -c (--check) will be used by"...
call _puts
lea rdi, aYouCanChangeTh; "You can change the default behavior by "...
call _puts
lea rdi, aCopyingThisFil; "copying this file somewhere with anothe"...
call _puts
lea rdi, aMysqlrepairThe; "mysqlrepair: The default option will "...
call _puts
lea rdi, aMysqlanalyzeTh; "mysqlanalyze: The default option will "...
call _puts
lea rdi, aMysqloptimizeT; "mysqloptimize: The default option will "...
call _puts
lea rax, my_progname
mov rsi, [rax]
lea rdi, aUsageSOptionsD; "Usage: %s [OPTIONS] database [tables]\n"
mov al, 0
call _printf
lea rax, my_progname
mov rsi, [rax]
lea rdi, aOrSOptionsData; "OR %s [OPTIONS] --databases DB1 [DB"...
mov al, 0
call _printf
lea rdi, aPleaseConsultT; "Please consult the MariaDB Knowledge Ba"...
call _puts
lea rdi, aHttpsMariadbCo; "https://mariadb.com/kb/en/mysqlcheck fo"...
call _puts
lea rdi, aThisProgram; "this program."
call _puts
lea rdi, aMy; "my"
lea rsi, load_default_groups
call print_defaults
lea rdi, asc_D0D8F+4; ""
call _puts
lea rdi, my_long_options
call my_print_help
lea rdi, my_long_options
call my_print_variables
jmp short $+2
loc_38546:
pop rbp
retn
| long long usage()
{
print_version();
puts("Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others.\n");
puts("This program can be used to CHECK (-c, -m, -C), REPAIR (-r), ANALYZE (-a),");
puts("or OPTIMIZE (-o) tables. Some of the options (like -e or -q) can be");
puts("used at the same time. Not all options are supported by all storage engines.");
puts("The options -c, -r, -a, and -o are exclusive to each other, which");
puts("means that the last option will be used, if several was specified.\n");
puts("The option -c (--check) will be used by default, if none was specified.");
puts("You can change the default behavior by making a symbolic link, or");
puts("copying this file somewhere with another name, the alternatives are:");
puts("mysqlrepair: The default option will be -r");
puts("mysqlanalyze: The default option will be -a");
puts("mysqloptimize: The default option will be -o\n");
printf("Usage: %s [OPTIONS] database [tables]\n", my_progname);
printf("OR %s [OPTIONS] --databases DB1 [DB2 DB3...]\n", my_progname);
puts("Please consult the MariaDB Knowledge Base at");
puts("https://mariadb.com/kb/en/mysqlcheck for latest information about");
puts("this program.");
print_defaults("my", load_default_groups);
puts("");
my_print_help(&my_long_options);
return my_print_variables(&my_long_options);
}
| usage:
PUSH RBP
MOV RBP,RSP
CALL 0x00138970
LEA RDI,[0x1c91fe]
CALL 0x001369b0
LEA RDI,[0x1c9244]
CALL 0x001369b0
LEA RDI,[0x1c928f]
CALL 0x001369b0
LEA RDI,[0x1c92d3]
CALL 0x001369b0
LEA RDI,[0x1c9320]
CALL 0x001369b0
LEA RDI,[0x1c9362]
CALL 0x001369b0
LEA RDI,[0x1c93a6]
CALL 0x001369b0
LEA RDI,[0x1c93ee]
CALL 0x001369b0
LEA RDI,[0x1c9430]
CALL 0x001369b0
LEA RDI,[0x1c9475]
CALL 0x001369b0
LEA RDI,[0x1c94a2]
CALL 0x001369b0
LEA RDI,[0x1c94cf]
CALL 0x001369b0
LEA RAX,[0x4f58c0]
MOV RSI,qword ptr [RAX]
LEA RDI,[0x1c94fd]
MOV AL,0x0
CALL 0x00136070
LEA RAX,[0x4f58c0]
MOV RSI,qword ptr [RAX]
LEA RDI,[0x1c9524]
MOV AL,0x0
CALL 0x00136070
LEA RDI,[0x1c9556]
CALL 0x001369b0
LEA RDI,[0x1c9583]
CALL 0x001369b0
LEA RDI,[0x1c95c5]
CALL 0x001369b0
LEA RDI,[0x1c904c]
LEA RSI,[0x330080]
CALL 0x001728e0
LEA RDI,[0x1d0d93]
CALL 0x001369b0
LEA RDI,[0x3300c0]
CALL 0x0017adc0
LEA RDI,[0x3300c0]
CALL 0x0017b470
JMP 0x00138546
LAB_00138546:
POP RBP
RET
|
void usage(void)
{
print_version();
puts("Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others.\n");
puts("This program can be used to CHECK (-c, -m, -C), REPAIR (-r), ANALYZE (-a),");
puts("or OPTIMIZE (-o) tables. Some of the options (like -e or -q) can be");
puts("used at the same time. Not all options are supported by all storage engines.");
puts("The options -c, -r, -a, and -o are exclusive to each other, which");
puts("means that the last option will be used, if several was specified.\n");
puts("The option -c (--check) will be used by default, if none was specified.");
puts("You can change the default behavior by making a symbolic link, or");
puts("copying this file somewhere with another name, the alternatives are:");
puts("mysqlrepair: The default option will be -r");
puts("mysqlanalyze: The default option will be -a");
puts("mysqloptimize: The default option will be -o\n");
printf("Usage: %s [OPTIONS] database [tables]\n",my_progname);
printf("OR %s [OPTIONS] --databases DB1 [DB2 DB3...]\n",my_progname);
puts("Please consult the MariaDB Knowledge Base at");
puts("https://mariadb.com/kb/en/mysqlcheck for latest information about");
puts("this program.");
print_defaults(&DAT_001c904c,load_default_groups);
puts(&DAT_001d0d93);
my_print_help(my_long_options);
my_print_variables(my_long_options);
return;
}
| |
23,933 | 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>>>>::insert(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>> const&) | monkey531[P]llama/common/json.hpp | std::pair<iterator, bool> insert( const value_type& value )
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, value.first))
{
return {it, false};
}
}
Container::push_back(value);
return {--this->end(), true};
} | O2 | 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>>>>::insert(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>> const&):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rbx
cmpq 0x8(%r14), %rbx
je 0x6dda1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x369f3
testb %al, %al
jne 0x6ddb8
addq $0x30, %rbx
jmp 0x6dd86
movq %r14, %rdi
movq %r15, %rsi
callq 0x6ddc4
movq 0x8(%r14), %rbx
addq $-0x30, %rbx
movb $0x1, %dl
jmp 0x6ddba
xorl %edx, %edx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE6insertERKSI_:
push r15
push r14
push rbx
mov r15, rsi
mov r14, rdi
mov rbx, [rdi]
loc_6DD86:
cmp rbx, [r14+8]
jz short loc_6DDA1
mov rdi, rbx
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_6DDB8
add rbx, 30h ; '0'
jmp short loc_6DD86
loc_6DDA1:
mov rdi, r14
mov rsi, r15
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE9push_backERKSG_; std::vector<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>>>::push_back(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>> const&)
mov rbx, [r14+8]
add rbx, 0FFFFFFFFFFFFFFD0h
mov dl, 1
jmp short loc_6DDBA
loc_6DDB8:
xor edx, edx
loc_6DDBA:
mov rax, rbx
pop rbx
pop r14
pop r15
retn
| 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>>>>::insert(
_QWORD **a1,
_QWORD *a2)
{
_QWORD *i; // rbx
for ( i = *a1; i != a1[1]; i += 6 )
{
if ( std::operator==<char>(i, a2) )
return (long long)i;
}
std::vector<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>>>::push_back(
a1,
a2);
return (long long)(a1[1] - 6);
}
| insert:
PUSH R15
PUSH R14
PUSH RBX
MOV R15,RSI
MOV R14,RDI
MOV RBX,qword ptr [RDI]
LAB_0016dd86:
CMP RBX,qword ptr [R14 + 0x8]
JZ 0x0016dda1
MOV RDI,RBX
MOV RSI,R15
CALL 0x001369f3
TEST AL,AL
JNZ 0x0016ddb8
ADD RBX,0x30
JMP 0x0016dd86
LAB_0016dda1:
MOV RDI,R14
MOV RSI,R15
CALL 0x0016ddc4
MOV RBX,qword ptr [R14 + 0x8]
ADD RBX,-0x30
MOV DL,0x1
JMP 0x0016ddba
LAB_0016ddb8:
XOR EDX,EDX
LAB_0016ddba:
MOV RAX,RBX
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> > > >::insert(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> > const&) */
int1 [16] __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>>>>
::insert(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,pair *param_1)
{
char cVar1;
int8 extraout_RDX;
int8 uVar2;
string *psVar3;
int1 auVar4 [16];
psVar3 = *(string **)this;
do {
if (psVar3 == *(string **)(this + 8)) {
std::
vector<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>>,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>>>>
::push_back((vector<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>>,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,param_1);
psVar3 = (string *)(*(long *)(this + 8) + -0x30);
uVar2 = CONCAT71((int7)((ulong)extraout_RDX >> 8),1);
LAB_0016ddba:
auVar4._8_8_ = uVar2;
auVar4._0_8_ = psVar3;
return auVar4;
}
cVar1 = std::operator==(psVar3,(string *)param_1);
if (cVar1 != '\0') {
uVar2 = 0;
goto LAB_0016ddba;
}
psVar3 = psVar3 + 0x30;
} while( true );
}
| |
23,934 | my_wc_mb_big5 | eloqsql/strings/ctype-big5.c | static int
my_wc_mb_big5(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int code;
if (s >= e)
return MY_CS_TOOSMALL;
if ((int) wc < 0x80)
{
s[0]= (uchar) wc;
return 1;
}
if (!(code=func_uni_big5_onechar(wc)))
return MY_CS_ILUNI;
if (s+2>e)
return MY_CS_TOOSMALL;
s[0]=code>>8;
s[1]=code&0xFF;
return 2;
} | O0 | c | my_wc_mb_big5:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0xe87bb
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0xe8834
movq -0x18(%rbp), %rax
cmpl $0x80, %eax
jge 0xe87db
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xe8834
movq -0x18(%rbp), %rax
movl %eax, %edi
callq 0xe8b30
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0xe87f7
movl $0x0, -0x4(%rbp)
jmp 0xe8834
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0xe880e
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0xe8834
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)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| my_wc_mb_big5:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_E87BB
mov [rbp+var_4], 0FFFFFF9Bh
jmp short loc_E8834
loc_E87BB:
mov rax, [rbp+var_18]
cmp eax, 80h
jge short loc_E87DB
mov rax, [rbp+var_18]
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov [rbp+var_4], 1
jmp short loc_E8834
loc_E87DB:
mov rax, [rbp+var_18]
mov edi, eax
call func_uni_big5_onechar
mov [rbp+var_2C], eax
cmp eax, 0
jnz short loc_E87F7
mov [rbp+var_4], 0
jmp short loc_E8834
loc_E87F7:
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_E880E
mov [rbp+var_4], 0FFFFFF9Bh
jmp short loc_E8834
loc_E880E:
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
loc_E8834:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long my_wc_mb_big5(long long a1, int a2, _BYTE *a3, unsigned long long a4)
{
int v5; // [rsp+4h] [rbp-2Ch]
if ( (unsigned long long)a3 < a4 )
{
if ( a2 >= 128 )
{
v5 = func_uni_big5_onechar((unsigned int)a2);
if ( v5 )
{
if ( (unsigned long long)(a3 + 2) <= a4 )
{
*a3 = BYTE1(v5);
a3[1] = v5;
return 2;
}
else
{
return (unsigned int)-101;
}
}
else
{
return 0;
}
}
else
{
*a3 = a2;
return 1;
}
}
else
{
return (unsigned int)-101;
}
}
| my_wc_mb_big5:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x001e87bb
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x001e8834
LAB_001e87bb:
MOV RAX,qword ptr [RBP + -0x18]
CMP EAX,0x80
JGE 0x001e87db
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 0x001e8834
LAB_001e87db:
MOV RAX,qword ptr [RBP + -0x18]
MOV EDI,EAX
CALL 0x001e8b30
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JNZ 0x001e87f7
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001e8834
LAB_001e87f7:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x001e880e
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x001e8834
LAB_001e880e:
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
LAB_001e8834:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 my_wc_mb_big5(int8 param_1,int param_2,int1 *param_3,int1 *param_4)
{
int iVar1;
int4 local_c;
if (param_3 < param_4) {
if (param_2 < 0x80) {
*param_3 = (char)param_2;
local_c = 1;
}
else {
iVar1 = func_uni_big5_onechar(param_2);
if (iVar1 == 0) {
local_c = 0;
}
else if (param_4 < param_3 + 2) {
local_c = 0xffffff9b;
}
else {
*param_3 = (char)((uint)iVar1 >> 8);
param_3[1] = (char)iVar1;
local_c = 2;
}
}
}
else {
local_c = 0xffffff9b;
}
return local_c;
}
| |
23,935 | JS_GetFunctionBytecode | bluesky950520[P]quickjs/quickjs.c | static JSFunctionBytecode *JS_GetFunctionBytecode(JSValue val)
{
JSObject *p;
if (JS_VALUE_GET_TAG(val) != JS_TAG_OBJECT)
return NULL;
p = JS_VALUE_GET_OBJ(val);
if (!js_class_has_bytecode(p->class_id))
return NULL;
return p->u.func.function_bytecode;
} | O0 | c | JS_GetFunctionBytecode:
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpl $-0x1, %eax
je 0x5fce3
movq $0x0, 0x20(%rsp)
jmp 0x5fd19
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzwl 0x6(%rax), %edi
callq 0x4a240
cmpl $0x0, %eax
jne 0x5fd0b
movq $0x0, 0x20(%rsp)
jmp 0x5fd19
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
| JS_GetFunctionBytecode:
sub rsp, 28h
mov [rsp+28h+var_18], rdi
mov [rsp+28h+var_10], rsi
mov rax, [rsp+28h+var_10]
cmp eax, 0FFFFFFFFh
jz short loc_5FCE3
mov [rsp+28h+var_8], 0
jmp short loc_5FD19
loc_5FCE3:
mov rax, [rsp+28h+var_18]
mov [rsp+28h+var_20], rax
mov rax, [rsp+28h+var_20]
movzx edi, word ptr [rax+6]
call js_class_has_bytecode
cmp eax, 0
jnz short loc_5FD0B
mov [rsp+28h+var_8], 0
jmp short loc_5FD19
loc_5FD0B:
mov rax, [rsp+28h+var_20]
mov rax, [rax+30h]
mov [rsp+28h+var_8], rax
loc_5FD19:
mov rax, [rsp+28h+var_8]
add rsp, 28h
retn
| long long JS_GetFunctionBytecode(long long a1, int a2)
{
if ( a2 != -1 )
return 0LL;
if ( js_class_has_bytecode(*(unsigned __int16 *)(a1 + 6)) )
return *(_QWORD *)(a1 + 48);
return 0LL;
}
| JS_GetFunctionBytecode:
SUB RSP,0x28
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x18],RSI
MOV RAX,qword ptr [RSP + 0x18]
CMP EAX,-0x1
JZ 0x0015fce3
MOV qword ptr [RSP + 0x20],0x0
JMP 0x0015fd19
LAB_0015fce3:
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOVZX EDI,word ptr [RAX + 0x6]
CALL 0x0014a240
CMP EAX,0x0
JNZ 0x0015fd0b
MOV qword ptr [RSP + 0x20],0x0
JMP 0x0015fd19
LAB_0015fd0b:
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RSP + 0x20],RAX
LAB_0015fd19:
MOV RAX,qword ptr [RSP + 0x20]
ADD RSP,0x28
RET
|
int8 JS_GetFunctionBytecode(long param_1,int param_2)
{
int iVar1;
int8 local_8;
if (param_2 == -1) {
iVar1 = js_class_has_bytecode(*(int2 *)(param_1 + 6));
if (iVar1 == 0) {
local_8 = 0;
}
else {
local_8 = *(int8 *)(param_1 + 0x30);
}
}
else {
local_8 = 0;
}
return local_8;
}
| |
23,936 | JS_GetFunctionBytecode | bluesky950520[P]quickjs/quickjs.c | static JSFunctionBytecode *JS_GetFunctionBytecode(JSValue val)
{
JSObject *p;
if (JS_VALUE_GET_TAG(val) != JS_TAG_OBJECT)
return NULL;
p = JS_VALUE_GET_OBJ(val);
if (!js_class_has_bytecode(p->class_id))
return NULL;
return p->u.func.function_bytecode;
} | O2 | c | JS_GetFunctionBytecode:
cmpl $-0x1, %edx
jne 0x31320
movzwl 0x6(%rsi), %eax
cmpq $0x38, %rax
ja 0x31320
movabsq $0x110000000012000, %rcx # imm = 0x110000000012000
btq %rax, %rcx
jae 0x31320
movq 0x30(%rsi), %rax
testq %rax, %rax
je 0x31320
movzwl 0x18(%rax), %eax
andl $0x3, %eax
cmpw $0x2, %ax
jne 0x31320
pushq $0x3
popq %rdx
jmp 0x31336
pushq %rax
leaq 0x574bb(%rip), %rsi # 0x887e3
xorl %eax, %eax
callq 0x1c64d
pushq $0x6
popq %rdx
addq $0x8, %rsp
xorl %eax, %eax
retq
| js_function_proto_caller:
cmp edx, 0FFFFFFFFh
jnz short loc_31320
movzx eax, word ptr [rsi+6]
cmp rax, 38h ; '8'
ja short loc_31320
mov rcx, 110000000012000h
bt rcx, rax
jnb short loc_31320
mov rax, [rsi+30h]
test rax, rax
jz short loc_31320
movzx eax, word ptr [rax+18h]
and eax, 3
cmp ax, 2
jnz short loc_31320
push 3
pop rdx
jmp short loc_31336
loc_31320:
push rax
lea rsi, aInvalidPropert; "invalid property access"
xor eax, eax
call JS_ThrowTypeError
push 6
pop rdx
add rsp, 8
loc_31336:
xor eax, eax
retn
| long long js_function_proto_caller(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
unsigned long long v14; // rax
if ( (_DWORD)a3 != -1
|| (v14 = *(unsigned __int16 *)(a2 + 6), v14 > 0x38)
|| (a4 = 0x110000000012000LL, !_bittest64(&a4, v14))
|| (v14 = *(_QWORD *)(a2 + 48)) == 0
|| (LOWORD(v14) = *(_WORD *)(v14 + 24) & 3, (_WORD)v14 != 2) )
{
JS_ThrowTypeError(a1, (long long)"invalid property access", a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v14);
}
return 0LL;
}
| js_function_proto_caller:
CMP EDX,-0x1
JNZ 0x00131320
MOVZX EAX,word ptr [RSI + 0x6]
CMP RAX,0x38
JA 0x00131320
MOV RCX,0x110000000012000
BT RCX,RAX
JNC 0x00131320
MOV RAX,qword ptr [RSI + 0x30]
TEST RAX,RAX
JZ 0x00131320
MOVZX EAX,word ptr [RAX + 0x18]
AND EAX,0x3
CMP AX,0x2
JNZ 0x00131320
PUSH 0x3
POP RDX
JMP 0x00131336
LAB_00131320:
PUSH RAX
LEA RSI,[0x1887e3]
XOR EAX,EAX
CALL 0x0011c64d
PUSH 0x6
POP RDX
ADD RSP,0x8
LAB_00131336:
XOR EAX,EAX
RET
|
int1 [16] js_function_proto_caller(int8 param_1,long param_2,int param_3)
{
int1 auVar1 [16];
ulong uVar2;
if ((((param_3 == -1) && ((ulong)*(ushort *)(param_2 + 6) < 0x39)) &&
((0x110000000012000U >> ((ulong)*(ushort *)(param_2 + 6) & 0x3f) & 1) != 0)) &&
((*(long *)(param_2 + 0x30) != 0 && ((*(ushort *)(*(long *)(param_2 + 0x30) + 0x18) & 3) == 2))
)) {
uVar2 = 3;
}
else {
JS_ThrowTypeError(param_1,"invalid property access");
uVar2 = 6;
}
auVar1._8_8_ = 0;
auVar1._0_8_ = uVar2;
return auVar1 << 0x40;
}
| |
23,937 | blst_derive_child_eip2333 | corpus-core[P]colibri-stateless/build_O3/_deps/blst-src/src/keygen.c | void blst_derive_child_eip2333(pow256 SK, const pow256 parent_SK,
unsigned int child_index)
{
parent_SK_to_lamport_PK(SK, parent_SK, child_index);
keygen(SK, SK, sizeof(pow256), NULL, 0, NULL, 0, 4);
} | O3 | c | blst_derive_child_eip2333:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x21a8, %rsp # imm = 0x21A8
movq %rdi, -0x38(%rbp)
bswapl %edx
movl %edx, -0x2c(%rbp)
leaq -0x2038(%rbp), %rcx
addq $0x1f, %rsi
movq $-0x20, %rax
movb (%rsi), %dl
movb %dl, -0x2018(%rbp,%rax)
decq %rsi
incq %rax
jne 0x183c9
leaq -0x2058(%rbp), %r13
leaq -0x21b8(%rbp), %rbx
movq %rbx, (%rsp)
leaq -0x2c(%rbp), %rsi
movl $0x4, %edx
movl $0x20, %r8d
movq %r13, %rdi
xorl %r9d, %r9d
callq 0x25aab
leaq -0x2018(%rbp), %rdi
movq %rbx, (%rsp)
movl $0x1fe0, %esi # imm = 0x1FE0
movq %r13, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x25b1d
movl $0x5, %eax
leaq -0x2190(%rbp), %r15
movq $0x0, -0x21b8(%rbp,%rax,8)
incq %rax
cmpq $0xd, %rax
jne 0x18432
leaq -0x21b8(%rbp), %r14
movb $-0x80, 0x48(%r14)
movw $0x1, 0x66(%r14)
movl $0x1a0, %ebx # imm = 0x1A0
movaps 0x272da(%rip), %xmm0 # 0x3f740
movaps 0x272e3(%rip), %xmm1 # 0x3f750
movups %xmm0, -0x21b8(%rbp)
movups %xmm1, -0x21a8(%rbp)
leaq (%rbx,%rbp), %r12
addq $-0x21b8, %r12 # imm = 0xDE48
movl $0x20, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2c7f0
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2a440
movq %r12, %rdi
movq %r14, %rsi
callq 0x2c7a0
movaps 0x27298(%rip), %xmm1 # 0x3f750
movaps 0x27281(%rip), %xmm0 # 0x3f740
addq $0x20, %rbx
cmpq $0x2180, %rbx # imm = 0x2180
jne 0x1846d
leaq -0x20c8(%rbp), %r12
movups %xmm0, (%r12)
movups %xmm1, 0x10(%r12)
movq $0x0, 0x20(%r12)
movl $0x23, %ecx
leaq -0x20a0(%rbp), %rax
movq $0x0, -0x21b8(%rbp,%rcx,8)
incq %rcx
cmpq $0x2b, %rcx
jne 0x184f3
movq $0x0, -0x2060(%rbp)
movl $0x1fe0, %edx # imm = 0x1FE0
movq %r12, %rdi
leaq -0x2018(%rbp), %rsi
callq 0x25582
movl $0x180, %eax # imm = 0x180
notb -0x21b8(%rbp,%rax)
incq %rax
cmpq $0x1a0, %rax # imm = 0x1A0
jne 0x1852c
movq %r14, (%rsp)
leaq -0x2c(%rbp), %rsi
movl $0x4, %edx
movl $0x20, %r8d
movq %r13, %rdi
leaq -0x2038(%rbp), %rcx
xorl %r9d, %r9d
callq 0x25aab
movq %r14, (%rsp)
movl $0x1fe0, %esi # imm = 0x1FE0
leaq -0x2018(%rbp), %rdi
movq %r13, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x25b1d
movl $0x5, %eax
movq $0x0, -0x21b8(%rbp,%rax,8)
incq %rax
cmpq $0xd, %rax
jne 0x18588
leaq -0x21b8(%rbp), %r14
movb $-0x80, 0x48(%r14)
movb $0x1, 0x66(%r14)
movl $0x1a0, %ebx # imm = 0x1A0
movaps 0x27186(%rip), %xmm0 # 0x3f740
movups %xmm0, -0x21b8(%rbp)
movaps 0x27188(%rip), %xmm0 # 0x3f750
movups %xmm0, -0x21a8(%rbp)
leaq (%rbx,%rbp), %r13
addq $-0x21b8, %r13 # imm = 0xDE48
movl $0x20, %edx
movq %r15, %rdi
movq %r13, %rsi
callq 0x2c7f0
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2a440
movq %r13, %rdi
movq %r14, %rsi
callq 0x2c7a0
addq $0x20, %rbx
cmpq $0x2180, %rbx # imm = 0x2180
jne 0x185b3
movl $0x1fe0, %edx # imm = 0x1FE0
movq %r12, %rdi
leaq -0x2018(%rbp), %rsi
callq 0x25582
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2567e
xorl %eax, %eax
movq $0x0, -0x21b8(%rbp,%rax,8)
incq %rax
cmpq $0x430, %rax # imm = 0x430
jne 0x18637
leaq -0x21b8(%rbp), %rax
movl $0x4, 0x8(%rsp)
movq $0x0, (%rsp)
movl $0x20, %edx
movq %rbx, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x18049
addq $0x21a8, %rsp # imm = 0x21A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| blst_derive_child_eip2333:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 21A8h
mov [rbp+var_38], rdi
bswap edx
mov [rbp+var_2C], edx
lea rcx, [rbp+var_2038]
add rsi, 1Fh
mov rax, 0FFFFFFFFFFFFFFE0h
loc_183C9:
mov dl, [rsi]
mov [rbp+rax+var_2018], dl
dec rsi
inc rax
jnz short loc_183C9
lea r13, [rbp+var_2058]
lea rbx, [rbp+var_21B8]
mov [rsp+21D0h+var_21D0], rbx
lea rsi, [rbp+var_2C]
mov edx, 4
mov r8d, 20h ; ' '
mov rdi, r13
xor r9d, r9d
call HKDF_Extract
lea rdi, [rbp+var_2018]
mov [rsp+21D0h+var_21D0], rbx
mov esi, 1FE0h
mov rdx, r13
xor ecx, ecx
xor r8d, r8d
xor r9d, r9d
call HKDF_Expand
mov eax, 5
lea r15, [rbp+var_2190]
loc_18432:
mov qword ptr [rbp+rax*8+var_21B8], 0
inc rax
cmp rax, 0Dh
jnz short loc_18432
lea r14, [rbp+var_21B8]
mov byte ptr [r14+48h], 80h
mov word ptr [r14+66h], 1
mov ebx, 1A0h
movaps xmm0, cs:xmmword_3F740
movaps xmm1, cs:xmmword_3F750
loc_1846D:
movups [rbp+var_21B8], xmm0
movups [rbp+var_21A8], xmm1
lea r12, [rbx+rbp]
add r12, 0FFFFFFFFFFFFDE48h
mov edx, 20h ; ' '
mov rdi, r15
mov rsi, r12
call blst_sha256_bcopy
mov edx, 1
mov rdi, r14
mov rsi, r15
call blst_sha256_block_data_order
mov rdi, r12
mov rsi, r14
call blst_sha256_emit
movaps xmm1, cs:xmmword_3F750
movaps xmm0, cs:xmmword_3F740
add rbx, 20h ; ' '
cmp rbx, 2180h
jnz short loc_1846D
lea r12, [rbp+var_20C8]
movups xmmword ptr [r12], xmm0
movups xmmword ptr [r12+10h], xmm1
mov qword ptr [r12+20h], 0
mov ecx, 23h ; '#'
lea rax, [rbp+var_20A0]
loc_184F3:
mov qword ptr [rbp+rcx*8+var_21B8], 0
inc rcx
cmp rcx, 2Bh ; '+'
jnz short loc_184F3
mov [rbp+var_2060], 0
mov edx, 1FE0h
mov rdi, r12
lea rsi, [rbp+var_2018]
call sha256_update
mov eax, 180h
loc_1852C:
not byte ptr [rbp+rax+var_21B8]
inc rax
cmp rax, 1A0h
jnz short loc_1852C
mov [rsp+21D0h+var_21D0], r14
lea rsi, [rbp+var_2C]
mov edx, 4
mov r8d, 20h ; ' '
mov rdi, r13
lea rcx, [rbp+var_2038]
xor r9d, r9d
call HKDF_Extract
mov [rsp+21D0h+var_21D0], r14
mov esi, 1FE0h
lea rdi, [rbp+var_2018]
mov rdx, r13
xor ecx, ecx
xor r8d, r8d
xor r9d, r9d
call HKDF_Expand
mov eax, 5
loc_18588:
mov qword ptr [rbp+rax*8+var_21B8], 0
inc rax
cmp rax, 0Dh
jnz short loc_18588
lea r14, [rbp+var_21B8]
mov byte ptr [r14+48h], 80h
mov byte ptr [r14+66h], 1
mov ebx, 1A0h
loc_185B3:
movaps xmm0, cs:xmmword_3F740
movups [rbp+var_21B8], xmm0
movaps xmm0, cs:xmmword_3F750
movups [rbp+var_21A8], xmm0
lea r13, [rbx+rbp]
add r13, 0FFFFFFFFFFFFDE48h
mov edx, 20h ; ' '
mov rdi, r15
mov rsi, r13
call blst_sha256_bcopy
mov edx, 1
mov rdi, r14
mov rsi, r15
call blst_sha256_block_data_order
mov rdi, r13
mov rsi, r14
call blst_sha256_emit
add rbx, 20h ; ' '
cmp rbx, 2180h
jnz short loc_185B3
mov edx, 1FE0h
mov rdi, r12
lea rsi, [rbp+var_2018]
call sha256_update
mov rbx, [rbp+var_38]
mov rdi, rbx
mov rsi, r12
call sha256_final
xor eax, eax
loc_18637:
mov qword ptr [rbp+rax*8+var_21B8], 0
inc rax
cmp rax, 430h
jnz short loc_18637
lea rax, [rbp+var_21B8]
mov [rsp+21D0h+var_21C8], 4
mov [rsp+21D0h+var_21D0], 0
mov edx, 20h ; ' '
mov rdi, rbx
mov rsi, rbx
xor ecx, ecx
xor r8d, r8d
xor r9d, r9d
call keygen
add rsp, 21A8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| __int128 * blst_derive_child_eip2333(_QWORD *a1, long long a2, unsigned int a3)
{
_BYTE *v3; // rsi
long long v4; // rax
long long i; // rax
long long v6; // rbx
__int128 v7; // xmm0
__int128 v8; // xmm1
int v9; // ecx
int v10; // r8d
int v11; // r9d
long long j; // rcx
long long k; // rax
long long m; // rax
long long n; // rbx
int v16; // ecx
int v17; // r8d
int v18; // r9d
_QWORD *v19; // rbx
long long ii; // rax
long long v22; // [rsp+0h] [rbp-21D0h]
long long v23; // [rsp+0h] [rbp-21D0h]
long long v24; // [rsp+8h] [rbp-21C8h]
long long v25; // [rsp+10h] [rbp-21C0h]
__int128 v26; // [rsp+18h] [rbp-21B8h] BYREF
__int128 v27; // [rsp+28h] [rbp-21A8h]
long long v28; // [rsp+38h] [rbp-2198h]
long long v29; // [rsp+40h] [rbp-2190h] BYREF
long long v30; // [rsp+48h] [rbp-2188h]
long long v31; // [rsp+50h] [rbp-2180h]
long long v32; // [rsp+58h] [rbp-2178h]
long long v33; // [rsp+60h] [rbp-2170h]
long long v34; // [rsp+68h] [rbp-2168h]
__int16 v35; // [rsp+7Eh] [rbp-2152h]
_OWORD v36[2]; // [rsp+108h] [rbp-20C8h] BYREF
long long v37; // [rsp+128h] [rbp-20A8h]
long long v38; // [rsp+170h] [rbp-2060h]
_BYTE v39[32]; // [rsp+178h] [rbp-2058h] BYREF
_BYTE v40[32]; // [rsp+198h] [rbp-2038h] BYREF
_BYTE v41[8160]; // [rsp+1B8h] [rbp-2018h] BYREF
_QWORD *v42; // [rsp+2198h] [rbp-38h]
_DWORD v43[11]; // [rsp+21A4h] [rbp-2Ch] BYREF
v42 = a1;
v43[0] = _byteswap_ulong(a3);
v3 = (_BYTE *)(a2 + 31);
v4 = -32LL;
do
v41[v4++] = *v3--;
while ( v4 );
HKDF_Extract((unsigned int)v39, (unsigned int)v43, 4, (unsigned int)v40, 32, 0, (long long)&v26);
HKDF_Expand((unsigned int)v41, 8160, (unsigned int)v39, 0, 0, 0, (long long)&v26);
for ( i = 5LL; i != 13; ++i )
*((_QWORD *)&v26 + i) = 0LL;
LOBYTE(v33) = 0x80;
v35 = 1;
v6 = 416LL;
v7 = xmmword_3F740;
v8 = xmmword_3F750;
do
{
v26 = v7;
v27 = v8;
blst_sha256_bcopy(&v29, (char *)&v26 + v6, 32LL);
blst_sha256_block_data_order(
(unsigned int)&v26,
(unsigned int)&v29,
1,
v9,
v10,
v11,
v22,
v24,
v25,
v26,
*((long long *)&v26 + 1),
v27,
*((long long *)&v27 + 1),
v28,
v29,
v30,
v31,
v32,
v33,
v34);
blst_sha256_emit((char *)&v26 + v6, &v26);
v8 = xmmword_3F750;
v7 = xmmword_3F740;
v6 += 32LL;
}
while ( v6 != 8576 );
v36[0] = xmmword_3F740;
v36[1] = xmmword_3F750;
v37 = 0LL;
for ( j = 35LL; j != 43; ++j )
*((_QWORD *)&v26 + j) = 0LL;
v38 = 0LL;
sha256_update(v36, v41, 8160LL);
for ( k = 384LL; k != 416; ++k )
*((_BYTE *)&v26 + k) = ~*((_BYTE *)&v26 + k);
HKDF_Extract((unsigned int)v39, (unsigned int)v43, 4, (unsigned int)v40, 32, 0, (long long)&v26);
HKDF_Expand((unsigned int)v41, 8160, (unsigned int)v39, 0, 0, 0, (long long)&v26);
for ( m = 5LL; m != 13; ++m )
*((_QWORD *)&v26 + m) = 0LL;
LOBYTE(v33) = 0x80;
LOBYTE(v35) = 1;
for ( n = 416LL; n != 8576; n += 32LL )
{
v26 = xmmword_3F740;
v27 = xmmword_3F750;
blst_sha256_bcopy(&v29, (char *)&v26 + n, 32LL);
blst_sha256_block_data_order(
(unsigned int)&v26,
(unsigned int)&v29,
1,
v16,
v17,
v18,
v23,
v24,
v25,
v26,
*((long long *)&v26 + 1),
v27,
*((long long *)&v27 + 1),
v28,
v29,
v30,
v31,
v32,
v33,
v34);
blst_sha256_emit((char *)&v26 + n, &v26);
}
sha256_update(v36, v41, 8160LL);
v19 = v42;
sha256_final(v42, v36);
for ( ii = 0LL; ii != 1072; ++ii )
*((_QWORD *)&v26 + ii) = 0LL;
return keygen(v19, (long long)v19, 0x20uLL, 0LL, 0LL, 0LL, 0LL, 4);
}
| blst_derive_child_eip2333:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x21a8
MOV qword ptr [RBP + -0x38],RDI
BSWAP EDX
MOV dword ptr [RBP + -0x2c],EDX
LEA RCX,[RBP + -0x2038]
ADD RSI,0x1f
MOV RAX,-0x20
LAB_001183c9:
MOV DL,byte ptr [RSI]
MOV byte ptr [RBP + RAX*0x1 + -0x2018],DL
DEC RSI
INC RAX
JNZ 0x001183c9
LEA R13,[RBP + -0x2058]
LEA RBX,[RBP + -0x21b8]
MOV qword ptr [RSP],RBX
LEA RSI,[RBP + -0x2c]
MOV EDX,0x4
MOV R8D,0x20
MOV RDI,R13
XOR R9D,R9D
CALL 0x00125aab
LEA RDI,[RBP + -0x2018]
MOV qword ptr [RSP],RBX
MOV ESI,0x1fe0
MOV RDX,R13
XOR ECX,ECX
XOR R8D,R8D
XOR R9D,R9D
CALL 0x00125b1d
MOV EAX,0x5
LEA R15,[RBP + -0x2190]
LAB_00118432:
MOV qword ptr [RBP + RAX*0x8 + -0x21b8],0x0
INC RAX
CMP RAX,0xd
JNZ 0x00118432
LEA R14,[RBP + -0x21b8]
MOV byte ptr [R14 + 0x48],0x80
MOV word ptr [R14 + 0x66],0x1
MOV EBX,0x1a0
MOVAPS XMM0,xmmword ptr [0x0013f740]
MOVAPS XMM1,xmmword ptr [0x0013f750]
LAB_0011846d:
MOVUPS xmmword ptr [RBP + -0x21b8],XMM0
MOVUPS xmmword ptr [RBP + -0x21a8],XMM1
LEA R12,[RBX + RBP*0x1]
ADD R12,-0x21b8
MOV EDX,0x20
MOV RDI,R15
MOV RSI,R12
CALL 0x0012c7f0
MOV EDX,0x1
MOV RDI,R14
MOV RSI,R15
CALL 0x0012a440
MOV RDI,R12
MOV RSI,R14
CALL 0x0012c7a0
MOVAPS XMM1,xmmword ptr [0x0013f750]
MOVAPS XMM0,xmmword ptr [0x0013f740]
ADD RBX,0x20
CMP RBX,0x2180
JNZ 0x0011846d
LEA R12,[RBP + -0x20c8]
MOVUPS xmmword ptr [R12],XMM0
MOVUPS xmmword ptr [R12 + 0x10],XMM1
MOV qword ptr [R12 + 0x20],0x0
MOV ECX,0x23
LEA RAX,[RBP + -0x20a0]
LAB_001184f3:
MOV qword ptr [RBP + RCX*0x8 + -0x21b8],0x0
INC RCX
CMP RCX,0x2b
JNZ 0x001184f3
MOV qword ptr [RBP + -0x2060],0x0
MOV EDX,0x1fe0
MOV RDI,R12
LEA RSI,[RBP + -0x2018]
CALL 0x00125582
MOV EAX,0x180
LAB_0011852c:
NOT byte ptr [RBP + RAX*0x1 + -0x21b8]
INC RAX
CMP RAX,0x1a0
JNZ 0x0011852c
MOV qword ptr [RSP],R14
LEA RSI,[RBP + -0x2c]
MOV EDX,0x4
MOV R8D,0x20
MOV RDI,R13
LEA RCX,[RBP + -0x2038]
XOR R9D,R9D
CALL 0x00125aab
MOV qword ptr [RSP],R14
MOV ESI,0x1fe0
LEA RDI,[RBP + -0x2018]
MOV RDX,R13
XOR ECX,ECX
XOR R8D,R8D
XOR R9D,R9D
CALL 0x00125b1d
MOV EAX,0x5
LAB_00118588:
MOV qword ptr [RBP + RAX*0x8 + -0x21b8],0x0
INC RAX
CMP RAX,0xd
JNZ 0x00118588
LEA R14,[RBP + -0x21b8]
MOV byte ptr [R14 + 0x48],0x80
MOV byte ptr [R14 + 0x66],0x1
MOV EBX,0x1a0
LAB_001185b3:
MOVAPS XMM0,xmmword ptr [0x0013f740]
MOVUPS xmmword ptr [RBP + -0x21b8],XMM0
MOVAPS XMM0,xmmword ptr [0x0013f750]
MOVUPS xmmword ptr [RBP + -0x21a8],XMM0
LEA R13,[RBX + RBP*0x1]
ADD R13,-0x21b8
MOV EDX,0x20
MOV RDI,R15
MOV RSI,R13
CALL 0x0012c7f0
MOV EDX,0x1
MOV RDI,R14
MOV RSI,R15
CALL 0x0012a440
MOV RDI,R13
MOV RSI,R14
CALL 0x0012c7a0
ADD RBX,0x20
CMP RBX,0x2180
JNZ 0x001185b3
MOV EDX,0x1fe0
MOV RDI,R12
LEA RSI,[RBP + -0x2018]
CALL 0x00125582
MOV RBX,qword ptr [RBP + -0x38]
MOV RDI,RBX
MOV RSI,R12
CALL 0x0012567e
XOR EAX,EAX
LAB_00118637:
MOV qword ptr [RBP + RAX*0x8 + -0x21b8],0x0
INC RAX
CMP RAX,0x430
JNZ 0x00118637
LEA RAX,[RBP + -0x21b8]
MOV dword ptr [RSP + 0x8],0x4
MOV qword ptr [RSP],0x0
MOV EDX,0x20
MOV RDI,RBX
MOV RSI,RBX
XOR ECX,ECX
XOR R8D,R8D
XOR R9D,R9D
CALL 0x00118049
ADD RSP,0x21a8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void blst_derive_child_eip2333(EVP_PKEY_CTX *param_1,long param_2,uint param_3)
{
EVP_PKEY_CTX *pkey;
long lVar1;
int1 *puVar2;
int8 local_21c0;
int8 uStack_21b8;
int4 local_21b0;
int4 uStack_21ac;
int4 uStack_21a8;
int4 uStack_21a4;
int8 local_2198 [4];
int1 local_2178;
int2 local_215a;
int4 local_20d0;
int4 uStack_20cc;
int4 uStack_20c8;
int4 uStack_20c4;
int4 local_20c0;
int4 uStack_20bc;
int4 uStack_20b8;
int4 uStack_20b4;
int8 local_20b0;
int8 local_20a8 [8];
int8 local_2068;
int1 local_2060 [32];
byte local_2040 [32];
int1 local_2020 [8160];
EVP_PKEY_CTX *local_40;
uint local_34;
local_34 = param_3 >> 0x18 | (param_3 & 0xff0000) >> 8 | (param_3 & 0xff00) << 8 | param_3 << 0x18
;
puVar2 = (int1 *)(param_2 + 0x1f);
lVar1 = -0x20;
do {
local_2020[lVar1] = *puVar2;
puVar2 = puVar2 + -1;
lVar1 = lVar1 + 1;
} while (lVar1 != 0);
local_40 = param_1;
HKDF_Extract(local_2060,&local_34,4,local_2040,0x20,0,&local_21c0);
HKDF_Expand(local_2020,0x1fe0,local_2060,0,0,0,&local_21c0);
lVar1 = 5;
do {
(&local_21c0)[lVar1] = 0;
lVar1 = lVar1 + 1;
} while (lVar1 != 0xd);
local_2178 = 0x80;
local_215a = 1;
lVar1 = 0x1a0;
do {
local_21c0 = CONCAT44(_UNK_0013f744,_DAT_0013f740);
uStack_21b8 = CONCAT44(_UNK_0013f74c,_UNK_0013f748);
local_21b0 = _DAT_0013f750;
uStack_21ac = _UNK_0013f754;
uStack_21a8 = _UNK_0013f758;
uStack_21a4 = _UNK_0013f75c;
blst_sha256_bcopy(local_2198,(long)&local_21c0 + lVar1,0x20);
blst_sha256_block_data_order(&local_21c0,local_2198,1);
blst_sha256_emit((long)&local_21c0 + lVar1,&local_21c0);
lVar1 = lVar1 + 0x20;
} while (lVar1 != 0x2180);
local_20d0 = _DAT_0013f740;
uStack_20cc = _UNK_0013f744;
uStack_20c8 = _UNK_0013f748;
uStack_20c4 = _UNK_0013f74c;
local_20c0 = _DAT_0013f750;
uStack_20bc = _UNK_0013f754;
uStack_20b8 = _UNK_0013f758;
uStack_20b4 = _UNK_0013f75c;
local_20b0 = 0;
lVar1 = 0x23;
do {
(&local_21c0)[lVar1] = 0;
lVar1 = lVar1 + 1;
} while (lVar1 != 0x2b);
local_2068 = 0;
sha256_update(&local_20d0,local_2020,0x1fe0);
lVar1 = 0x180;
do {
*(byte *)((long)&local_21c0 + lVar1) = ~*(byte *)((long)&local_21c0 + lVar1);
lVar1 = lVar1 + 1;
} while (lVar1 != 0x1a0);
HKDF_Extract(local_2060,&local_34,4,local_2040,0x20,0,&local_21c0);
HKDF_Expand(local_2020,0x1fe0,local_2060,0,0,0,&local_21c0);
lVar1 = 5;
do {
(&local_21c0)[lVar1] = 0;
lVar1 = lVar1 + 1;
} while (lVar1 != 0xd);
local_2178 = 0x80;
local_215a = CONCAT11(local_215a._1_1_,1);
lVar1 = 0x1a0;
do {
local_21c0 = CONCAT44(_UNK_0013f744,_DAT_0013f740);
uStack_21b8 = CONCAT44(_UNK_0013f74c,_UNK_0013f748);
local_21b0 = _DAT_0013f750;
uStack_21ac = _UNK_0013f754;
uStack_21a8 = _UNK_0013f758;
uStack_21a4 = _UNK_0013f75c;
blst_sha256_bcopy(local_2198,(long)&local_21c0 + lVar1,0x20);
blst_sha256_block_data_order(&local_21c0,local_2198,1);
blst_sha256_emit((long)&local_21c0 + lVar1,&local_21c0);
lVar1 = lVar1 + 0x20;
} while (lVar1 != 0x2180);
sha256_update(&local_20d0,local_2020,0x1fe0);
pkey = local_40;
sha256_final(local_40,&local_20d0);
lVar1 = 0;
do {
(&local_21c0)[lVar1] = 0;
lVar1 = lVar1 + 1;
} while (lVar1 != 0x430);
keygen(pkey,(EVP_PKEY *)pkey);
return;
}
| |
23,938 | ftxui::(anonymous namespace)::InputBase::HandleRightCtrl() | Andrewchistyakov[P]flashcards_lyc/build_O0/_deps/ftxui-src/src/ftxui/component/input.cpp | bool HandleRightCtrl() {
if (cursor_position() == (int)content().size()) {
return false;
}
// Move right, until entering a word.
while (cursor_position() < (int)content().size()) {
cursor_position() = GlyphNext(content(), cursor_position());
if (IsWordCharacter(content(), cursor_position())) {
break;
}
}
// Move right, as long as right is a word character:
while (cursor_position() < (int)content().size()) {
const size_t next = GlyphNext(content(), cursor_position());
if (!IsWordCharacter(content(), cursor_position())) {
break;
}
cursor_position() = next;
}
return true;
} | O0 | cpp | ftxui::(anonymous namespace)::InputBase::HandleRightCtrl():
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x28, %rdi
addq $0xd0, %rdi
callq 0x5d970
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
addq $0x28, %rdi
callq 0x5d850
movq %rax, %rdi
callq 0xd3c0
movq %rax, %rcx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jne 0x5b941
movb $0x0, -0x1(%rbp)
jmp 0x5badd
jmp 0x5b943
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
addq $0xd0, %rdi
callq 0x5d970
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
addq $0x28, %rdi
callq 0x5d850
movq %rax, %rdi
callq 0xd3c0
movq %rax, %rcx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x5ba0a
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x5d850
movq -0x28(%rbp), %rdi
movq %rax, -0x48(%rbp)
addq $0x28, %rdi
addq $0xd0, %rdi
callq 0x5d970
movq -0x48(%rbp), %rdi
movslq (%rax), %rsi
callq 0x8db60
movq -0x28(%rbp), %rdi
movl %eax, -0x3c(%rbp)
addq $0x28, %rdi
addq $0xd0, %rdi
callq 0x5d970
movl -0x3c(%rbp), %ecx
movq -0x28(%rbp), %rdi
movl %ecx, (%rax)
addq $0x28, %rdi
callq 0x5d850
movq -0x28(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x28, %rdi
addq $0xd0, %rdi
callq 0x5d970
movq -0x38(%rbp), %rdi
movslq (%rax), %rsi
callq 0x5bd40
testb $0x1, %al
jne 0x5ba03
jmp 0x5ba05
jmp 0x5ba0a
jmp 0x5b943
jmp 0x5ba0c
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
addq $0xd0, %rdi
callq 0x5d970
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
addq $0x28, %rdi
callq 0x5d850
movq %rax, %rdi
callq 0xd3c0
movq %rax, %rcx
movl -0x4c(%rbp), %eax
cmpl %ecx, %eax
jge 0x5bad9
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x5d850
movq -0x28(%rbp), %rdi
movq %rax, -0x60(%rbp)
addq $0x28, %rdi
addq $0xd0, %rdi
callq 0x5d970
movq -0x60(%rbp), %rdi
movslq (%rax), %rsi
callq 0x8db60
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x28, %rdi
callq 0x5d850
movq -0x28(%rbp), %rdi
movq %rax, -0x58(%rbp)
addq $0x28, %rdi
addq $0xd0, %rdi
callq 0x5d970
movq -0x58(%rbp), %rdi
movslq (%rax), %rsi
callq 0x5bd40
testb $0x1, %al
jne 0x5bab4
jmp 0x5bad9
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, -0x64(%rbp)
addq $0x28, %rdi
addq $0xd0, %rdi
callq 0x5d970
movl -0x64(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x5ba0c
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ZN5ftxui12_GLOBAL__N_19InputBase15HandleRightCtrlEv:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_10], rdi
mov rdi, [rbp+var_10]
mov [rbp+var_28], rdi
add rdi, 28h ; '('
add rdi, 0D0h
call _ZN5ftxui3RefIiEclEv; ftxui::Ref<int>::operator()(void)
mov rdi, [rbp+var_28]
mov eax, [rax]
mov [rbp+var_1C], eax
add rdi, 28h ; '('
call _ZN5ftxui3RefINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEv; ftxui::Ref<std::string>::operator()(void)
mov rdi, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4sizeEv; std::string::size(void)
mov rcx, rax
mov eax, [rbp+var_1C]
cmp eax, ecx
jnz short loc_5B941
mov [rbp+var_1], 0
jmp loc_5BADD
loc_5B941:
jmp short $+2
loc_5B943:
mov rdi, [rbp+var_28]
add rdi, 28h ; '('
add rdi, 0D0h
call _ZN5ftxui3RefIiEclEv; ftxui::Ref<int>::operator()(void)
mov rdi, [rbp+var_28]
mov eax, [rax]
mov [rbp+var_2C], eax
add rdi, 28h ; '('
call _ZN5ftxui3RefINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEv; ftxui::Ref<std::string>::operator()(void)
mov rdi, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4sizeEv; std::string::size(void)
mov rcx, rax
mov eax, [rbp+var_2C]
cmp eax, ecx
jge loc_5BA0A
mov rdi, [rbp+var_28]
add rdi, 28h ; '('
call _ZN5ftxui3RefINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEv; ftxui::Ref<std::string>::operator()(void)
mov rdi, [rbp+var_28]
mov [rbp+var_48], rax
add rdi, 28h ; '('
add rdi, 0D0h
call _ZN5ftxui3RefIiEclEv; ftxui::Ref<int>::operator()(void)
mov rdi, [rbp+var_48]
movsxd rsi, dword ptr [rax]
call _ZN5ftxui9GlyphNextERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEm; ftxui::GlyphNext(std::string const&,ulong)
mov rdi, [rbp+var_28]
mov [rbp+var_3C], eax
add rdi, 28h ; '('
add rdi, 0D0h
call _ZN5ftxui3RefIiEclEv; ftxui::Ref<int>::operator()(void)
mov ecx, [rbp+var_3C]
mov rdi, [rbp+var_28]
mov [rax], ecx
add rdi, 28h ; '('
call _ZN5ftxui3RefINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEv; ftxui::Ref<std::string>::operator()(void)
mov rdi, [rbp+var_28]
mov [rbp+var_38], rax
add rdi, 28h ; '('
add rdi, 0D0h
call _ZN5ftxui3RefIiEclEv; ftxui::Ref<int>::operator()(void)
mov rdi, [rbp+var_38]
movsxd rsi, dword ptr [rax]
call _ZN5ftxui12_GLOBAL__N_115IsWordCharacterERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEm; ftxui::`anonymous namespace'::IsWordCharacter(std::string const&,ulong)
test al, 1
jnz short loc_5BA03
jmp short loc_5BA05
loc_5BA03:
jmp short loc_5BA0A
loc_5BA05:
jmp loc_5B943
loc_5BA0A:
jmp short $+2
loc_5BA0C:
mov rdi, [rbp+var_28]
add rdi, 28h ; '('
add rdi, 0D0h
call _ZN5ftxui3RefIiEclEv; ftxui::Ref<int>::operator()(void)
mov rdi, [rbp+var_28]
mov eax, [rax]
mov [rbp+var_4C], eax
add rdi, 28h ; '('
call _ZN5ftxui3RefINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEv; ftxui::Ref<std::string>::operator()(void)
mov rdi, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4sizeEv; std::string::size(void)
mov rcx, rax
mov eax, [rbp+var_4C]
cmp eax, ecx
jge loc_5BAD9
mov rdi, [rbp+var_28]
add rdi, 28h ; '('
call _ZN5ftxui3RefINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEv; ftxui::Ref<std::string>::operator()(void)
mov rdi, [rbp+var_28]
mov [rbp+var_60], rax
add rdi, 28h ; '('
add rdi, 0D0h
call _ZN5ftxui3RefIiEclEv; ftxui::Ref<int>::operator()(void)
mov rdi, [rbp+var_60]
movsxd rsi, dword ptr [rax]
call _ZN5ftxui9GlyphNextERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEm; ftxui::GlyphNext(std::string const&,ulong)
mov rdi, [rbp+var_28]
mov [rbp+var_18], rax
add rdi, 28h ; '('
call _ZN5ftxui3RefINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEv; ftxui::Ref<std::string>::operator()(void)
mov rdi, [rbp+var_28]
mov [rbp+var_58], rax
add rdi, 28h ; '('
add rdi, 0D0h
call _ZN5ftxui3RefIiEclEv; ftxui::Ref<int>::operator()(void)
mov rdi, [rbp+var_58]
movsxd rsi, dword ptr [rax]
call _ZN5ftxui12_GLOBAL__N_115IsWordCharacterERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEm; ftxui::`anonymous namespace'::IsWordCharacter(std::string const&,ulong)
test al, 1
jnz short loc_5BAB4
jmp short loc_5BAD9
loc_5BAB4:
mov rdi, [rbp+var_28]
mov rax, [rbp+var_18]
mov [rbp+var_64], eax
add rdi, 28h ; '('
add rdi, 0D0h
call _ZN5ftxui3RefIiEclEv; ftxui::Ref<int>::operator()(void)
mov ecx, [rbp+var_64]
mov [rax], ecx
jmp loc_5BA0C
loc_5BAD9:
mov [rbp+var_1], 1
loc_5BADD:
mov al, [rbp+var_1]
and al, 1
add rsp, 70h
pop rbp
retn
| char ftxui::`anonymous namespace'::InputBase::HandleRightCtrl(ftxui::_anonymous_namespace_::InputBase *this)
{
long long v1; // rax
long long v2; // rax
int *v3; // rax
int *v4; // rax
long long v5; // rax
int *v6; // rax
int *v7; // rax
long long v9; // [rsp+10h] [rbp-60h]
long long v10; // [rsp+18h] [rbp-58h]
int v11; // [rsp+24h] [rbp-4Ch]
long long v12; // [rsp+28h] [rbp-48h]
int v13; // [rsp+34h] [rbp-3Ch]
long long v14; // [rsp+38h] [rbp-38h]
int v15; // [rsp+44h] [rbp-2Ch]
int v16; // [rsp+54h] [rbp-1Ch]
int v17; // [rsp+58h] [rbp-18h]
v16 = *(_DWORD *)ftxui::Ref<int>::operator()((char *)this + 248);
v1 = ftxui::Ref<std::string>::operator()((char *)this + 40);
if ( v16 == (unsigned int)std::string::size(v1) )
return 0;
do
{
v15 = *(_DWORD *)ftxui::Ref<int>::operator()((char *)this + 248);
v2 = ftxui::Ref<std::string>::operator()((char *)this + 40);
if ( v15 >= (int)std::string::size(v2) )
break;
v12 = ftxui::Ref<std::string>::operator()((char *)this + 40);
v3 = (int *)ftxui::Ref<int>::operator()((char *)this + 248);
v13 = ftxui::GlyphNext(v12, *v3);
*(_DWORD *)ftxui::Ref<int>::operator()((char *)this + 248) = v13;
v14 = ftxui::Ref<std::string>::operator()((char *)this + 40);
v4 = (int *)ftxui::Ref<int>::operator()((char *)this + 248);
}
while ( (ftxui::`anonymous namespace'::IsWordCharacter(v14, *v4) & 1) == 0 );
while ( 1 )
{
v11 = *(_DWORD *)ftxui::Ref<int>::operator()((char *)this + 248);
v5 = ftxui::Ref<std::string>::operator()((char *)this + 40);
if ( v11 >= (int)std::string::size(v5) )
break;
v9 = ftxui::Ref<std::string>::operator()((char *)this + 40);
v6 = (int *)ftxui::Ref<int>::operator()((char *)this + 248);
v17 = ftxui::GlyphNext(v9, *v6);
v10 = ftxui::Ref<std::string>::operator()((char *)this + 40);
v7 = (int *)ftxui::Ref<int>::operator()((char *)this + 248);
if ( (ftxui::`anonymous namespace'::IsWordCharacter(v10, *v7) & 1) == 0 )
break;
*(_DWORD *)ftxui::Ref<int>::operator()((char *)this + 248) = v17;
}
return 1;
}
| HandleRightCtrl:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x10],RDI
MOV RDI,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RDI
ADD RDI,0x28
ADD RDI,0xd0
CALL 0x0015d970
MOV RDI,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x1c],EAX
ADD RDI,0x28
CALL 0x0015d850
MOV RDI,RAX
CALL 0x0010d3c0
MOV RCX,RAX
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,ECX
JNZ 0x0015b941
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0015badd
LAB_0015b941:
JMP 0x0015b943
LAB_0015b943:
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x28
ADD RDI,0xd0
CALL 0x0015d970
MOV RDI,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x2c],EAX
ADD RDI,0x28
CALL 0x0015d850
MOV RDI,RAX
CALL 0x0010d3c0
MOV RCX,RAX
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,ECX
JGE 0x0015ba0a
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x28
CALL 0x0015d850
MOV RDI,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x48],RAX
ADD RDI,0x28
ADD RDI,0xd0
CALL 0x0015d970
MOV RDI,qword ptr [RBP + -0x48]
MOVSXD RSI,dword ptr [RAX]
CALL 0x0018db60
MOV RDI,qword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x3c],EAX
ADD RDI,0x28
ADD RDI,0xd0
CALL 0x0015d970
MOV ECX,dword ptr [RBP + -0x3c]
MOV RDI,qword ptr [RBP + -0x28]
MOV dword ptr [RAX],ECX
ADD RDI,0x28
CALL 0x0015d850
MOV RDI,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x38],RAX
ADD RDI,0x28
ADD RDI,0xd0
CALL 0x0015d970
MOV RDI,qword ptr [RBP + -0x38]
MOVSXD RSI,dword ptr [RAX]
CALL 0x0015bd40
TEST AL,0x1
JNZ 0x0015ba03
JMP 0x0015ba05
LAB_0015ba03:
JMP 0x0015ba0a
LAB_0015ba05:
JMP 0x0015b943
LAB_0015ba0a:
JMP 0x0015ba0c
LAB_0015ba0c:
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x28
ADD RDI,0xd0
CALL 0x0015d970
MOV RDI,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4c],EAX
ADD RDI,0x28
CALL 0x0015d850
MOV RDI,RAX
CALL 0x0010d3c0
MOV RCX,RAX
MOV EAX,dword ptr [RBP + -0x4c]
CMP EAX,ECX
JGE 0x0015bad9
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x28
CALL 0x0015d850
MOV RDI,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x60],RAX
ADD RDI,0x28
ADD RDI,0xd0
CALL 0x0015d970
MOV RDI,qword ptr [RBP + -0x60]
MOVSXD RSI,dword ptr [RAX]
CALL 0x0018db60
MOV RDI,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x18],RAX
ADD RDI,0x28
CALL 0x0015d850
MOV RDI,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x58],RAX
ADD RDI,0x28
ADD RDI,0xd0
CALL 0x0015d970
MOV RDI,qword ptr [RBP + -0x58]
MOVSXD RSI,dword ptr [RAX]
CALL 0x0015bd40
TEST AL,0x1
JNZ 0x0015bab4
JMP 0x0015bad9
LAB_0015bab4:
MOV RDI,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x64],EAX
ADD RDI,0x28
ADD RDI,0xd0
CALL 0x0015d970
MOV ECX,dword ptr [RBP + -0x64]
MOV dword ptr [RAX],ECX
JMP 0x0015ba0c
LAB_0015bad9:
MOV byte ptr [RBP + -0x1],0x1
LAB_0015badd:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0x70
POP RBP
RET
|
/* ftxui::(anonymous namespace)::InputBase::HandleRightCtrl() */
int1 __thiscall ftxui::(anonymous_namespace)::InputBase::HandleRightCtrl(InputBase *this)
{
int iVar1;
int iVar2;
int4 uVar3;
int *piVar4;
string *psVar5;
int4 *puVar6;
ulong uVar7;
piVar4 = (int *)Ref<int>::operator()((Ref<int> *)(this + 0xf8));
iVar1 = *piVar4;
Ref<std::__cxx11::string>::operator()((Ref<std::__cxx11::string> *)(this + 0x28));
iVar2 = std::__cxx11::string::size();
if (iVar1 == iVar2) {
return 0;
}
do {
piVar4 = (int *)Ref<int>::operator()((Ref<int> *)(this + 0xf8));
iVar1 = *piVar4;
Ref<std::__cxx11::string>::operator()((Ref<std::__cxx11::string> *)(this + 0x28));
iVar2 = std::__cxx11::string::size();
if (iVar2 <= iVar1) break;
psVar5 = (string *)
Ref<std::__cxx11::string>::operator()((Ref<std::__cxx11::string> *)(this + 0x28));
piVar4 = (int *)Ref<int>::operator()((Ref<int> *)(this + 0xf8));
uVar3 = GlyphNext(psVar5,(long)*piVar4);
puVar6 = (int4 *)Ref<int>::operator()((Ref<int> *)(this + 0xf8));
*puVar6 = uVar3;
psVar5 = (string *)
Ref<std::__cxx11::string>::operator()((Ref<std::__cxx11::string> *)(this + 0x28));
piVar4 = (int *)Ref<int>::operator()((Ref<int> *)(this + 0xf8));
uVar7 = IsWordCharacter(psVar5,(long)*piVar4);
} while ((uVar7 & 1) == 0);
while( true ) {
piVar4 = (int *)Ref<int>::operator()((Ref<int> *)(this + 0xf8));
iVar1 = *piVar4;
Ref<std::__cxx11::string>::operator()((Ref<std::__cxx11::string> *)(this + 0x28));
iVar2 = std::__cxx11::string::size();
if (iVar2 <= iVar1) {
return 1;
}
psVar5 = (string *)
Ref<std::__cxx11::string>::operator()((Ref<std::__cxx11::string> *)(this + 0x28));
piVar4 = (int *)Ref<int>::operator()((Ref<int> *)(this + 0xf8));
uVar3 = GlyphNext(psVar5,(long)*piVar4);
psVar5 = (string *)
Ref<std::__cxx11::string>::operator()((Ref<std::__cxx11::string> *)(this + 0x28));
piVar4 = (int *)Ref<int>::operator()((Ref<int> *)(this + 0xf8));
uVar7 = IsWordCharacter(psVar5,(long)*piVar4);
if ((uVar7 & 1) == 0) break;
puVar6 = (int4 *)Ref<int>::operator()((Ref<int> *)(this + 0xf8));
*puVar6 = uVar3;
}
return 1;
}
| |
23,939 | my_coll_parser_scan_logical_position | eloqsql/strings/ctype-uca.c | static int
my_coll_parser_scan_logical_position(MY_COLL_RULE_PARSER *p,
my_wc_t *pwc, size_t limit)
{
MY_COLL_RULES *rules= p->rules;
MY_COLL_LEXEM *lexem= my_coll_parser_curr(p);
if (!lex_cmp(lexem, C_STRING_WITH_LEN("[first non-ignorable]")))
lexem->code= rules->uca->first_non_ignorable;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[last non-ignorable]")))
lexem->code= rules->uca->last_non_ignorable;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[first primary ignorable]")))
lexem->code= rules->uca->first_primary_ignorable;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[last primary ignorable]")))
lexem->code= rules->uca->last_primary_ignorable;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[first secondary ignorable]")))
lexem->code= rules->uca->first_secondary_ignorable;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[last secondary ignorable]")))
lexem->code= rules->uca->last_secondary_ignorable;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[first tertiary ignorable]")))
lexem->code= rules->uca->first_tertiary_ignorable;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[last tertiary ignorable]")))
lexem->code= rules->uca->last_tertiary_ignorable;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[first trailing]")))
lexem->code= rules->uca->first_trailing;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[last trailing]")))
lexem->code= rules->uca->last_trailing;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[first variable]")))
lexem->code= rules->uca->first_variable;
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[last variable]")))
lexem->code= rules->uca->last_variable;
else
return 0; /* Don't scan the next token */
if (!my_coll_rule_expand(pwc, limit, lexem->code))
{
/*
Logical position can not be in a contraction,
so the above call should never fail.
Let's assert in debug version and print
a nice error message in production version.
*/
DBUG_ASSERT(0);
return my_coll_parser_too_long_error(p, "Logical position");
}
return my_coll_parser_scan(p);
} | O0 | c | my_coll_parser_scan_logical_position:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xad970
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x2dc13(%rip), %rsi # 0xdc25e
movl $0x15, %edx
callq 0xae0f0
cmpl $0x0, %eax
jne 0xae674
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x70(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0xae8e4
movq -0x30(%rbp), %rdi
leaq 0x2dbf5(%rip), %rsi # 0xdc274
movl $0x14, %edx
callq 0xae0f0
cmpl $0x0, %eax
jne 0xae6a8
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x78(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0xae8e2
movq -0x30(%rbp), %rdi
leaq 0x2dbd6(%rip), %rsi # 0xdc289
movl $0x19, %edx
callq 0xae0f0
cmpl $0x0, %eax
jne 0xae6df
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x80(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0xae8e0
movq -0x30(%rbp), %rdi
leaq 0x2dbb9(%rip), %rsi # 0xdc2a3
movl $0x18, %edx
callq 0xae0f0
cmpl $0x0, %eax
jne 0xae716
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x88(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0xae8de
movq -0x30(%rbp), %rdi
leaq 0x2db9b(%rip), %rsi # 0xdc2bc
movl $0x1b, %edx
callq 0xae0f0
cmpl $0x0, %eax
jne 0xae74d
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x90(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0xae8dc
movq -0x30(%rbp), %rdi
leaq 0x2db80(%rip), %rsi # 0xdc2d8
movl $0x1a, %edx
callq 0xae0f0
cmpl $0x0, %eax
jne 0xae784
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x98(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0xae8da
movq -0x30(%rbp), %rdi
leaq 0x2db64(%rip), %rsi # 0xdc2f3
movl $0x1a, %edx
callq 0xae0f0
cmpl $0x0, %eax
jne 0xae7bb
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xa0(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0xae8d8
movq -0x30(%rbp), %rdi
leaq 0x2db48(%rip), %rsi # 0xdc30e
movl $0x19, %edx
callq 0xae0f0
cmpl $0x0, %eax
jne 0xae7f2
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xa8(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0xae8d6
movq -0x30(%rbp), %rdi
leaq 0x2db2b(%rip), %rsi # 0xdc328
movl $0x10, %edx
callq 0xae0f0
cmpl $0x0, %eax
jne 0xae829
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xb0(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0xae8d4
movq -0x30(%rbp), %rdi
leaq 0x2db05(%rip), %rsi # 0xdc339
movl $0xf, %edx
callq 0xae0f0
cmpl $0x0, %eax
jne 0xae85d
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xb8(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0xae8d2
movq -0x30(%rbp), %rdi
leaq 0x2dae1(%rip), %rsi # 0xdc349
movl $0x10, %edx
callq 0xae0f0
cmpl $0x0, %eax
jne 0xae891
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xc0(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0xae8d0
movq -0x30(%rbp), %rdi
leaq 0x2dabe(%rip), %rsi # 0xdc35a
movl $0xf, %edx
callq 0xae0f0
cmpl $0x0, %eax
jne 0xae8c5
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xc8(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0xae8ce
movl $0x0, -0x4(%rbp)
jmp 0xae923
jmp 0xae8d0
jmp 0xae8d2
jmp 0xae8d4
jmp 0xae8d6
jmp 0xae8d8
jmp 0xae8da
jmp 0xae8dc
jmp 0xae8de
jmp 0xae8e0
jmp 0xae8e2
jmp 0xae8e4
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rax
movslq 0x24(%rax), %rdx
callq 0xaea40
cmpl $0x0, %eax
jne 0xae917
jmp 0xae900
jmp 0xae902
movq -0x10(%rbp), %rdi
leaq 0x2da5d(%rip), %rsi # 0xdc36a
callq 0xaeab0
movl %eax, -0x4(%rbp)
jmp 0xae923
movq -0x10(%rbp), %rdi
callq 0xae150
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| my_coll_parser_scan_logical_position:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
mov rax, [rax+0F0h]
mov [rbp+var_28], rax
mov rdi, [rbp+var_10]
call my_coll_parser_curr
mov [rbp+var_30], rax
mov rdi, [rbp+var_30]
lea rsi, aFirstNonIgnora; "[first non-ignorable]"
mov edx, 15h
call lex_cmp
cmp eax, 0
jnz short loc_AE674
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+70h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp loc_AE8E4
loc_AE674:
mov rdi, [rbp+var_30]
lea rsi, aLastNonIgnorab; "[last non-ignorable]"
mov edx, 14h
call lex_cmp
cmp eax, 0
jnz short loc_AE6A8
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+78h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp loc_AE8E2
loc_AE6A8:
mov rdi, [rbp+var_30]
lea rsi, aFirstPrimaryIg; "[first primary ignorable]"
mov edx, 19h
call lex_cmp
cmp eax, 0
jnz short loc_AE6DF
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+80h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp loc_AE8E0
loc_AE6DF:
mov rdi, [rbp+var_30]
lea rsi, aLastPrimaryIgn; "[last primary ignorable]"
mov edx, 18h
call lex_cmp
cmp eax, 0
jnz short loc_AE716
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+88h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp loc_AE8DE
loc_AE716:
mov rdi, [rbp+var_30]
lea rsi, aFirstSecondary; "[first secondary ignorable]"
mov edx, 1Bh
call lex_cmp
cmp eax, 0
jnz short loc_AE74D
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+90h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp loc_AE8DC
loc_AE74D:
mov rdi, [rbp+var_30]
lea rsi, aLastSecondaryI; "[last secondary ignorable]"
mov edx, 1Ah
call lex_cmp
cmp eax, 0
jnz short loc_AE784
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+98h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp loc_AE8DA
loc_AE784:
mov rdi, [rbp+var_30]
lea rsi, aFirstTertiaryI; "[first tertiary ignorable]"
mov edx, 1Ah
call lex_cmp
cmp eax, 0
jnz short loc_AE7BB
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+0A0h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp loc_AE8D8
loc_AE7BB:
mov rdi, [rbp+var_30]
lea rsi, aLastTertiaryIg; "[last tertiary ignorable]"
mov edx, 19h
call lex_cmp
cmp eax, 0
jnz short loc_AE7F2
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+0A8h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp loc_AE8D6
loc_AE7F2:
mov rdi, [rbp+var_30]
lea rsi, aFirstTrailing; "[first trailing]"
mov edx, 10h
call lex_cmp
cmp eax, 0
jnz short loc_AE829
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+0B0h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp loc_AE8D4
loc_AE829:
mov rdi, [rbp+var_30]
lea rsi, aLastTrailing; "[last trailing]"
mov edx, 0Fh
call lex_cmp
cmp eax, 0
jnz short loc_AE85D
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+0B8h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp short loc_AE8D2
loc_AE85D:
mov rdi, [rbp+var_30]
lea rsi, aFirstVariable; "[first variable]"
mov edx, 10h
call lex_cmp
cmp eax, 0
jnz short loc_AE891
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+0C0h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp short loc_AE8D0
loc_AE891:
mov rdi, [rbp+var_30]
lea rsi, aLastVariable; "[last variable]"
mov edx, 0Fh
call lex_cmp
cmp eax, 0
jnz short loc_AE8C5
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rax, [rax+0C8h]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax+24h], ecx
jmp short loc_AE8CE
loc_AE8C5:
mov [rbp+var_4], 0
jmp short loc_AE923
loc_AE8CE:
jmp short $+2
loc_AE8D0:
jmp short $+2
loc_AE8D2:
jmp short $+2
loc_AE8D4:
jmp short $+2
loc_AE8D6:
jmp short $+2
loc_AE8D8:
jmp short $+2
loc_AE8DA:
jmp short $+2
loc_AE8DC:
jmp short $+2
loc_AE8DE:
jmp short $+2
loc_AE8E0:
jmp short $+2
loc_AE8E2:
jmp short $+2
loc_AE8E4:
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rax, [rbp+var_30]
movsxd rdx, dword ptr [rax+24h]
call my_coll_rule_expand
cmp eax, 0
jnz short loc_AE917
jmp short $+2
loc_AE900:
jmp short $+2
loc_AE902:
mov rdi, [rbp+var_10]
lea rsi, aLogicalPositio; "Logical position"
call my_coll_parser_too_long_error
mov [rbp+var_4], eax
jmp short loc_AE923
loc_AE917:
mov rdi, [rbp+var_10]
call my_coll_parser_scan
mov [rbp+var_4], eax
loc_AE923:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long my_coll_parser_scan_logical_position(long long a1, long long a2, long long a3)
{
long long v4; // [rsp+0h] [rbp-30h]
long long v5; // [rsp+8h] [rbp-28h]
v5 = *(_QWORD *)(a1 + 240);
v4 = my_coll_parser_curr(a1);
if ( (unsigned int)lex_cmp(v4, (long long)"[first non-ignorable]", 0x15uLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[last non-ignorable]", 0x14uLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[first primary ignorable]", 0x19uLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[last primary ignorable]", 0x18uLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[first secondary ignorable]", 0x1BuLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[last secondary ignorable]", 0x1AuLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[first tertiary ignorable]", 0x1AuLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[last tertiary ignorable]", 0x19uLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[first trailing]", 0x10uLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[last trailing]", 0xFuLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[first variable]", 0x10uLL) )
{
if ( (unsigned int)lex_cmp(v4, (long long)"[last variable]", 0xFuLL) )
return 0;
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 200LL);
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 192LL);
}
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 184LL);
}
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 176LL);
}
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 168LL);
}
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 160LL);
}
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 152LL);
}
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 144LL);
}
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 136LL);
}
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 128LL);
}
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 120LL);
}
}
else
{
*(_DWORD *)(v4 + 36) = *(_QWORD *)(*(_QWORD *)(v5 + 8) + 112LL);
}
if ( (unsigned int)my_coll_rule_expand(a2, a3, *(int *)(v4 + 36)) )
return (unsigned int)my_coll_parser_scan(a1);
else
return (unsigned int)my_coll_parser_too_long_error(a1, "Logical position");
}
| my_coll_parser_scan_logical_position:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xf0]
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001ad970
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x1dc25e]
MOV EDX,0x15
CALL 0x001ae0f0
CMP EAX,0x0
JNZ 0x001ae674
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x70]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x001ae8e4
LAB_001ae674:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x1dc274]
MOV EDX,0x14
CALL 0x001ae0f0
CMP EAX,0x0
JNZ 0x001ae6a8
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x001ae8e2
LAB_001ae6a8:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x1dc289]
MOV EDX,0x19
CALL 0x001ae0f0
CMP EAX,0x0
JNZ 0x001ae6df
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x80]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x001ae8e0
LAB_001ae6df:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x1dc2a3]
MOV EDX,0x18
CALL 0x001ae0f0
CMP EAX,0x0
JNZ 0x001ae716
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x88]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x001ae8de
LAB_001ae716:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x1dc2bc]
MOV EDX,0x1b
CALL 0x001ae0f0
CMP EAX,0x0
JNZ 0x001ae74d
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x90]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x001ae8dc
LAB_001ae74d:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x1dc2d8]
MOV EDX,0x1a
CALL 0x001ae0f0
CMP EAX,0x0
JNZ 0x001ae784
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x98]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x001ae8da
LAB_001ae784:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x1dc2f3]
MOV EDX,0x1a
CALL 0x001ae0f0
CMP EAX,0x0
JNZ 0x001ae7bb
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0xa0]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x001ae8d8
LAB_001ae7bb:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x1dc30e]
MOV EDX,0x19
CALL 0x001ae0f0
CMP EAX,0x0
JNZ 0x001ae7f2
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0xa8]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x001ae8d6
LAB_001ae7f2:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x1dc328]
MOV EDX,0x10
CALL 0x001ae0f0
CMP EAX,0x0
JNZ 0x001ae829
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0xb0]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x001ae8d4
LAB_001ae829:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x1dc339]
MOV EDX,0xf
CALL 0x001ae0f0
CMP EAX,0x0
JNZ 0x001ae85d
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0xb8]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x001ae8d2
LAB_001ae85d:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x1dc349]
MOV EDX,0x10
CALL 0x001ae0f0
CMP EAX,0x0
JNZ 0x001ae891
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0xc0]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x001ae8d0
LAB_001ae891:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x1dc35a]
MOV EDX,0xf
CALL 0x001ae0f0
CMP EAX,0x0
JNZ 0x001ae8c5
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0xc8]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x001ae8ce
LAB_001ae8c5:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001ae923
LAB_001ae8ce:
JMP 0x001ae8d0
LAB_001ae8d0:
JMP 0x001ae8d2
LAB_001ae8d2:
JMP 0x001ae8d4
LAB_001ae8d4:
JMP 0x001ae8d6
LAB_001ae8d6:
JMP 0x001ae8d8
LAB_001ae8d8:
JMP 0x001ae8da
LAB_001ae8da:
JMP 0x001ae8dc
LAB_001ae8dc:
JMP 0x001ae8de
LAB_001ae8de:
JMP 0x001ae8e0
LAB_001ae8e0:
JMP 0x001ae8e2
LAB_001ae8e2:
JMP 0x001ae8e4
LAB_001ae8e4:
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x30]
MOVSXD RDX,dword ptr [RAX + 0x24]
CALL 0x001aea40
CMP EAX,0x0
JNZ 0x001ae917
JMP 0x001ae900
LAB_001ae900:
JMP 0x001ae902
LAB_001ae902:
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x1dc36a]
CALL 0x001aeab0
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001ae923
LAB_001ae917:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001ae150
MOV dword ptr [RBP + -0x4],EAX
LAB_001ae923:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 my_coll_parser_scan_logical_position(long param_1,int8 param_2,int8 param_3)
{
long lVar1;
int iVar2;
long lVar3;
int4 local_c;
lVar1 = *(long *)(param_1 + 0xf0);
lVar3 = my_coll_parser_curr(param_1);
iVar2 = lex_cmp(lVar3,"[first non-ignorable]",0x15);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0x70);
}
else {
iVar2 = lex_cmp(lVar3,"[last non-ignorable]",0x14);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0x78);
}
else {
iVar2 = lex_cmp(lVar3,"[first primary ignorable]",0x19);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0x80);
}
else {
iVar2 = lex_cmp(lVar3,"[last primary ignorable]",0x18);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0x88);
}
else {
iVar2 = lex_cmp(lVar3,"[first secondary ignorable]",0x1b);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0x90);
}
else {
iVar2 = lex_cmp(lVar3,"[last secondary ignorable]",0x1a);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0x98);
}
else {
iVar2 = lex_cmp(lVar3,"[first tertiary ignorable]",0x1a);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0xa0);
}
else {
iVar2 = lex_cmp(lVar3,"[last tertiary ignorable]",0x19);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0xa8);
}
else {
iVar2 = lex_cmp(lVar3,"[first trailing]",0x10);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0xb0);
}
else {
iVar2 = lex_cmp(lVar3,"[last trailing]",0xf);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0xb8);
}
else {
iVar2 = lex_cmp(lVar3,"[first variable]",0x10);
if (iVar2 == 0) {
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 0xc0);
}
else {
iVar2 = lex_cmp(lVar3,"[last variable]",0xf);
if (iVar2 != 0) {
return 0;
}
*(int *)(lVar3 + 0x24) = (int)*(int8 *)(*(long *)(lVar1 + 8) + 200);
}
}
}
}
}
}
}
}
}
}
}
iVar2 = my_coll_rule_expand(param_2,param_3,(long)*(int *)(lVar3 + 0x24));
if (iVar2 == 0) {
local_c = my_coll_parser_too_long_error(param_1,"Logical position");
}
else {
local_c = my_coll_parser_scan(param_1);
}
return local_c;
}
| |
23,940 | HUDButton::checkHover() | GhostEscape/src/screen/hud_button.cpp | void HUDButton::checkHover()
{
bool new_hover_;
auto pos = render_position_ + sprite_normal_->getOffset();
auto size = sprite_normal_->getSize();
if (game_.isMouseInRect(pos, pos + size)){
new_hover_ = true;
} else {
new_hover_ = false;
}
if (new_hover_ != is_hover_){
is_hover_ = new_hover_;
if (is_hover_ && !is_press_) game_.playSound("assets/sound/UI_button12.wav");
}
} | O0 | cpp | HUDButton::checkHover():
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x98(%rbp)
movq %rax, %rcx
addq $0x4c, %rcx
movq %rcx, -0xa0(%rbp)
movq 0x58(%rax), %rdi
callq 0x15890
movq -0xa0(%rbp), %rdi
movlpd %xmm0, -0x3c(%rbp)
leaq -0x3c(%rbp), %rsi
callq 0x118e0
movq -0x98(%rbp), %rax
movlpd %xmm0, -0x34(%rbp)
movq 0x58(%rax), %rdi
callq 0x158b0
movq -0x98(%rbp), %rax
movlpd %xmm0, -0x44(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x90(%rbp)
leaq -0x34(%rbp), %rdi
leaq -0x44(%rbp), %rsi
callq 0x118e0
movq -0x90(%rbp), %rdi
movlpd %xmm0, -0x4c(%rbp)
leaq -0x34(%rbp), %rsi
leaq -0x4c(%rbp), %rdx
callq 0x7570
testb $0x1, %al
jne 0x1737e
jmp 0x17384
movb $0x1, -0x29(%rbp)
jmp 0x17388
movb $0x0, -0x29(%rbp)
movq -0x98(%rbp), %rcx
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb 0x70(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x17473
movq -0x98(%rbp), %rax
movb -0x29(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x70(%rax)
testb $0x1, 0x70(%rax)
je 0x17471
movq -0x98(%rbp), %rax
testb $0x1, 0x71(%rax)
jne 0x17471
movq -0x98(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0xa8(%rbp)
leaq -0x71(%rbp), %rdx
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq 0xaf28(%rip), %rsi # 0x22324
leaq -0x70(%rbp), %rdi
callq 0x7b70
jmp 0x17407
movq -0xa8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x17670
jmp 0x17419
leaq -0x70(%rbp), %rdi
callq 0x62c0
leaq -0x71(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9fa0
jmp 0x17471
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x1745e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x62c0
leaq -0x71(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9fa0
jmp 0x1747c
jmp 0x17473
addq $0xb0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x6750
nopw %cs:(%rax,%rax)
| _ZN9HUDButton10checkHoverEv:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov [rbp+var_28], rdi
mov rax, [rbp+var_28]
mov [rbp+var_98], rax
mov rcx, rax
add rcx, 4Ch ; 'L'
mov [rbp+var_A0], rcx
mov rdi, [rax+58h]; this
call _ZNK15ObjectAffiliate9getOffsetEv; ObjectAffiliate::getOffset(void)
mov rdi, [rbp+var_A0]
movlpd [rbp+var_3C], xmm0
lea rsi, [rbp+var_3C]
call _ZN3glmplIfLNS_9qualifierE0EEENS_3vecILi2ET_XT0_EEERKS4_S6_; glm::operator+<float,(glm::qualifier)0>(glm::vec<2,float,(glm::qualifier)0> const&,glm::vec<2,float,(glm::qualifier)0> const&)
mov rax, [rbp+var_98]
movlpd [rbp+var_34], xmm0
mov rdi, [rax+58h]; this
call _ZNK15ObjectAffiliate7getSizeEv; ObjectAffiliate::getSize(void)
mov rax, [rbp+var_98]
movlpd [rbp+var_44], xmm0
mov rax, [rax+10h]
mov [rbp+var_90], rax
lea rdi, [rbp+var_34]
lea rsi, [rbp+var_44]
call _ZN3glmplIfLNS_9qualifierE0EEENS_3vecILi2ET_XT0_EEERKS4_S6_; glm::operator+<float,(glm::qualifier)0>(glm::vec<2,float,(glm::qualifier)0> const&,glm::vec<2,float,(glm::qualifier)0> const&)
mov rdi, [rbp+var_90]
movlpd [rbp+var_4C], xmm0
lea rsi, [rbp+var_34]
lea rdx, [rbp+var_4C]
call _ZN4Game13isMouseInRectERKN3glm3vecILi2EfLNS0_9qualifierE0EEES5_; Game::isMouseInRect(glm::vec<2,float,(glm::qualifier)0> const&,glm::vec<2,float,(glm::qualifier)0> const&)
test al, 1
jnz short loc_1737E
jmp short loc_17384
loc_1737E:
mov [rbp+var_29], 1
jmp short loc_17388
loc_17384:
mov [rbp+var_29], 0
loc_17388:
mov rcx, [rbp+var_98]
mov al, [rbp+var_29]
and al, 1
movzx eax, al
mov cl, [rcx+70h]
and cl, 1
movzx ecx, cl
cmp eax, ecx
jz loc_17473
mov rax, [rbp+var_98]
mov cl, [rbp+var_29]
and cl, 1
mov [rax+70h], cl
test byte ptr [rax+70h], 1
jz loc_17471
mov rax, [rbp+var_98]
test byte ptr [rax+71h], 1
jnz loc_17471
mov rax, [rbp+var_98]
mov rax, [rax+10h]
mov [rbp+var_A8], rax
lea rdx, [rbp+var_71]
mov [rbp+var_20], rdx
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
lea rsi, aAssetsSoundUiB_0; "assets/sound/UI_button12.wav"
lea rdi, [rbp+var_70]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_17407:
mov rdi, [rbp+var_A8]
lea rsi, [rbp+var_70]
call _ZN4Game9playSoundERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; Game::playSound(std::string const&)
jmp short $+2
loc_17419:
lea rdi, [rbp+var_70]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rax, [rbp+var_71]
mov [rbp+var_18], rax
mov rdi, [rbp+var_18]
call _ZNSt15__new_allocatorIcED2Ev; std::__new_allocator<char>::~__new_allocator()
jmp short loc_17471
mov rcx, rax
mov eax, edx
mov [rbp+var_80], rcx
mov [rbp+var_84], eax
jmp short loc_1745E
mov rcx, rax
mov eax, edx
mov [rbp+var_80], rcx
mov [rbp+var_84], eax
lea rdi, [rbp+var_70]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_1745E:
lea rax, [rbp+var_71]
mov [rbp+var_10], rax
mov rdi, [rbp+var_10]
call _ZNSt15__new_allocatorIcED2Ev; std::__new_allocator<char>::~__new_allocator()
jmp short loc_1747C
loc_17471:
jmp short $+2
loc_17473:
add rsp, 0B0h
pop rbp
retn
loc_1747C:
mov rdi, [rbp+var_80]
call __Unwind_Resume
| void HUDButton::checkHover(HUDButton *this)
{
long long v1; // [rsp+8h] [rbp-A8h]
long long v2; // [rsp+20h] [rbp-90h]
char v3; // [rsp+3Fh] [rbp-71h] BYREF
_BYTE v4[36]; // [rsp+40h] [rbp-70h] BYREF
double v5; // [rsp+64h] [rbp-4Ch] BYREF
double Size; // [rsp+6Ch] [rbp-44h] BYREF
double Offset; // [rsp+74h] [rbp-3Ch] BYREF
double v8; // [rsp+7Ch] [rbp-34h] BYREF
bool isMouseInRect; // [rsp+87h] [rbp-29h]
HUDButton *v10; // [rsp+88h] [rbp-28h]
char *v11; // [rsp+90h] [rbp-20h]
char *v12; // [rsp+98h] [rbp-18h]
char *v13; // [rsp+A8h] [rbp-8h]
v10 = this;
Offset = ObjectAffiliate::getOffset(*((ObjectAffiliate **)this + 11));
v8 = glm::operator+<float,(glm::qualifier)0>((float *)this + 19, (float *)&Offset);
Size = ObjectAffiliate::getSize(*((ObjectAffiliate **)this + 11));
v2 = *((_QWORD *)this + 2);
v5 = glm::operator+<float,(glm::qualifier)0>((float *)&v8, (float *)&Size);
isMouseInRect = Game::isMouseInRect(v2, (float *)&v8, (float *)&v5);
if ( isMouseInRect != (*((_BYTE *)this + 112) & 1) )
{
*((_BYTE *)this + 112) = isMouseInRect;
if ( (*((_BYTE *)this + 112) & 1) != 0 && (*((_BYTE *)this + 113) & 1) == 0 )
{
v1 = *((_QWORD *)this + 2);
v11 = &v3;
v13 = &v3;
std::string::basic_string<std::allocator<char>>(
(long long)v4,
(long long)"assets/sound/UI_button12.wav",
(long long)&v3);
Game::playSound(v1, v4);
std::string::~string(v4);
v12 = &v3;
std::__new_allocator<char>::~__new_allocator();
}
}
}
| checkHover:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV qword ptr [RBP + -0x28],RDI
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x98],RAX
MOV RCX,RAX
ADD RCX,0x4c
MOV qword ptr [RBP + -0xa0],RCX
MOV RDI,qword ptr [RAX + 0x58]
CALL 0x00115890
MOV RDI,qword ptr [RBP + -0xa0]
MOVLPD qword ptr [RBP + -0x3c],XMM0
LEA RSI,[RBP + -0x3c]
CALL 0x001118e0
MOV RAX,qword ptr [RBP + -0x98]
MOVLPD qword ptr [RBP + -0x34],XMM0
MOV RDI,qword ptr [RAX + 0x58]
CALL 0x001158b0
MOV RAX,qword ptr [RBP + -0x98]
MOVLPD qword ptr [RBP + -0x44],XMM0
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x90],RAX
LEA RDI,[RBP + -0x34]
LEA RSI,[RBP + -0x44]
CALL 0x001118e0
MOV RDI,qword ptr [RBP + -0x90]
MOVLPD qword ptr [RBP + -0x4c],XMM0
LEA RSI,[RBP + -0x34]
LEA RDX,[RBP + -0x4c]
CALL 0x00107570
TEST AL,0x1
JNZ 0x0011737e
JMP 0x00117384
LAB_0011737e:
MOV byte ptr [RBP + -0x29],0x1
JMP 0x00117388
LAB_00117384:
MOV byte ptr [RBP + -0x29],0x0
LAB_00117388:
MOV RCX,qword ptr [RBP + -0x98]
MOV AL,byte ptr [RBP + -0x29]
AND AL,0x1
MOVZX EAX,AL
MOV CL,byte ptr [RCX + 0x70]
AND CL,0x1
MOVZX ECX,CL
CMP EAX,ECX
JZ 0x00117473
MOV RAX,qword ptr [RBP + -0x98]
MOV CL,byte ptr [RBP + -0x29]
AND CL,0x1
MOV byte ptr [RAX + 0x70],CL
TEST byte ptr [RAX + 0x70],0x1
JZ 0x00117471
MOV RAX,qword ptr [RBP + -0x98]
TEST byte ptr [RAX + 0x71],0x1
JNZ 0x00117471
MOV RAX,qword ptr [RBP + -0x98]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0xa8],RAX
LEA RDX,[RBP + -0x71]
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
LAB_001173f5:
LEA RSI,[0x122324]
LEA RDI,[RBP + -0x70]
CALL 0x00107b70
JMP 0x00117407
LAB_00117407:
MOV RDI,qword ptr [RBP + -0xa8]
LEA RSI,[RBP + -0x70]
CALL 0x00117670
LAB_00117417:
JMP 0x00117419
LAB_00117419:
LEA RDI,[RBP + -0x70]
CALL 0x001062c0
LEA RAX,[RBP + -0x71]
MOV qword ptr [RBP + -0x18],RAX
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00109fa0
JMP 0x00117471
LAB_00117471:
JMP 0x00117473
LAB_00117473:
ADD RSP,0xb0
POP RBP
RET
|
/* HUDButton::checkHover() */
void __thiscall HUDButton::checkHover(HUDButton *this)
{
Game *pGVar1;
ulong uVar2;
allocator local_79;
string local_78 [36];
int8 local_54;
int8 local_4c;
int8 local_44;
int8 local_3c;
HUDButton local_31;
HUDButton *local_30;
allocator *local_28;
__new_allocator<char> *local_20;
allocator *local_10;
local_30 = this;
local_44 = ObjectAffiliate::getOffset(*(ObjectAffiliate **)(this + 0x58));
local_3c = glm::operator+((vec *)(this + 0x4c),(vec *)&local_44);
local_4c = ObjectAffiliate::getSize(*(ObjectAffiliate **)(this + 0x58));
pGVar1 = *(Game **)(this + 0x10);
local_54 = glm::operator+((vec *)&local_3c,(vec *)&local_4c);
uVar2 = Game::isMouseInRect(pGVar1,(vec *)&local_3c,(vec *)&local_54);
local_31 = (HUDButton)((uVar2 & 1) != 0);
if (((local_31 != (HUDButton)((byte)this[0x70] & 1)) &&
(this[0x70] = local_31, ((byte)this[0x70] & 1) != 0)) && (((byte)this[0x71] & 1) == 0)) {
pGVar1 = *(Game **)(this + 0x10);
local_28 = &local_79;
/* try { // try from 001173f5 to 00117404 has its CatchHandler @ 00117435 */
local_10 = local_28;
std::__cxx11::string::string<std::allocator<char>>
(local_78,"assets/sound/UI_button12.wav",local_28);
/* try { // try from 00117407 to 00117416 has its CatchHandler @ 00117446 */
Game::playSound(pGVar1,local_78);
std::__cxx11::string::~string(local_78);
local_20 = (__new_allocator<char> *)&local_79;
std::__new_allocator<char>::~__new_allocator(local_20);
}
return;
}
| |
23,941 | HUDButton::checkHover() | GhostEscape/src/screen/hud_button.cpp | void HUDButton::checkHover()
{
bool new_hover_;
auto pos = render_position_ + sprite_normal_->getOffset();
auto size = sprite_normal_->getSize();
if (game_.isMouseInRect(pos, pos + size)){
new_hover_ = true;
} else {
new_hover_ = false;
}
if (new_hover_ != is_hover_){
is_hover_ = new_hover_;
if (is_hover_ && !is_press_) game_.playSound("assets/sound/UI_button12.wav");
}
} | O3 | cpp | HUDButton::checkHover():
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x58(%rdi), %rax
movsd 0x58(%rax), %xmm0
movss 0x4c(%rdi), %xmm1
addss %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
addss 0x50(%rdi), %xmm0
movaps %xmm1, %xmm2
unpcklps %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
leaq -0x40(%rbp), %rsi
movlps %xmm2, (%rsi)
movsd 0x60(%rax), %xmm2
movq 0x10(%rdi), %rdi
addss %xmm2, %xmm1
shufps $0x55, %xmm2, %xmm2 # xmm2 = xmm2[1,1,1,1]
addss %xmm0, %xmm2
unpcklps %xmm2, %xmm1 # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
leaq -0x38(%rbp), %rdx
movlps %xmm1, (%rdx)
callq 0x6314
cmpb %al, 0x70(%rbx)
je 0xaa59
movb %al, 0x70(%rbx)
testb %al, %al
je 0xaa59
cmpb $0x0, 0x71(%rbx)
jne 0xaa59
movq 0x10(%rbx), %r15
leaq -0x28(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x59bb(%rip), %rsi # 0x103d2
leaq 0x59d0(%rip), %rdx # 0x103ee
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x6b6c
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x6ff6
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
movq %rax, %rsi
xorl %edx, %edx
callq 0x5130
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0xaa59
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x53d0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0xaa7c
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x53d0
movq %rbx, %rdi
callq 0x5600
| _ZN9HUDButton10checkHoverEv:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 28h
mov rbx, rdi
mov rax, [rdi+58h]
movsd xmm0, qword ptr [rax+58h]
movss xmm1, dword ptr [rdi+4Ch]
addss xmm1, xmm0
shufps xmm0, xmm0, 55h ; 'U'
addss xmm0, dword ptr [rdi+50h]
movaps xmm2, xmm1
unpcklps xmm2, xmm0
lea rsi, [rbp+var_40]
movlps qword ptr [rsi], xmm2
movsd xmm2, qword ptr [rax+60h]
mov rdi, [rdi+10h]
addss xmm1, xmm2
shufps xmm2, xmm2, 55h ; 'U'
addss xmm2, xmm0
unpcklps xmm1, xmm2
lea rdx, [rbp+var_38]
movlps qword ptr [rdx], xmm1
call _ZN4Game13isMouseInRectERKN3glm3vecILi2EfLNS0_9qualifierE0EEES5_; Game::isMouseInRect(glm::vec<2,float,(glm::qualifier)0> const&,glm::vec<2,float,(glm::qualifier)0> const&)
cmp [rbx+70h], al
jz short loc_AA59
mov [rbx+70h], al
test al, al
jz short loc_AA59
cmp byte ptr [rbx+71h], 0
jnz short loc_AA59
mov r15, [rbx+10h]
lea r14, [rbp+var_28]
mov [r14-10h], r14
lea rsi, aAssetsSoundUiB_0; "assets/sound/UI_button12.wav"
lea rdx, aAssetsSoundUiB_0+1Ch; ""
lea rbx, [rbp+var_38]
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rdi, [r15]
mov rsi, rbx
call _ZN10AssetStore8getSoundERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; AssetStore::getSound(std::string const&)
mov edi, 0FFFFFFFFh
mov rsi, rax
xor edx, edx
call _Mix_PlayChannel
mov rdi, [rbp+var_38]; void *
cmp rdi, r14
jz short loc_AA59
mov rsi, [rbp+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_AA59:
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rbp+var_38]; void *
cmp rdi, r14
jz short loc_AA7C
mov rsi, [rbp+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_AA7C:
mov rdi, rbx
call __Unwind_Resume
| void HUDButton::checkHover(HUDButton *this)
{
long long v2; // rax
__m128 v3; // xmm0
__m128 v4; // xmm1
__m128 v5; // xmm0
__m128 v6; // xmm2
long long v7; // rdi
__m128 v8; // xmm2
char isMouseInRect; // al
long long *v10; // r15
long long Sound; // rax
double v12; // [rsp+0h] [rbp-40h] BYREF
void *v13[2]; // [rsp+8h] [rbp-38h] BYREF
_QWORD v14[5]; // [rsp+18h] [rbp-28h] BYREF
v2 = *((_QWORD *)this + 11);
v3 = (__m128)*(unsigned long long *)(v2 + 88);
v4 = (__m128)*((unsigned int *)this + 19);
v4.m128_f32[0] = v4.m128_f32[0] + v3.m128_f32[0];
v5 = _mm_shuffle_ps(v3, v3, 85);
v5.m128_f32[0] = v5.m128_f32[0] + *((float *)this + 20);
_mm_storel_ps(&v12, _mm_unpacklo_ps(v4, v5));
v6 = (__m128)*(unsigned long long *)(v2 + 96);
v7 = *((_QWORD *)this + 2);
v4.m128_f32[0] = v4.m128_f32[0] + v6.m128_f32[0];
v8 = _mm_shuffle_ps(v6, v6, 85);
v8.m128_f32[0] = v8.m128_f32[0] + v5.m128_f32[0];
_mm_storel_ps((double *)v13, _mm_unpacklo_ps(v4, v8));
isMouseInRect = Game::isMouseInRect(v7, (float *)&v12, (float *)v13);
if ( *((_BYTE *)this + 112) != isMouseInRect )
{
*((_BYTE *)this + 112) = isMouseInRect;
if ( isMouseInRect )
{
if ( !*((_BYTE *)this + 113) )
{
v10 = (long long *)*((_QWORD *)this + 2);
v13[0] = v14;
std::string::_M_construct<char const*>((long long)v13, "assets/sound/UI_button12.wav", (long long)"");
Sound = AssetStore::getSound(*v10, (const char **)v13);
Mix_PlayChannel(0xFFFFFFFFLL, Sound, 0LL);
if ( v13[0] != v14 )
operator delete(v13[0], v14[0] + 1LL);
}
}
}
}
| checkHover:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x58]
MOVSD XMM0,qword ptr [RAX + 0x58]
MOVSS XMM1,dword ptr [RDI + 0x4c]
ADDSS XMM1,XMM0
SHUFPS XMM0,XMM0,0x55
ADDSS XMM0,dword ptr [RDI + 0x50]
MOVAPS XMM2,XMM1
UNPCKLPS XMM2,XMM0
LEA RSI,[RBP + -0x40]
MOVLPS qword ptr [RSI],XMM2
MOVSD XMM2,qword ptr [RAX + 0x60]
MOV RDI,qword ptr [RDI + 0x10]
ADDSS XMM1,XMM2
SHUFPS XMM2,XMM2,0x55
ADDSS XMM2,XMM0
UNPCKLPS XMM1,XMM2
LEA RDX,[RBP + -0x38]
MOVLPS qword ptr [RDX],XMM1
CALL 0x00106314
CMP byte ptr [RBX + 0x70],AL
JZ 0x0010aa59
MOV byte ptr [RBX + 0x70],AL
TEST AL,AL
JZ 0x0010aa59
CMP byte ptr [RBX + 0x71],0x0
JNZ 0x0010aa59
MOV R15,qword ptr [RBX + 0x10]
LEA R14,[RBP + -0x28]
MOV qword ptr [R14 + -0x10],R14
LEA RSI,[0x1103d2]
LEA RDX,[0x1103ee]
LEA RBX,[RBP + -0x38]
MOV RDI,RBX
CALL 0x00106b6c
MOV RDI,qword ptr [R15]
LAB_0010aa2d:
MOV RSI,RBX
CALL 0x00106ff6
MOV EDI,0xffffffff
MOV RSI,RAX
XOR EDX,EDX
CALL 0x00105130
LAB_0010aa44:
MOV RDI,qword ptr [RBP + -0x38]
CMP RDI,R14
JZ 0x0010aa59
MOV RSI,qword ptr [RBP + -0x28]
INC RSI
CALL 0x001053d0
LAB_0010aa59:
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* HUDButton::checkHover() */
void __thiscall HUDButton::checkHover(HUDButton *this)
{
int8 *puVar1;
HUDButton HVar2;
int8 uVar3;
float fVar4;
float fVar5;
int8 local_48;
long *local_40 [2];
long local_30 [2];
uVar3 = *(int8 *)(*(long *)(this + 0x58) + 0x58);
fVar5 = *(float *)(this + 0x4c) + (float)uVar3;
fVar4 = (float)((ulong)uVar3 >> 0x20) + *(float *)(this + 0x50);
local_48 = CONCAT44(fVar4,fVar5);
uVar3 = *(int8 *)(*(long *)(this + 0x58) + 0x60);
local_40[0] = (long *)CONCAT44((float)((ulong)uVar3 >> 0x20) + fVar4,fVar5 + (float)uVar3);
HVar2 = (HUDButton)Game::isMouseInRect(*(Game **)(this + 0x10),(vec *)&local_48,(vec *)local_40);
if (((this[0x70] != HVar2) && (this[0x70] = HVar2, HVar2 != (HUDButton)0x0)) &&
(this[0x71] == (HUDButton)0x0)) {
puVar1 = *(int8 **)(this + 0x10);
local_40[0] = local_30;
std::__cxx11::string::_M_construct<char_const*>
((string *)local_40,"assets/sound/UI_button12.wav","");
/* try { // try from 0010aa2d to 0010aa43 has its CatchHandler @ 0010aa64 */
uVar3 = AssetStore::getSound((AssetStore *)*puVar1,(string *)local_40);
Mix_PlayChannel(0xffffffff,uVar3,0);
if (local_40[0] != local_30) {
operator_delete(local_40[0],local_30[0] + 1);
}
}
return;
}
| |
23,942 | optimize_scope_make_ref | bluesky950520[P]quickjs/quickjs.c | static int optimize_scope_make_ref(JSContext *ctx, JSFunctionDef *s,
DynBuf *bc, uint8_t *bc_buf,
LabelSlot *ls, int pos_next,
int get_op, int var_idx)
{
int label_pos, end_pos, pos;
/* XXX: should optimize `loc(a) += expr` as `expr add_loc(a)`
but only if expr does not modify `a`.
should scan the code between pos_next and label_pos
for operations that can potentially change `a`:
OP_scope_make_ref(a), function calls, jumps and gosub.
*/
/* replace the reference get/put with normal variable
accesses */
if (bc_buf[pos_next] == OP_get_ref_value) {
dbuf_putc(bc, get_op);
dbuf_put_u16(bc, var_idx);
pos_next++;
}
/* remove the OP_label to make room for replacement */
/* label should have a refcount of 0 anyway */
/* XXX: should avoid this patch by inserting nops in phase 1 */
label_pos = ls->pos;
pos = label_pos - 5;
assert(bc_buf[pos] == OP_label);
/* label points to an instruction pair:
- insert3 / put_ref_value
- perm4 / put_ref_value
- rot3l / put_ref_value
- nop / put_ref_value
*/
end_pos = label_pos + 2;
if (bc_buf[label_pos] == OP_insert3)
bc_buf[pos++] = OP_dup;
bc_buf[pos] = get_op + 1;
put_u16(bc_buf + pos + 1, var_idx);
pos += 3;
/* pad with OP_nop */
while (pos < end_pos)
bc_buf[pos++] = OP_nop;
return pos_next;
} | O1 | c | optimize_scope_make_ref:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movl %r8d, %r15d
movl %ecx, %ebx
movq %rdx, %r12
movq %rsi, %r14
movslq %ecx, %rax
cmpb $0x3c, (%rsi,%rax)
jne 0x6e4ba
movq %rdi, %r13
movzbl %r15b, %esi
callq 0x1a8bc
leaq 0x6(%rsp), %rsi
movw %bp, (%rsi)
movl $0x2, %edx
movq %r13, %rdi
callq 0x1a80e
incl %ebx
movslq 0x4(%r12), %rdx
leaq -0x5(%rdx), %rax
cmpb $0x16, (%r14,%rdx)
jne 0x6e4d2
movb $0x11, (%r14,%rax)
leal -0x4(%rdx), %eax
incb %r15b
cltq
movb %r15b, (%r14,%rax)
movw %bp, 0x1(%r14,%rax)
leal 0x1(%rax), %ecx
cmpl %edx, %ecx
jge 0x6e502
leaq (%r14,%rax), %rdi
addq $0x3, %rdi
subl %eax, %edx
addl $-0x2, %edx
incq %rdx
movl $0xb2, %esi
callq 0xe340
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| optimize_scope_make_ref:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebp, r9d
mov r15d, r8d
mov ebx, ecx
mov r12, rdx
mov r14, rsi
movsxd rax, ecx
cmp byte ptr [rsi+rax], 3Ch ; '<'
jnz short loc_6E4BA
mov r13, rdi
movzx esi, r15b
call dbuf_putc
lea rsi, [rsp+38h+var_32]
mov [rsi], bp
mov edx, 2
mov rdi, r13
call dbuf_put
inc ebx
loc_6E4BA:
movsxd rdx, dword ptr [r12+4]
lea rax, [rdx-5]
cmp byte ptr [r14+rdx], 16h
jnz short loc_6E4D2
mov byte ptr [r14+rax], 11h
lea eax, [rdx-4]
loc_6E4D2:
inc r15b
cdqe
mov [r14+rax], r15b
mov [r14+rax+1], bp
lea ecx, [rax+1]
cmp ecx, edx
jge short loc_6E502
lea rdi, [r14+rax]
add rdi, 3
sub edx, eax
add edx, 0FFFFFFFEh
inc rdx
mov esi, 0B2h
call _memset
loc_6E502:
mov eax, ebx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long optimize_scope_make_ref(_QWORD *a1, long long a2, long long a3, unsigned int a4, char a5, __int16 a6)
{
long long v6; // rax
unsigned int v9; // ebx
long long v11; // rdx
long long v12; // rax
_WORD v14[25]; // [rsp+0h] [rbp-32h] BYREF
v14[0] = HIWORD(v6);
v9 = a4;
if ( *(_BYTE *)(a2 + (int)a4) == 60 )
{
dbuf_putc(a1, a5);
v14[0] = a6;
dbuf_put(a1, (long long)v14, 2LL);
++v9;
}
v11 = *(int *)(a3 + 4);
v12 = v11 - 5;
if ( *(_BYTE *)(a2 + v11) == 22 )
{
*(_BYTE *)(a2 + v12) = 17;
LODWORD(v12) = v11 - 4;
}
*(_BYTE *)(a2 + (int)v12) = a5 + 1;
*(_WORD *)(a2 + (int)v12 + 1) = a6;
if ( (int)v12 + 1 < (int)v11 )
memset(a2 + (int)v12 + 3, 178LL, (unsigned int)(v11 - v12 - 2) + 1LL);
return v9;
}
| optimize_scope_make_ref:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EBP,R9D
MOV R15D,R8D
MOV EBX,ECX
MOV R12,RDX
MOV R14,RSI
MOVSXD RAX,ECX
CMP byte ptr [RSI + RAX*0x1],0x3c
JNZ 0x0016e4ba
MOV R13,RDI
MOVZX ESI,R15B
CALL 0x0011a8bc
LEA RSI,[RSP + 0x6]
MOV word ptr [RSI],BP
MOV EDX,0x2
MOV RDI,R13
CALL 0x0011a80e
INC EBX
LAB_0016e4ba:
MOVSXD RDX,dword ptr [R12 + 0x4]
LEA RAX,[RDX + -0x5]
CMP byte ptr [R14 + RDX*0x1],0x16
JNZ 0x0016e4d2
MOV byte ptr [R14 + RAX*0x1],0x11
LEA EAX,[RDX + -0x4]
LAB_0016e4d2:
INC R15B
CDQE
MOV byte ptr [R14 + RAX*0x1],R15B
MOV word ptr [R14 + RAX*0x1 + 0x1],BP
LEA ECX,[RAX + 0x1]
CMP ECX,EDX
JGE 0x0016e502
LEA RDI,[R14 + RAX*0x1]
ADD RDI,0x3
SUB EDX,EAX
ADD EDX,-0x2
INC RDX
MOV ESI,0xb2
CALL 0x0010e340
LAB_0016e502:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int optimize_scope_make_ref
(int8 param_1,long param_2,long param_3,int param_4,char param_5,
int2 param_6)
{
int iVar1;
int iVar2;
int8 in_RAX;
ulong uVar3;
int8 uStack_38;
long lVar4;
uStack_38 = in_RAX;
if (*(char *)(param_2 + param_4) == '<') {
dbuf_putc(param_1,param_5);
uStack_38 = CONCAT26(param_6,(int6)uStack_38);
dbuf_put(param_1,(long)&uStack_38 + 6,2);
param_4 = param_4 + 1;
}
iVar1 = *(int *)(param_3 + 4);
uVar3 = (long)iVar1 - 5;
if (*(char *)(param_2 + iVar1) == '\x16') {
*(int1 *)(param_2 + uVar3) = 0x11;
uVar3 = (ulong)(iVar1 - 4);
}
iVar2 = (int)uVar3;
lVar4 = (long)iVar2;
*(char *)(param_2 + lVar4) = param_5 + '\x01';
*(int2 *)(param_2 + 1 + lVar4) = param_6;
if (iVar2 + 1 < iVar1) {
memset((void *)(param_2 + lVar4 + 3),0xb2,(ulong)((iVar1 - iVar2) - 2) + 1);
}
return param_4;
}
| |
23,943 | dbuf_write | bluesky950520[P]quickjs/cutils.c | int dbuf_write(DynBuf *s, size_t offset, const void *data, size_t len)
{
size_t end;
end = offset + len;
if (dbuf_realloc(s, end))
return -1;
memcpy(s->buf + offset, data, len);
if (end > s->size)
s->size = end;
return 0;
} | O0 | c | dbuf_write:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x20(%rsp), %rax
addq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x246e0
cmpl $0x0, %eax
je 0x247f5
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x24837
movq 0x28(%rsp), %rax
movq (%rax), %rdi
addq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0xe610
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x2482f
movq 0x8(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
| dbuf_write:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_18], rsi
mov [rsp+38h+var_20], rdx
mov [rsp+38h+var_28], rcx
mov rax, [rsp+38h+var_18]
add rax, [rsp+38h+var_28]
mov [rsp+38h+var_30], rax
mov rdi, [rsp+38h+var_10]
mov rsi, [rsp+38h+var_30]
call dbuf_realloc
cmp eax, 0
jz short loc_247F5
mov [rsp+38h+var_4], 0FFFFFFFFh
jmp short loc_24837
loc_247F5:
mov rax, [rsp+38h+var_10]
mov rdi, [rax]
add rdi, [rsp+38h+var_18]
mov rsi, [rsp+38h+var_20]
mov rdx, [rsp+38h+var_28]
call _memcpy
mov rax, [rsp+38h+var_30]
mov rcx, [rsp+38h+var_10]
cmp rax, [rcx+8]
jbe short loc_2482F
mov rcx, [rsp+38h+var_30]
mov rax, [rsp+38h+var_10]
mov [rax+8], rcx
loc_2482F:
mov [rsp+38h+var_4], 0
loc_24837:
mov eax, [rsp+38h+var_4]
add rsp, 38h
retn
| long long dbuf_write(_QWORD *a1, long long a2, long long a3, long long a4)
{
unsigned long long v5; // [rsp+8h] [rbp-30h]
v5 = a4 + a2;
if ( (unsigned int)dbuf_realloc((long long)a1, a4 + a2) )
{
return (unsigned int)-1;
}
else
{
memcpy(a2 + *a1, a3, a4);
if ( v5 > a1[1] )
a1[1] = v5;
return 0;
}
}
| dbuf_write:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RDI
MOV qword ptr [RSP + 0x20],RSI
MOV qword ptr [RSP + 0x18],RDX
MOV qword ptr [RSP + 0x10],RCX
MOV RAX,qword ptr [RSP + 0x20]
ADD RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x001246e0
CMP EAX,0x0
JZ 0x001247f5
MOV dword ptr [RSP + 0x34],0xffffffff
JMP 0x00124837
LAB_001247f5:
MOV RAX,qword ptr [RSP + 0x28]
MOV RDI,qword ptr [RAX]
ADD RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x10]
CALL 0x0010e610
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x28]
CMP RAX,qword ptr [RCX + 0x8]
JBE 0x0012482f
MOV RCX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RAX + 0x8],RCX
LAB_0012482f:
MOV dword ptr [RSP + 0x34],0x0
LAB_00124837:
MOV EAX,dword ptr [RSP + 0x34]
ADD RSP,0x38
RET
|
int4 dbuf_write(long *param_1,long param_2,void *param_3,size_t param_4)
{
int iVar1;
ulong uVar2;
int4 local_4;
uVar2 = param_2 + param_4;
iVar1 = dbuf_realloc(param_1,uVar2);
if (iVar1 == 0) {
memcpy((void *)(*param_1 + param_2),param_3,param_4);
if ((ulong)param_1[1] < uVar2) {
param_1[1] = uVar2;
}
local_4 = 0;
}
else {
local_4 = 0xffffffff;
}
return local_4;
}
| |
23,944 | dbuf_write | bluesky950520[P]quickjs/cutils.c | int dbuf_write(DynBuf *s, size_t offset, const void *data, size_t len)
{
size_t end;
end = offset + len;
if (dbuf_realloc(s, end))
return -1;
memcpy(s->buf + offset, data, len);
if (end > s->size)
s->size = end;
return 0;
} | O1 | c | dbuf_write:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq (%rcx,%rsi), %r14
movq %r14, %rsi
callq 0x1f3d1
movl %eax, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x1f474
addq (%rbx), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xe620
xorl %eax, %eax
cmpq 0x8(%rbx), %r14
jbe 0x1f474
movq %r14, 0x8(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| dbuf_write:
push r15
push r14
push r13
push r12
push rbx
mov r15, rcx
mov r12, rdx
mov r13, rsi
mov rbx, rdi
lea r14, [rcx+rsi]
mov rsi, r14
call dbuf_realloc
mov ecx, eax
mov eax, 0FFFFFFFFh
test ecx, ecx
jnz short loc_1F474
add r13, [rbx]
mov rdi, r13
mov rsi, r12
mov rdx, r15
call _memcpy
xor eax, eax
cmp r14, [rbx+8]
jbe short loc_1F474
mov [rbx+8], r14
loc_1F474:
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| long long dbuf_write(_QWORD *a1, long long a2, long long a3, long long a4)
{
unsigned long long v6; // r14
int v7; // ecx
long long result; // rax
v6 = a4 + a2;
v7 = dbuf_realloc((long long)a1, a4 + a2);
result = 0xFFFFFFFFLL;
if ( !v7 )
{
memcpy(*a1 + a2, a3, a4);
result = 0LL;
if ( v6 > a1[1] )
a1[1] = v6;
}
return result;
}
| dbuf_write:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R15,RCX
MOV R12,RDX
MOV R13,RSI
MOV RBX,RDI
LEA R14,[RCX + RSI*0x1]
MOV RSI,R14
CALL 0x0011f3d1
MOV ECX,EAX
MOV EAX,0xffffffff
TEST ECX,ECX
JNZ 0x0011f474
ADD R13,qword ptr [RBX]
MOV RDI,R13
MOV RSI,R12
MOV RDX,R15
CALL 0x0010e620
XOR EAX,EAX
CMP R14,qword ptr [RBX + 0x8]
JBE 0x0011f474
MOV qword ptr [RBX + 0x8],R14
LAB_0011f474:
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
int8 dbuf_write(long *param_1,long param_2,void *param_3,size_t param_4)
{
ulong uVar1;
int iVar2;
int8 uVar3;
uVar1 = param_4 + param_2;
iVar2 = dbuf_realloc(param_1,uVar1);
uVar3 = 0xffffffff;
if (iVar2 == 0) {
memcpy((void *)(param_2 + *param_1),param_3,param_4);
uVar3 = 0;
if ((ulong)param_1[1] < uVar1) {
param_1[1] = uVar1;
}
}
return uVar3;
}
| |
23,945 | dbuf_write | bluesky950520[P]quickjs/cutils.c | int dbuf_write(DynBuf *s, size_t offset, const void *data, size_t len)
{
size_t end;
end = offset + len;
if (dbuf_realloc(s, end))
return -1;
memcpy(s->buf + offset, data, len);
if (end > s->size)
s->size = end;
return 0;
} | O2 | c | dbuf_write:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq (%rcx,%rsi), %r14
movq %r14, %rsi
callq 0x1978f
testl %eax, %eax
je 0x19811
pushq $-0x1
popq %rax
jmp 0x1982e
addq (%rbx), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xe630
xorl %eax, %eax
cmpq 0x8(%rbx), %r14
jbe 0x1982e
movq %r14, 0x8(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| dbuf_write:
push r15
push r14
push r13
push r12
push rbx
mov r15, rcx
mov r12, rdx
mov r13, rsi
mov rbx, rdi
lea r14, [rcx+rsi]
mov rsi, r14
call dbuf_realloc
test eax, eax
jz short loc_19811
push 0FFFFFFFFFFFFFFFFh
pop rax
jmp short loc_1982E
loc_19811:
add r13, [rbx]
mov rdi, r13
mov rsi, r12
mov rdx, r15
call _memcpy
xor eax, eax
cmp r14, [rbx+8]
jbe short loc_1982E
mov [rbx+8], r14
loc_1982E:
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| long long dbuf_write(_QWORD *a1, long long a2, long long a3, long long a4)
{
unsigned long long v6; // r14
long long result; // rax
v6 = a4 + a2;
if ( (unsigned int)dbuf_realloc((long long)a1, a4 + a2) )
return -1LL;
memcpy(*a1 + a2, a3, a4);
result = 0LL;
if ( v6 > a1[1] )
a1[1] = v6;
return result;
}
| dbuf_write:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R15,RCX
MOV R12,RDX
MOV R13,RSI
MOV RBX,RDI
LEA R14,[RCX + RSI*0x1]
MOV RSI,R14
CALL 0x0011978f
TEST EAX,EAX
JZ 0x00119811
PUSH -0x1
POP RAX
JMP 0x0011982e
LAB_00119811:
ADD R13,qword ptr [RBX]
MOV RDI,R13
MOV RSI,R12
MOV RDX,R15
CALL 0x0010e630
XOR EAX,EAX
CMP R14,qword ptr [RBX + 0x8]
JBE 0x0011982e
MOV qword ptr [RBX + 0x8],R14
LAB_0011982e:
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
int8 dbuf_write(long *param_1,long param_2,void *param_3,size_t param_4)
{
ulong uVar1;
int iVar2;
int8 uVar3;
uVar1 = param_4 + param_2;
iVar2 = dbuf_realloc(param_1,uVar1);
if (iVar2 == 0) {
memcpy((void *)(param_2 + *param_1),param_3,param_4);
uVar3 = 0;
if ((ulong)param_1[1] < uVar1) {
param_1[1] = uVar1;
}
}
else {
uVar3 = 0xffffffffffffffff;
}
return uVar3;
}
| |
23,946 | PFS_table_share::find_or_create_index_stat(TABLE_SHARE const*, unsigned int) | eloqsql/storage/perfschema/pfs_instr_class.cc | PFS_table_share_index*
PFS_table_share::find_or_create_index_stat(const TABLE_SHARE *server_share, uint index)
{
assert(index <= MAX_INDEXES);
void *addr= & this->m_race_index_stat[index];
void * volatile * typed_addr= static_cast<void * volatile *>(addr);
void *ptr;
/* (1) Atomic Load */
ptr= my_atomic_loadptr(typed_addr);
PFS_table_share_index *pfs;
if (ptr != NULL)
{
pfs= static_cast<PFS_table_share_index *>(ptr);
return pfs;
}
/* (2) Create an index stat */
pfs= create_table_share_index_stat(server_share, index);
if (pfs == NULL)
return NULL;
pfs->m_owner= this;
void *old_ptr= NULL;
ptr= pfs;
/* (3) Atomic CAS */
if (my_atomic_casptr(typed_addr, & old_ptr, ptr))
{
/* Ok. */
return pfs;
}
/* Collision with another thread that also executed (2) and (3). */
release_table_share_index_stat(pfs);
pfs= static_cast<PFS_table_share_index *>(old_ptr);
return pfs;
} | O0 | cpp | PFS_table_share::find_or_create_index_stat(TABLE_SHARE const*, unsigned int):
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movl -0x1c(%rbp), %ecx
leaq 0x1c8(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x2dab4
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2db5a
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x2db70
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x2dad8
movq $0x0, -0x8(%rbp)
jmp 0x2db5a
movq -0x68(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x150(%rax)
movq $0x0, -0x50(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rdx
lock
cmpxchgq %rdx, (%rcx)
movq %rax, %rcx
sete %al
movb %al, -0x71(%rbp)
movq %rcx, -0x70(%rbp)
testb $0x1, %al
jne 0x2db29
movq -0x70(%rbp), %rax
movq %rax, -0x50(%rbp)
movb -0x71(%rbp), %al
andb $0x1, %al
movb %al, -0x59(%rbp)
testb $0x1, -0x59(%rbp)
je 0x2db41
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2db5a
movq -0x48(%rbp), %rdi
callq 0x2dc40
movq -0x50(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _ZN15PFS_table_share25find_or_create_index_statEPK11TABLE_SHAREj:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov rax, [rbp+var_10]
mov [rbp+var_68], rax
mov ecx, [rbp+var_1C]
lea rax, [rax+rcx*8+1C8h]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
mov rax, [rax]
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov [rbp+var_38], rax
cmp [rbp+var_38], 0
jz short loc_2DAB4
mov rax, [rbp+var_38]
mov [rbp+var_48], rax
mov rax, [rbp+var_48]
mov [rbp+var_8], rax
jmp loc_2DB5A
loc_2DAB4:
mov rdi, [rbp+var_18]
mov esi, [rbp+var_1C]
call _Z29create_table_share_index_statPK11TABLE_SHAREj; create_table_share_index_stat(TABLE_SHARE const*,uint)
mov [rbp+var_48], rax
cmp [rbp+var_48], 0
jnz short loc_2DAD8
mov [rbp+var_8], 0
jmp loc_2DB5A
loc_2DAD8:
mov rcx, [rbp+var_68]
mov rax, [rbp+var_48]
mov [rax+150h], rcx
mov [rbp+var_50], 0
mov rax, [rbp+var_48]
mov [rbp+var_38], rax
mov rcx, [rbp+var_30]
mov rax, [rbp+var_38]
mov [rbp+var_58], rax
mov rax, [rbp+var_50]
mov rdx, [rbp+var_58]
lock cmpxchg [rcx], rdx
mov rcx, rax
setz al
mov [rbp+var_71], al
mov [rbp+var_70], rcx
test al, 1
jnz short loc_2DB29
mov rax, [rbp+var_70]
mov [rbp+var_50], rax
loc_2DB29:
mov al, [rbp+var_71]
and al, 1
mov [rbp+var_59], al
test [rbp+var_59], 1
jz short loc_2DB41
mov rax, [rbp+var_48]
mov [rbp+var_8], rax
jmp short loc_2DB5A
loc_2DB41:
mov rdi, [rbp+var_48]
call _Z30release_table_share_index_statP21PFS_table_share_index; release_table_share_index_stat(PFS_table_share_index *)
mov rax, [rbp+var_50]
mov [rbp+var_48], rax
mov rax, [rbp+var_48]
mov [rbp+var_8], rax
loc_2DB5A:
mov rax, [rbp+var_8]
add rsp, 80h
pop rbp
retn
| signed long long PFS_table_share::find_or_create_index_stat(long long a1, long long a2, unsigned int a3)
{
signed long long v3; // rcx
signed long long v5; // [rsp+30h] [rbp-50h]
signed long long table_share_index_stat; // [rsp+38h] [rbp-48h]
volatile signed long long *v7; // [rsp+50h] [rbp-30h]
v7 = (volatile signed long long *)(a1 + 8LL * a3 + 456);
if ( *v7 )
return *(_QWORD *)(a1 + 8LL * a3 + 456);
table_share_index_stat = create_table_share_index_stat(a2, a3);
if ( !table_share_index_stat )
return 0LL;
*(_QWORD *)(table_share_index_stat + 336) = a1;
v3 = _InterlockedCompareExchange64(v7, table_share_index_stat, 0LL);
if ( !v3 )
return table_share_index_stat;
v5 = v3;
release_table_share_index_stat(table_share_index_stat);
return v5;
}
| find_or_create_index_stat:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x68],RAX
MOV ECX,dword ptr [RBP + -0x1c]
LEA RAX,[RAX + RCX*0x8 + 0x1c8]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x38],0x0
JZ 0x0012dab4
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0012db5a
LAB_0012dab4:
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,dword ptr [RBP + -0x1c]
CALL 0x0012db70
MOV qword ptr [RBP + -0x48],RAX
CMP qword ptr [RBP + -0x48],0x0
JNZ 0x0012dad8
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0012db5a
LAB_0012dad8:
MOV RCX,qword ptr [RBP + -0x68]
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x150],RCX
MOV qword ptr [RBP + -0x50],0x0
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x38],RAX
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x58]
CMPXCHG.LOCK qword ptr [RCX],RDX
MOV RCX,RAX
SETZ AL
MOV byte ptr [RBP + -0x71],AL
MOV qword ptr [RBP + -0x70],RCX
TEST AL,0x1
JNZ 0x0012db29
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x50],RAX
LAB_0012db29:
MOV AL,byte ptr [RBP + -0x71]
AND AL,0x1
MOV byte ptr [RBP + -0x59],AL
TEST byte ptr [RBP + -0x59],0x1
JZ 0x0012db41
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0012db5a
LAB_0012db41:
MOV RDI,qword ptr [RBP + -0x48]
CALL 0x0012dc40
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x8],RAX
LAB_0012db5a:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x80
POP RBP
RET
|
/* PFS_table_share::find_or_create_index_stat(TABLE_SHARE const*, unsigned int) */
PFS_table_share_index * __thiscall
PFS_table_share::find_or_create_index_stat(PFS_table_share *this,TABLE_SHARE *param_1,uint param_2)
{
PFS_table_share *pPVar1;
PFS_table_share_index *pPVar2;
bool bVar3;
PFS_table_share_index *local_10;
pPVar1 = this + (ulong)param_2 * 8 + 0x1c8;
local_10 = *(PFS_table_share_index **)pPVar1;
if (local_10 == (PFS_table_share_index *)0x0) {
local_10 = (PFS_table_share_index *)create_table_share_index_stat(param_1,param_2);
if (local_10 == (PFS_table_share_index *)0x0) {
local_10 = (PFS_table_share_index *)0x0;
}
else {
*(PFS_table_share **)(local_10 + 0x150) = this;
LOCK();
pPVar2 = *(PFS_table_share_index **)pPVar1;
bVar3 = pPVar2 == (PFS_table_share_index *)0x0;
if (bVar3) {
*(PFS_table_share_index **)pPVar1 = local_10;
pPVar2 = (PFS_table_share_index *)0x0;
}
UNLOCK();
if (!bVar3) {
release_table_share_index_stat(local_10);
local_10 = pPVar2;
}
}
}
return local_10;
}
| |
23,947 | PFS_table_share::find_or_create_index_stat(TABLE_SHARE const*, unsigned int) | eloqsql/storage/perfschema/pfs_instr_class.cc | PFS_table_share_index*
PFS_table_share::find_or_create_index_stat(const TABLE_SHARE *server_share, uint index)
{
assert(index <= MAX_INDEXES);
void *addr= & this->m_race_index_stat[index];
void * volatile * typed_addr= static_cast<void * volatile *>(addr);
void *ptr;
/* (1) Atomic Load */
ptr= my_atomic_loadptr(typed_addr);
PFS_table_share_index *pfs;
if (ptr != NULL)
{
pfs= static_cast<PFS_table_share_index *>(ptr);
return pfs;
}
/* (2) Create an index stat */
pfs= create_table_share_index_stat(server_share, index);
if (pfs == NULL)
return NULL;
pfs->m_owner= this;
void *old_ptr= NULL;
ptr= pfs;
/* (3) Atomic CAS */
if (my_atomic_casptr(typed_addr, & old_ptr, ptr))
{
/* Ok. */
return pfs;
}
/* Collision with another thread that also executed (2) and (3). */
release_table_share_index_stat(pfs);
pfs= static_cast<PFS_table_share_index *>(old_ptr);
return pfs;
} | O3 | cpp | PFS_table_share::find_or_create_index_stat(TABLE_SHARE const*, unsigned int):
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %r14d
movq 0x1c8(%rdi,%r14,8), %rcx
testq %rcx, %rcx
je 0x2fe6b
movq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rdi, %rbx
movq %rsi, %rdi
movl %edx, %esi
callq 0x2fec5
testq %rax, %rax
je 0x2fec1
movq %rax, %rcx
movq %rbx, 0x150(%rax)
xorl %eax, %eax
lock
cmpxchgq %rcx, 0x1c8(%rbx,%r14,8)
je 0x2fe63
movq $0x0, 0x150(%rcx)
movq 0x158(%rcx), %rdx
movl (%rcx), %esi
andl $-0x4, %esi
xchgl %esi, (%rcx)
xorl %ecx, %ecx
movb %cl, (%rdx)
leaq 0x37d7ef(%rip), %rdx # 0x3ad6a8
movb %cl, 0x9(%rdx)
movq %rax, %rcx
jmp 0x2fe63
xorl %ecx, %ecx
jmp 0x2fe63
| _ZN15PFS_table_share25find_or_create_index_statEPK11TABLE_SHAREj:
push rbp
mov rbp, rsp
push r14
push rbx
mov r14d, edx
mov rcx, [rdi+r14*8+1C8h]
test rcx, rcx
jz short loc_2FE6B
loc_2FE63:
mov rax, rcx
pop rbx
pop r14
pop rbp
retn
loc_2FE6B:
mov rbx, rdi
mov rdi, rsi
mov esi, edx
call _Z29create_table_share_index_statPK11TABLE_SHAREj; create_table_share_index_stat(TABLE_SHARE const*,uint)
test rax, rax
jz short loc_2FEC1
mov rcx, rax
mov [rax+150h], rbx
xor eax, eax
lock cmpxchg [rbx+r14*8+1C8h], rcx
jz short loc_2FE63
mov qword ptr [rcx+150h], 0
mov rdx, [rcx+158h]
mov esi, [rcx]
and esi, 0FFFFFFFCh
xchg esi, [rcx]
xor ecx, ecx
mov [rdx], cl
lea rdx, global_table_share_index_container
mov [rdx+9], cl
mov rcx, rax
jmp short loc_2FE63
loc_2FEC1:
xor ecx, ecx
jmp short loc_2FE63
| signed long long PFS_table_share::find_or_create_index_stat(long long a1, long long a2, unsigned int a3)
{
long long v3; // r14
signed long long v4; // rcx
signed long long table_share_index_stat; // rax
signed long long v7; // rax
_BYTE *v8; // rdx
v3 = a3;
v4 = *(_QWORD *)(a1 + 8LL * a3 + 456);
if ( !v4 )
{
table_share_index_stat = create_table_share_index_stat(a2, a3);
if ( table_share_index_stat )
{
v4 = table_share_index_stat;
*(_QWORD *)(table_share_index_stat + 336) = a1;
v7 = _InterlockedCompareExchange64((volatile signed long long *)(a1 + 8 * v3 + 456), table_share_index_stat, 0LL);
if ( v7 )
{
*(_QWORD *)(v4 + 336) = 0LL;
v8 = *(_BYTE **)(v4 + 344);
_InterlockedExchange((volatile __int32 *)v4, *(_DWORD *)v4 & 0xFFFFFFFC);
*v8 = 0;
*((_BYTE *)&global_table_share_index_container + 9) = 0;
return v7;
}
}
else
{
return 0LL;
}
}
return v4;
}
| find_or_create_index_stat:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV R14D,EDX
MOV RCX,qword ptr [RDI + R14*0x8 + 0x1c8]
TEST RCX,RCX
JZ 0x0012fe6b
LAB_0012fe63:
MOV RAX,RCX
POP RBX
POP R14
POP RBP
RET
LAB_0012fe6b:
MOV RBX,RDI
MOV RDI,RSI
MOV ESI,EDX
CALL 0x0012fec5
TEST RAX,RAX
JZ 0x0012fec1
MOV RCX,RAX
MOV qword ptr [RAX + 0x150],RBX
XOR EAX,EAX
CMPXCHG.LOCK qword ptr [RBX + R14*0x8 + 0x1c8],RCX
JZ 0x0012fe63
MOV qword ptr [RCX + 0x150],0x0
MOV RDX,qword ptr [RCX + 0x158]
MOV ESI,dword ptr [RCX]
AND ESI,0xfffffffc
XCHG dword ptr [RCX],ESI
XOR ECX,ECX
MOV byte ptr [RDX],CL
LEA RDX,[0x4ad6a8]
MOV byte ptr [RDX + 0x9],CL
MOV RCX,RAX
JMP 0x0012fe63
LAB_0012fec1:
XOR ECX,ECX
JMP 0x0012fe63
|
/* PFS_table_share::find_or_create_index_stat(TABLE_SHARE const*, unsigned int) */
uint * __thiscall
PFS_table_share::find_or_create_index_stat(PFS_table_share *this,TABLE_SHARE *param_1,uint param_2)
{
uint *puVar1;
uint *puVar2;
bool bVar3;
puVar1 = *(uint **)(this + (ulong)param_2 * 8 + 0x1c8);
if (*(uint **)(this + (ulong)param_2 * 8 + 0x1c8) == (uint *)0x0) {
puVar1 = (uint *)create_table_share_index_stat(param_1,param_2);
if (puVar1 == (uint *)0x0) {
puVar1 = (uint *)0x0;
}
else {
*(PFS_table_share **)(puVar1 + 0x54) = this;
LOCK();
puVar2 = *(uint **)(this + (ulong)param_2 * 8 + 0x1c8);
bVar3 = puVar2 == (uint *)0x0;
if (bVar3) {
*(uint **)(this + (ulong)param_2 * 8 + 0x1c8) = puVar1;
puVar2 = (uint *)0x0;
}
UNLOCK();
if (!bVar3) {
puVar1[0x54] = 0;
puVar1[0x55] = 0;
LOCK();
*puVar1 = *puVar1 & 0xfffffffc;
UNLOCK();
**(int1 **)(puVar1 + 0x56) = 0;
global_table_share_index_container[9] = 0;
puVar1 = puVar2;
}
}
}
return puVar1;
}
| |
23,948 | my_strntod_mb2_or_mb4 | eloqsql/strings/ctype-ucs2.c | static double
my_strntod_mb2_or_mb4(CHARSET_INFO *cs,
char *nptr, size_t length,
char **endptr, int *err)
{
char buf[256];
double res;
register char *b= buf;
register const uchar *s= (const uchar*) nptr;
const uchar *end;
my_wc_t wc;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
int cnv;
*err= 0;
/* Cut too long strings */
if (length >= sizeof(buf))
length= sizeof(buf) - 1;
end= s + length;
while ((cnv= mb_wc(cs, &wc, s, end)) > 0)
{
s+= cnv;
if (wc > (int) (uchar) 'e' || !wc)
break; /* Can't be part of double */
*b++= (char) wc;
}
*endptr= b;
res= my_strtod(buf, endptr, err);
*endptr= nptr + cs->mbminlen * (size_t) (*endptr - buf);
return res;
} | O0 | c | my_strntod_mb2_or_mb4:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x118(%rbp)
movq %rsi, -0x120(%rbp)
movq %rdx, -0x128(%rbp)
movq %rcx, -0x130(%rbp)
movq %r8, -0x138(%rbp)
leaq -0x110(%rbp), %rax
movq %rax, -0x148(%rbp)
movq -0x120(%rbp), %rax
movq %rax, -0x150(%rbp)
movq -0x118(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x168(%rbp)
movq -0x138(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x100, -0x128(%rbp) # imm = 0x100
jb 0x5a595
movq $0xff, -0x128(%rbp)
movq -0x150(%rbp), %rax
addq -0x128(%rbp), %rax
movq %rax, -0x158(%rbp)
movq -0x168(%rbp), %rax
movq -0x118(%rbp), %rdi
movq -0x150(%rbp), %rdx
movq -0x158(%rbp), %rcx
leaq -0x160(%rbp), %rsi
callq *%rax
movl %eax, -0x16c(%rbp)
cmpl $0x0, %eax
jle 0x5a62f
movl -0x16c(%rbp), %ecx
movq -0x150(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x150(%rbp)
cmpq $0x65, -0x160(%rbp)
ja 0x5a608
cmpq $0x0, -0x160(%rbp)
jne 0x5a60a
jmp 0x5a62f
movq -0x160(%rbp), %rax
movb %al, %cl
movq -0x148(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x148(%rbp)
movb %cl, (%rax)
jmp 0x5a5aa
movq -0x148(%rbp), %rcx
movq -0x130(%rbp), %rax
movq %rcx, (%rax)
movq -0x130(%rbp), %rsi
movq -0x138(%rbp), %rdx
leaq -0x110(%rbp), %rdi
movq %rdi, -0x180(%rbp)
callq 0x70af0
movq -0x180(%rbp), %rdi
movsd %xmm0, -0x140(%rbp)
movq -0x120(%rbp), %rcx
movq -0x118(%rbp), %rax
movl 0x98(%rax), %eax
movl %eax, %edx
movq -0x130(%rbp), %rax
movq (%rax), %rsi
subq %rdi, %rsi
imulq %rsi, %rdx
addq %rdx, %rcx
movq %rcx, (%rax)
movsd -0x140(%rbp), %xmm0
movsd %xmm0, -0x178(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x5a6d0
movsd -0x178(%rbp), %xmm0
addq $0x180, %rsp # imm = 0x180
popq %rbp
retq
callq 0x242e0
nopw %cs:(%rax,%rax)
| my_strntod_mb2_or_mb4:
push rbp
mov rbp, rsp
sub rsp, 180h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_118], rdi
mov [rbp+var_120], rsi
mov [rbp+var_128], rdx
mov [rbp+var_130], rcx
mov [rbp+var_138], r8
lea rax, [rbp+var_110]
mov [rbp+var_148], rax
mov rax, [rbp+var_120]
mov [rbp+var_150], rax
mov rax, [rbp+var_118]
mov rax, [rax+0B8h]
mov rax, [rax+28h]
mov [rbp+var_168], rax
mov rax, [rbp+var_138]
mov dword ptr [rax], 0
cmp [rbp+var_128], 100h
jb short loc_5A595
mov [rbp+var_128], 0FFh
loc_5A595:
mov rax, [rbp+var_150]
add rax, [rbp+var_128]
mov [rbp+var_158], rax
loc_5A5AA:
mov rax, [rbp+var_168]
mov rdi, [rbp+var_118]
mov rdx, [rbp+var_150]
mov rcx, [rbp+var_158]
lea rsi, [rbp+var_160]
call rax
mov [rbp+var_16C], eax
cmp eax, 0
jle short loc_5A62F
mov ecx, [rbp+var_16C]
mov rax, [rbp+var_150]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_150], rax
cmp [rbp+var_160], 65h ; 'e'
ja short loc_5A608
cmp [rbp+var_160], 0
jnz short loc_5A60A
loc_5A608:
jmp short loc_5A62F
loc_5A60A:
mov rax, [rbp+var_160]
mov cl, al
mov rax, [rbp+var_148]
mov rdx, rax
add rdx, 1
mov [rbp+var_148], rdx
mov [rax], cl
jmp loc_5A5AA
loc_5A62F:
mov rcx, [rbp+var_148]
mov rax, [rbp+var_130]
mov [rax], rcx
mov rsi, [rbp+var_130]
mov rdx, [rbp+var_138]
lea rdi, [rbp+var_110]
mov [rbp+var_180], rdi
call my_strtod
mov rdi, [rbp+var_180]
movsd [rbp+var_140], xmm0
mov rcx, [rbp+var_120]
mov rax, [rbp+var_118]
mov eax, [rax+98h]
mov edx, eax
mov rax, [rbp+var_130]
mov rsi, [rax]
sub rsi, rdi
imul rdx, rsi
add rcx, rdx
mov [rax], rcx
movsd xmm0, [rbp+var_140]
movsd [rbp+var_178], xmm0
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_5A6D0
movsd xmm0, [rbp+var_178]
add rsp, 180h
pop rbp
retn
loc_5A6D0:
call ___stack_chk_fail
| double my_strntod_mb2_or_mb4(long long a1, long long a2, unsigned long long a3, _QWORD *a4, _DWORD *a5)
{
_BYTE *v5; // rax
int v7; // [rsp+14h] [rbp-16Ch]
long long ( *v8)(long long, unsigned long long *, long long, long long); // [rsp+18h] [rbp-168h]
unsigned long long v9; // [rsp+20h] [rbp-160h] BYREF
long long v10; // [rsp+28h] [rbp-158h]
long long v11; // [rsp+30h] [rbp-150h]
_BYTE *v12; // [rsp+38h] [rbp-148h]
double v13; // [rsp+40h] [rbp-140h]
_DWORD *v14; // [rsp+48h] [rbp-138h]
_QWORD *v15; // [rsp+50h] [rbp-130h]
unsigned long long v16; // [rsp+58h] [rbp-128h]
long long v17; // [rsp+60h] [rbp-120h]
long long v18; // [rsp+68h] [rbp-118h]
_BYTE v19[264]; // [rsp+70h] [rbp-110h] BYREF
unsigned long long v20; // [rsp+178h] [rbp-8h]
v20 = __readfsqword(0x28u);
v18 = a1;
v17 = a2;
v16 = a3;
v15 = a4;
v14 = a5;
v12 = v19;
v11 = a2;
v8 = *(long long ( **)(long long, unsigned long long *, long long, long long))(*(_QWORD *)(a1 + 184) + 40LL);
*a5 = 0;
if ( v16 >= 0x100 )
v16 = 255LL;
v10 = v16 + v11;
while ( 1 )
{
v7 = v8(v18, &v9, v11, v10);
if ( v7 <= 0 )
break;
v11 += v7;
if ( v9 > 0x65 || !v9 )
break;
v5 = v12++;
*v5 = v9;
}
*v15 = v12;
v13 = my_strtod(v19, v15, v14);
*v15 = (*v15 - (_QWORD)v19) * *(unsigned int *)(v18 + 152) + v17;
return v13;
}
| my_strntod_mb2_or_mb4:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x180
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x118],RDI
MOV qword ptr [RBP + -0x120],RSI
MOV qword ptr [RBP + -0x128],RDX
MOV qword ptr [RBP + -0x130],RCX
MOV qword ptr [RBP + -0x138],R8
LEA RAX,[RBP + -0x110]
MOV qword ptr [RBP + -0x148],RAX
MOV RAX,qword ptr [RBP + -0x120]
MOV qword ptr [RBP + -0x150],RAX
MOV RAX,qword ptr [RBP + -0x118]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x168],RAX
MOV RAX,qword ptr [RBP + -0x138]
MOV dword ptr [RAX],0x0
CMP qword ptr [RBP + -0x128],0x100
JC 0x0015a595
MOV qword ptr [RBP + -0x128],0xff
LAB_0015a595:
MOV RAX,qword ptr [RBP + -0x150]
ADD RAX,qword ptr [RBP + -0x128]
MOV qword ptr [RBP + -0x158],RAX
LAB_0015a5aa:
MOV RAX,qword ptr [RBP + -0x168]
MOV RDI,qword ptr [RBP + -0x118]
MOV RDX,qword ptr [RBP + -0x150]
MOV RCX,qword ptr [RBP + -0x158]
LEA RSI,[RBP + -0x160]
CALL RAX
MOV dword ptr [RBP + -0x16c],EAX
CMP EAX,0x0
JLE 0x0015a62f
MOV ECX,dword ptr [RBP + -0x16c]
MOV RAX,qword ptr [RBP + -0x150]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x150],RAX
CMP qword ptr [RBP + -0x160],0x65
JA 0x0015a608
CMP qword ptr [RBP + -0x160],0x0
JNZ 0x0015a60a
LAB_0015a608:
JMP 0x0015a62f
LAB_0015a60a:
MOV RAX,qword ptr [RBP + -0x160]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x148]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x148],RDX
MOV byte ptr [RAX],CL
JMP 0x0015a5aa
LAB_0015a62f:
MOV RCX,qword ptr [RBP + -0x148]
MOV RAX,qword ptr [RBP + -0x130]
MOV qword ptr [RAX],RCX
MOV RSI,qword ptr [RBP + -0x130]
MOV RDX,qword ptr [RBP + -0x138]
LEA RDI,[RBP + -0x110]
MOV qword ptr [RBP + -0x180],RDI
CALL 0x00170af0
MOV RDI,qword ptr [RBP + -0x180]
MOVSD qword ptr [RBP + -0x140],XMM0
MOV RCX,qword ptr [RBP + -0x120]
MOV RAX,qword ptr [RBP + -0x118]
MOV EAX,dword ptr [RAX + 0x98]
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x130]
MOV RSI,qword ptr [RAX]
SUB RSI,RDI
IMUL RDX,RSI
ADD RCX,RDX
MOV qword ptr [RAX],RCX
MOVSD XMM0,qword ptr [RBP + -0x140]
MOVSD qword ptr [RBP + -0x178],XMM0
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0015a6d0
MOVSD XMM0,qword ptr [RBP + -0x178]
ADD RSP,0x180
POP RBP
RET
LAB_0015a6d0:
CALL 0x001242e0
|
int8
my_strntod_mb2_or_mb4(long param_1,long param_2,ulong param_3,long *param_4,int4 *param_5)
{
code *pcVar1;
int iVar2;
long in_FS_OFFSET;
ulong local_168;
long local_160;
long local_158;
int1 *local_150;
int8 local_148;
int4 *local_140;
long *local_138;
ulong local_130;
long local_128;
long local_120;
int1 local_118 [264];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
pcVar1 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
*param_5 = 0;
local_130 = param_3;
if (0xff < param_3) {
local_130 = 0xff;
}
local_160 = param_2 + local_130;
local_158 = param_2;
local_150 = local_118;
local_140 = param_5;
local_138 = param_4;
local_128 = param_2;
local_120 = param_1;
while (((iVar2 = (*pcVar1)(local_120,&local_168,local_158,local_160), 0 < iVar2 &&
(local_158 = local_158 + iVar2, local_168 < 0x66)) && (local_168 != 0))) {
*local_150 = (char)local_168;
local_150 = local_150 + 1;
}
*local_138 = (long)local_150;
local_148 = my_strtod(local_118,local_138,local_140);
*local_138 = local_128 + (ulong)*(uint *)(local_120 + 0x98) * (*local_138 - (long)local_118);
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_148;
}
| |
23,949 | break_str_into_lines(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long) | monkey531[P]llama/common/arg.cpp | static std::vector<std::string> break_str_into_lines(std::string input, size_t max_char_per_line) {
std::vector<std::string> result;
std::istringstream iss(input);
std::string line;
auto add_line = [&](const std::string& l) {
if (l.length() <= max_char_per_line) {
result.push_back(l);
} else {
std::istringstream line_stream(l);
std::string word, current_line;
while (line_stream >> word) {
if (current_line.length() + !current_line.empty() + word.length() > max_char_per_line) {
if (!current_line.empty()) result.push_back(current_line);
current_line = word;
} else {
current_line += (!current_line.empty() ? " " : "") + word;
}
}
if (!current_line.empty()) result.push_back(current_line);
}
};
while (std::getline(iss, line)) {
add_line(line);
}
return result;
} | O0 | cpp | break_str_into_lines(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long):
subq $0x208, %rsp # imm = 0x208
movq %rsi, 0x20(%rsp)
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x200(%rsp)
movq %rsi, 0x1f8(%rsp)
movq %rdx, 0x1f0(%rsp)
movb $0x0, 0x1ef(%rsp)
callq 0x63190
movq 0x20(%rsp), %rsi
leaq 0x68(%rsp), %rdi
movl $0x8, %edx
callq 0x5a800
jmp 0x68e64
leaq 0x38(%rsp), %rdi
callq 0x5a5e0
movq 0x10(%rsp), %rax
leaq 0x1f0(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movq %rax, 0x30(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x5a8d0
movq %rax, 0x8(%rsp)
jmp 0x68e9b
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x5a620
movb %al, 0x7(%rsp)
jmp 0x68eb5
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x68ebf
jmp 0x68f06
leaq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x82650
jmp 0x68ed0
jmp 0x68e85
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x68f43
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x5b588
leaq 0x68(%rsp), %rdi
callq 0x5a9b0
jmp 0x68f43
movb $0x1, 0x1ef(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x5b588
leaq 0x68(%rsp), %rdi
callq 0x5a9b0
testb $0x1, 0x1ef(%rsp)
jne 0x68f36
movq 0x10(%rsp), %rdi
callq 0x631d0
movq 0x18(%rsp), %rax
addq $0x208, %rsp # imm = 0x208
retq
movq 0x10(%rsp), %rdi
callq 0x631d0
movq 0x60(%rsp), %rdi
callq 0x5aba0
nopw (%rax,%rax)
| _ZL20break_str_into_linesNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEm:
sub rsp, 208h
mov [rsp+208h+var_1E8], rsi
mov [rsp+208h+var_1F8], rdi
mov rax, rdi
mov [rsp+208h+var_1F0], rax
mov [rsp+208h+var_8], rdi
mov [rsp+208h+var_10], rsi
mov [rsp+208h+var_18], rdx
mov [rsp+208h+var_19], 0
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2Ev; std::vector<std::string>::vector(void)
mov rsi, [rsp+208h+var_1E8]
lea rdi, [rsp+208h+var_1A0]
mov edx, 8
call __ZNSt7__cxx1119basic_istringstreamIcSt11char_traitsIcESaIcEEC1ERKNS_12basic_stringIcS2_S3_EESt13_Ios_Openmode; std::istringstream::basic_istringstream(std::string const&,std::_Ios_Openmode)
jmp short $+2
loc_68E64:
lea rdi, [rsp+208h+var_1D0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
mov rax, [rsp+208h+var_1F8]
lea rcx, [rsp+208h+var_18]
mov [rsp+208h+var_1E0], rcx
mov [rsp+208h+var_1D8], rax
loc_68E85:
lea rdi, [rsp+208h+var_1A0]
lea rsi, [rsp+208h+var_1D0]
call __ZSt7getlineIcSt11char_traitsIcESaIcEERSt13basic_istreamIT_T0_ES7_RNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::getline<char,std::char_traits<char>,std::allocator<char>>(std::istream &,std::string &)
mov [rsp+208h+var_200], rax
jmp short $+2
loc_68E9B:
mov rdi, [rsp+208h+var_200]
mov rax, [rdi]
mov rax, [rax-18h]
add rdi, rax
call __ZNKSt9basic_iosIcSt11char_traitsIcEEcvbEv; std::ios::operator bool(void)
mov [rsp+208h+var_201], al
jmp short $+2
loc_68EB5:
mov al, [rsp+208h+var_201]
test al, 1
jnz short loc_68EBF
jmp short loc_68F06
loc_68EBF:
lea rdi, [rsp+208h+var_1E0]
lea rsi, [rsp+208h+var_1D0]
call _ZZL20break_str_into_linesNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEmENK3$_0clERKS4_; break_str_into_lines(std::string,ulong)::$_0::operator()(std::string const&)
jmp short $+2
loc_68ED0:
jmp short loc_68E85
mov rcx, rax
mov eax, edx
mov [rsp+arg_58], rcx
mov [rsp+arg_54], eax
jmp short loc_68F43
mov rcx, rax
mov eax, edx
mov [rsp+arg_58], rcx
mov [rsp+arg_54], eax
lea rdi, [rsp+arg_30]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+arg_60]
call __ZNSt7__cxx1119basic_istringstreamIcSt11char_traitsIcESaIcEED1Ev; std::istringstream::~istringstream()
jmp short loc_68F43
loc_68F06:
mov [rsp+208h+var_19], 1
lea rdi, [rsp+208h+var_1D0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+208h+var_1A0]
call __ZNSt7__cxx1119basic_istringstreamIcSt11char_traitsIcESaIcEED1Ev; std::istringstream::~istringstream()
test [rsp+208h+var_19], 1
jnz short loc_68F36
mov rdi, [rsp+208h+var_1F8]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
loc_68F36:
mov rax, [rsp+208h+var_1F0]
add rsp, 208h
retn
loc_68F43:
mov rdi, [rsp+arg_8]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, [rsp+arg_58]
call __Unwind_Resume
| long long break_str_into_lines(long long a1, long long a2, long long a3)
{
int v3; // edx
int v4; // ecx
int v5; // r8d
int v6; // r9d
int v8; // [rsp+0h] [rbp-208h]
_QWORD *v9; // [rsp+8h] [rbp-200h]
long long *v10; // [rsp+10h] [rbp-1F8h]
long long v11; // [rsp+18h] [rbp-1F0h]
char v12; // [rsp+20h] [rbp-1E8h]
_QWORD *v13; // [rsp+28h] [rbp-1E0h] BYREF
long long i; // [rsp+30h] [rbp-1D8h]
_DWORD v15[4]; // [rsp+38h] [rbp-1D0h] BYREF
long long v16; // [rsp+48h] [rbp-1C0h]
char v17; // [rsp+50h] [rbp-1B8h]
int v18; // [rsp+58h] [rbp-1B0h]
int v19; // [rsp+60h] [rbp-1A8h]
int v20; // [rsp+68h] [rbp-1A0h] BYREF
char v21; // [rsp+70h] [rbp-198h]
int v22; // [rsp+78h] [rbp-190h]
int v23; // [rsp+80h] [rbp-188h]
int v24; // [rsp+88h] [rbp-180h]
char v25; // [rsp+90h] [rbp-178h]
char v26; // [rsp+1EFh] [rbp-19h]
_QWORD v27[3]; // [rsp+1F0h] [rbp-18h] BYREF
v12 = a2;
v10 = (long long *)a1;
v11 = a1;
v27[2] = a1;
v27[1] = a2;
v27[0] = a3;
v26 = 0;
std::vector<std::string>::vector(a1);
std::istringstream::basic_istringstream(&v20, a2, 8LL);
std::string::basic_string(v15);
v13 = v27;
for ( i = a1;
;
break_str_into_lines(std::string,unsigned long)::$_0::operator()(
(unsigned int)&v13,
(unsigned int)v15,
v3,
v4,
v5,
v6,
v8,
(_DWORD)v9,
(_DWORD)v10,
v11,
v12,
(_DWORD)v13,
i,
v15[0],
v15[2],
v16,
v17,
v18,
v19,
v20,
v21,
v22,
v23,
v24,
v25) )
{
v9 = (_QWORD *)std::getline<char,std::char_traits<char>,std::allocator<char>>(&v20, v15);
if ( (std::ios::operator bool((char *)v9 + *(_QWORD *)(*v9 - 24LL)) & 1) == 0 )
break;
}
v26 = 1;
std::string::~string(v15);
std::istringstream::~istringstream(&v20);
if ( (v26 & 1) == 0 )
std::vector<std::string>::~vector(v10);
return v11;
}
| break_str_into_lines:
SUB RSP,0x208
MOV qword ptr [RSP + 0x20],RSI
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x200],RDI
MOV qword ptr [RSP + 0x1f8],RSI
MOV qword ptr [RSP + 0x1f0],RDX
MOV byte ptr [RSP + 0x1ef],0x0
CALL 0x00163190
MOV RSI,qword ptr [RSP + 0x20]
LAB_00168e53:
LEA RDI,[RSP + 0x68]
MOV EDX,0x8
CALL 0x0015a800
JMP 0x00168e64
LAB_00168e64:
LEA RDI,[RSP + 0x38]
CALL 0x0015a5e0
MOV RAX,qword ptr [RSP + 0x10]
LEA RCX,[RSP + 0x1f0]
MOV qword ptr [RSP + 0x28],RCX
MOV qword ptr [RSP + 0x30],RAX
LAB_00168e85:
LEA RDI,[RSP + 0x68]
LEA RSI,[RSP + 0x38]
CALL 0x0015a8d0
MOV qword ptr [RSP + 0x8],RAX
JMP 0x00168e9b
LAB_00168e9b:
MOV RDI,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + -0x18]
ADD RDI,RAX
CALL 0x0015a620
MOV byte ptr [RSP + 0x7],AL
JMP 0x00168eb5
LAB_00168eb5:
MOV AL,byte ptr [RSP + 0x7]
TEST AL,0x1
JNZ 0x00168ebf
JMP 0x00168f06
LAB_00168ebf:
LEA RDI,[RSP + 0x28]
LEA RSI,[RSP + 0x38]
CALL 0x00182650
LAB_00168ece:
JMP 0x00168ed0
LAB_00168ed0:
JMP 0x00168e85
LAB_00168f06:
MOV byte ptr [RSP + 0x1ef],0x1
LEA RDI,[RSP + 0x38]
CALL 0x0015b588
LEA RDI,[RSP + 0x68]
CALL 0x0015a9b0
TEST byte ptr [RSP + 0x1ef],0x1
JNZ 0x00168f36
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x001631d0
LAB_00168f36:
MOV RAX,qword ptr [RSP + 0x18]
ADD RSP,0x208
RET
|
/* break_str_into_lines(std::__cxx11::string, unsigned long) */
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *
break_str_into_lines
(vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *param_1,
int8 param_2,int8 param_3)
{
bool bVar1;
istream *piVar2;
int8 *local_1e0;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *local_1d8;
string local_1d0 [48];
istringstream local_1a0 [391];
byte local_19;
int8 local_18;
int8 local_10;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *local_8;
local_19 = 0;
local_18 = param_3;
local_10 = param_2;
local_8 = param_1;
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::vector(param_1);
/* try { // try from 00168e53 to 00168e61 has its CatchHandler @ 00168ed2 */
std::__cxx11::istringstream::istringstream(local_1a0,param_2,8);
std::__cxx11::string::string(local_1d0);
local_1e0 = &local_18;
local_1d8 = param_1;
while( true ) {
/* try { // try from 00168e85 to 00168ecd has its CatchHandler @ 00168ee2 */
piVar2 = std::getline<char,std::char_traits<char>,std::allocator<char>>
((istream *)local_1a0,local_1d0);
bVar1 = std::ios::operator_cast_to_bool((ios *)(piVar2 + *(long *)(*(long *)piVar2 + -0x18)));
if (!bVar1) break;
break_str_into_lines(std::__cxx11::string,unsigned_long)::$_0::operator()
((__0 *)&local_1e0,local_1d0);
}
local_19 = 1;
std::__cxx11::string::~string(local_1d0);
std::__cxx11::istringstream::~istringstream(local_1a0);
if ((local_19 & 1) == 0) {
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector(param_1);
}
return param_1;
}
| |
23,950 | ggml_backend_buffer_init | 7CodeWizard[P]stablediffusion/ggml/src/ggml-backend.c | ggml_backend_buffer_t ggml_backend_buffer_init(
ggml_backend_buffer_type_t buft,
struct ggml_backend_buffer_i iface,
ggml_backend_buffer_context_t context,
size_t size) {
ggml_backend_buffer_t buffer = malloc(sizeof(struct ggml_backend_buffer));
GGML_ASSERT(iface.get_base != NULL);
(*buffer) = (struct ggml_backend_buffer) {
/* .interface = */ iface,
/* .buft = */ buft,
/* .context = */ context,
/* .size = */ size,
};
return buffer;
} | O1 | c | ggml_backend_buffer_init:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x58, %edi
callq 0xa7c0
cmpq $0x0, 0x28(%rsp)
je 0xb3e37
leaq 0x20(%rsp), %rcx
vmovups (%rcx), %ymm0
vmovups 0x20(%rcx), %ymm1
vmovups %ymm1, 0x20(%rax)
vmovups %ymm0, (%rax)
movq %r15, 0x40(%rax)
movq %r14, 0x48(%rax)
movq %rbx, 0x50(%rax)
popq %rbx
popq %r14
popq %r15
vzeroupper
retq
callq 0x180b9
| ggml_backend_buffer_init:
push r15
push r14
push rbx
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov edi, 58h ; 'X'
call _malloc
cmp [rsp+18h+arg_8], 0
jz short loc_B3E37
lea rcx, [rsp+18h+arg_0]
vmovups ymm0, ymmword ptr [rcx]
vmovups ymm1, ymmword ptr [rcx+20h]
vmovups ymmword ptr [rax+20h], ymm1
vmovups ymmword ptr [rax], ymm0
mov [rax+40h], r15
mov [rax+48h], r14
mov [rax+50h], rbx
pop rbx
pop r14
pop r15
vzeroupper
retn
loc_B3E37:
call ggml_backend_buffer_init_cold_1
| _QWORD * ggml_backend_buffer_init(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
char a7,
long long a8)
{
_QWORD *result; // rax
result = (_QWORD *)malloc(88LL);
if ( !a8 )
ggml_backend_buffer_init_cold_1();
_RCX = &a7;
__asm
{
vmovups ymm0, ymmword ptr [rcx]
vmovups ymm1, ymmword ptr [rcx+20h]
vmovups ymmword ptr [rax+20h], ymm1
vmovups ymmword ptr [rax], ymm0
}
result[8] = a1;
result[9] = a2;
result[10] = a3;
__asm { vzeroupper }
return result;
}
| |||
23,951 | ggml_backend_buffer_init | 7CodeWizard[P]stablediffusion/ggml/src/ggml-backend.c | ggml_backend_buffer_t ggml_backend_buffer_init(
ggml_backend_buffer_type_t buft,
struct ggml_backend_buffer_i iface,
ggml_backend_buffer_context_t context,
size_t size) {
ggml_backend_buffer_t buffer = malloc(sizeof(struct ggml_backend_buffer));
GGML_ASSERT(iface.get_base != NULL);
(*buffer) = (struct ggml_backend_buffer) {
/* .interface = */ iface,
/* .buft = */ buft,
/* .context = */ context,
/* .size = */ size,
};
return buffer;
} | O2 | c | ggml_backend_buffer_init:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x58
popq %rdi
callq 0xa7e0
cmpq $0x0, 0x28(%rsp)
je 0x8fbf9
leaq 0x20(%rsp), %rcx
vmovups (%rcx), %ymm0
vmovups 0x20(%rcx), %ymm1
vmovups %ymm1, 0x20(%rax)
vmovups %ymm0, (%rax)
movq %r15, 0x40(%rax)
movq %r14, 0x48(%rax)
movq %rbx, 0x50(%rax)
popq %rbx
popq %r14
popq %r15
vzeroupper
retq
movq 0x46348(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x46399(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0xa605(%rip), %rsi # 0x9a21e
leaq 0x14b10(%rip), %rdx # 0xa4730
leaq 0x14b67(%rip), %r8 # 0xa478e
pushq $0x36
popq %rcx
xorl %eax, %eax
callq 0xa8b0
callq 0x67550
callq 0xa300
| ggml_backend_buffer_init:
push r15
push r14
push rbx
mov rbx, rdx
mov r14, rsi
mov r15, rdi
push 58h ; 'X'
pop rdi
call _malloc
cmp [rsp+18h+arg_8], 0
jz short loc_8FBF9
lea rcx, [rsp+18h+arg_0]
vmovups ymm0, ymmword ptr [rcx]
vmovups ymm1, ymmword ptr [rcx+20h]
vmovups ymmword ptr [rax+20h], ymm1
vmovups ymmword ptr [rax], ymm0
mov [rax+40h], r15
mov [rax+48h], r14
mov [rax+50h], rbx
pop rbx
pop r14
pop r15
vzeroupper
retn
loc_8FBF9:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_9; "/workspace/llm4binary/github/2025_star3"...
lea r8, aIfaceGetBaseNu; "iface.get_base != NULL"
push 36h ; '6'
pop rcx
xor eax, eax
call _fprintf
call ggml_print_backtrace
call _abort
| _QWORD * ggml_backend_buffer_init(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
char a7,
long long a8)
{
_QWORD *result; // rax
long long v13; // rdi
result = (_QWORD *)malloc(88LL);
if ( !a8 )
{
fflush(stdout);
v13 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml-backend.c",
54,
"iface.get_base != NULL");
ggml_print_backtrace();
abort(v13);
}
_RCX = &a7;
__asm
{
vmovups ymm0, ymmword ptr [rcx]
vmovups ymm1, ymmword ptr [rcx+20h]
vmovups ymmword ptr [rax+20h], ymm1
vmovups ymmword ptr [rax], ymm0
}
result[8] = a1;
result[9] = a2;
result[10] = a3;
__asm { vzeroupper }
return result;
}
| ggml_backend_buffer_init:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
PUSH 0x58
POP RDI
CALL 0x0010a7e0
CMP qword ptr [RSP + 0x28],0x0
JZ 0x0018fbf9
LEA RCX,[RSP + 0x20]
VMOVUPS YMM0,ymmword ptr [RCX]
VMOVUPS YMM1,ymmword ptr [RCX + 0x20]
VMOVUPS ymmword ptr [RAX + 0x20],YMM1
VMOVUPS ymmword ptr [RAX],YMM0
MOV qword ptr [RAX + 0x40],R15
MOV qword ptr [RAX + 0x48],R14
MOV qword ptr [RAX + 0x50],RBX
POP RBX
POP R14
POP R15
VZEROUPPER
RET
LAB_0018fbf9:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a4730]
LEA R8,[0x1a478e]
PUSH 0x36
POP RCX
XOR EAX,EAX
CALL 0x0010a8b0
CALL 0x00167550
CALL 0x0010a300
|
void ggml_backend_buffer_init(int8 param_1,int8 param_2,int8 param_3)
{
int8 *puVar1;
int8 in_stack_00000008;
long in_stack_00000010;
int8 in_stack_00000018;
int8 in_stack_00000020;
int8 in_stack_00000028;
int8 in_stack_00000030;
int8 in_stack_00000038;
int8 in_stack_00000040;
puVar1 = (int8 *)malloc(0x58);
if (in_stack_00000010 != 0) {
puVar1[4] = in_stack_00000028;
puVar1[5] = in_stack_00000030;
puVar1[6] = in_stack_00000038;
puVar1[7] = in_stack_00000040;
*puVar1 = in_stack_00000008;
puVar1[1] = in_stack_00000010;
puVar1[2] = in_stack_00000018;
puVar1[3] = in_stack_00000020;
puVar1[8] = param_1;
puVar1[9] = param_2;
puVar1[10] = param_3;
return;
}
fflush(*(FILE **)PTR_stdout_001d5f48);
fprintf(*(FILE **)PTR_stderr_001d5fa8,"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml-backend.c"
,0x36,"iface.get_base != NULL");
ggml_print_backtrace();
/* WARNING: Subroutine does not return */
abort();
}
| |
23,952 | my_uni_utf32 | eloqsql/strings/ctype-ucs2.c | static int
my_uni_utf32(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
if (s + 4 > e)
return MY_CS_TOOSMALL4;
if (wc > 0x10FFFF)
return MY_CS_ILUNI;
s[0]= (uchar) (wc >> 24);
s[1]= (uchar) (wc >> 16) & 0xFF;
s[2]= (uchar) (wc >> 8) & 0xFF;
s[3]= (uchar) wc & 0xFF;
return 4;
} | O3 | c | my_uni_utf32:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq %rsi, %rbx
leaq 0x4(%rdx), %rsi
movl $0xffffff98, %eax # imm = 0xFFFFFF98
cmpq %rcx, %rsi
ja 0xc490c
xorl %eax, %eax
cmpq $0x10ffff, %rbx # imm = 0x10FFFF
ja 0xc490c
movb $0x0, (%rdx)
movl %ebx, %eax
shrl $0x10, %eax
movb %al, 0x1(%rdx)
movb %bh, 0x2(%rdx)
movb %bl, 0x3(%rdx)
movl $0x4, %eax
popq %rbx
popq %rbp
retq
| my_uni_utf32:
push rbp
mov rbp, rsp
push rbx
mov rbx, rsi
lea rsi, [rdx+4]
mov eax, 0FFFFFF98h
cmp rsi, rcx
ja short loc_C490C
xor eax, eax
cmp rbx, offset unk_10FFFF
ja short loc_C490C
mov byte ptr [rdx], 0
mov eax, ebx
shr eax, 10h
mov [rdx+1], al
mov [rdx+2], bh
mov [rdx+3], bl
mov eax, 4
loc_C490C:
pop rbx
pop rbp
retn
| long long my_uni_utf32(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
long long result; // rax
result = 4294967192LL;
if ( (unsigned long long)(a3 + 4) <= a4 )
{
result = 0LL;
if ( a2 <= (unsigned long long)&unk_10FFFF )
{
*a3 = 0;
a3[1] = BYTE2(a2);
a3[2] = BYTE1(a2);
a3[3] = a2;
return 4LL;
}
}
return result;
}
| my_uni_utf32:
PUSH RBP
MOV RBP,RSP
PUSH RBX
MOV RBX,RSI
LEA RSI,[RDX + 0x4]
MOV EAX,0xffffff98
CMP RSI,RCX
JA 0x001c490c
XOR EAX,EAX
CMP RBX,0x10ffff
JA 0x001c490c
MOV byte ptr [RDX],0x0
MOV EAX,EBX
SHR EAX,0x10
MOV byte ptr [RDX + 0x1],AL
MOV byte ptr [RDX + 0x2],BH
MOV byte ptr [RDX + 0x3],BL
MOV EAX,0x4
LAB_001c490c:
POP RBX
POP RBP
RET
|
int8 my_uni_utf32(int8 param_1,ulong param_2,int1 *param_3,int1 *param_4)
{
int8 uVar1;
uVar1 = 0xffffff98;
if ((param_3 + 4 <= param_4) && (uVar1 = 0, param_2 < 0x110000)) {
*param_3 = 0;
param_3[1] = (char)(param_2 >> 0x10);
param_3[2] = (char)(param_2 >> 8);
param_3[3] = (char)param_2;
uVar1 = 4;
}
return uVar1;
}
| |
23,953 | bool minja::Value::get<bool>() const | monkey531[P]llama/common/minja.hpp | T get() const {
if (is_primitive()) return primitive_.get<T>();
throw std::runtime_error("get<T> not defined for this value type: " + dump());
} | O0 | cpp | bool minja::Value::get<bool>() const:
subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xa1050
testb $0x1, %al
jne 0xa57d6
jmp 0xa57f6
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
addq $0x40, %rsi
callq 0xa5d60
movq 0x18(%rsp), %rax
addq $0x88, %rsp
retq
movb $0x1, 0x2b(%rsp)
movl $0x10, %edi
callq 0x50540
movq 0x20(%rsp), %rsi
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0xa10d0
jmp 0xa5822
leaq 0x112a28(%rip), %rsi # 0x1b8251
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x63460
jmp 0xa583a
movq 0x8(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x50390
jmp 0xa584b
movq 0x8(%rsp), %rdi
movb $0x0, 0x2b(%rsp)
movq 0x191754(%rip), %rsi # 0x236fb0
movq 0x191715(%rip), %rdx # 0x236f78
callq 0x508f0
jmp 0xa58cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0xa58ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0xa58a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x510d0
leaq 0x38(%rsp), %rdi
callq 0x510d0
testb $0x1, 0x2b(%rsp)
jne 0xa58b5
jmp 0xa58bf
movq 0x8(%rsp), %rdi
callq 0x50c40
jmp 0xa58c1
movq 0x30(%rsp), %rdi
callq 0x50940
nopl (%rax,%rax)
| _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v:
sub rsp, 88h
mov [rsp+88h+var_78], rdi
mov rax, rdi
mov [rsp+88h+var_70], rax
mov [rsp+88h+var_8], rdi
mov [rsp+88h+var_10], rsi
mov rdi, [rsp+88h+var_10]; this
mov [rsp+88h+var_68], rdi
call _ZNK5minja5Value12is_primitiveEv; minja::Value::is_primitive(void)
test al, 1
jnz short loc_A57D6
jmp short loc_A57F6
loc_A57D6:
mov rdi, [rsp+88h+var_78]; void *
mov rsi, [rsp+88h+var_68]
add rsi, 40h ; '@'; __int64
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE3getIS9_S9_EEDTcldtclL_ZSt7declvalIRKSD_EDTcl9__declvalIT_ELi0EEEvEE8get_implIT0_EtlNS0_6detail12priority_tagILj4EEEEEEv
mov rax, [rsp+88h+var_70]
add rsp, 88h
retn
loc_A57F6:
mov [rsp+88h+var_5D], 1
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rsi, [rsp+88h+var_68]
mov [rsp+88h+var_80], rax
lea rdi, [rsp+88h+var_50]
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
jmp short $+2
loc_A5822:
lea rsi, aGetTNotDefined; "get<T> not defined for this value type:"...
lea rdi, [rsp+88h+var_30]
lea rdx, [rsp+88h+var_50]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
jmp short $+2
loc_A583A:
mov rdi, [rsp+88h+var_80]
lea rsi, [rsp+88h+var_30]
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
jmp short $+2
loc_A584B:
mov rdi, [rsp+88h+var_80]; void *
mov [rsp+88h+var_5D], 0
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
| void * minja::Value::get<std::string>(void *a1, minja::Value *a2)
{
void *exception; // [rsp+8h] [rbp-80h]
_BYTE v4[32]; // [rsp+38h] [rbp-50h] BYREF
_BYTE v5[32]; // [rsp+58h] [rbp-30h] BYREF
minja::Value *v6; // [rsp+78h] [rbp-10h]
void *v7; // [rsp+80h] [rbp-8h]
v7 = a1;
v6 = a2;
if ( (minja::Value::is_primitive(a2) & 1) == 0 )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v4, (long long)a2, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v5, (long long)"get<T> not defined for this value type: ", (long long)v4);
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);
}
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::get<std::string,std::string>(
a1,
(long long)a2 + 64);
return a1;
}
| get<std::__cxx11::string>:
SUB RSP,0x88
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x80],RDI
MOV qword ptr [RSP + 0x78],RSI
MOV RDI,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x20],RDI
CALL 0x001a1050
TEST AL,0x1
JNZ 0x001a57d6
JMP 0x001a57f6
LAB_001a57d6:
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x20]
ADD RSI,0x40
CALL 0x001a5d60
MOV RAX,qword ptr [RSP + 0x18]
ADD RSP,0x88
RET
LAB_001a57f6:
MOV byte ptr [RSP + 0x2b],0x1
MOV EDI,0x10
CALL 0x00150540
MOV RSI,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x8],RAX
LAB_001a580f:
LEA RDI,[RSP + 0x38]
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x001a10d0
JMP 0x001a5822
LAB_001a5822:
LEA RSI,[0x2b8251]
LEA RDI,[RSP + 0x58]
LEA RDX,[RSP + 0x38]
CALL 0x00163460
JMP 0x001a583a
LAB_001a583a:
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[RSP + 0x58]
CALL 0x00150390
JMP 0x001a584b
LAB_001a584b:
MOV RDI,qword ptr [RSP + 0x8]
MOV byte ptr [RSP + 0x2b],0x0
MOV RSI,qword ptr [0x00336fb0]
MOV RDX,qword ptr [0x00336f78]
CALL 0x001508f0
|
/* std::__cxx11::string minja::Value::get<std::__cxx11::string >() const */
int8 minja::Value::get<std::__cxx11::string>(void)
{
ulong uVar1;
runtime_error *this;
Value *in_RSI;
int8 in_RDI;
int1 local_50 [32];
string local_30 [48];
uVar1 = is_primitive(in_RSI);
if ((uVar1 & 1) == 0) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001a580f to 001a581f has its CatchHandler @ 001a586a */
dump_abi_cxx11_((int)local_50,SUB81(in_RSI,0));
/* try { // try from 001a5822 to 001a5837 has its CatchHandler @ 001a587a */
std::operator+((char *)local_30,(string *)"get<T> not defined for this value type: ");
/* try { // try from 001a583a to 001a5867 has its CatchHandler @ 001a588a */
std::runtime_error::runtime_error(this,local_30);
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_00336fb0,PTR__runtime_error_00336f78);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::get<std::__cxx11::string,std::__cxx11::string>();
return in_RDI;
}
| |
23,954 | bool minja::Value::get<bool>() const | monkey531[P]llama/common/minja.hpp | T get() const {
if (is_primitive()) return primitive_.get<T>();
throw std::runtime_error("get<T> not defined for this value type: " + dump());
} | O1 | cpp | bool minja::Value::get<bool>() const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
cmpq $0x0, 0x10(%rsi)
jne 0x3f6cf
cmpq $0x0, 0x20(%r14)
jne 0x3f6cf
cmpq $0x0, 0x30(%r14)
jne 0x3f6cf
movq %rdi, %rbx
addq $0x40, %r14
movq %r14, %rsi
callq 0x3f95a
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x18350
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x3dd5a
leaq 0x6c0be(%rip), %rsi # 0xab7b3
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x2463f
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x18a80
xorl %ebp, %ebp
movq 0x9e8d5(%rip), %rsi # 0xddff0
movq 0x9e84e(%rip), %rdx # 0xddf70
movq %rbx, %rdi
callq 0x18b30
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3f750
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x186a0
jmp 0x3f750
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3f773
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x186a0
jmp 0x3f773
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x3f780
movq %rbx, %rdi
callq 0x184f0
movq %r14, %rdi
callq 0x18ba0
| _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v:
push rbp
push r14
push rbx
sub rsp, 40h
mov r14, rsi
cmp qword ptr [rsi+10h], 0
jnz short loc_3F6CF
cmp qword ptr [r14+20h], 0
jnz short loc_3F6CF
cmp qword ptr [r14+30h], 0
jnz short loc_3F6CF
mov rbx, rdi
add r14, 40h ; '@'
mov rsi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE
mov rax, rbx
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
loc_3F6CF:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, rsp
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aGetTNotDefined; "get<T> not defined for this value type:"...
lea rdi, [rsp+58h+var_38]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+58h+var_38]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+58h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_3F750
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_3F750
mov r14, rax
mov bpl, 1
loc_3F750:
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_3F773
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_3F773
mov r14, rax
mov bpl, 1
loc_3F773:
test bpl, bpl
jz short loc_3F780
mov rdi, rbx; void *
call ___cxa_free_exception
loc_3F780:
mov rdi, r14
call __Unwind_Resume
| long long minja::Value::get<std::string>(long long a1, _QWORD *a2)
{
void *exception; // rbx
_BYTE v4[16]; // [rsp+0h] [rbp-58h] BYREF
_BYTE v5[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)v4, (long long)a2, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v5, (long long)"get<T> not defined for this value type: ", (long long)v4);
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);
}
ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE(
a1,
a2 + 8);
return a1;
}
| get<std::__cxx11::string>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RSI
CMP qword ptr [RSI + 0x10],0x0
JNZ 0x0013f6cf
CMP qword ptr [R14 + 0x20],0x0
JNZ 0x0013f6cf
CMP qword ptr [R14 + 0x30],0x0
JNZ 0x0013f6cf
MOV RBX,RDI
ADD R14,0x40
MOV RSI,R14
CALL 0x0013f95a
MOV RAX,RBX
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
LAB_0013f6cf:
MOV EDI,0x10
CALL 0x00118350
MOV RBX,RAX
LAB_0013f6dc:
MOV RDI,RSP
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0013dd5a
LAB_0013f6ee:
LEA RSI,[0x1ab7b3]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x0012463f
MOV BPL,0x1
LAB_0013f705:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x00118a80
XOR EBP,EBP
MOV RSI,qword ptr [0x001ddff0]
MOV RDX,qword ptr [0x001ddf70]
MOV RDI,RBX
CALL 0x00118b30
|
/* std::__cxx11::string minja::Value::get<std::__cxx11::string >() const */
void minja::Value::get<std::__cxx11::string>(void)
{
runtime_error *this;
long in_RSI;
int8 in_RDI;
int1 auStack_58 [32];
string local_38 [32];
if (((*(long *)(in_RSI + 0x10) == 0) && (*(long *)(in_RSI + 0x20) == 0)) &&
(*(long *)(in_RSI + 0x30) == 0)) {
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE
(in_RDI,in_RSI + 0x40);
return;
}
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0013f6dc to 0013f6ed has its CatchHandler @ 0013f76d */
dump_abi_cxx11_((int)auStack_58,SUB81(in_RSI,0));
/* try { // try from 0013f6ee to 0013f701 has its CatchHandler @ 0013f74a */
std::operator+((char *)local_38,(string *)"get<T> not defined for this value type: ");
/* try { // try from 0013f705 to 0013f729 has its CatchHandler @ 0013f72a */
std::runtime_error::runtime_error(this,local_38);
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_001ddff0,PTR__runtime_error_001ddf70);
}
| |
23,955 | bool minja::Value::get<bool>() const | monkey531[P]llama/common/minja.hpp | T get() const {
if (is_primitive()) return primitive_.get<T>();
throw std::runtime_error("get<T> not defined for this value type: " + dump());
} | O2 | cpp | bool minja::Value::get<bool>() const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
callq 0x3c82e
testb %al, %al
je 0x3c782
addq $0x40, %r14
movq %r14, %rdi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x3db00
pushq $0x10
popq %rdi
callq 0x20380
movq %rax, %rbx
movq %rsp, %rdi
pushq $-0x1
popq %rdx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x3c83e
leaq 0x51fbf(%rip), %rsi # 0x8e763
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x282ed
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x20aa0
xorl %ebp, %ebp
movq 0x92826(%rip), %rsi # 0xceff0
movq 0x9279f(%rip), %rdx # 0xcef70
movq %rbx, %rdi
callq 0x20b30
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x20d88
jmp 0x3c7ee
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0x20d88
testb %bpl, %bpl
jne 0x3c800
jmp 0x3c808
movq %rax, %r14
movq %rbx, %rdi
callq 0x20510
movq %r14, %rdi
callq 0x20ba0
| _ZNK5minja5Value3getIdEET_v:
push rbp
push r14
push rbx
sub rsp, 40h
mov r14, rdi
call _ZNK5minja5Value12is_primitiveEv; minja::Value::is_primitive(void)
test al, al
jz short loc_3C782
add r14, 40h ; '@'
mov rdi, r14
add rsp, 40h
pop rbx
pop r14
pop rbp
jmp _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIdTnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE
loc_3C782:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, rsp
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rsi, r14
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aGetTNotDefined; "get<T> not defined for this value type:"...
lea rdi, [rsp+58h+var_38]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+58h+var_38]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rdi, [rsp+58h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_3C7EE
mov r14, rax
mov bpl, 1
loc_3C7EE:
mov rdi, rsp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_3C800
jmp short loc_3C808
mov r14, rax
loc_3C800:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_3C808:
mov rdi, r14
call __Unwind_Resume
| long long minja::Value::get<double>(minja::Value *a1)
{
void *exception; // rbx
int v3; // r8d
int v4; // r9d
char v5[32]; // [rsp+0h] [rbp-58h] BYREF
_BYTE v6[56]; // [rsp+20h] [rbp-38h] BYREF
if ( !(unsigned __int8)minja::Value::is_primitive(a1) )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((unsigned int)v5, (_DWORD)a1, -1, 0, v3, v4, v5[0]);
std::operator+<char>((long long)v6, (long long)"get<T> not defined for this value type: ", (long long)v5);
std::runtime_error::runtime_error(exception, v6);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIdTnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE((char *)a1 + 64);
}
| get<double>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
CALL 0x0013c82e
TEST AL,AL
JZ 0x0013c782
ADD R14,0x40
MOV RDI,R14
ADD RSP,0x40
POP RBX
POP R14
POP RBP
JMP 0x0013db00
LAB_0013c782:
PUSH 0x10
POP RDI
CALL 0x00120380
MOV RBX,RAX
LAB_0013c78d:
MOV RDI,RSP
PUSH -0x1
POP RDX
MOV RSI,R14
XOR ECX,ECX
CALL 0x0013c83e
LAB_0013c79d:
LEA RSI,[0x18e763]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x001282ed
MOV BPL,0x1
LAB_0013c7b4:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x00120aa0
XOR EBP,EBP
MOV RSI,qword ptr [0x001ceff0]
MOV RDX,qword ptr [0x001cef70]
MOV RDI,RBX
CALL 0x00120b30
|
/* double minja::Value::get<double>() const */
double __thiscall minja::Value::get<double>(Value *this)
{
runtime_error *this_00;
char cVar1;
double dVar2;
int1 auStack_58 [32];
string local_38 [32];
cVar1 = is_primitive(this);
if (cVar1 != '\0') {
dVar2 = (double)_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIdTnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE
(this + 0x40);
return dVar2;
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0013c78d to 0013c79c has its CatchHandler @ 0013c7fd */
dump_abi_cxx11_((int)auStack_58,SUB81(this,0));
/* try { // try from 0013c79d to 0013c7b0 has its CatchHandler @ 0013c7e8 */
std::operator+((char *)local_38,(string *)"get<T> not defined for this value type: ");
/* try { // try from 0013c7b4 to 0013c7d8 has its CatchHandler @ 0013c7d9 */
std::runtime_error::runtime_error(this_00,local_38);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_001ceff0,PTR__runtime_error_001cef70);
}
| |
23,956 | IsAddressInCurrentStack(void*) | BadAccessGuards/src/BadAccessGuards.cpp | bool IsAddressInCurrentStack(void* ptr)
{
// TODO: handle failure properly. For now return false on failure. (Assume this is a MT error)
pthread_attr_t attributes;
if (0 != pthread_getattr_np(pthread_self(), &attributes)) return false;
void* stackAddr;
size_t stackSize;
if (0 != pthread_attr_getstack(&attributes, &stackAddr, &stackSize)) return false;
// On POSIX, address is indeed the start address (what you would give if allocating yourself)
return stackAddr <= ptr && uintptr_t(ptr) < (uintptr_t(stackAddr) + stackSize);
} | O0 | cpp | IsAddressInCurrentStack(void*):
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
callq 0x43f0
movq %rax, %rdi
leaq -0x48(%rbp), %rsi
callq 0x42d0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x11c3b
movb $0x0, -0x1(%rbp)
jmp 0x11c86
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x46f0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x11c5a
movb $0x0, -0x1(%rbp)
jmp 0x11c86
movq -0x50(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x59(%rbp)
ja 0x11c7e
movq -0x10(%rbp), %rax
movq -0x50(%rbp), %rcx
addq -0x58(%rbp), %rcx
cmpq %rcx, %rax
setb %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _Z23IsAddressInCurrentStackPv:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
call _pthread_self
mov rdi, rax
lea rsi, [rbp+var_48]
call _pthread_getattr_np
mov ecx, eax
xor eax, eax
cmp eax, ecx
jz short loc_11C3B
mov [rbp+var_1], 0
jmp short loc_11C86
loc_11C3B:
lea rdi, [rbp+var_48]
lea rsi, [rbp+var_50]
lea rdx, [rbp+var_58]
call _pthread_attr_getstack
mov ecx, eax
xor eax, eax
cmp eax, ecx
jz short loc_11C5A
mov [rbp+var_1], 0
jmp short loc_11C86
loc_11C5A:
mov rcx, [rbp+var_50]
xor eax, eax
cmp rcx, [rbp+var_10]
mov [rbp+var_59], al
ja short loc_11C7E
mov rax, [rbp+var_10]
mov rcx, [rbp+var_50]
add rcx, [rbp+var_58]
cmp rax, rcx
setb al
mov [rbp+var_59], al
loc_11C7E:
mov al, [rbp+var_59]
and al, 1
mov [rbp+var_1], al
loc_11C86:
mov al, [rbp+var_1]
and al, 1
add rsp, 60h
pop rbp
retn
| bool IsAddressInCurrentStack(unsigned long long a1)
{
long long v1; // rax
bool v3; // [rsp+7h] [rbp-59h]
long long v4; // [rsp+8h] [rbp-58h] BYREF
unsigned long long v5; // [rsp+10h] [rbp-50h] BYREF
_BYTE v6[56]; // [rsp+18h] [rbp-48h] BYREF
unsigned long long v7; // [rsp+50h] [rbp-10h]
v7 = a1;
v1 = pthread_self();
if ( (unsigned int)pthread_getattr_np(v1, v6) )
return 0;
if ( (unsigned int)pthread_attr_getstack(v6, &v5, &v4) )
return 0;
v3 = 0;
if ( v5 <= v7 )
return v7 < v4 + v5;
return v3;
}
| IsAddressInCurrentStack:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x10],RDI
CALL 0x001043f0
MOV RDI,RAX
LEA RSI,[RBP + -0x48]
CALL 0x001042d0
MOV ECX,EAX
XOR EAX,EAX
CMP EAX,ECX
JZ 0x00111c3b
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00111c86
LAB_00111c3b:
LEA RDI,[RBP + -0x48]
LEA RSI,[RBP + -0x50]
LEA RDX,[RBP + -0x58]
CALL 0x001046f0
MOV ECX,EAX
XOR EAX,EAX
CMP EAX,ECX
JZ 0x00111c5a
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00111c86
LAB_00111c5a:
MOV RCX,qword ptr [RBP + -0x50]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x10]
MOV byte ptr [RBP + -0x59],AL
JA 0x00111c7e
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x50]
ADD RCX,qword ptr [RBP + -0x58]
CMP RAX,RCX
SETC AL
MOV byte ptr [RBP + -0x59],AL
LAB_00111c7e:
MOV AL,byte ptr [RBP + -0x59]
AND AL,0x1
MOV byte ptr [RBP + -0x1],AL
LAB_00111c86:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0x60
POP RBP
RET
|
/* IsAddressInCurrentStack(void*) */
int8 IsAddressInCurrentStack(void *param_1)
{
int iVar1;
pthread_t __th;
int7 uVar2;
bool local_61;
size_t local_60;
void *local_58;
pthread_attr_t local_50;
void *local_18;
bool local_9;
local_18 = param_1;
__th = pthread_self();
iVar1 = pthread_getattr_np(__th,&local_50);
uVar2 = 0;
if (iVar1 == 0) {
iVar1 = pthread_attr_getstack(&local_50,&local_58,&local_60);
uVar2 = 0;
if (iVar1 == 0) {
uVar2 = 0;
if (local_58 <= local_18) {
uVar2 = (int7)((ulong)local_18 >> 8);
}
local_61 = local_58 <= local_18 && local_18 < (void *)((long)local_58 + local_60);
local_9 = local_61;
}
else {
local_9 = false;
}
}
else {
local_9 = false;
}
return CONCAT71(uVar2,local_9);
}
| |
23,957 | IsAddressInCurrentStack(void*) | BadAccessGuards/src/BadAccessGuards.cpp | bool IsAddressInCurrentStack(void* ptr)
{
// TODO: handle failure properly. For now return false on failure. (Assume this is a MT error)
pthread_attr_t attributes;
if (0 != pthread_getattr_np(pthread_self(), &attributes)) return false;
void* stackAddr;
size_t stackSize;
if (0 != pthread_attr_getstack(&attributes, &stackAddr, &stackSize)) return false;
// On POSIX, address is indeed the start address (what you would give if allocating yourself)
return stackAddr <= ptr && uintptr_t(ptr) < (uintptr_t(stackAddr) + stackSize);
} | O3 | cpp | IsAddressInCurrentStack(void*):
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
callq 0x32b0
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x3200
testl %eax, %eax
jne 0x6d86
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x3500
testl %eax, %eax
je 0x6d8e
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
retq
movq 0x10(%rsp), %rax
cmpq %rbx, %rax
setbe %cl
addq 0x8(%rsp), %rax
cmpq %rbx, %rax
seta %al
andb %cl, %al
jmp 0x6d88
| _Z23IsAddressInCurrentStackPv:
push rbx
sub rsp, 50h
mov rbx, rdi
call _pthread_self
lea rsi, [rsp+58h+var_40]
mov rdi, rax
call _pthread_getattr_np
test eax, eax
jnz short loc_6D86
lea rdi, [rsp+58h+var_40]
lea rsi, [rsp+58h+var_48]
lea rdx, [rsp+58h+var_50]
call _pthread_attr_getstack
test eax, eax
jz short loc_6D8E
loc_6D86:
xor eax, eax
loc_6D88:
add rsp, 50h
pop rbx
retn
loc_6D8E:
mov rax, [rsp+58h+var_48]
cmp rax, rbx
setbe cl
add rax, [rsp+58h+var_50]
cmp rax, rbx
setnbe al
and al, cl
jmp short loc_6D88
| bool IsAddressInCurrentStack(unsigned long long a1)
{
long long v1; // rax
long long v3; // [rsp+8h] [rbp-50h] BYREF
unsigned long long v4; // [rsp+10h] [rbp-48h] BYREF
_BYTE v5[64]; // [rsp+18h] [rbp-40h] BYREF
v1 = pthread_self();
return !(unsigned int)pthread_getattr_np(v1, v5)
&& !(unsigned int)pthread_attr_getstack(v5, &v4, &v3)
&& v4 <= a1
&& v3 + v4 > a1;
}
| IsAddressInCurrentStack:
PUSH RBX
SUB RSP,0x50
MOV RBX,RDI
CALL 0x001032b0
LEA RSI,[RSP + 0x18]
MOV RDI,RAX
CALL 0x00103200
TEST EAX,EAX
JNZ 0x00106d86
LEA RDI,[RSP + 0x18]
LEA RSI,[RSP + 0x10]
LEA RDX,[RSP + 0x8]
CALL 0x00103500
TEST EAX,EAX
JZ 0x00106d8e
LAB_00106d86:
XOR EAX,EAX
LAB_00106d88:
ADD RSP,0x50
POP RBX
RET
LAB_00106d8e:
MOV RAX,qword ptr [RSP + 0x10]
CMP RAX,RBX
SETBE CL
ADD RAX,qword ptr [RSP + 0x8]
CMP RAX,RBX
SETA AL
AND AL,CL
JMP 0x00106d88
|
/* IsAddressInCurrentStack(void*) */
int8 IsAddressInCurrentStack(void *param_1)
{
int iVar1;
pthread_t __th;
size_t local_50;
void *local_48;
pthread_attr_t local_40;
__th = pthread_self();
iVar1 = pthread_getattr_np(__th,&local_40);
if ((iVar1 == 0) && (iVar1 = pthread_attr_getstack(&local_40,&local_48,&local_50), iVar1 == 0)) {
return CONCAT71((int7)((ulong)((long)local_48 + local_50) >> 8),
param_1 < (void *)((long)local_48 + local_50) && local_48 <= param_1);
}
return 0;
}
| |
23,958 | Ort::detail::SessionImpl<OrtSession>::Run(Ort::RunOptions const&, char const* const*, Ort::Value const*, unsigned long, char const* const*, unsigned long) | Depths-CPP/onnxruntime-linux-x64-gpu-1.19.2/include/onnxruntime_cxx_inline.h | inline std::vector<Value> SessionImpl<T>::Run(const RunOptions& run_options, const char* const* input_names, const Value* input_values, size_t input_count,
const char* const* output_names, size_t output_count) {
std::vector<Value> output_values;
output_values.reserve(output_count);
for (size_t i = 0; i < output_count; i++)
output_values.emplace_back(nullptr);
Run(run_options, input_names, input_values, input_count, output_names, output_values.data(), output_count);
return output_values;
} | O0 | c | Ort::detail::SessionImpl<OrtSession>::Run(Ort::RunOptions const&, char const* const*, Ort::Value const*, unsigned long, char const* const*, unsigned long):
subq $0xa8, %rsp
movq %rdi, 0x48(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
movq 0xb8(%rsp), %rax
movq 0xb0(%rsp), %rax
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq %r8, 0x80(%rsp)
movq %r9, 0x78(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x40(%rsp)
movb $0x0, 0x77(%rsp)
callq 0x37770
movq 0x48(%rsp), %rdi
movq 0xb8(%rsp), %rsi
callq 0x37780
jmp 0x2dd0c
movq $0x0, 0x58(%rsp)
movq 0x58(%rsp), %rax
cmpq 0xb8(%rsp), %rax
jae 0x2dd6d
movq 0x48(%rsp), %rdi
movq $0x0, 0x50(%rsp)
leaq 0x50(%rsp), %rsi
callq 0x37890
jmp 0x2dd3e
jmp 0x2dd40
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
jmp 0x2dd15
movq 0x48(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
callq 0x2ded0
jmp 0x2de12
movq 0x48(%rsp), %rdi
movq 0x90(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x30(%rsp)
callq 0x379d0
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %r8
movq 0x30(%rsp), %r9
movq %rax, %r10
movq 0xb8(%rsp), %r11
movq %rsp, %rax
movq %r11, 0x8(%rax)
movq %r10, (%rax)
callq 0x37910
jmp 0x2ddef
movb $0x1, 0x77(%rsp)
testb $0x1, 0x77(%rsp)
jne 0x2de05
movq 0x48(%rsp), %rdi
callq 0x2ded0
movq 0x38(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0x23430
nopl (%rax)
| _ZN3Ort6detail11SessionImplI10OrtSessionE3RunERKNS_10RunOptionsEPKPKcPKNS_5ValueEmSA_m:
sub rsp, 0A8h
mov [rsp+0A8h+var_60], rdi
mov rax, rdi
mov [rsp+0A8h+var_70], rax
mov rax, [rsp+0A8h+arg_8]
mov rax, [rsp+0A8h+arg_0]
mov [rsp+0A8h+var_8], rdi
mov [rsp+0A8h+var_10], rsi
mov [rsp+0A8h+var_18], rdx
mov [rsp+0A8h+var_20], rcx
mov [rsp+0A8h+var_28], r8
mov [rsp+0A8h+var_30], r9
mov rax, [rsp+0A8h+var_10]
mov [rsp+0A8h+var_68], rax
mov [rsp+0A8h+var_31], 0
call _ZNSt6vectorIN3Ort5ValueESaIS1_EEC2Ev; std::vector<Ort::Value>::vector(void)
mov rdi, [rsp+0A8h+var_60]
mov rsi, [rsp+0A8h+arg_8]
call _ZNSt6vectorIN3Ort5ValueESaIS1_EE7reserveEm; std::vector<Ort::Value>::reserve(ulong)
jmp short $+2
loc_2DD0C:
mov [rsp+0A8h+var_50], 0
loc_2DD15:
mov rax, [rsp+0A8h+var_50]
cmp rax, [rsp+0A8h+arg_8]
jnb short loc_2DD6D
mov rdi, [rsp+0A8h+var_60]
mov [rsp+0A8h+var_58], 0
lea rsi, [rsp+0A8h+var_58]
call _ZNSt6vectorIN3Ort5ValueESaIS1_EE12emplace_backIJDnEEERS1_DpOT_; std::vector<Ort::Value>::emplace_back<decltype(nullptr)>(decltype(nullptr) &&)
jmp short $+2
loc_2DD3E:
jmp short $+2
loc_2DD40:
mov rax, [rsp+0A8h+var_50]
add rax, 1
mov [rsp+0A8h+var_50], rax
jmp short loc_2DD15
mov rdi, [rsp+arg_40]
mov rcx, rax
mov eax, edx
mov [rsp+arg_60], rcx
mov [rsp+arg_5C], eax
call _ZNSt6vectorIN3Ort5ValueESaIS1_EED2Ev; std::vector<Ort::Value>::~vector()
jmp loc_2DE12
loc_2DD6D:
mov rdi, [rsp+0A8h+var_60]
mov rax, [rsp+0A8h+var_18]
mov [rsp+0A8h+var_98], rax
mov rax, [rsp+0A8h+var_20]
mov [rsp+0A8h+var_90], rax
mov rax, [rsp+0A8h+var_28]
mov [rsp+0A8h+var_88], rax
mov rax, [rsp+0A8h+var_30]
mov [rsp+0A8h+var_80], rax
mov rax, [rsp+0A8h+arg_0]
mov [rsp+0A8h+var_78], rax
call _ZNSt6vectorIN3Ort5ValueESaIS1_EE4dataEv; std::vector<Ort::Value>::data(void)
mov rdi, [rsp+0A8h+var_68]
mov rsi, [rsp+0A8h+var_98]
mov rdx, [rsp+0A8h+var_90]
mov rcx, [rsp+0A8h+var_88]
mov r8, [rsp+0A8h+var_80]
mov r9, [rsp+0A8h+var_78]
mov r10, rax
mov r11, [rsp+0A8h+arg_8]
mov rax, rsp
mov [rax+8], r11
mov [rax], r10
call _ZN3Ort6detail11SessionImplI10OrtSessionE3RunERKNS_10RunOptionsEPKPKcPKNS_5ValueEmSA_PSB_m; Ort::detail::SessionImpl<OrtSession>::Run(Ort::RunOptions const&,char const* const*,Ort::Value const*,ulong,char const* const*,Ort::Value*,ulong)
jmp short $+2
loc_2DDEF:
mov [rsp+0A8h+var_31], 1
test [rsp+0A8h+var_31], 1
jnz short loc_2DE05
mov rdi, [rsp+0A8h+var_60]
call _ZNSt6vectorIN3Ort5ValueESaIS1_EED2Ev; std::vector<Ort::Value>::~vector()
loc_2DE05:
mov rax, [rsp+0A8h+var_70]
add rsp, 0A8h
retn
loc_2DE12:
mov rdi, [rsp+arg_60]
call __Unwind_Resume
| long long Ort::detail::SessionImpl<OrtSession>::Run(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
long long a7,
unsigned long long a8)
{
long long v8; // rax
int v10; // [rsp+10h] [rbp-98h]
int v11; // [rsp+18h] [rbp-90h]
int v12; // [rsp+20h] [rbp-88h]
int v13; // [rsp+28h] [rbp-80h]
long long v14; // [rsp+50h] [rbp-58h] BYREF
unsigned long long i; // [rsp+58h] [rbp-50h]
char v16; // [rsp+77h] [rbp-31h]
long long v17; // [rsp+78h] [rbp-30h]
long long v18; // [rsp+80h] [rbp-28h]
long long v19; // [rsp+88h] [rbp-20h]
long long v20; // [rsp+90h] [rbp-18h]
long long v21; // [rsp+98h] [rbp-10h]
long long v22; // [rsp+A0h] [rbp-8h]
v22 = a1;
v21 = a2;
v20 = a3;
v19 = a4;
v18 = a5;
v17 = a6;
v16 = 0;
std::vector<Ort::Value>::vector();
std::vector<Ort::Value>::reserve(a1, a8);
for ( i = 0LL; i < a8; ++i )
{
v14 = 0LL;
std::vector<Ort::Value>::emplace_back<decltype(nullptr)>(a1, &v14);
}
v10 = v20;
v11 = v19;
v12 = v18;
v13 = v17;
v8 = std::vector<Ort::Value>::data(a1);
Ort::detail::SessionImpl<OrtSession>::Run(a2, v10, v11, v12, v13, a7, v8, a8);
return a1;
}
| Run:
SUB RSP,0xa8
MOV qword ptr [RSP + 0x48],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x38],RAX
MOV RAX,qword ptr [RSP + 0xb8]
MOV RAX,qword ptr [RSP + 0xb0]
MOV qword ptr [RSP + 0xa0],RDI
MOV qword ptr [RSP + 0x98],RSI
MOV qword ptr [RSP + 0x90],RDX
MOV qword ptr [RSP + 0x88],RCX
MOV qword ptr [RSP + 0x80],R8
MOV qword ptr [RSP + 0x78],R9
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0x40],RAX
MOV byte ptr [RSP + 0x77],0x0
CALL 0x00137770
MOV RDI,qword ptr [RSP + 0x48]
MOV RSI,qword ptr [RSP + 0xb8]
LAB_0012dd05:
CALL 0x00137780
JMP 0x0012dd0c
LAB_0012dd0c:
MOV qword ptr [RSP + 0x58],0x0
LAB_0012dd15:
MOV RAX,qword ptr [RSP + 0x58]
CMP RAX,qword ptr [RSP + 0xb8]
JNC 0x0012dd6d
MOV RDI,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x50],0x0
LEA RSI,[RSP + 0x50]
CALL 0x00137890
JMP 0x0012dd3e
LAB_0012dd3e:
JMP 0x0012dd40
LAB_0012dd40:
MOV RAX,qword ptr [RSP + 0x58]
ADD RAX,0x1
MOV qword ptr [RSP + 0x58],RAX
JMP 0x0012dd15
LAB_0012dd6d:
MOV RDI,qword ptr [RSP + 0x48]
MOV RAX,qword ptr [RSP + 0x90]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [RSP + 0xb0]
MOV qword ptr [RSP + 0x30],RAX
CALL 0x001379d0
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x20]
MOV R8,qword ptr [RSP + 0x28]
MOV R9,qword ptr [RSP + 0x30]
MOV R10,RAX
MOV R11,qword ptr [RSP + 0xb8]
MOV RAX,RSP
MOV qword ptr [RAX + 0x8],R11
MOV qword ptr [RAX],R10
CALL 0x00137910
LAB_0012dded:
JMP 0x0012ddef
LAB_0012ddef:
MOV byte ptr [RSP + 0x77],0x1
TEST byte ptr [RSP + 0x77],0x1
JNZ 0x0012de05
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x0012ded0
LAB_0012de05:
MOV RAX,qword ptr [RSP + 0x38]
ADD RSP,0xa8
RET
|
/* WARNING: Removing unreachable block (ram,0x0012ddfb) */
/* Ort::detail::SessionImpl<OrtSession>::Run(Ort::RunOptions const&, char const* const*, Ort::Value
const*, unsigned long, char const* const*, unsigned long) */
RunOptions *
Ort::detail::SessionImpl<OrtSession>::Run
(RunOptions *param_1,char **param_2,Value *param_3,ulong param_4,char **param_5,
ulong param_6)
{
ulong uVar1;
Value *pVVar2;
char **ppcVar3;
Value *pVVar4;
Value *pVVar5;
char **in_stack_00000008;
ulong in_stack_00000010;
_func_decltype_nullptr *local_58;
ulong local_50;
int1 local_31;
ulong local_30;
Value *local_28;
char **local_20;
Value *local_18;
char **local_10;
RunOptions *local_8;
local_31 = 0;
local_30 = param_6;
local_28 = (Value *)param_5;
local_20 = (char **)param_4;
local_18 = param_3;
local_10 = param_2;
local_8 = param_1;
std::vector<Ort::Value,std::allocator<Ort::Value>>::vector
((vector<Ort::Value,std::allocator<Ort::Value>> *)param_1);
/* try { // try from 0012dd05 to 0012ddec has its CatchHandler @ 0012dd50 */
std::vector<Ort::Value,std::allocator<Ort::Value>>::reserve
((vector<Ort::Value,std::allocator<Ort::Value>> *)param_1,in_stack_00000010);
for (local_50 = 0; pVVar4 = local_18, ppcVar3 = local_20, pVVar2 = local_28, uVar1 = local_30,
local_50 < in_stack_00000010; local_50 = local_50 + 1) {
local_58 = (_func_decltype_nullptr *)0x0;
std::vector<Ort::Value,std::allocator<Ort::Value>>::emplace_back<decltype(nullptr)>
((vector<Ort::Value,std::allocator<Ort::Value>> *)param_1,&local_58);
}
pVVar5 = (Value *)std::vector<Ort::Value,std::allocator<Ort::Value>>::data
((vector<Ort::Value,std::allocator<Ort::Value>> *)param_1);
Run((SessionImpl<OrtSession> *)param_2,(RunOptions *)pVVar4,ppcVar3,pVVar2,uVar1,in_stack_00000008
,pVVar5,in_stack_00000010);
return param_1;
}
| |
23,959 | ftxui::Renderer(std::shared_ptr<ftxui::ComponentBase>, std::function<std::shared_ptr<ftxui::Node> ()>) | Andrewchistyakov[P]flashcards_lyc/build_O1/_deps/ftxui-src/src/ftxui/component/renderer.cpp | Component Renderer(Component child, std::function<Element()> render) {
Component renderer = Renderer(std::move(render));
renderer->Add(std::move(child));
return renderer;
} | O1 | cpp | ftxui::Renderer(std::shared_ptr<ftxui::ComponentBase>, std::function<std::shared_ptr<ftxui::Node> ()>):
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%rdx), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rdx), %rax
testq %rax, %rax
je 0x2d14d
movups (%rdx), %xmm1
addq $0x10, %rdx
movaps %xmm1, (%rsp)
movq %rax, 0x10(%rsp)
movups %xmm0, (%rdx)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2d01c
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2d16f
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq (%rbx), %rdi
movq (%r14), %rax
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
xorl %eax, %eax
movq %rax, 0x8(%rsi)
movq 0x8(%r14), %rcx
movq %rax, 0x8(%r14)
movq %rcx, 0x8(%rsi)
movq %rax, (%r14)
callq 0x273a2
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2d1a6
callq 0x14c7c
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0x2d1f7
movq %rax, %r14
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2d1c5
callq 0x14c7c
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2d1ef
callq 0x14c7c
jmp 0x2d1ef
movq %rax, %r14
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2d1ef
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %r14, %rdi
callq 0xb780
movq %rax, %rdi
callq 0x106a9
| _ZN5ftxui8RendererESt10shared_ptrINS_13ComponentBaseEESt8functionIFS0_INS_4NodeEEvEE:
push r14
push rbx
sub rsp, 38h
mov r14, rsi
mov rbx, rdi
xorps xmm0, xmm0
movaps [rsp+48h+var_48], xmm0
mov [rsp+48h+var_38], 0
mov rax, [rdx+18h]
mov [rsp+48h+var_30], rax
mov rax, [rdx+10h]
test rax, rax
jz short loc_2D14D
movups xmm1, xmmword ptr [rdx]
add rdx, 10h
movaps [rsp+48h+var_48], xmm1
mov [rsp+48h+var_38], rax
movups xmmword ptr [rdx], xmm0
loc_2D14D:
mov rsi, rsp
mov rdi, rbx
call _ZN5ftxui8RendererESt8functionIFSt10shared_ptrINS_4NodeEEvEE; ftxui::Renderer(std::function<std::shared_ptr<ftxui::Node> ()(void)>)
mov rax, [rsp+48h+var_38]
test rax, rax
jz short loc_2D16F
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
loc_2D16F:
mov rdi, [rbx]
mov rax, [r14]
lea rsi, [rsp+48h+var_20]
mov [rsi], rax
xor eax, eax
mov [rsi+8], rax
mov rcx, [r14+8]
mov [r14+8], rax
mov [rsi+8], rcx
mov [r14], rax
call _ZN5ftxui13ComponentBase3AddESt10shared_ptrIS0_E; ftxui::ComponentBase::Add(std::shared_ptr<ftxui::ComponentBase>)
mov rdi, [rsp+48h+var_18]
test rdi, rdi
jz short loc_2D1A6
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_2D1A6:
mov rax, rbx
add rsp, 38h
pop rbx
pop r14
retn
jmp short loc_2D1F7
mov r14, rax
mov rdi, [rsp+48h+var_18]
test rdi, rdi
jz short loc_2D1C5
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_2D1C5:
mov rdi, [rbx+8]
test rdi, rdi
jz short loc_2D1EF
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
jmp short loc_2D1EF
mov r14, rax
mov rax, [rsp+48h+var_38]
test rax, rax
jz short loc_2D1EF
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
loc_2D1EF:
mov rdi, r14
call __Unwind_Resume
loc_2D1F7:
mov rdi, rax
call __clang_call_terminate
| long long * ftxui::Renderer(long long *a1, long long a2, long long a3)
{
void ( *v4)(__int128 *, __int128 *, long long); // rax
long long v5; // rdi
volatile signed __int32 *v6; // rcx
__int128 v8; // [rsp+0h] [rbp-48h] BYREF
void ( *v9)(__int128 *, __int128 *, long long); // [rsp+10h] [rbp-38h]
long long v10; // [rsp+18h] [rbp-30h]
ftxui::ComponentBase *v11; // [rsp+28h] [rbp-20h] BYREF
volatile signed __int32 *v12; // [rsp+30h] [rbp-18h]
v8 = 0LL;
v9 = 0LL;
v10 = *(_QWORD *)(a3 + 24);
v4 = *(void ( **)(__int128 *, __int128 *, long long))(a3 + 16);
if ( v4 )
{
v8 = *(_OWORD *)a3;
v9 = v4;
*(_OWORD *)(a3 + 16) = 0LL;
}
ftxui::Renderer(a1, &v8);
if ( v9 )
v9(&v8, &v8, 3LL);
v5 = *a1;
v11 = *(ftxui::ComponentBase **)a2;
v12 = 0LL;
v6 = *(volatile signed __int32 **)(a2 + 8);
*(_QWORD *)(a2 + 8) = 0LL;
v12 = v6;
*(_QWORD *)a2 = 0LL;
ftxui::ComponentBase::Add(v5, &v11);
if ( v12 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v12);
return a1;
}
| Renderer:
PUSH R14
PUSH RBX
SUB RSP,0x38
MOV R14,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],0x0
MOV RAX,qword ptr [RDX + 0x18]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RDX + 0x10]
TEST RAX,RAX
JZ 0x0012d14d
MOVUPS XMM1,xmmword ptr [RDX]
ADD RDX,0x10
MOVAPS xmmword ptr [RSP],XMM1
MOV qword ptr [RSP + 0x10],RAX
MOVUPS xmmword ptr [RDX],XMM0
LAB_0012d14d:
MOV RSI,RSP
MOV RDI,RBX
CALL 0x0012d01c
MOV RAX,qword ptr [RSP + 0x10]
TEST RAX,RAX
JZ 0x0012d16f
LAB_0012d162:
MOV RDI,RSP
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_0012d16f:
MOV RDI,qword ptr [RBX]
MOV RAX,qword ptr [R14]
LEA RSI,[RSP + 0x28]
MOV qword ptr [RSI],RAX
XOR EAX,EAX
MOV qword ptr [RSI + 0x8],RAX
MOV RCX,qword ptr [R14 + 0x8]
MOV qword ptr [R14 + 0x8],RAX
MOV qword ptr [RSI + 0x8],RCX
MOV qword ptr [R14],RAX
LAB_0012d192:
CALL 0x001273a2
MOV RDI,qword ptr [RSP + 0x30]
TEST RDI,RDI
JZ 0x0012d1a6
CALL 0x00114c7c
LAB_0012d1a6:
MOV RAX,RBX
ADD RSP,0x38
POP RBX
POP R14
RET
|
/* ftxui::Renderer(std::shared_ptr<ftxui::ComponentBase>, std::function<std::shared_ptr<ftxui::Node>
()>) */
ftxui * __thiscall ftxui::Renderer(ftxui *this,int8 *param_2,int8 *param_3)
{
code *pcVar1;
ComponentBase *pCVar2;
int8 local_48;
int8 uStack_40;
code *local_38;
int8 local_30;
int8 local_20;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_18;
local_48 = 0;
uStack_40 = 0;
local_38 = (code *)0x0;
local_30 = param_3[3];
pcVar1 = (code *)param_3[2];
if (pcVar1 != (code *)0x0) {
local_48 = *param_3;
uStack_40 = param_3[1];
param_3[2] = 0;
param_3[3] = 0;
local_38 = pcVar1;
}
/* try { // try from 0012d14d to 0012d157 has its CatchHandler @ 0012d1d5 */
Renderer(this,&local_48);
if (local_38 != (code *)0x0) {
/* try { // try from 0012d162 to 0012d16e has its CatchHandler @ 0012d1b1 */
(*local_38)(&local_48,&local_48,3);
}
pCVar2 = *(ComponentBase **)this;
local_20 = *param_2;
local_18 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)param_2[1];
param_2[1] = 0;
*param_2 = 0;
/* try { // try from 0012d192 to 0012d196 has its CatchHandler @ 0012d1b3 */
ComponentBase::Add(pCVar2);
if (local_18 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_18);
}
return this;
}
| |
23,960 | mi_open_keyfile | eloqsql/storage/myisam/mi_open.c | int mi_open_keyfile(MYISAM_SHARE *share)
{
if ((share->kfile= mysql_file_open(mi_key_file_kfile,
share->unique_file_name,
share->mode | O_SHARE | O_NOFOLLOW | O_CLOEXEC,
MYF(MY_NOSYMLINKS | MY_WME))) < 0)
return 1;
return 0;
} | O0 | c | mi_open_keyfile:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
leaq 0xbc0799(%rip), %rax # 0xc7a5dc
movl (%rax), %edi
movq -0x10(%rbp), %rax
movq 0x258(%rax), %rcx
movq -0x10(%rbp), %rax
movl 0x358(%rax), %r8d
orl $0x0, %r8d
orl $0x20000, %r8d # imm = 0x20000
orl $0x80000, %r8d # imm = 0x80000
leaq 0x99d0b(%rip), %rsi # 0x153b7f
movl $0x504, %edx # imm = 0x504
movl $0x210, %r9d # imm = 0x210
callq 0xb4bc0
movq -0x10(%rbp), %rcx
movl %eax, 0x350(%rcx)
cmpl $0x0, %eax
jge 0xb9e9c
movl $0x1, -0x4(%rbp)
jmp 0xb9ea3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| mi_open_keyfile:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_10], rdi
lea rax, mi_key_file_kfile
mov edi, [rax]
mov rax, [rbp+var_10]
mov rcx, [rax+258h]
mov rax, [rbp+var_10]
mov r8d, [rax+358h]
or r8d, 0
or r8d, 20000h
or r8d, 80000h
lea rsi, aWorkspaceLlm4b_29; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 504h
mov r9d, 210h
call inline_mysql_file_open_2
mov rcx, [rbp+var_10]
mov [rcx+350h], eax
cmp eax, 0
jge short loc_B9E9C
mov [rbp+var_4], 1
jmp short loc_B9EA3
loc_B9E9C:
mov [rbp+var_4], 0
loc_B9EA3:
mov eax, [rbp+var_4]
add rsp, 10h
pop rbp
retn
| _BOOL8 mi_open_keyfile(long long a1)
{
int v1; // eax
v1 = inline_mysql_file_open_2(
mi_key_file_kfile,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_open.c",
0x504u,
*(_QWORD *)(a1 + 600),
*(_DWORD *)(a1 + 856) | 0xA0000u,
528LL);
*(_DWORD *)(a1 + 848) = v1;
return v1 < 0;
}
| mi_open_keyfile:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x10],RDI
LEA RAX,[0xd7a5dc]
MOV EDI,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x258]
MOV RAX,qword ptr [RBP + -0x10]
MOV R8D,dword ptr [RAX + 0x358]
OR R8D,0x0
OR R8D,0x20000
OR R8D,0x80000
LEA RSI,[0x253b7f]
MOV EDX,0x504
MOV R9D,0x210
CALL 0x001b4bc0
MOV RCX,qword ptr [RBP + -0x10]
MOV dword ptr [RCX + 0x350],EAX
CMP EAX,0x0
JGE 0x001b9e9c
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001b9ea3
LAB_001b9e9c:
MOV dword ptr [RBP + -0x4],0x0
LAB_001b9ea3:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x10
POP RBP
RET
|
bool mi_open_keyfile(long param_1)
{
int iVar1;
iVar1 = inline_mysql_file_open
(mi_key_file_kfile,
"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_open.c",0x504,
*(int8 *)(param_1 + 600),*(uint *)(param_1 + 0x358) | 0xa0000,0x210);
*(int *)(param_1 + 0x350) = iVar1;
return iVar1 < 0;
}
| |
23,961 | mi_open_keyfile | eloqsql/storage/myisam/mi_open.c | int mi_open_keyfile(MYISAM_SHARE *share)
{
if ((share->kfile= mysql_file_open(mi_key_file_kfile,
share->unique_file_name,
share->mode | O_SHARE | O_NOFOLLOW | O_CLOEXEC,
MYF(MY_NOSYMLINKS | MY_WME))) < 0)
return 1;
return 0;
} | O3 | c | mi_open_keyfile:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0xb7f1c4(%rip), %rax # 0xbff9dc
movl (%rax), %esi
movq 0x258(%rdi), %r15
movl $0xa0000, %r14d # imm = 0xA0000
orl 0x358(%rdi), %r14d
leaq 0x3057db(%rip), %r13 # 0x386010
movq (%r13), %rax
leaq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %r12
movl $0x2, %edx
movq %r15, %rcx
movq %r12, %r8
callq *0x148(%rax)
movq %rax, (%r12)
testq %rax, %rax
jne 0x8088b
movl $0x210, %edx # imm = 0x210
movq %r15, %rdi
movl %r14d, %esi
callq 0xa03e0
movl %eax, %r14d
movl %r14d, 0x350(%rbx)
shrl $0x1f, %r14d
movl %r14d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r13), %rcx
leaq 0x5b471(%rip), %rsi # 0xdbd07
movq %rax, %rdi
movl $0x504, %edx # imm = 0x504
callq *0x1f0(%rcx)
movl $0x210, %edx # imm = 0x210
movq %r15, %rdi
movl %r14d, %esi
callq 0xa03e0
movl %eax, %r14d
movq (%r13), %rax
movq -0x30(%rbp), %rdi
movl %r14d, %esi
callq *0x200(%rax)
jmp 0x8086e
| mi_open_keyfile:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov rbx, rdi
lea rax, mi_key_file_kfile
mov esi, [rax]
mov r15, [rdi+258h]
mov r14d, offset loc_A0000
or r14d, [rdi+358h]
lea r13, PSI_server
mov rax, [r13+0]
lea rdi, [rbp+var_78]
lea r12, [rbp+var_30]
mov edx, 2
mov rcx, r15
mov r8, r12
call qword ptr [rax+148h]
mov [r12], rax
test rax, rax
jnz short loc_8088B
mov edx, 210h
mov rdi, r15
mov esi, r14d
call my_open
mov r14d, eax
loc_8086E:
mov [rbx+350h], r14d
shr r14d, 1Fh
mov eax, r14d
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_8088B:
mov rcx, [r13+0]
lea rsi, aWorkspaceLlm4b_17; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, rax
mov edx, 504h
call qword ptr [rcx+1F0h]
mov edx, 210h
mov rdi, r15
mov esi, r14d
call my_open
mov r14d, eax
mov rax, [r13+0]
mov rdi, [rbp+var_30]
mov esi, r14d
call qword ptr [rax+200h]
jmp short loc_8086E
| long long mi_open_keyfile(long long a1)
{
long long v1; // r15
unsigned int v2; // r14d
long long v3; // rax
long long v4; // r14
_BYTE v6[72]; // [rsp+8h] [rbp-78h] BYREF
long long v7[6]; // [rsp+50h] [rbp-30h] BYREF
v1 = *(_QWORD *)(a1 + 600);
v2 = *(_DWORD *)(a1 + 856) | (unsigned int)&loc_A0000;
v3 = ((long long ( *)(_BYTE *, _QWORD, long long, long long, long long *))PSI_server[41])(
v6,
mi_key_file_kfile,
2LL,
v1,
v7);
v7[0] = v3;
if ( v3 )
{
((void ( *)(long long, const char *, long long))PSI_server[62])(
v3,
"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_open.c",
1284LL);
v4 = (unsigned int)my_open(v1, v2, 528LL);
((void ( *)(long long, long long))PSI_server[64])(v7[0], v4);
}
else
{
LODWORD(v4) = my_open(v1, v2, 528LL);
}
*(_DWORD *)(a1 + 848) = v4;
return (unsigned int)v4 >> 31;
}
| mi_open_keyfile:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
LEA RAX,[0xcff9dc]
MOV ESI,dword ptr [RAX]
MOV R15,qword ptr [RDI + 0x258]
MOV R14D,0xa0000
OR R14D,dword ptr [RDI + 0x358]
LEA R13,[0x486010]
MOV RAX,qword ptr [R13]
LEA RDI,[RBP + -0x78]
LEA R12,[RBP + -0x30]
MOV EDX,0x2
MOV RCX,R15
MOV R8,R12
CALL qword ptr [RAX + 0x148]
MOV qword ptr [R12],RAX
TEST RAX,RAX
JNZ 0x0018088b
MOV EDX,0x210
MOV RDI,R15
MOV ESI,R14D
CALL 0x001a03e0
MOV R14D,EAX
LAB_0018086e:
MOV dword ptr [RBX + 0x350],R14D
SHR R14D,0x1f
MOV EAX,R14D
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0018088b:
MOV RCX,qword ptr [R13]
LEA RSI,[0x1dbd07]
MOV RDI,RAX
MOV EDX,0x504
CALL qword ptr [RCX + 0x1f0]
MOV EDX,0x210
MOV RDI,R15
MOV ESI,R14D
CALL 0x001a03e0
MOV R14D,EAX
MOV RAX,qword ptr [R13]
MOV RDI,qword ptr [RBP + -0x30]
MOV ESI,R14D
CALL qword ptr [RAX + 0x200]
JMP 0x0018086e
|
uint mi_open_keyfile(long param_1)
{
int8 uVar1;
uint uVar2;
int1 local_80 [72];
long local_38;
uVar1 = *(int8 *)(param_1 + 600);
uVar2 = *(uint *)(param_1 + 0x358) | 0xa0000;
local_38 = (**(code **)(PSI_server + 0x148))(local_80,mi_key_file_kfile,2,uVar1,&local_38);
if (local_38 == 0) {
uVar2 = my_open(uVar1,uVar2,0x210);
}
else {
(**(code **)(PSI_server + 0x1f0))
(local_38,"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_open.c",0x504);
uVar2 = my_open(uVar1,uVar2,0x210);
(**(code **)(PSI_server + 0x200))(local_38,uVar2);
}
*(uint *)(param_1 + 0x350) = uVar2;
return uVar2 >> 0x1f;
}
| |
23,962 | init_huff_count | eloqsql/storage/myisam/myisampack.c | static HUFF_COUNTS *init_huff_count(MI_INFO *info,my_off_t records)
{
reg2 uint i;
reg1 HUFF_COUNTS *count;
if ((count = (HUFF_COUNTS*) my_malloc(PSI_NOT_INSTRUMENTED, info->s->base.fields*
sizeof(HUFF_COUNTS),
MYF(MY_ZEROFILL | MY_WME))))
{
for (i=0 ; i < info->s->base.fields ; i++)
{
enum en_fieldtype type;
count[i].field_length=info->s->rec[i].length;
type= count[i].field_type= (enum en_fieldtype) info->s->rec[i].type;
if (type == FIELD_INTERVALL ||
type == FIELD_CONSTANT ||
type == FIELD_ZERO)
type = FIELD_NORMAL;
if (count[i].field_length <= 8 &&
(type == FIELD_NORMAL ||
type == FIELD_SKIP_ZERO))
count[i].max_zero_fill= count[i].field_length;
/*
For every column initialize a tree, which is used to detect distinct
column values. 'int_tree' works together with 'tree_buff' and
'tree_pos'. It's keys are implemented by pointers into 'tree_buff'.
This is accomplished by '-1' as the element size.
*/
init_tree(&count[i].int_tree,0,0,-1,(qsort_cmp2) compare_tree, NULL,
NULL, MYF(0));
if (records && type != FIELD_BLOB && type != FIELD_VARCHAR)
count[i].tree_pos=count[i].tree_buff =
my_malloc(PSI_NOT_INSTRUMENTED, count[i].field_length > 1 ? tree_buff_length : 2,
MYF(MY_WME));
}
}
return count;
} | O0 | c | init_huff_count:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0xb88, 0x168(%rax), %rsi # imm = 0xB88
xorl %edi, %edi
movl $0x30, %edx
callq 0x8a930
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x2b0f7
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpq 0x168(%rcx), %rax
jae 0x2b0f5
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x230(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movzwl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %edx
imulq $0xb88, %rdx, %rdx # imm = 0xB88
addq %rdx, %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x230(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %edx
imulq $0xb88, %rdx, %rdx # imm = 0xB88
addq %rdx, %rcx
movl %eax, 0x28(%rcx)
movl %eax, -0x24(%rbp)
cmpl $0x6, -0x24(%rbp)
je 0x2afcc
cmpl $0x5, -0x24(%rbp)
je 0x2afcc
cmpl $0x7, -0x24(%rbp)
jne 0x2afd3
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
imulq $0xb88, %rcx, %rcx # imm = 0xB88
addq %rcx, %rax
cmpl $0x8, (%rax)
ja 0x2b01c
cmpl $0x0, -0x24(%rbp)
je 0x2aff5
cmpl $0x3, -0x24(%rbp)
jne 0x2b01c
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
imulq $0xb88, %rcx, %rcx # imm = 0xB88
addq %rcx, %rax
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %edx
imulq $0xb88, %rdx, %rdx # imm = 0xB88
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
imulq $0xb88, %rax, %rax # imm = 0xB88
addq %rax, %rdi
addq $0x8e0, %rdi # imm = 0x8E0
xorl %eax, %eax
movl %eax, %r9d
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
leaq 0x3a0b(%rip), %r8 # 0x2ea50
movq %r9, %rsi
movq %r9, %rdx
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0x91920
cmpq $0x0, -0x10(%rbp)
je 0x2b0e5
cmpl $0x4, -0x24(%rbp)
je 0x2b0e5
cmpl $0x8, -0x24(%rbp)
je 0x2b0e5
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
imulq $0xb88, %rcx, %rcx # imm = 0xB88
addq %rcx, %rax
cmpl $0x1, (%rax)
jbe 0x2b095
movl 0x219544(%rip), %eax # 0x2445d4
movl %eax, -0x28(%rbp)
jmp 0x2b09f
movl $0x2, %eax
movl %eax, -0x28(%rbp)
jmp 0x2b09f
movl -0x28(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
xorl %edi, %edi
movl $0x10, %edx
callq 0x8a930
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %edx
imulq $0xb88, %rdx, %rdx # imm = 0xB88
addq %rdx, %rax
movq %rcx, 0xb78(%rax)
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %edx
imulq $0xb88, %rdx, %rdx # imm = 0xB88
addq %rdx, %rax
movq %rcx, 0xb80(%rax)
jmp 0x2b0e7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2af43
jmp 0x2b0f7
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| init_huff_count:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov rax, [rax]
imul rsi, [rax+168h], 0B88h
xor edi, edi
mov edx, 30h ; '0'
call my_malloc
mov [rbp+var_20], rax
cmp rax, 0
jz loc_2B0F7
mov [rbp+var_14], 0
loc_2AF43:
mov eax, [rbp+var_14]
mov rcx, [rbp+var_8]
mov rcx, [rcx]
cmp rax, [rcx+168h]
jnb loc_2B0F5
mov rax, [rbp+var_8]
mov rax, [rax]
mov rax, [rax+230h]
mov ecx, [rbp+var_14]
imul rcx, 30h ; '0'
add rax, rcx
movzx ecx, word ptr [rax+4]
mov rax, [rbp+var_20]
mov edx, [rbp+var_14]
imul rdx, 0B88h
add rax, rdx
mov [rax], ecx
mov rax, [rbp+var_8]
mov rax, [rax]
mov rax, [rax+230h]
mov ecx, [rbp+var_14]
imul rcx, 30h ; '0'
add rax, rcx
mov eax, [rax]
mov rcx, [rbp+var_20]
mov edx, [rbp+var_14]
imul rdx, 0B88h
add rcx, rdx
mov [rcx+28h], eax
mov [rbp+var_24], eax
cmp [rbp+var_24], 6
jz short loc_2AFCC
cmp [rbp+var_24], 5
jz short loc_2AFCC
cmp [rbp+var_24], 7
jnz short loc_2AFD3
loc_2AFCC:
mov [rbp+var_24], 0
loc_2AFD3:
mov rax, [rbp+var_20]
mov ecx, [rbp+var_14]
imul rcx, 0B88h
add rax, rcx
cmp dword ptr [rax], 8
ja short loc_2B01C
cmp [rbp+var_24], 0
jz short loc_2AFF5
cmp [rbp+var_24], 3
jnz short loc_2B01C
loc_2AFF5:
mov rax, [rbp+var_20]
mov ecx, [rbp+var_14]
imul rcx, 0B88h
add rax, rcx
mov ecx, [rax]
mov rax, [rbp+var_20]
mov edx, [rbp+var_14]
imul rdx, 0B88h
add rax, rdx
mov [rax+4], ecx
loc_2B01C:
mov rdi, [rbp+var_20]
mov eax, [rbp+var_14]
imul rax, 0B88h
add rdi, rax
add rdi, 8E0h
xor eax, eax
mov r9d, eax
mov ecx, 0FFFFFFFFh
lea r8, compare_tree
mov rsi, r9
mov rdx, r9
mov [rsp+40h+var_40], 0
mov [rsp+40h+var_38], 0
call init_tree
cmp [rbp+var_10], 0
jz short loc_2B0E5
cmp [rbp+var_24], 4
jz short loc_2B0E5
cmp [rbp+var_24], 8
jz short loc_2B0E5
mov rax, [rbp+var_20]
mov ecx, [rbp+var_14]
imul rcx, 0B88h
add rax, rcx
cmp dword ptr [rax], 1
jbe short loc_2B095
mov eax, cs:tree_buff_length
mov [rbp+var_28], eax
jmp short loc_2B09F
loc_2B095:
mov eax, 2
mov [rbp+var_28], eax
jmp short $+2
loc_2B09F:
mov eax, [rbp+var_28]
mov eax, eax
mov esi, eax
xor edi, edi
mov edx, 10h
call my_malloc
mov rcx, rax
mov rax, [rbp+var_20]
mov edx, [rbp+var_14]
imul rdx, 0B88h
add rax, rdx
mov [rax+0B78h], rcx
mov rax, [rbp+var_20]
mov edx, [rbp+var_14]
imul rdx, 0B88h
add rax, rdx
mov [rax+0B80h], rcx
loc_2B0E5:
jmp short $+2
loc_2B0E7:
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
jmp loc_2AF43
loc_2B0F5:
jmp short $+2
loc_2B0F7:
mov rax, [rbp+var_20]
add rsp, 40h
pop rbp
retn
| long long init_huff_count(long long a1, long long a2)
{
int v2; // eax
long long v3; // rax
unsigned int v5; // [rsp+18h] [rbp-28h]
int v6; // [rsp+1Ch] [rbp-24h]
long long v7; // [rsp+20h] [rbp-20h]
unsigned int i; // [rsp+2Ch] [rbp-14h]
v7 = my_malloc(0LL, 2952LL * *(_QWORD *)(*(_QWORD *)a1 + 360LL), 48LL);
if ( v7 )
{
for ( i = 0; (unsigned long long)i < *(_QWORD *)(*(_QWORD *)a1 + 360LL); ++i )
{
*(_DWORD *)(2952LL * i + v7) = *(unsigned __int16 *)(48LL * i + *(_QWORD *)(*(_QWORD *)a1 + 560LL) + 4);
v2 = *(_DWORD *)(48LL * i + *(_QWORD *)(*(_QWORD *)a1 + 560LL));
*(_DWORD *)(2952LL * i + v7 + 40) = v2;
v6 = v2;
if ( v2 == 6 || v2 == 5 || v2 == 7 )
v6 = 0;
if ( *(_DWORD *)(2952LL * i + v7) <= 8u && (!v6 || v6 == 3) )
*(_DWORD *)(2952LL * i + v7 + 4) = *(_DWORD *)(2952LL * i + v7);
init_tree(2952 * i + v7 + 2272, 0, 0, -1, (unsigned int)compare_tree, 0, 0LL, 0LL);
if ( a2 && v6 != 4 && v6 != 8 )
{
if ( *(_DWORD *)(2952LL * i + v7) <= 1u )
v5 = 2;
else
v5 = tree_buff_length;
v3 = my_malloc(0LL, v5, 16LL);
*(_QWORD *)(2952LL * i + v7 + 2936) = v3;
*(_QWORD *)(2952LL * i + v7 + 2944) = v3;
}
}
}
return v7;
}
| init_huff_count:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
IMUL RSI,qword ptr [RAX + 0x168],0xb88
XOR EDI,EDI
MOV EDX,0x30
CALL 0x0018a930
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JZ 0x0012b0f7
MOV dword ptr [RBP + -0x14],0x0
LAB_0012af43:
MOV EAX,dword ptr [RBP + -0x14]
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX]
CMP RAX,qword ptr [RCX + 0x168]
JNC 0x0012b0f5
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x230]
MOV ECX,dword ptr [RBP + -0x14]
IMUL RCX,RCX,0x30
ADD RAX,RCX
MOVZX ECX,word ptr [RAX + 0x4]
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x14]
IMUL RDX,RDX,0xb88
ADD RAX,RDX
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x230]
MOV ECX,dword ptr [RBP + -0x14]
IMUL RCX,RCX,0x30
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x14]
IMUL RDX,RDX,0xb88
ADD RCX,RDX
MOV dword ptr [RCX + 0x28],EAX
MOV dword ptr [RBP + -0x24],EAX
CMP dword ptr [RBP + -0x24],0x6
JZ 0x0012afcc
CMP dword ptr [RBP + -0x24],0x5
JZ 0x0012afcc
CMP dword ptr [RBP + -0x24],0x7
JNZ 0x0012afd3
LAB_0012afcc:
MOV dword ptr [RBP + -0x24],0x0
LAB_0012afd3:
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x14]
IMUL RCX,RCX,0xb88
ADD RAX,RCX
CMP dword ptr [RAX],0x8
JA 0x0012b01c
CMP dword ptr [RBP + -0x24],0x0
JZ 0x0012aff5
CMP dword ptr [RBP + -0x24],0x3
JNZ 0x0012b01c
LAB_0012aff5:
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x14]
IMUL RCX,RCX,0xb88
ADD RAX,RCX
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x14]
IMUL RDX,RDX,0xb88
ADD RAX,RDX
MOV dword ptr [RAX + 0x4],ECX
LAB_0012b01c:
MOV RDI,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x14]
IMUL RAX,RAX,0xb88
ADD RDI,RAX
ADD RDI,0x8e0
XOR EAX,EAX
MOV R9D,EAX
MOV ECX,0xffffffff
LEA R8,[0x12ea50]
MOV RSI,R9
MOV RDX,R9
MOV qword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],0x0
CALL 0x00191920
CMP qword ptr [RBP + -0x10],0x0
JZ 0x0012b0e5
CMP dword ptr [RBP + -0x24],0x4
JZ 0x0012b0e5
CMP dword ptr [RBP + -0x24],0x8
JZ 0x0012b0e5
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x14]
IMUL RCX,RCX,0xb88
ADD RAX,RCX
CMP dword ptr [RAX],0x1
JBE 0x0012b095
MOV EAX,dword ptr [0x003445d4]
MOV dword ptr [RBP + -0x28],EAX
JMP 0x0012b09f
LAB_0012b095:
MOV EAX,0x2
MOV dword ptr [RBP + -0x28],EAX
JMP 0x0012b09f
LAB_0012b09f:
MOV EAX,dword ptr [RBP + -0x28]
MOV EAX,EAX
MOV ESI,EAX
XOR EDI,EDI
MOV EDX,0x10
CALL 0x0018a930
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x14]
IMUL RDX,RDX,0xb88
ADD RAX,RDX
MOV qword ptr [RAX + 0xb78],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x14]
IMUL RDX,RDX,0xb88
ADD RAX,RDX
MOV qword ptr [RAX + 0xb80],RCX
LAB_0012b0e5:
JMP 0x0012b0e7
LAB_0012b0e7:
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x0012af43
LAB_0012b0f5:
JMP 0x0012b0f7
LAB_0012b0f7:
MOV RAX,qword ptr [RBP + -0x20]
ADD RSP,0x40
POP RBP
RET
|
long init_huff_count(long *param_1,long param_2)
{
long lVar1;
int8 uVar2;
int4 local_30;
int local_2c;
uint local_1c;
lVar1 = my_malloc(0,*(long *)(*param_1 + 0x168) * 0xb88,0x30);
if (lVar1 != 0) {
for (local_1c = 0; (ulong)local_1c < *(ulong *)(*param_1 + 0x168); local_1c = local_1c + 1) {
*(uint *)(lVar1 + (ulong)local_1c * 0xb88) =
(uint)*(ushort *)(*(long *)(*param_1 + 0x230) + (ulong)local_1c * 0x30 + 4);
local_2c = *(int *)(*(long *)(*param_1 + 0x230) + (ulong)local_1c * 0x30);
*(int *)(lVar1 + (ulong)local_1c * 0xb88 + 0x28) = local_2c;
if (((local_2c == 6) || (local_2c == 5)) || (local_2c == 7)) {
local_2c = 0;
}
if ((*(uint *)(lVar1 + (ulong)local_1c * 0xb88) < 9) && ((local_2c == 0 || (local_2c == 3))))
{
*(int4 *)(lVar1 + (ulong)local_1c * 0xb88 + 4) =
*(int4 *)(lVar1 + (ulong)local_1c * 0xb88);
}
init_tree(lVar1 + (ulong)local_1c * 0xb88 + 0x8e0,0,0,0xffffffff,compare_tree,0,0,0);
if (((param_2 != 0) && (local_2c != 4)) && (local_2c != 8)) {
if (*(uint *)(lVar1 + (ulong)local_1c * 0xb88) < 2) {
local_30 = 2;
}
else {
local_30 = tree_buff_length;
}
uVar2 = my_malloc(0,local_30,0x10);
*(int8 *)(lVar1 + (ulong)local_1c * 0xb88 + 0xb78) = uVar2;
*(int8 *)(lVar1 + (ulong)local_1c * 0xb88 + 0xb80) = uVar2;
}
}
}
return lVar1;
}
| |
23,963 | re_parse_group_name | bluesky950520[P]quickjs/libregexp.c | static int re_parse_group_name(char *buf, int buf_size, const uint8_t **pp)
{
const uint8_t *p, *p_next;
uint32_t c, d;
char *q;
p = *pp;
q = buf;
for(;;) {
c = *p++;
if (c == '\\') {
if (*p != 'u')
return -1;
c = lre_parse_escape(&p, 2); // accept surrogate pairs
if ((int)c < 0)
return -1;
} else if (c == '>') {
break;
} else if (c >= 0x80) {
c = utf8_decode(p - 1, &p_next);
if (p_next == p)
return -1;
p = p_next;
if (is_hi_surrogate(c)) {
d = utf8_decode(p, &p_next);
if (is_lo_surrogate(d)) {
c = from_surrogate(c, d);
p = p_next;
}
}
}
if (q == buf) {
if (!lre_js_is_ident_first(c))
return -1;
} else {
if (!lre_js_is_ident_next(c))
return -1;
}
if ((q - buf + UTF8_CHAR_LEN_MAX + 1) > buf_size)
return -1;
if (c < 0x80) {
*q++ = c;
} else {
q += utf8_encode((uint8_t*)q, c);
}
}
if (q == buf)
return -1;
*q = '\0';
*pp = p;
return 0;
} | O0 | c | re_parse_group_name:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rsp)
movzbl (%rax), %eax
movl %eax, 0x14(%rsp)
cmpl $0x5c, 0x14(%rsp)
jne 0x1083ce
movq 0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x75, %eax
je 0x1083a2
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x108558
leaq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x103180
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jge 0x1083c9
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x108558
jmp 0x108474
cmpl $0x3e, 0x14(%rsp)
jne 0x1083da
jmp 0x108525
cmpl $0x80, 0x14(%rsp)
jb 0x108470
movq 0x20(%rsp), %rdi
addq $-0x1, %rdi
leaq 0x18(%rsp), %rsi
callq 0x24e40
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
jne 0x108418
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x108558
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x14(%rsp), %edi
callq 0x103580
cmpl $0x0, %eax
je 0x10846e
movq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x24e40
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %edi
callq 0x1035a0
cmpl $0x0, %eax
je 0x10846c
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
callq 0x1035c0
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x10846e
jmp 0x108470
jmp 0x108472
jmp 0x108474
movq 0x8(%rsp), %rax
cmpq 0x38(%rsp), %rax
jne 0x10849d
movl 0x14(%rsp), %edi
callq 0x1095f0
cmpl $0x0, %eax
jne 0x10849b
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x108558
jmp 0x1084ba
movl 0x14(%rsp), %edi
callq 0x109640
cmpl $0x0, %eax
jne 0x1084b8
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x108558
jmp 0x1084ba
movq 0x8(%rsp), %rax
movq 0x38(%rsp), %rcx
subq %rcx, %rax
addq $0x4, %rax
addq $0x1, %rax
movslq 0x34(%rsp), %rcx
cmpq %rcx, %rax
jle 0x1084e3
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x108558
cmpl $0x80, 0x14(%rsp)
jae 0x108508
movl 0x14(%rsp), %eax
movb %al, %cl
movq 0x8(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rsp)
movb %cl, (%rax)
jmp 0x108520
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x24cd0
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x108369
movq 0x8(%rsp), %rax
cmpq 0x38(%rsp), %rax
jne 0x10853b
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x108558
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
| re_parse_group_name:
sub rsp, 48h
mov [rsp+48h+var_10], rdi
mov [rsp+48h+var_14], esi
mov [rsp+48h+var_20], rdx
mov rax, [rsp+48h+var_20]
mov rax, [rax]
mov [rsp+48h+var_28], rax
mov rax, [rsp+48h+var_10]
mov [rsp+48h+var_40], rax
loc_108369:
mov rax, [rsp+48h+var_28]
mov rcx, rax
add rcx, 1
mov [rsp+48h+var_28], rcx
movzx eax, byte ptr [rax]
mov [rsp+48h+var_34], eax
cmp [rsp+48h+var_34], 5Ch ; '\'
jnz short loc_1083CE
mov rax, [rsp+48h+var_28]
movzx eax, byte ptr [rax]
cmp eax, 75h ; 'u'
jz short loc_1083A2
mov [rsp+48h+var_4], 0FFFFFFFFh
jmp loc_108558
loc_1083A2:
lea rdi, [rsp+48h+var_28]
mov esi, 2
call lre_parse_escape
mov [rsp+48h+var_34], eax
cmp [rsp+48h+var_34], 0
jge short loc_1083C9
mov [rsp+48h+var_4], 0FFFFFFFFh
jmp loc_108558
loc_1083C9:
jmp loc_108474
loc_1083CE:
cmp [rsp+48h+var_34], 3Eh ; '>'
jnz short loc_1083DA
jmp loc_108525
loc_1083DA:
cmp [rsp+48h+var_34], 80h
jb loc_108470
mov rdi, [rsp+48h+var_28]
add rdi, 0FFFFFFFFFFFFFFFFh
lea rsi, [rsp+48h+var_30]
call utf8_decode
mov [rsp+48h+var_34], eax
mov rax, [rsp+48h+var_30]
cmp rax, [rsp+48h+var_28]
jnz short loc_108418
mov [rsp+48h+var_4], 0FFFFFFFFh
jmp loc_108558
loc_108418:
mov rax, [rsp+48h+var_30]
mov [rsp+48h+var_28], rax
mov edi, [rsp+48h+var_34]
call is_hi_surrogate_1
cmp eax, 0
jz short loc_10846E
mov rdi, [rsp+48h+var_28]
lea rsi, [rsp+48h+var_30]
call utf8_decode
mov [rsp+48h+var_38], eax
mov edi, [rsp+48h+var_38]
call is_lo_surrogate_1
cmp eax, 0
jz short loc_10846C
mov edi, [rsp+48h+var_34]
mov esi, [rsp+48h+var_38]
call from_surrogate_1
mov [rsp+48h+var_34], eax
mov rax, [rsp+48h+var_30]
mov [rsp+48h+var_28], rax
loc_10846C:
jmp short $+2
loc_10846E:
jmp short $+2
loc_108470:
jmp short $+2
loc_108472:
jmp short $+2
loc_108474:
mov rax, [rsp+48h+var_40]
cmp rax, [rsp+48h+var_10]
jnz short loc_10849D
mov edi, [rsp+48h+var_34]
call lre_js_is_ident_first_0
cmp eax, 0
jnz short loc_10849B
mov [rsp+48h+var_4], 0FFFFFFFFh
jmp loc_108558
loc_10849B:
jmp short loc_1084BA
loc_10849D:
mov edi, [rsp+48h+var_34]
call lre_js_is_ident_next_0
cmp eax, 0
jnz short loc_1084B8
mov [rsp+48h+var_4], 0FFFFFFFFh
jmp loc_108558
loc_1084B8:
jmp short $+2
loc_1084BA:
mov rax, [rsp+48h+var_40]
mov rcx, [rsp+48h+var_10]
sub rax, rcx
add rax, 4
add rax, 1
movsxd rcx, [rsp+48h+var_14]
cmp rax, rcx
jle short loc_1084E3
mov [rsp+48h+var_4], 0FFFFFFFFh
jmp short loc_108558
loc_1084E3:
cmp [rsp+48h+var_34], 80h
jnb short loc_108508
mov eax, [rsp+48h+var_34]
mov cl, al
mov rax, [rsp+48h+var_40]
mov rdx, rax
add rdx, 1
mov [rsp+48h+var_40], rdx
mov [rax], cl
jmp short loc_108520
loc_108508:
mov rdi, [rsp+48h+var_40]
mov esi, [rsp+48h+var_34]
call utf8_encode
add rax, [rsp+48h+var_40]
mov [rsp+48h+var_40], rax
loc_108520:
jmp loc_108369
loc_108525:
mov rax, [rsp+48h+var_40]
cmp rax, [rsp+48h+var_10]
jnz short loc_10853B
mov [rsp+48h+var_4], 0FFFFFFFFh
jmp short loc_108558
loc_10853B:
mov rax, [rsp+48h+var_40]
mov byte ptr [rax], 0
mov rcx, [rsp+48h+var_28]
mov rax, [rsp+48h+var_20]
mov [rax], rcx
mov [rsp+48h+var_4], 0
loc_108558:
mov eax, [rsp+48h+var_4]
add rsp, 48h
retn
| long long re_parse_group_name(_BYTE *a1, int a2, unsigned __int8 **a3)
{
unsigned __int8 *v3; // rax
_BYTE *v4; // rax
_BYTE *v6; // [rsp+8h] [rbp-40h]
unsigned int v7; // [rsp+10h] [rbp-38h]
unsigned int v8; // [rsp+14h] [rbp-34h]
unsigned __int8 *v9; // [rsp+18h] [rbp-30h] BYREF
unsigned __int8 *v10; // [rsp+20h] [rbp-28h] BYREF
unsigned __int8 **v11; // [rsp+28h] [rbp-20h]
int v12; // [rsp+34h] [rbp-14h]
_BYTE *v13; // [rsp+38h] [rbp-10h]
v13 = a1;
v12 = a2;
v11 = a3;
v10 = *a3;
v6 = a1;
while ( 1 )
{
v3 = v10++;
v8 = *v3;
if ( v8 == 92 )
{
if ( *v10 != 117 )
return (unsigned int)-1;
v8 = lre_parse_escape(&v10, 2);
if ( (v8 & 0x80000000) != 0 )
return (unsigned int)-1;
goto LABEL_15;
}
if ( v8 == 62 )
break;
if ( v8 >= 0x80 )
{
v8 = utf8_decode(v10 - 1, &v9);
if ( v9 == v10 )
return (unsigned int)-1;
v10 = v9;
if ( is_hi_surrogate_1(v8) )
{
v7 = utf8_decode(v10, &v9);
if ( is_lo_surrogate_1(v7) )
{
v8 = from_surrogate_1(v8, v7);
v10 = v9;
}
}
}
LABEL_15:
if ( v6 == v13 )
{
if ( !(unsigned int)lre_js_is_ident_first_0(v8) )
return (unsigned int)-1;
}
else if ( !(unsigned int)lre_js_is_ident_next_0(v8) )
{
return (unsigned int)-1;
}
if ( v6 - v13 + 5 > v12 )
return (unsigned int)-1;
if ( v8 >= 0x80 )
{
v6 += utf8_encode(v6, v8);
}
else
{
v4 = v6++;
*v4 = v8;
}
}
if ( v6 == v13 )
{
return (unsigned int)-1;
}
else
{
*v6 = 0;
*v11 = v10;
return 0;
}
}
| |||
23,964 | re_parse_group_name | bluesky950520[P]quickjs/libregexp.c | static int re_parse_group_name(char *buf, int buf_size, const uint8_t **pp)
{
const uint8_t *p, *p_next;
uint32_t c, d;
char *q;
p = *pp;
q = buf;
for(;;) {
c = *p++;
if (c == '\\') {
if (*p != 'u')
return -1;
c = lre_parse_escape(&p, 2); // accept surrogate pairs
if ((int)c < 0)
return -1;
} else if (c == '>') {
break;
} else if (c >= 0x80) {
c = utf8_decode(p - 1, &p_next);
if (p_next == p)
return -1;
p = p_next;
if (is_hi_surrogate(c)) {
d = utf8_decode(p, &p_next);
if (is_lo_surrogate(d)) {
c = from_surrogate(c, d);
p = p_next;
}
}
}
if (q == buf) {
if (!lre_js_is_ident_first(c))
return -1;
} else {
if (!lre_js_is_ident_next(c))
return -1;
}
if ((q - buf + UTF8_CHAR_LEN_MAX + 1) > buf_size)
return -1;
if (c < 0x80) {
*q++ = c;
} else {
q += utf8_encode((uint8_t*)q, c);
}
}
if (q == buf)
return -1;
*q = '\0';
*pp = p;
return 0;
} | O2 | c | re_parse_group_name:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq %rsp, %r13
pushq $0x2
popq %rbp
movq %rsi, 0x10(%rsp)
movq %rsi, %rax
movq %rdi, %r15
movq (%rax), %rdi
leaq 0x1(%rdi), %r12
movq %r12, (%rsp)
movzbl (%rdi), %ebx
cmpl $0x5c, %ebx
je 0x81f70
cmpl $0x3e, %ebx
je 0x82034
testb %bl, %bl
jns 0x81f8f
leaq 0x8(%rsp), %rsi
callq 0x19b30
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x82022
movl %eax, %ebx
movq %rdi, (%rsp)
andl $0xfffffc00, %eax # imm = 0xFFFFFC00
cmpl $0xd800, %eax # imm = 0xD800
jne 0x81f8f
leaq 0x8(%rsp), %rsi
callq 0x19b30
movl %eax, %ecx
andl $0xfffffc00, %ecx # imm = 0xFFFFFC00
cmpl $0xdc00, %ecx # imm = 0xDC00
jne 0x81f8f
shll $0xa, %ebx
andl $0xffc00, %ebx # imm = 0xFFC00
andl $0x3ff, %eax # imm = 0x3FF
addl %eax, %ebx
addl $0x10000, %ebx # imm = 0x10000
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
jmp 0x81f8f
cmpb $0x75, (%r12)
jne 0x82022
movq %r13, %rdi
movl %ebp, %esi
callq 0x7f4e6
movl %eax, %ebx
testl %eax, %eax
js 0x82022
movq %r15, %r12
subq %r14, %r12
je 0x81faa
cmpl $0x7f, %ebx
ja 0x81fc8
movl %ebx, %eax
shrl $0x5, %eax
leaq 0xb588(%rip), %rcx # 0x8d530
jmp 0x81fbb
cmpl $0x7f, %ebx
ja 0x81fe9
movl %ebx, %eax
shrl $0x5, %eax
leaq 0xb565(%rip), %rcx # 0x8d520
movl (%rcx,%rax,4), %ecx
xorl %eax, %eax
btl %ebx, %ecx
setb %al
jmp 0x81ff0
movl %ebx, %edi
callq 0x832b7
testl %eax, %eax
setne %al
movl %ebx, %ecx
andl $-0x2, %ecx
cmpl $0x200c, %ecx # imm = 0x200C
sete %cl
orb %al, %cl
movzbl %cl, %eax
jmp 0x81ff0
movl %ebx, %edi
callq 0x832a1
testl %eax, %eax
je 0x82022
cmpq $0x7b, %r12
jg 0x82022
cmpl $0x7f, %ebx
ja 0x8200d
movb %bl, (%r15)
incq %r15
movq %r13, %rax
jmp 0x81ee7
movq %r15, %rdi
movl %ebx, %esi
callq 0x19a8f
addq %rax, %r15
movq %r13, %rax
jmp 0x81ee7
pushq $-0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq %r14, %r15
pushq $-0x1
popq %rax
je 0x82025
movb $0x0, (%r15)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
xorl %eax, %eax
jmp 0x82025
| re_parse_group_name:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r14, rdi
mov r13, rsp
push 2
pop rbp
mov [rsp+48h+var_38], rsi
mov rax, rsi
mov r15, rdi
loc_81EE7:
mov rdi, [rax]
lea r12, [rdi+1]
mov [rsp+48h+var_48], r12
movzx ebx, byte ptr [rdi]
cmp ebx, 5Ch ; '\'
jz short loc_81F70
cmp ebx, 3Eh ; '>'
jz loc_82034
test bl, bl
jns loc_81F8F
lea rsi, [rsp+48h+var_40]
call utf8_decode
mov rdi, [rsp+48h+var_40]
cmp rdi, r12
jz loc_82022
mov ebx, eax
mov [rsp+48h+var_48], rdi
and eax, 0FFFFFC00h
cmp eax, 0D800h
jnz short loc_81F8F
lea rsi, [rsp+48h+var_40]
call utf8_decode
mov ecx, eax
and ecx, 0FFFFFC00h
cmp ecx, 0DC00h
jnz short loc_81F8F
shl ebx, 0Ah
and ebx, 0FFC00h
and eax, 3FFh
add ebx, eax
add ebx, 10000h
mov rax, [rsp+48h+var_40]
mov [rsp+48h+var_48], rax
jmp short loc_81F8F
loc_81F70:
cmp byte ptr [r12], 75h ; 'u'
jnz loc_82022
mov rdi, r13
mov esi, ebp
call lre_parse_escape
mov ebx, eax
test eax, eax
js loc_82022
loc_81F8F:
mov r12, r15
sub r12, r14
jz short loc_81FAA
cmp ebx, 7Fh
ja short loc_81FC8
mov eax, ebx
shr eax, 5
lea rcx, lre_id_continue_table_ascii
jmp short loc_81FBB
loc_81FAA:
cmp ebx, 7Fh
ja short loc_81FE9
mov eax, ebx
shr eax, 5
lea rcx, lre_id_start_table_ascii
loc_81FBB:
mov ecx, [rcx+rax*4]
xor eax, eax
bt ecx, ebx
setb al
jmp short loc_81FF0
loc_81FC8:
mov edi, ebx
call lre_is_id_continue
test eax, eax
setnz al
mov ecx, ebx
and ecx, 0FFFFFFFEh
cmp ecx, 200Ch
setz cl
or cl, al
movzx eax, cl
jmp short loc_81FF0
loc_81FE9:
mov edi, ebx
call lre_is_id_start
loc_81FF0:
test eax, eax
jz short loc_82022
cmp r12, 7Bh ; '{'
jg short loc_82022
cmp ebx, 7Fh
ja short loc_8200D
mov [r15], bl
inc r15
mov rax, r13
jmp loc_81EE7
loc_8200D:
mov rdi, r15
mov esi, ebx
call utf8_encode
add r15, rax
mov rax, r13
jmp loc_81EE7
loc_82022:
push 0FFFFFFFFFFFFFFFFh
pop rax
loc_82025:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_82034:
cmp r15, r14
push 0FFFFFFFFFFFFFFFFh
pop rax
jz short loc_82025
mov byte ptr [r15], 0
mov rax, [rsp+48h+var_48]
mov rcx, [rsp+48h+var_38]
mov [rcx], rax
xor eax, eax
jmp short loc_82025
| long long re_parse_group_name(_BYTE *a1, _QWORD *a2)
{
char **v3; // rax
_BYTE *v4; // r15
char *v5; // rdi
unsigned __int8 *v6; // r12
unsigned int v7; // ebx
unsigned int v8; // eax
int v9; // eax
long long v10; // rax
_DWORD *v11; // rcx
int v12; // ecx
int is_id_start; // eax
long long result; // rax
unsigned __int8 *v15; // [rsp+0h] [rbp-48h] BYREF
char *v16; // [rsp+8h] [rbp-40h] BYREF
_QWORD *v17; // [rsp+10h] [rbp-38h]
v17 = a2;
v3 = (char **)a2;
v4 = a1;
while ( 1 )
{
v5 = *v3;
v6 = (unsigned __int8 *)(*v3 + 1);
v15 = v6;
v7 = (unsigned __int8)*v5;
if ( v7 != 92 )
break;
if ( *v6 != 117 )
return -1LL;
v7 = lre_parse_escape(&v15, 2);
if ( (v7 & 0x80000000) != 0 )
return -1LL;
LABEL_11:
if ( v4 == a1 )
{
if ( v7 > 0x7F )
{
is_id_start = lre_is_id_start(v7);
goto LABEL_19;
}
v10 = v7 >> 5;
v11 = lre_id_start_table_ascii;
}
else
{
if ( v7 > 0x7F )
{
is_id_start = (unsigned int)lre_is_id_continue(v7) != 0 || (v7 & 0xFFFFFFFE) == 8204;
goto LABEL_19;
}
v10 = v7 >> 5;
v11 = lre_id_continue_table_ascii;
}
v12 = v11[v10];
is_id_start = _bittest(&v12, v7);
LABEL_19:
if ( !is_id_start || v4 - a1 > 123 )
return -1LL;
if ( v7 > 0x7F )
v4 += utf8_encode(v4, v7);
else
*v4++ = v7;
v3 = (char **)&v15;
}
if ( v7 != 62 )
{
if ( (v7 & 0x80u) != 0 )
{
v8 = utf8_decode(v5, &v16);
if ( v16 == (char *)v6 )
return -1LL;
v7 = v8;
v15 = (unsigned __int8 *)v16;
if ( (v8 & 0xFFFFFC00) == 0xD800 )
{
v9 = utf8_decode(v16, &v16);
if ( (v9 & 0xFFFFFC00) == 0xDC00 )
{
v7 = (v9 & 0x3FF) + ((v7 << 10) & 0xFFC00) + 0x10000;
v15 = (unsigned __int8 *)v16;
}
}
}
goto LABEL_11;
}
result = -1LL;
if ( v4 != a1 )
{
*v4 = 0;
*v17 = v15;
return 0LL;
}
return result;
}
| re_parse_group_name:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R14,RDI
MOV R13,RSP
PUSH 0x2
POP RBP
MOV qword ptr [RSP + 0x10],RSI
MOV RAX,RSI
MOV R15,RDI
LAB_00181ee7:
MOV RDI,qword ptr [RAX]
LEA R12,[RDI + 0x1]
MOV qword ptr [RSP],R12
MOVZX EBX,byte ptr [RDI]
CMP EBX,0x5c
JZ 0x00181f70
CMP EBX,0x3e
JZ 0x00182034
TEST BL,BL
JNS 0x00181f8f
LEA RSI,[RSP + 0x8]
CALL 0x00119b30
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R12
JZ 0x00182022
MOV EBX,EAX
MOV qword ptr [RSP],RDI
AND EAX,0xfffffc00
CMP EAX,0xd800
JNZ 0x00181f8f
LEA RSI,[RSP + 0x8]
CALL 0x00119b30
MOV ECX,EAX
AND ECX,0xfffffc00
CMP ECX,0xdc00
JNZ 0x00181f8f
SHL EBX,0xa
AND EBX,0xffc00
AND EAX,0x3ff
ADD EBX,EAX
ADD EBX,0x10000
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP],RAX
JMP 0x00181f8f
LAB_00181f70:
CMP byte ptr [R12],0x75
JNZ 0x00182022
MOV RDI,R13
MOV ESI,EBP
CALL 0x0017f4e6
MOV EBX,EAX
TEST EAX,EAX
JS 0x00182022
LAB_00181f8f:
MOV R12,R15
SUB R12,R14
JZ 0x00181faa
CMP EBX,0x7f
JA 0x00181fc8
MOV EAX,EBX
SHR EAX,0x5
LEA RCX,[0x18d530]
JMP 0x00181fbb
LAB_00181faa:
CMP EBX,0x7f
JA 0x00181fe9
MOV EAX,EBX
SHR EAX,0x5
LEA RCX,[0x18d520]
LAB_00181fbb:
MOV ECX,dword ptr [RCX + RAX*0x4]
XOR EAX,EAX
BT ECX,EBX
SETC AL
JMP 0x00181ff0
LAB_00181fc8:
MOV EDI,EBX
CALL 0x001832b7
TEST EAX,EAX
SETNZ AL
MOV ECX,EBX
AND ECX,0xfffffffe
CMP ECX,0x200c
SETZ CL
OR CL,AL
MOVZX EAX,CL
JMP 0x00181ff0
LAB_00181fe9:
MOV EDI,EBX
CALL 0x001832a1
LAB_00181ff0:
TEST EAX,EAX
JZ 0x00182022
CMP R12,0x7b
JG 0x00182022
CMP EBX,0x7f
JA 0x0018200d
MOV byte ptr [R15],BL
INC R15
MOV RAX,R13
JMP 0x00181ee7
LAB_0018200d:
MOV RDI,R15
MOV ESI,EBX
CALL 0x00119a8f
ADD R15,RAX
MOV RAX,R13
JMP 0x00181ee7
LAB_00182022:
PUSH -0x1
POP RAX
LAB_00182025:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00182034:
CMP R15,R14
PUSH -0x1
POP RAX
JZ 0x00182025
MOV byte ptr [R15],0x0
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RCX],RAX
XOR EAX,EAX
JMP 0x00182025
|
int8 re_parse_group_name(int1 *param_1,byte **param_2)
{
byte *pbVar1;
byte bVar2;
byte *pbVar3;
uint uVar4;
uint uVar5;
int iVar6;
long lVar7;
int1 *puVar8;
ulong uVar9;
int1 *puVar10;
byte *local_48;
byte *local_40;
long *local_38;
local_38 = (long *)param_2;
puVar10 = param_1;
do {
pbVar3 = *param_2;
pbVar1 = pbVar3 + 1;
local_48 = pbVar1;
bVar2 = *pbVar3;
uVar9 = (ulong)bVar2;
if (bVar2 == 0x5c) {
if (*pbVar1 != 0x75) {
return 0xffffffffffffffff;
}
uVar4 = lre_parse_escape(&local_48,2);
uVar9 = (ulong)uVar4;
if ((int)uVar4 < 0) {
return 0xffffffffffffffff;
}
}
else {
if (bVar2 == 0x3e) {
if (puVar10 != param_1) {
*puVar10 = 0;
*local_38 = (long)pbVar1;
return 0;
}
return 0xffffffffffffffff;
}
if ((char)bVar2 < '\0') {
uVar4 = utf8_decode(pbVar3,&local_40);
if (local_40 == pbVar1) {
return 0xffffffffffffffff;
}
uVar9 = (ulong)uVar4;
local_48 = local_40;
if (((uVar4 & 0xfffffc00) == 0xd800) &&
(uVar5 = utf8_decode(local_40,&local_40), (uVar5 & 0xfffffc00) == 0xdc00)) {
uVar9 = (ulong)((uVar4 & 0x3ff) * 0x400 + (uVar5 & 0x3ff) + 0x10000);
local_48 = local_40;
}
}
}
uVar4 = (uint)uVar9;
if (puVar10 == param_1) {
if (uVar4 < 0x80) {
puVar8 = lre_id_start_table_ascii;
goto LAB_00181fbb;
}
uVar5 = lre_is_id_start(uVar9);
}
else if (uVar4 < 0x80) {
puVar8 = lre_id_continue_table_ascii;
LAB_00181fbb:
uVar5 = (uint)((*(uint *)(puVar8 + (uVar9 >> 5) * 4) >> (uVar4 & 0x1f) & 1) != 0);
}
else {
iVar6 = lre_is_id_continue(uVar9);
uVar5 = (uint)((uVar4 & 0xfffffffe) == 0x200c || iVar6 != 0);
}
if (uVar5 == 0) {
return 0xffffffffffffffff;
}
if (0x7b < (long)puVar10 - (long)param_1) {
return 0xffffffffffffffff;
}
if (uVar4 < 0x80) {
*puVar10 = (char)uVar9;
puVar10 = puVar10 + 1;
param_2 = &local_48;
}
else {
lVar7 = utf8_encode(puVar10,uVar9);
puVar10 = puVar10 + lVar7;
param_2 = &local_48;
}
} while( true );
}
| |
23,965 | re_parse_group_name | bluesky950520[P]quickjs/libregexp.c | static int re_parse_group_name(char *buf, int buf_size, const uint8_t **pp)
{
const uint8_t *p, *p_next;
uint32_t c, d;
char *q;
p = *pp;
q = buf;
for(;;) {
c = *p++;
if (c == '\\') {
if (*p != 'u')
return -1;
c = lre_parse_escape(&p, 2); // accept surrogate pairs
if ((int)c < 0)
return -1;
} else if (c == '>') {
break;
} else if (c >= 0x80) {
c = utf8_decode(p - 1, &p_next);
if (p_next == p)
return -1;
p = p_next;
if (is_hi_surrogate(c)) {
d = utf8_decode(p, &p_next);
if (is_lo_surrogate(d)) {
c = from_surrogate(c, d);
p = p_next;
}
}
}
if (q == buf) {
if (!lre_js_is_ident_first(c))
return -1;
} else {
if (!lre_js_is_ident_next(c))
return -1;
}
if ((q - buf + UTF8_CHAR_LEN_MAX + 1) > buf_size)
return -1;
if (c < 0x80) {
*q++ = c;
} else {
q += utf8_encode((uint8_t*)q, c);
}
}
if (q == buf)
return -1;
*q = '\0';
*pp = p;
return 0;
} | O3 | c | re_parse_group_name:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq %rsp, %r15
movq %rsi, 0x10(%rsp)
movq %rsi, %rax
movq %rdi, %r12
movq (%rax), %rdi
leaq 0x1(%rdi), %rbx
movq %rbx, (%rsp)
movzbl (%rdi), %ebp
cmpl $0x5c, %ebp
je 0x9dde9
cmpl $0x3e, %ebp
je 0x9dea3
testb %bpl, %bpl
jns 0x9de0f
leaq 0x8(%rsp), %rsi
callq 0x20066
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x9debe
movl %eax, %ebp
movq %rdi, (%rsp)
andl $0xfffffc00, %eax # imm = 0xFFFFFC00
cmpl $0xd800, %eax # imm = 0xD800
jne 0x9de0f
leaq 0x8(%rsp), %rsi
callq 0x20066
movl %eax, %ecx
andl $0xfffffc00, %ecx # imm = 0xFFFFFC00
cmpl $0xdc00, %ecx # imm = 0xDC00
jne 0x9de0f
shll $0xa, %ebp
andl $0xffc00, %ebp # imm = 0xFFC00
andl $0x3ff, %eax # imm = 0x3FF
addl %eax, %ebp
addl $0x10000, %ebp # imm = 0x10000
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
jmp 0x9de0f
movl $0xffffffff, %r13d # imm = 0xFFFFFFFF
cmpb $0x75, (%rbx)
jne 0x9dec4
movq %r15, %rdi
movl $0x2, %esi
callq 0x9b087
movl %eax, %ebp
testl %eax, %eax
js 0x9dec4
movq %r12, %r13
subq %r14, %r13
je 0x9de2a
cmpl $0x7f, %ebp
ja 0x9de48
movl %ebp, %eax
shrl $0x5, %eax
leaq 0xc748(%rip), %rcx # 0xaa570
jmp 0x9de3b
cmpl $0x7f, %ebp
ja 0x9de69
movl %ebp, %eax
shrl $0x5, %eax
leaq 0xc725(%rip), %rcx # 0xaa560
movl (%rcx,%rax,4), %ecx
xorl %eax, %eax
btl %ebp, %ecx
setb %al
jmp 0x9de70
movl %ebp, %edi
callq 0x9f284
testl %eax, %eax
setne %al
movl %ebp, %ecx
andl $-0x2, %ecx
cmpl $0x200c, %ecx # imm = 0x200C
sete %cl
orb %al, %cl
movzbl %cl, %eax
jmp 0x9de70
movl %ebp, %edi
callq 0x9f26c
testl %eax, %eax
je 0x9debe
cmpq $0x7b, %r13
jg 0x9debe
cmpl $0x7f, %ebp
ja 0x9de8e
movb %bpl, (%r12)
incq %r12
movq %r15, %rax
jmp 0x9dd5f
movq %r12, %rdi
movl %ebp, %esi
callq 0x1ffc0
addq %rax, %r12
movq %r15, %rax
jmp 0x9dd5f
cmpq %r14, %r12
je 0x9debe
movb $0x0, (%r12)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
xorl %r13d, %r13d
jmp 0x9dec4
movl $0xffffffff, %r13d # imm = 0xFFFFFFFF
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| re_parse_group_name:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r14, rdi
mov r15, rsp
mov [rsp+48h+var_38], rsi
mov rax, rsi
mov r12, rdi
loc_9DD5F:
mov rdi, [rax]
lea rbx, [rdi+1]
mov [rsp+48h+var_48], rbx
movzx ebp, byte ptr [rdi]
cmp ebp, 5Ch ; '\'
jz short loc_9DDE9
cmp ebp, 3Eh ; '>'
jz loc_9DEA3
test bpl, bpl
jns loc_9DE0F
lea rsi, [rsp+48h+var_40]
call utf8_decode
mov rdi, [rsp+48h+var_40]
cmp rdi, rbx
jz loc_9DEBE
mov ebp, eax
mov [rsp+48h+var_48], rdi
and eax, 0FFFFFC00h
cmp eax, 0D800h
jnz short loc_9DE0F
lea rsi, [rsp+48h+var_40]
call utf8_decode
mov ecx, eax
and ecx, 0FFFFFC00h
cmp ecx, 0DC00h
jnz short loc_9DE0F
shl ebp, 0Ah
and ebp, 0FFC00h
and eax, 3FFh
add ebp, eax
add ebp, 10000h
mov rax, [rsp+48h+var_40]
mov [rsp+48h+var_48], rax
jmp short loc_9DE0F
loc_9DDE9:
mov r13d, 0FFFFFFFFh
cmp byte ptr [rbx], 75h ; 'u'
jnz loc_9DEC4
mov rdi, r15
mov esi, 2
call lre_parse_escape
mov ebp, eax
test eax, eax
js loc_9DEC4
loc_9DE0F:
mov r13, r12
sub r13, r14
jz short loc_9DE2A
cmp ebp, 7Fh
ja short loc_9DE48
mov eax, ebp
shr eax, 5
lea rcx, lre_id_continue_table_ascii
jmp short loc_9DE3B
loc_9DE2A:
cmp ebp, 7Fh
ja short loc_9DE69
mov eax, ebp
shr eax, 5
lea rcx, lre_id_start_table_ascii
loc_9DE3B:
mov ecx, [rcx+rax*4]
xor eax, eax
bt ecx, ebp
setb al
jmp short loc_9DE70
loc_9DE48:
mov edi, ebp
call lre_is_id_continue
test eax, eax
setnz al
mov ecx, ebp
and ecx, 0FFFFFFFEh
cmp ecx, 200Ch
setz cl
or cl, al
movzx eax, cl
jmp short loc_9DE70
loc_9DE69:
mov edi, ebp
call lre_is_id_start
loc_9DE70:
test eax, eax
jz short loc_9DEBE
cmp r13, 7Bh ; '{'
jg short loc_9DEBE
cmp ebp, 7Fh
ja short loc_9DE8E
mov [r12], bpl
inc r12
mov rax, r15
jmp loc_9DD5F
loc_9DE8E:
mov rdi, r12
mov esi, ebp
call utf8_encode
add r12, rax
mov rax, r15
jmp loc_9DD5F
loc_9DEA3:
cmp r12, r14
jz short loc_9DEBE
mov byte ptr [r12], 0
mov rax, [rsp+48h+var_48]
mov rcx, [rsp+48h+var_38]
mov [rcx], rax
xor r13d, r13d
jmp short loc_9DEC4
loc_9DEBE:
mov r13d, 0FFFFFFFFh
loc_9DEC4:
mov eax, r13d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long re_parse_group_name(_BYTE *a1, _QWORD *a2)
{
char **v3; // rax
_BYTE *v4; // r12
char *v5; // rdi
unsigned __int8 *v6; // rbx
unsigned int v7; // ebp
unsigned int v8; // eax
int v9; // eax
unsigned int v10; // r13d
long long v11; // rax
unsigned int *v12; // rcx
unsigned int v13; // ecx
int is_id_start; // eax
unsigned __int8 *v16; // [rsp+0h] [rbp-48h] BYREF
char *v17; // [rsp+8h] [rbp-40h] BYREF
_QWORD *v18; // [rsp+10h] [rbp-38h]
v18 = a2;
v3 = (char **)a2;
v4 = a1;
while ( 1 )
{
v5 = *v3;
v6 = (unsigned __int8 *)(*v3 + 1);
v16 = v6;
v7 = (unsigned __int8)*v5;
if ( v7 == 92 )
{
v10 = -1;
if ( *v6 != 117 )
return v10;
v7 = lre_parse_escape(&v16, 2);
if ( (v7 & 0x80000000) != 0 )
return v10;
goto LABEL_11;
}
if ( v7 == 62 )
break;
if ( (v7 & 0x80u) != 0 )
{
v8 = utf8_decode(v5, &v17);
if ( v17 == (char *)v6 )
return (unsigned int)-1;
v7 = v8;
v16 = (unsigned __int8 *)v17;
if ( (v8 & 0xFFFFFC00) == 0xD800 )
{
v9 = utf8_decode(v17, &v17);
if ( (v9 & 0xFFFFFC00) == 0xDC00 )
{
v7 = (v9 & 0x3FF) + ((v7 << 10) & 0xFFC00) + 0x10000;
v16 = (unsigned __int8 *)v17;
}
}
}
LABEL_11:
if ( v4 == a1 )
{
if ( v7 > 0x7F )
{
is_id_start = lre_is_id_start(v7);
goto LABEL_19;
}
v11 = v7 >> 5;
v12 = lre_id_start_table_ascii;
}
else
{
if ( v7 > 0x7F )
{
is_id_start = (unsigned int)lre_is_id_continue(v7) != 0 || (v7 & 0xFFFFFFFE) == 8204;
goto LABEL_19;
}
v11 = v7 >> 5;
v12 = lre_id_continue_table_ascii;
}
v13 = v12[v11];
is_id_start = _bittest((const int *)&v13, v7);
LABEL_19:
if ( !is_id_start || v4 - a1 > 123 )
return (unsigned int)-1;
if ( v7 > 0x7F )
v4 += utf8_encode(v4, v7);
else
*v4++ = v7;
v3 = (char **)&v16;
}
if ( v4 != a1 )
{
*v4 = 0;
*v18 = v16;
return 0;
}
return (unsigned int)-1;
}
| re_parse_group_name:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R14,RDI
MOV R15,RSP
MOV qword ptr [RSP + 0x10],RSI
MOV RAX,RSI
MOV R12,RDI
LAB_0019dd5f:
MOV RDI,qword ptr [RAX]
LEA RBX,[RDI + 0x1]
MOV qword ptr [RSP],RBX
MOVZX EBP,byte ptr [RDI]
CMP EBP,0x5c
JZ 0x0019dde9
CMP EBP,0x3e
JZ 0x0019dea3
TEST BPL,BPL
JNS 0x0019de0f
LEA RSI,[RSP + 0x8]
CALL 0x00120066
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,RBX
JZ 0x0019debe
MOV EBP,EAX
MOV qword ptr [RSP],RDI
AND EAX,0xfffffc00
CMP EAX,0xd800
JNZ 0x0019de0f
LEA RSI,[RSP + 0x8]
CALL 0x00120066
MOV ECX,EAX
AND ECX,0xfffffc00
CMP ECX,0xdc00
JNZ 0x0019de0f
SHL EBP,0xa
AND EBP,0xffc00
AND EAX,0x3ff
ADD EBP,EAX
ADD EBP,0x10000
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP],RAX
JMP 0x0019de0f
LAB_0019dde9:
MOV R13D,0xffffffff
CMP byte ptr [RBX],0x75
JNZ 0x0019dec4
MOV RDI,R15
MOV ESI,0x2
CALL 0x0019b087
MOV EBP,EAX
TEST EAX,EAX
JS 0x0019dec4
LAB_0019de0f:
MOV R13,R12
SUB R13,R14
JZ 0x0019de2a
CMP EBP,0x7f
JA 0x0019de48
MOV EAX,EBP
SHR EAX,0x5
LEA RCX,[0x1aa570]
JMP 0x0019de3b
LAB_0019de2a:
CMP EBP,0x7f
JA 0x0019de69
MOV EAX,EBP
SHR EAX,0x5
LEA RCX,[0x1aa560]
LAB_0019de3b:
MOV ECX,dword ptr [RCX + RAX*0x4]
XOR EAX,EAX
BT ECX,EBP
SETC AL
JMP 0x0019de70
LAB_0019de48:
MOV EDI,EBP
CALL 0x0019f284
TEST EAX,EAX
SETNZ AL
MOV ECX,EBP
AND ECX,0xfffffffe
CMP ECX,0x200c
SETZ CL
OR CL,AL
MOVZX EAX,CL
JMP 0x0019de70
LAB_0019de69:
MOV EDI,EBP
CALL 0x0019f26c
LAB_0019de70:
TEST EAX,EAX
JZ 0x0019debe
CMP R13,0x7b
JG 0x0019debe
CMP EBP,0x7f
JA 0x0019de8e
MOV byte ptr [R12],BPL
INC R12
MOV RAX,R15
JMP 0x0019dd5f
LAB_0019de8e:
MOV RDI,R12
MOV ESI,EBP
CALL 0x0011ffc0
ADD R12,RAX
MOV RAX,R15
JMP 0x0019dd5f
LAB_0019dea3:
CMP R12,R14
JZ 0x0019debe
MOV byte ptr [R12],0x0
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RCX],RAX
XOR R13D,R13D
JMP 0x0019dec4
LAB_0019debe:
MOV R13D,0xffffffff
LAB_0019dec4:
MOV EAX,R13D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 re_parse_group_name(int1 *param_1,byte **param_2)
{
byte *pbVar1;
byte bVar2;
byte *pbVar3;
uint uVar4;
uint uVar5;
int iVar6;
long lVar7;
int1 *puVar8;
ulong uVar9;
int1 *puVar10;
byte *local_48;
byte *local_40;
long *local_38;
local_38 = (long *)param_2;
puVar10 = param_1;
do {
pbVar3 = *param_2;
pbVar1 = pbVar3 + 1;
local_48 = pbVar1;
bVar2 = *pbVar3;
uVar9 = (ulong)bVar2;
if (bVar2 == 0x5c) {
if (*pbVar1 != 0x75) {
return 0xffffffff;
}
uVar4 = lre_parse_escape(&local_48,2);
uVar9 = (ulong)uVar4;
if ((int)uVar4 < 0) {
return 0xffffffff;
}
}
else {
if (bVar2 == 0x3e) {
if (puVar10 == param_1) {
return 0xffffffff;
}
*puVar10 = 0;
*local_38 = (long)pbVar1;
return 0;
}
if ((char)bVar2 < '\0') {
uVar4 = utf8_decode(pbVar3,&local_40);
if (local_40 == pbVar1) {
return 0xffffffff;
}
uVar9 = (ulong)uVar4;
local_48 = local_40;
if (((uVar4 & 0xfffffc00) == 0xd800) &&
(uVar5 = utf8_decode(local_40,&local_40), (uVar5 & 0xfffffc00) == 0xdc00)) {
uVar9 = (ulong)((uVar4 & 0x3ff) * 0x400 + (uVar5 & 0x3ff) + 0x10000);
local_48 = local_40;
}
}
}
uVar4 = (uint)uVar9;
if (puVar10 == param_1) {
if (uVar4 < 0x80) {
puVar8 = lre_id_start_table_ascii;
goto LAB_0019de3b;
}
uVar5 = lre_is_id_start(uVar9);
}
else if (uVar4 < 0x80) {
puVar8 = lre_id_continue_table_ascii;
LAB_0019de3b:
uVar5 = (uint)((*(uint *)(puVar8 + (uVar9 >> 5) * 4) >> (uVar4 & 0x1f) & 1) != 0);
}
else {
iVar6 = lre_is_id_continue(uVar9);
uVar5 = (uint)((uVar4 & 0xfffffffe) == 0x200c || iVar6 != 0);
}
if (uVar5 == 0) {
return 0xffffffff;
}
if (0x7b < (long)puVar10 - (long)param_1) {
return 0xffffffff;
}
if (uVar4 < 0x80) {
*puVar10 = (char)uVar9;
puVar10 = puVar10 + 1;
param_2 = &local_48;
}
else {
lVar7 = utf8_encode(puVar10,uVar9);
puVar10 = puVar10 + lVar7;
param_2 = &local_48;
}
} while( true );
}
| |
23,966 | void nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2<double>(char*, int&, int&, double) | monkey531[P]llama/common/json.hpp | JSON_HEDLEY_NON_NULL(1)
void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
{
static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
"internal error: not enough precision");
JSON_ASSERT(std::isfinite(value));
JSON_ASSERT(value > 0);
// If the neighbors (and boundaries) of 'value' are always computed for double-precision
// numbers, all float's can be recovered using strtod (and strtof). However, the resulting
// decimal representations are not exactly "short".
//
// The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars)
// says "value is converted to a string as if by std::sprintf in the default ("C") locale"
// and since sprintf promotes floats to doubles, I think this is exactly what 'std::to_chars'
// does.
// On the other hand, the documentation for 'std::to_chars' requires that "parsing the
// representation using the corresponding std::from_chars function recovers value exactly". That
// indicates that single precision floating-point numbers should be recovered using
// 'std::strtof'.
//
// NB: If the neighbors are computed for single-precision numbers, there is a single float
// (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision
// value is off by 1 ulp.
#if 0 // NOLINT(readability-avoid-unconditional-preprocessor-if)
const boundaries w = compute_boundaries(static_cast<double>(value));
#else
const boundaries w = compute_boundaries(value);
#endif
grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
} | O3 | cpp | void nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2<double>(char*, int&, int&, double):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jge 0x7c459
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x7c475
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x7c712
movq 0x10(%r12), %rcx
movl 0x18(%r12), %r8d
movups (%r12), %xmm0
movups 0x20(%r12), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7c86b
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2e33d(%rip), %rdi # 0xaa79d
leaq 0x2cb0a(%rip), %rdx # 0xa8f71
leaq 0x30e71(%rip), %rcx # 0xad2df
movl $0x4589, %esi # imm = 0x4589
jmp 0x7c48f
leaq 0x2e321(%rip), %rdi # 0xaa79d
leaq 0x2caee(%rip), %rdx # 0xa8f71
leaq 0x30f6e(%rip), %rcx # 0xad3f8
movl $0x458a, %esi # imm = 0x458A
xorl %eax, %eax
callq 0x18af0
| _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl6grisu2IdEEvPcRiS5_T_:
push r15
push r14
push r12
push rbx
sub rsp, 58h
movq rax, xmm0
btr rax, 3Fh ; '?'
mov rcx, 7FF0000000000000h
cmp rax, rcx
jge short loc_7C459
xorpd xmm1, xmm1
ucomisd xmm0, xmm1
jbe short loc_7C475
mov rbx, rdx
mov r14, rsi
mov r15, rdi
lea r12, [rsp+78h+var_50]
mov rdi, r12
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl18compute_boundariesIdEENS2_10boundariesET_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::compute_boundaries<double>(double)
mov rcx, [r12+10h]
mov r8d, [r12+18h]
movups xmm0, xmmword ptr [r12]
movups xmm1, xmmword ptr [r12+20h]
movups [rsp+78h+var_68], xmm1
movups [rsp+78h+var_78], xmm0
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl6grisu2EPcRiS4_NS2_5diyfpES5_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(char *,int &,int &,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp)
add rsp, 58h
pop rbx
pop r12
pop r14
pop r15
retn
loc_7C459:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aStdIsfiniteVal; "std::isfinite(value)"
mov esi, 4589h
jmp short loc_7C48F
loc_7C475:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aValue0; "value > 0"
mov esi, 458Ah
loc_7C48F:
xor eax, eax
call _ggml_abort
| long long nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2<double>(
long long a1,
long long a2,
long long a3,
double a4)
{
long long v5; // r9
char *v7; // rsi
int v8; // edx
int v9; // ecx
int v10; // r8d
int v11; // r9d
_QWORD v12[3]; // [rsp+28h] [rbp-50h] BYREF
unsigned int v13; // [rsp+40h] [rbp-38h]
long long v14; // [rsp+48h] [rbp-30h]
long long v15; // [rsp+50h] [rbp-28h]
if ( (*(_QWORD *)&a4 & 0x7FFFFFFFFFFFFFFFuLL) >= 0x7FF0000000000000LL )
{
v7 = (_BYTE *)(&stru_4578 + 17);
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17801LL,
"GGML_ASSERT(%s) failed",
"std::isfinite(value)");
}
else
{
if ( a4 > 0.0 )
{
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::compute_boundaries<double>(v12);
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(
a1,
a2,
a3,
v12[2],
v13,
v5,
v12[0],
v12[1],
v14,
v15);
}
v7 = (_BYTE *)(&stru_4578 + 18);
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17802LL,
"GGML_ASSERT(%s) failed",
"value > 0");
}
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::format_buffer(
(nlohmann::json_abi_v3_11_3::detail::dtoa_impl *)"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
v7,
v8,
v9,
v10,
v11);
}
| grisu2<double>:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x58
MOVQ RAX,XMM0
BTR RAX,0x3f
MOV RCX,0x7ff0000000000000
CMP RAX,RCX
JGE 0x0017c459
XORPD XMM1,XMM1
UCOMISD XMM0,XMM1
JBE 0x0017c475
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
LEA R12,[RSP + 0x28]
MOV RDI,R12
CALL 0x0017c712
MOV RCX,qword ptr [R12 + 0x10]
MOV R8D,dword ptr [R12 + 0x18]
MOVUPS XMM0,xmmword ptr [R12]
MOVUPS XMM1,xmmword ptr [R12 + 0x20]
MOVUPS xmmword ptr [RSP + 0x10],XMM1
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x0017c86b
ADD RSP,0x58
POP RBX
POP R12
POP R14
POP R15
RET
LAB_0017c459:
LEA RDI,[0x1aa79d]
LEA RDX,[0x1a8f71]
LEA RCX,[0x1ad2df]
MOV ESI,0x4589
JMP 0x0017c48f
LAB_0017c475:
LEA RDI,[0x1aa79d]
LEA RDX,[0x1a8f71]
LEA RCX,[0x1ad3f8]
MOV ESI,0x458a
LAB_0017c48f:
XOR EAX,EAX
CALL 0x00118af0
|
/* void nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2<double>(char*, int&, int&, double) */
void nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2<double>
(char *param_1,int *param_2,int *param_3,double param_4)
{
char *pcVar1;
int8 uVar2;
int8 in_R9;
int4 local_50 [2];
int4 uStack_48;
int8 local_40;
int4 local_38;
int4 local_30;
int4 uStack_28;
if ((ulong)ABS(param_4) < 0x7ff0000000000000) {
if (0.0 < param_4) {
compute_boundaries<double>((dtoa_impl *)local_50,param_4);
grisu2(param_1,param_2,param_3,local_40,local_38,in_R9,local_50[0],uStack_48,local_30,
uStack_28);
return;
}
pcVar1 = "value > 0";
uVar2 = 0x458a;
}
else {
pcVar1 = "std::isfinite(value)";
uVar2 = 0x4589;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",uVar2,
"GGML_ASSERT(%s) failed",pcVar1);
}
| |
23,967 | nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::hex_bytes(unsigned char) | monkey531[P]llama/common/./json.hpp | static std::string hex_bytes(std::uint8_t byte)
{
std::string result = "FF";
constexpr const char* nibble_to_hex = "0123456789ABCDEF";
result[0] = nibble_to_hex[byte / 16];
result[1] = nibble_to_hex[byte % 16];
return result;
} | O1 | cpp | nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::hex_bytes(unsigned char):
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
leaq 0x531c0(%rip), %rsi # 0xbbe85
leaq 0x531bb(%rip), %rdx # 0xbbe87
callq 0x5abde
movl %ebx, %eax
shrl $0x4, %eax
leaq 0x57297(%rip), %rcx # 0xbff74
movb (%rax,%rcx), %al
movq (%r14), %rdx
movb %al, (%rdx)
andl $0xf, %ebx
movb (%rbx,%rcx), %al
movq (%r14), %rcx
movb %al, 0x1(%rcx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE9hex_bytesEh:
push r14
push rbx
push rax
mov ebx, esi
mov r14, rdi
lea rax, [rdi+10h]
mov [rdi], rax
lea rsi, aInvalidStringS_0+41h; "FF"
lea rdx, aInvalidStringS_0+43h; ""
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov eax, ebx
shr eax, 4
lea rcx, a0123456789abcd; "0123456789ABCDEF"
mov al, [rax+rcx]
mov rdx, [r14]
mov [rdx], al
and ebx, 0Fh
mov al, [rbx+rcx]
mov rcx, [r14]
mov [rcx+1], al
mov rax, r14
add rsp, 8
pop rbx
pop r14
retn
| _QWORD * nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::hex_bytes(
_QWORD *a1,
unsigned int a2)
{
*a1 = a1 + 2;
std::string::_M_construct<char const*>(a1, "FF", (long long)"");
*(_BYTE *)*a1 = a0123456789abcd[a2 >> 4];
*(_BYTE *)(*a1 + 1LL) = a0123456789abcd[a2 & 0xF];
return a1;
}
| hex_bytes:
PUSH R14
PUSH RBX
PUSH RAX
MOV EBX,ESI
MOV R14,RDI
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
LEA RSI,[0x1bbe85]
LEA RDX,[0x1bbe87]
CALL 0x0015abde
MOV EAX,EBX
SHR EAX,0x4
LEA RCX,[0x1bff74]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV RDX,qword ptr [R14]
MOV byte ptr [RDX],AL
AND EBX,0xf
MOV AL,byte ptr [RBX + RCX*0x1]
MOV RCX,qword ptr [R14]
MOV byte ptr [RCX + 0x1],AL
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::hex_bytes(unsigned char) */
serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
* __thiscall
nlohmann::json_abi_v3_11_3::detail::
serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::hex_bytes(serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this,uchar param_1)
{
int7 in_register_00000031;
*(serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
**)this = this + 0x10;
std::__cxx11::string::_M_construct<char_const*>(this,"FF","");
**(char **)this = "0123456789ABCDEF"[(CONCAT71(in_register_00000031,param_1) & 0xffffffff) >> 4];
*(char *)(*(long *)this + 1) =
"0123456789ABCDEF"[(uint)CONCAT71(in_register_00000031,param_1) & 0xf];
return this;
}
| |
23,968 | mi_kpointer | eloqsql/storage/myisam/mi_search.c | void _mi_kpointer(register MI_INFO *info, register uchar *buff, my_off_t pos)
{
pos/=MI_MIN_KEY_BLOCK_LENGTH;
switch (info->s->base.key_reflength) {
#if SIZEOF_OFF_T > 4
case 7: mi_int7store(buff,pos); break;
case 6: mi_int6store(buff,pos); break;
case 5: mi_int5store(buff,pos); break;
#else
case 7: *buff++=0;
/* fall through */
case 6: *buff++=0;
/* fall through */
case 5: *buff++=0;
/* fall through */
#endif
case 4: mi_int4store(buff,pos); break;
case 3: mi_int3store(buff,pos); break;
case 2: mi_int2store(buff,(uint) pos); break;
case 1: buff[0]= (uchar) pos; break;
default: abort(); /* impossible */
}
} | O0 | c | mi_kpointer:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0xa, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x17c(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x68(%rbp)
subl $0x6, %eax
ja 0x46d16
movq -0x68(%rbp), %rax
leaq 0x97c37(%rip), %rcx # 0xde730
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x6(%rax)
movq -0x20(%rbp), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x5(%rax)
movq -0x20(%rbp), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x20(%rbp), %rax
shrq $0x18, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x28(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x28(%rbp), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x28(%rbp), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
jmp 0x46d1b
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x5(%rax)
movq -0x30(%rbp), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x30(%rbp), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x30(%rbp), %rax
shrq $0x18, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x38(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x38(%rbp), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
jmp 0x46d1b
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x40(%rbp), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x40(%rbp), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x40(%rbp), %rax
shrq $0x18, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x48(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
jmp 0x46d1b
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x50(%rbp), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x50(%rbp), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x50(%rbp), %rax
shrq $0x18, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
jmp 0x46d1b
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x58(%rbp), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x58(%rbp), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
jmp 0x46d1b
movq -0x18(%rbp), %rax
movl %eax, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x5c(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
jmp 0x46d1b
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
jmp 0x46d1b
callq 0x281e0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _mi_kpointer:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_18]
shr rax, 0Ah
mov [rbp+var_18], rax
mov rax, [rbp+var_8]
mov rax, [rax]
mov eax, [rax+17Ch]
dec eax; switch 7 cases
mov ecx, eax
mov [rbp+var_68], rcx
sub eax, 6
ja def_46B00; jumptable 0000000000046B00 default case
mov rax, [rbp+var_68]
lea rcx, jpt_46B00
movsxd rax, ds:(jpt_46B00 - 0DE730h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_46B02:
mov rax, [rbp+var_18]; jumptable 0000000000046B00 case 7
mov [rbp+var_20], rax
mov rax, [rbp+var_18]
shr rax, 20h
mov [rbp+var_28], rax
mov rax, [rbp+var_20]
mov cl, al
mov rax, [rbp+var_10]
mov [rax+6], cl
mov rax, [rbp+var_20]
shr rax, 8
mov cl, al
mov rax, [rbp+var_10]
mov [rax+5], cl
mov rax, [rbp+var_20]
shr rax, 10h
mov cl, al
mov rax, [rbp+var_10]
mov [rax+4], cl
mov rax, [rbp+var_20]
shr rax, 18h
mov cl, al
mov rax, [rbp+var_10]
mov [rax+3], cl
mov rax, [rbp+var_28]
mov cl, al
mov rax, [rbp+var_10]
mov [rax+2], cl
mov rax, [rbp+var_28]
shr rax, 8
mov cl, al
mov rax, [rbp+var_10]
mov [rax+1], cl
mov rax, [rbp+var_28]
shr rax, 10h
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
jmp loc_46D1B
loc_46B89:
mov rax, [rbp+var_18]; jumptable 0000000000046B00 case 6
mov [rbp+var_30], rax
mov rax, [rbp+var_18]
shr rax, 20h
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
mov cl, al
mov rax, [rbp+var_10]
mov [rax+5], cl
mov rax, [rbp+var_30]
shr rax, 8
mov cl, al
mov rax, [rbp+var_10]
mov [rax+4], cl
mov rax, [rbp+var_30]
shr rax, 10h
mov cl, al
mov rax, [rbp+var_10]
mov [rax+3], cl
mov rax, [rbp+var_30]
shr rax, 18h
mov cl, al
mov rax, [rbp+var_10]
mov [rax+2], cl
mov rax, [rbp+var_38]
mov cl, al
mov rax, [rbp+var_10]
mov [rax+1], cl
mov rax, [rbp+var_38]
shr rax, 8
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
jmp loc_46D1B
loc_46BFF:
mov rax, [rbp+var_18]; jumptable 0000000000046B00 case 5
mov [rbp+var_40], rax
mov rax, [rbp+var_18]
shr rax, 20h
mov [rbp+var_48], rax
mov rax, [rbp+var_40]
mov cl, al
mov rax, [rbp+var_10]
mov [rax+4], cl
mov rax, [rbp+var_40]
shr rax, 8
mov cl, al
mov rax, [rbp+var_10]
mov [rax+3], cl
mov rax, [rbp+var_40]
shr rax, 10h
mov cl, al
mov rax, [rbp+var_10]
mov [rax+2], cl
mov rax, [rbp+var_40]
shr rax, 18h
mov cl, al
mov rax, [rbp+var_10]
mov [rax+1], cl
mov rax, [rbp+var_48]
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
jmp loc_46D1B
loc_46C64:
mov rax, [rbp+var_18]; jumptable 0000000000046B00 case 4
mov [rbp+var_50], rax
mov rax, [rbp+var_50]
mov cl, al
mov rax, [rbp+var_10]
mov [rax+3], cl
mov rax, [rbp+var_50]
shr rax, 8
mov cl, al
mov rax, [rbp+var_10]
mov [rax+2], cl
mov rax, [rbp+var_50]
shr rax, 10h
mov cl, al
mov rax, [rbp+var_10]
mov [rax+1], cl
mov rax, [rbp+var_50]
shr rax, 18h
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
jmp short loc_46D1B
loc_46CAD:
mov rax, [rbp+var_18]; jumptable 0000000000046B00 case 3
mov [rbp+var_58], rax
mov rax, [rbp+var_58]
mov cl, al
mov rax, [rbp+var_10]
mov [rax+2], cl
mov rax, [rbp+var_58]
shr rax, 8
mov cl, al
mov rax, [rbp+var_10]
mov [rax+1], cl
mov rax, [rbp+var_58]
shr rax, 10h
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
jmp short loc_46D1B
loc_46CE5:
mov rax, [rbp+var_18]; jumptable 0000000000046B00 case 2
mov [rbp+var_5C], eax
mov eax, [rbp+var_5C]
mov cl, al
mov rax, [rbp+var_10]
mov [rax+1], cl
mov eax, [rbp+var_5C]
shr eax, 8
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
jmp short loc_46D1B
loc_46D08:
mov rax, [rbp+var_18]; jumptable 0000000000046B00 case 1
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
jmp short loc_46D1B
def_46B00:
call _abort; jumptable 0000000000046B00 default case
loc_46D1B:
add rsp, 70h
pop rbp
retn
| _BYTE * mi_kpointer(long long a1, _BYTE *a2, unsigned long long a3)
{
_BYTE *result; // rax
unsigned long long v4; // [rsp+58h] [rbp-18h]
v4 = a3 >> 10;
switch ( *(_DWORD *)(*(_QWORD *)a1 + 380LL) )
{
case 1:
result = a2;
*a2 = v4;
break;
case 2:
a2[1] = v4;
result = a2;
*a2 = BYTE1(v4);
break;
case 3:
a2[2] = v4;
a2[1] = BYTE1(v4);
result = a2;
*a2 = BYTE2(v4);
break;
case 4:
a2[3] = v4;
a2[2] = BYTE1(v4);
a2[1] = BYTE2(v4);
result = a2;
*a2 = BYTE3(v4);
break;
case 5:
a2[4] = v4;
a2[3] = BYTE1(v4);
a2[2] = BYTE2(v4);
a2[1] = BYTE3(v4);
result = a2;
*a2 = BYTE4(v4);
break;
case 6:
a2[5] = v4;
a2[4] = BYTE1(v4);
a2[3] = BYTE2(v4);
a2[2] = BYTE3(v4);
a2[1] = BYTE4(v4);
result = a2;
*a2 = BYTE5(v4);
break;
case 7:
a2[6] = v4;
a2[5] = BYTE1(v4);
a2[4] = BYTE2(v4);
a2[3] = BYTE3(v4);
a2[2] = BYTE4(v4);
a2[1] = BYTE5(v4);
result = a2;
*a2 = BYTE6(v4);
break;
default:
abort();
}
return result;
}
| _mi_kpointer:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0xa
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x17c]
DEC EAX
MOV ECX,EAX
MOV qword ptr [RBP + -0x68],RCX
SUB EAX,0x6
JA 0x00146d16
MOV RAX,qword ptr [RBP + -0x68]
LEA RCX,[0x1de730]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_7:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x20
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x6],CL
MOV RAX,qword ptr [RBP + -0x20]
SHR RAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x5],CL
MOV RAX,qword ptr [RBP + -0x20]
SHR RAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x4],CL
MOV RAX,qword ptr [RBP + -0x20]
SHR RAX,0x18
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x3],CL
MOV RAX,qword ptr [RBP + -0x28]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x2],CL
MOV RAX,qword ptr [RBP + -0x28]
SHR RAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x28]
SHR RAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
JMP 0x00146d1b
caseD_6:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x20
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x5],CL
MOV RAX,qword ptr [RBP + -0x30]
SHR RAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x4],CL
MOV RAX,qword ptr [RBP + -0x30]
SHR RAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x3],CL
MOV RAX,qword ptr [RBP + -0x30]
SHR RAX,0x18
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x2],CL
MOV RAX,qword ptr [RBP + -0x38]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x38]
SHR RAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
JMP 0x00146d1b
caseD_5:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x20
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x4],CL
MOV RAX,qword ptr [RBP + -0x40]
SHR RAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x3],CL
MOV RAX,qword ptr [RBP + -0x40]
SHR RAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x2],CL
MOV RAX,qword ptr [RBP + -0x40]
SHR RAX,0x18
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x48]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
JMP 0x00146d1b
caseD_4:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x3],CL
MOV RAX,qword ptr [RBP + -0x50]
SHR RAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x2],CL
MOV RAX,qword ptr [RBP + -0x50]
SHR RAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x50]
SHR RAX,0x18
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
JMP 0x00146d1b
caseD_3:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x58]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x2],CL
MOV RAX,qword ptr [RBP + -0x58]
SHR RAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x58]
SHR RAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
JMP 0x00146d1b
caseD_2:
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x5c],EAX
MOV EAX,dword ptr [RBP + -0x5c]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x1],CL
MOV EAX,dword ptr [RBP + -0x5c]
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
JMP 0x00146d1b
caseD_1:
MOV RAX,qword ptr [RBP + -0x18]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
JMP 0x00146d1b
default:
CALL 0x001281e0
LAB_00146d1b:
ADD RSP,0x70
POP RBP
RET
|
void _mi_kpointer(long *param_1,byte *param_2,ulong param_3)
{
byte bVar1;
byte bVar2;
byte bVar3;
byte bVar4;
byte bVar5;
byte bVar6;
ulong uVar7;
uVar7 = param_3 >> 10;
bVar1 = (byte)uVar7;
bVar2 = (byte)(uVar7 >> 8);
bVar3 = (byte)(uVar7 >> 0x10);
bVar4 = (byte)(uVar7 >> 0x18);
bVar5 = (byte)(uVar7 >> 0x20);
bVar6 = (byte)(uVar7 >> 0x28);
switch(*(int4 *)(*param_1 + 0x17c)) {
case 1:
*param_2 = bVar1;
break;
case 2:
param_2[1] = bVar1;
*param_2 = bVar2;
break;
case 3:
param_2[2] = bVar1;
param_2[1] = bVar2;
*param_2 = bVar3;
break;
case 4:
param_2[3] = bVar1;
param_2[2] = bVar2;
param_2[1] = bVar3;
*param_2 = bVar4;
break;
case 5:
param_2[4] = bVar1;
param_2[3] = bVar2;
param_2[2] = bVar3;
param_2[1] = bVar4;
*param_2 = bVar5;
break;
case 6:
param_2[5] = bVar1;
param_2[4] = bVar2;
param_2[3] = bVar3;
param_2[2] = bVar4;
param_2[1] = bVar5;
*param_2 = bVar6;
break;
case 7:
param_2[6] = bVar1;
param_2[5] = bVar2;
param_2[4] = bVar3;
param_2[3] = bVar4;
param_2[2] = bVar5;
param_2[1] = bVar6;
*param_2 = (byte)(param_3 >> 0x3a);
break;
default:
/* WARNING: Subroutine does not return */
abort();
}
return;
}
| |
23,969 | Balloc | eloqsql/strings/dtoa.c | static Bigint *Balloc(int k, Stack_alloc *alloc)
{
Bigint *rv;
DBUG_ASSERT(k <= Kmax);
if (k <= Kmax && alloc->freelist[k])
{
rv= alloc->freelist[k];
alloc->freelist[k]= rv->p.next;
}
else
{
int x, len;
x= 1 << k;
len= MY_ALIGN(sizeof(Bigint) + x * sizeof(ULong), SIZEOF_CHARP);
if (alloc->free + len <= alloc->end)
{
rv= (Bigint*) alloc->free;
alloc->free+= len;
}
else
rv= (Bigint*) malloc(len);
rv->k= k;
rv->maxwds= x;
}
rv->sign= rv->wds= 0;
rv->p.x= (ULong*) (rv + 1);
return rv;
} | O3 | c | Balloc:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
cmpl $0xf, %edi
jg 0x641dd
movslq %ebx, %rcx
movq 0x18(%rsi,%rcx,8), %rax
testq %rax, %rax
je 0x641dd
movq (%rax), %rdx
movq %rdx, 0x18(%rsi,%rcx,8)
jmp 0x64218
movl $0x1, %r14d
movl %ebx, %ecx
shll %cl, %r14d
movl $0x4, %edx
shll %cl, %edx
addl $0x1f, %edx
andl $-0x8, %edx
movq 0x8(%rsi), %rax
movslq %edx, %rdi
leaq (%rax,%rdi), %rcx
cmpq 0x10(%rsi), %rcx
jbe 0x6420d
callq 0x24450
jmp 0x64211
movq %rcx, 0x8(%rsi)
movl %ebx, 0x8(%rax)
movl %r14d, 0xc(%rax)
movq $0x0, 0x10(%rax)
leaq 0x18(%rax), %rcx
movq %rcx, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
| Balloc:
push rbp
mov rbp, rsp
push r14
push rbx
mov ebx, edi
cmp edi, 0Fh
jg short loc_641DD
movsxd rcx, ebx
mov rax, [rsi+rcx*8+18h]
test rax, rax
jz short loc_641DD
mov rdx, [rax]
mov [rsi+rcx*8+18h], rdx
jmp short loc_64218
loc_641DD:
mov r14d, 1
mov ecx, ebx
shl r14d, cl
mov edx, 4
shl edx, cl
add edx, 1Fh
and edx, 0FFFFFFF8h
mov rax, [rsi+8]
movsxd rdi, edx
lea rcx, [rax+rdi]
cmp rcx, [rsi+10h]
jbe short loc_6420D
call _malloc
jmp short loc_64211
loc_6420D:
mov [rsi+8], rcx
loc_64211:
mov [rax+8], ebx
mov [rax+0Ch], r14d
loc_64218:
mov qword ptr [rax+10h], 0
lea rcx, [rax+18h]
mov [rax], rcx
pop rbx
pop r14
pop rbp
retn
| long long Balloc(int a1, long long a2)
{
long long result; // rax
long long v4; // rdi
if ( a1 <= 15 && (result = *(_QWORD *)(a2 + 8LL * a1 + 24)) != 0 )
{
*(_QWORD *)(a2 + 8LL * a1 + 24) = *(_QWORD *)result;
}
else
{
result = *(_QWORD *)(a2 + 8);
v4 = (int)(((4 << a1) + 31) & 0xFFFFFFF8);
if ( (unsigned long long)(result + v4) <= *(_QWORD *)(a2 + 16) )
*(_QWORD *)(a2 + 8) = result + v4;
else
result = malloc(v4);
*(_DWORD *)(result + 8) = a1;
*(_DWORD *)(result + 12) = 1 << a1;
}
*(_QWORD *)(result + 16) = 0LL;
*(_QWORD *)result = result + 24;
return result;
}
| Balloc:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV EBX,EDI
CMP EDI,0xf
JG 0x001641dd
MOVSXD RCX,EBX
MOV RAX,qword ptr [RSI + RCX*0x8 + 0x18]
TEST RAX,RAX
JZ 0x001641dd
MOV RDX,qword ptr [RAX]
MOV qword ptr [RSI + RCX*0x8 + 0x18],RDX
JMP 0x00164218
LAB_001641dd:
MOV R14D,0x1
MOV ECX,EBX
SHL R14D,CL
MOV EDX,0x4
SHL EDX,CL
ADD EDX,0x1f
AND EDX,0xfffffff8
MOV RAX,qword ptr [RSI + 0x8]
MOVSXD RDI,EDX
LEA RCX,[RAX + RDI*0x1]
CMP RCX,qword ptr [RSI + 0x10]
JBE 0x0016420d
CALL 0x00124450
JMP 0x00164211
LAB_0016420d:
MOV qword ptr [RSI + 0x8],RCX
LAB_00164211:
MOV dword ptr [RAX + 0x8],EBX
MOV dword ptr [RAX + 0xc],R14D
LAB_00164218:
MOV qword ptr [RAX + 0x10],0x0
LEA RCX,[RAX + 0x18]
MOV qword ptr [RAX],RCX
POP RBX
POP R14
POP RBP
RET
|
void Balloc(int param_1,long param_2)
{
ulong uVar1;
long *plVar2;
size_t __size;
if (param_1 < 0x10) {
plVar2 = *(long **)(param_2 + 0x18 + (long)param_1 * 8);
if (plVar2 != (long *)0x0) {
*(long *)(param_2 + 0x18 + (long)param_1 * 8) = *plVar2;
goto LAB_00164218;
}
}
plVar2 = *(long **)(param_2 + 8);
__size = (size_t)(int)((4 << ((byte)param_1 & 0x1f)) + 0x1fU & 0xfffffff8);
uVar1 = (long)plVar2 + __size;
if (*(ulong *)(param_2 + 0x10) < uVar1) {
plVar2 = (long *)malloc(__size);
}
else {
*(ulong *)(param_2 + 8) = uVar1;
}
*(int *)(plVar2 + 1) = param_1;
*(int *)((long)plVar2 + 0xc) = 1 << ((byte)param_1 & 0x1f);
LAB_00164218:
plVar2[2] = 0;
*plVar2 = (long)(plVar2 + 3);
return;
}
| |
23,970 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::at<char const (&) [11], 0>(char const (&) [11]) const | monkey531[P]llama/common/./json.hpp | const_reference at(KeyType && key) const
{
// at only works for objects
if (JSON_HEDLEY_UNLIKELY(!is_object()))
{
JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
}
auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
if (it == m_data.m_value.object->end())
{
JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
}
return it->second;
} | 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> 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>::at<char const (&) [11], 0>(char const (&) [11]) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpb $0x1, (%rdi)
jne 0xe50c3
movq %rsi, %r15
movq 0x8(%r14), %r12
movq (%r12), %rbx
movq 0x8(%r12), %rax
cmpq %rax, %rbx
je 0xe50ad
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1a220
testl %eax, %eax
je 0xe50a2
addq $0x30, %rbx
movq 0x8(%r12), %rax
cmpq %rax, %rbx
jne 0xe5083
jmp 0xe50a5
movq %rbx, %rax
movq 0x8(%r14), %rcx
movq 0x8(%rcx), %rbx
cmpq %rbx, %rax
je 0xe5121
addq $0x20, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x1a440
movq %rax, %rbx
movq %r14, %rdi
callq 0x5f708
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0xc5bd(%rip), %rsi # 0xf16a2
leaq 0x20(%rsp), %rdi
callq 0xab6b1
movb $0x1, %bpl
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movl $0x130, %esi # imm = 0x130
movq %r14, %rcx
callq 0x87016
xorl %ebp, %ebp
leaq 0x44e48(%rip), %rsi # 0x129f58
leaq -0x897d9(%rip), %rdx # 0x5b93e
movq %rbx, %rdi
callq 0x1af30
jmp 0xe519a
movl $0x20, %edi
callq 0x1a440
movq %rax, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r15, %rdi
callq 0x1a3e0
leaq (%rax,%r15), %rdx
movq %rsp, %rdi
movq %r15, %rsi
callq 0x22610
leaq 0xc57c(%rip), %rsi # 0xf16d2
leaq 0xc57b(%rip), %rcx # 0xf16d8
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xabc8e
movb $0x1, %bpl
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movl $0x193, %esi # imm = 0x193
movq %r14, %rcx
callq 0xac006
xorl %ebp, %ebp
leaq 0x44d4d(%rip), %rsi # 0x129ed8
leaq -0x89854(%rip), %rdx # 0x5b93e
movq %rbx, %rdi
callq 0x1af30
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe51b8
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a900
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xe5203
movq 0x10(%rsp), %rsi
jmp 0xe51fb
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xe520d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a900
jmp 0xe520d
jmp 0xe520a
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe5203
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a900
testb %bpl, %bpl
jne 0xe520d
jmp 0xe5215
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a680
movq %r14, %rdi
callq 0x1afc0
nop
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA11_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_:
push rbp; char
push r15; int
push r14; int
push r12; int
push rbx; char
sub rsp, 40h
mov r14, rdi
cmp byte ptr [rdi], 1
jnz short loc_E50C3
mov r15, rsi
mov r12, [r14+8]
mov rbx, [r12]
mov rax, [r12+8]
cmp rbx, rax
jz short loc_E50AD
loc_E5083:
mov rdi, rbx
mov rsi, r15
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_E50A2
add rbx, 30h ; '0'
mov rax, [r12+8]
cmp rbx, rax
jnz short loc_E5083
jmp short loc_E50A5
loc_E50A2:
mov rax, rbx
loc_E50A5:
mov rcx, [r14+8]
mov rbx, [rcx+8]
loc_E50AD:
cmp rax, rbx
jz short loc_E5121
add rax, 20h ; ' '
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_E50C3:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
mov rdx, rsp
mov [rdx], rax
lea rsi, aCannotUseAtWit; "cannot use at() with "
lea rdi, [rsp+68h+var_48]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA22_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(char const(&)[22],char const* &&)
mov bpl, 1
lea rdx, [rsp+68h+var_48]
mov rdi, rbx; this
mov esi, 130h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp short loc_E519A
loc_E5121:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r12, [rsp+68h+var_58]
mov [r12-10h], r12
mov rdi, r15
call _strlen
lea rdx, [rax+r15]
mov rdi, rsp
mov rsi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rsi, aKey; "key '"
lea rcx, aNotFound; "' not found"
lea rdi, [rsp+68h+var_48]
mov rdx, rsp
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA6_KcS8_RA12_S9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(char const(&)[6],std::string,char const(&)[12] &&)
mov bpl, 1
lea rdx, [rsp+68h+var_48]
mov rdi, rbx; this
mov esi, 193h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail12out_of_rangeE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_E519A:
mov r14, rax
lea rax, [rsp+68h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_E51B8
mov rsi, [rsp+68h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_E51B8:
mov rdi, [rsp+68h+var_68]
cmp rdi, r12
jz short loc_E5203
mov rsi, [rsp+68h+var_58]
jmp short loc_E51FB
mov r14, rax
mov rdi, [rsp+68h+var_68]; void *
cmp rdi, r12
jz short loc_E520D
mov rsi, [rsp+68h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_E520D
jmp short loc_E520A
mov r14, rax
lea rax, [rsp+68h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_E5203
mov rsi, [rsp+68h+var_38]
loc_E51FB:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_E5203:
test bpl, bpl
jnz short loc_E520D
jmp short loc_E5215
loc_E520A:
mov r14, rax
loc_E520D:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_E5215:
mov rdi, r14
call __Unwind_Resume
| long long ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA11_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_(
long long a1,
_BYTE *a2)
{
long long *v2; // r12
long long v3; // rbx
long long v4; // rax
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
nlohmann::json_abi_v3_11_3::detail::exception *v7; // rbx
long long v8; // rax
void *v9[2]; // [rsp+0h] [rbp-68h] BYREF
long long v10; // [rsp+10h] [rbp-58h] BYREF
_QWORD v11[2]; // [rsp+20h] [rbp-48h] BYREF
if ( *(_BYTE *)a1 != 1 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v9[0] = (void *)nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(
(long long)v11,
(long long)"cannot use at() with ",
v9);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
304,
v11);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
v2 = *(long long **)(a1 + 8);
v3 = *v2;
v4 = v2[1];
if ( *v2 != v4 )
{
while ( (unsigned int)std::string::compare(v3, a2) )
{
v3 += 48LL;
v4 = v2[1];
if ( v3 == v4 )
goto LABEL_7;
}
v4 = v3;
LABEL_7:
v3 = *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL);
}
if ( v4 == v3 )
{
v7 = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v9[0] = &v10;
v8 = strlen(a2);
std::string::_M_construct<char const*>((long long)v9, a2, (long long)&a2[v8]);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(
(long long)v11,
(long long)"key '",
v9,
(long long)"' not found");
ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
v7,
403,
v11);
__cxa_throw(
v7,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::out_of_range,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return v4 + 32;
}
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA11_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
CMP byte ptr [RDI],0x1
JNZ 0x001e50c3
MOV R15,RSI
MOV R12,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [R12]
MOV RAX,qword ptr [R12 + 0x8]
CMP RBX,RAX
JZ 0x001e50ad
LAB_001e5083:
MOV RDI,RBX
MOV RSI,R15
CALL 0x0011a220
TEST EAX,EAX
JZ 0x001e50a2
ADD RBX,0x30
MOV RAX,qword ptr [R12 + 0x8]
CMP RBX,RAX
JNZ 0x001e5083
JMP 0x001e50a5
LAB_001e50a2:
MOV RAX,RBX
LAB_001e50a5:
MOV RCX,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [RCX + 0x8]
LAB_001e50ad:
CMP RAX,RBX
JZ 0x001e5121
ADD RAX,0x20
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001e50c3:
MOV EDI,0x20
CALL 0x0011a440
MOV RBX,RAX
MOV RDI,R14
CALL 0x0015f708
MOV RDX,RSP
MOV qword ptr [RDX],RAX
LAB_001e50de:
LEA RSI,[0x1f16a2]
LEA RDI,[RSP + 0x20]
CALL 0x001ab6b1
MOV BPL,0x1
LAB_001e50f2:
LEA RDX,[RSP + 0x20]
MOV RDI,RBX
MOV ESI,0x130
MOV RCX,R14
CALL 0x00187016
XOR EBP,EBP
LEA RSI,[0x229f58]
LEA RDX,[0x15b93e]
MOV RDI,RBX
CALL 0x0011af30
LAB_001e5121:
MOV EDI,0x20
CALL 0x0011a440
MOV RBX,RAX
LEA R12,[RSP + 0x10]
MOV qword ptr [R12 + -0x10],R12
MOV RDI,R15
CALL 0x0011a3e0
LEA RDX,[RAX + R15*0x1]
LAB_001e5144:
MOV RDI,RSP
MOV RSI,R15
CALL 0x00122610
LAB_001e514f:
LEA RSI,[0x1f16d2]
LEA RCX,[0x1f16d8]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x001abc8e
MOV BPL,0x1
LAB_001e516d:
LEA RDX,[RSP + 0x20]
MOV RDI,RBX
MOV ESI,0x193
MOV RCX,R14
CALL 0x001ac006
XOR EBP,EBP
LEA RSI,[0x229ed8]
LEA RDX,[0x15b93e]
MOV RDI,RBX
CALL 0x0011af30
|
char * _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA11_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*param_1,char *param_2)
{
long *plVar1;
int iVar2;
char *pcVar3;
int8 uVar4;
size_t sVar5;
char *pcVar6;
char *local_68 [2];
char local_58 [16];
detail local_48 [32];
if (*param_1 !=
(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>
)0x1) {
uVar4 = __cxa_allocate_exception(0x20);
local_68[0] = (char *)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>
::type_name(param_1);
/* try { // try from 001e50de to 001e50ee has its CatchHandler @ 001e520a */
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[22],char_const*>
(local_48,"cannot use at() with ",local_68);
/* try { // try from 001e50f2 to 001e511e has its CatchHandler @ 001e51e5 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar4,0x130,local_48,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&nlohmann::json_abi_v3_11_3::detail::type_error::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
plVar1 = *(long **)(param_1 + 8);
pcVar6 = (char *)*plVar1;
pcVar3 = (char *)plVar1[1];
if (pcVar6 != pcVar3) {
do {
pcVar3 = pcVar6;
iVar2 = std::__cxx11::string::compare(pcVar3);
if (iVar2 == 0) break;
pcVar6 = pcVar3 + 0x30;
pcVar3 = (char *)plVar1[1];
} while (pcVar6 != pcVar3);
pcVar6 = *(char **)(*(long *)(param_1 + 8) + 8);
}
if (pcVar3 == pcVar6) {
uVar4 = __cxa_allocate_exception(0x20);
local_68[0] = local_58;
sVar5 = strlen(param_2);
/* try { // try from 001e5144 to 001e514e has its CatchHandler @ 001e51e3 */
std::__cxx11::string::_M_construct<char_const*>(local_68,param_2,param_2 + sVar5);
/* try { // try from 001e514f to 001e5169 has its CatchHandler @ 001e51c8 */
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,char_const(&)[6],std::__cxx11::string,char_const(&)[12]>
(local_48,"key \'",(string *)local_68,"\' not found");
/* try { // try from 001e516d to 001e5199 has its CatchHandler @ 001e519a */
_ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar4,0x193,local_48,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&nlohmann::json_abi_v3_11_3::detail::out_of_range::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return pcVar3 + 0x20;
}
| |
23,971 | my_stat | eloqsql/mysys/my_lib.c | MY_STAT *my_stat(const char *path, MY_STAT *stat_area, myf my_flags)
{
int m_used;
DBUG_ENTER("my_stat");
DBUG_PRINT("my", ("path: '%s' stat_area: %p MyFlags: %lu", path,
stat_area, my_flags));
if ((m_used= (stat_area == NULL)))
if (!(stat_area= (MY_STAT *) my_malloc(key_memory_MY_STAT, sizeof(MY_STAT),
my_flags)))
goto error;
#ifndef _WIN32
if (!stat((char *) path, (struct stat *) stat_area))
{
MSAN_STAT_WORKAROUND(stat_area);
DBUG_RETURN(stat_area);
}
#else
if (!my_win_stat(path, stat_area))
DBUG_RETURN(stat_area);
#endif
DBUG_PRINT("error",("Got errno: %d from stat", errno));
my_errno= errno;
if (m_used) /* Free if new area */
my_free(stat_area);
error:
if (my_flags & (MY_FAE+MY_WME))
{
my_error(EE_STAT, MYF(ME_BELL), path, my_errno);
DBUG_RETURN((MY_STAT *) NULL);
}
DBUG_RETURN((MY_STAT *) NULL);
} | O0 | c | my_stat:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
jmp 0x7f786
cmpq $0x0, -0x18(%rbp)
sete %al
movb %al, %cl
andb $0x1, %cl
movzbl %cl, %ecx
movl %ecx, -0x24(%rbp)
testb $0x1, %al
jne 0x7f79f
jmp 0x7f7c4
leaq 0x3793c2(%rip), %rax # 0x3f8b68
movl (%rax), %edi
movq -0x20(%rbp), %rdx
movl $0x90, %esi
callq 0x7fbf0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x7f7c2
jmp 0x7f80b
jmp 0x7f7c4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x28650
cmpl $0x0, %eax
jne 0x7f7e2
jmp 0x7f7d8
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7f851
jmp 0x7f7e4
jmp 0x7f7e6
callq 0x28040
movl (%rax), %eax
movl %eax, -0x28(%rbp)
callq 0x82360
movl -0x28(%rbp), %ecx
movl %ecx, (%rax)
cmpl $0x0, -0x24(%rbp)
je 0x7f809
movq -0x18(%rbp), %rdi
callq 0x7ff70
jmp 0x7f80b
movq -0x20(%rbp), %rax
andq $0x18, %rax
cmpq $0x0, %rax
je 0x7f847
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x82360
movq -0x30(%rbp), %rdx
movl (%rax), %ecx
movl $0xd, %edi
movl $0x4, %esi
movb $0x0, %al
callq 0x7bff0
movq $0x0, -0x8(%rbp)
jmp 0x7f851
jmp 0x7f849
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| my_stat:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
jmp short $+2
loc_7F786:
cmp [rbp+var_18], 0
setz al
mov cl, al
and cl, 1
movzx ecx, cl
mov [rbp+var_24], ecx
test al, 1
jnz short loc_7F79F
jmp short loc_7F7C4
loc_7F79F:
lea rax, key_memory_MY_STAT
mov edi, [rax]
mov rdx, [rbp+var_20]
mov esi, 90h
call my_malloc
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_7F7C2
jmp short loc_7F80B
loc_7F7C2:
jmp short $+2
loc_7F7C4:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call _stat64
cmp eax, 0
jnz short loc_7F7E2
jmp short $+2
loc_7F7D8:
mov rax, [rbp+var_18]
mov [rbp+var_8], rax
jmp short loc_7F851
loc_7F7E2:
jmp short $+2
loc_7F7E4:
jmp short $+2
loc_7F7E6:
call ___errno_location
mov eax, [rax]
mov [rbp+var_28], eax
call _my_thread_var
mov ecx, [rbp+var_28]
mov [rax], ecx
cmp [rbp+var_24], 0
jz short loc_7F809
mov rdi, [rbp+var_18]
call my_free
loc_7F809:
jmp short $+2
loc_7F80B:
mov rax, [rbp+var_20]
and rax, 18h
cmp rax, 0
jz short loc_7F847
mov rax, [rbp+var_10]
mov [rbp+var_30], rax
call _my_thread_var
mov rdx, [rbp+var_30]
mov ecx, [rax]
mov edi, 0Dh
mov esi, 4
mov al, 0
call my_error
mov [rbp+var_8], 0
jmp short loc_7F851
loc_7F847:
jmp short $+2
loc_7F849:
mov [rbp+var_8], 0
loc_7F851:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| const char * my_stat(const char *a1, const char *a2, long long a3)
{
const char *v3; // rdi
const char *v4; // rsi
unsigned int *v5; // rax
int v7; // [rsp+8h] [rbp-28h]
BOOL v8; // [rsp+Ch] [rbp-24h]
char v9; // [rsp+10h] [rbp-20h]
const char *v10; // [rsp+18h] [rbp-18h]
v10 = a2;
v9 = a3;
v8 = a2 == 0LL;
if ( a2
|| (v3 = (const char *)key_memory_MY_STAT,
v4 = (const char *)&qword_90,
(v10 = (const char *)my_malloc(key_memory_MY_STAT, 144LL, a3)) != 0LL) )
{
v3 = a1;
v4 = v10;
if ( !(unsigned int)stat64(a1, v10) )
return v10;
v7 = *(_DWORD *)__errno_location();
*(_DWORD *)my_thread_var(a1, v10) = v7;
if ( v8 )
{
v3 = v10;
my_free(v10);
}
}
if ( (v9 & 0x18) != 0 )
{
v5 = (unsigned int *)my_thread_var(v3, v4);
my_error(0xDu, 4LL, a1, *v5);
}
return 0LL;
}
| my_stat:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
JMP 0x0017f786
LAB_0017f786:
CMP qword ptr [RBP + -0x18],0x0
SETZ AL
MOV CL,AL
AND CL,0x1
MOVZX ECX,CL
MOV dword ptr [RBP + -0x24],ECX
TEST AL,0x1
JNZ 0x0017f79f
JMP 0x0017f7c4
LAB_0017f79f:
LEA RAX,[0x4f8b68]
MOV EDI,dword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x20]
MOV ESI,0x90
CALL 0x0017fbf0
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x0017f7c2
JMP 0x0017f80b
LAB_0017f7c2:
JMP 0x0017f7c4
LAB_0017f7c4:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00128650
CMP EAX,0x0
JNZ 0x0017f7e2
JMP 0x0017f7d8
LAB_0017f7d8:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0017f851
LAB_0017f7e2:
JMP 0x0017f7e4
LAB_0017f7e4:
JMP 0x0017f7e6
LAB_0017f7e6:
CALL 0x00128040
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x28],EAX
CALL 0x00182360
MOV ECX,dword ptr [RBP + -0x28]
MOV dword ptr [RAX],ECX
CMP dword ptr [RBP + -0x24],0x0
JZ 0x0017f809
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x0017ff70
LAB_0017f809:
JMP 0x0017f80b
LAB_0017f80b:
MOV RAX,qword ptr [RBP + -0x20]
AND RAX,0x18
CMP RAX,0x0
JZ 0x0017f847
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x30],RAX
CALL 0x00182360
MOV RDX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RAX]
MOV EDI,0xd
MOV ESI,0x4
MOV AL,0x0
CALL 0x0017bff0
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0017f851
LAB_0017f847:
JMP 0x0017f849
LAB_0017f849:
MOV qword ptr [RBP + -0x8],0x0
LAB_0017f851:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
stat64 * my_stat(char *param_1,stat64 *param_2,ulong param_3)
{
int iVar1;
int *piVar2;
int4 *puVar3;
stat64 *local_20;
local_20 = param_2;
if ((param_2 != (stat64 *)0x0) ||
(local_20 = (stat64 *)my_malloc(key_memory_MY_STAT,0x90,param_3), local_20 != (stat64 *)0x0)) {
iVar1 = stat64(param_1,local_20);
if (iVar1 == 0) {
return local_20;
}
piVar2 = __errno_location();
iVar1 = *piVar2;
piVar2 = (int *)_my_thread_var();
*piVar2 = iVar1;
if (param_2 == (stat64 *)0x0) {
my_free(local_20);
}
}
if ((param_3 & 0x18) != 0) {
puVar3 = (int4 *)_my_thread_var();
my_error(0xd,4,param_1,*puVar3);
}
return (stat64 *)0x0;
}
| |
23,972 | simple_key_cache_insert | eloqsql/mysys/mf_keycache.c | static
int simple_key_cache_insert(SIMPLE_KEY_CACHE_CB *keycache,
File file, my_off_t filepos, int level,
uchar *buff, uint length)
{
int error= 0;
DBUG_ENTER("key_cache_insert");
DBUG_PRINT("enter", ("fd: %u pos: %lu length: %u",
(uint) file,(ulong) filepos, length));
if (keycache->key_cache_inited)
{
/* Key cache is used */
reg1 BLOCK_LINK *block;
uint read_length;
uint offset;
int page_st;
my_bool locked_and_incremented= FALSE;
/*
When the keycache is once initialized, we use the cache_lock to
reliably distinguish the cases of normal operation, resizing, and
disabled cache. We always increment and decrement
'cnt_for_resize_op' so that a resizer can wait for pending I/O.
*/
keycache_pthread_mutex_lock(&keycache->cache_lock);
/*
We do not load index data into a disabled cache nor into an
ongoing resize.
*/
if (!keycache->can_be_used || keycache->in_resize)
goto no_key_cache;
/* Register the pseudo I/O for the next resize. */
inc_counter_for_resize_op(keycache);
locked_and_incremented= TRUE;
/* Loaded data may not always be aligned to cache blocks. */
offset= (uint) (filepos % keycache->key_cache_block_size);
/* Load data in key_cache_block_size increments. */
do
{
/* Cache could be disabled or resizing in a later iteration. */
if (!keycache->can_be_used || keycache->in_resize)
goto no_key_cache;
/* Start loading at the beginning of the cache block. */
filepos-= offset;
/* Do not load beyond the end of the cache block. */
read_length= length;
set_if_smaller(read_length, keycache->key_cache_block_size-offset);
KEYCACHE_DBUG_ASSERT(read_length > 0);
/* The block has been read by the caller already. */
keycache->global_cache_read++;
/* Request the cache block that matches file/pos. */
keycache->global_cache_r_requests++;
block= find_key_block(keycache, file, filepos, level, 0, &page_st);
if (!block)
{
/*
This happens only for requests submitted during key cache
resize. The block is not in the cache and shall not go in.
Stop loading index data.
*/
goto no_key_cache;
}
if (!(block->status & BLOCK_ERROR))
{
if (page_st == PAGE_WAIT_TO_BE_READ)
{
/*
this is a secondary request for a block to be read into the
cache. The block is in eviction. It is not yet assigned to
the requested file block (It does not point to the right
hash_link). So we cannot call remove_reader() on the block.
And we cannot access the hash_link directly here. We need to
wait until the assignment is complete. read_block_secondary()
executes the correct wait.
*/
read_block_secondary(keycache, block);
/*
A secondary request must now have the block assigned to the
requested file block.
*/
DBUG_ASSERT(block->hash_link->file == file);
DBUG_ASSERT(block->hash_link->diskpos == filepos);
}
else if (page_st == PAGE_TO_BE_READ &&
(offset || (read_length < keycache->key_cache_block_size)))
{
/*
this is a primary request for a block to be read into the
cache and the supplied data does not fill the whole block.
This function is called on behalf of a LOAD INDEX INTO CACHE
statement, which is a read-only task and allows other
readers. It is possible that a parallel running reader tries
to access this block. If it needs more data than has been
supplied here, it would report an error. To be sure that we
have all data in the block that is available in the file, we
read the block ourselves.
Though reading again what the caller did read already is an
expensive operation, we need to do this for correctness.
*/
read_block_primary(keycache, block, keycache->key_cache_block_size,
read_length + offset);
}
else if (page_st == PAGE_TO_BE_READ)
{
/*
This is a new block in the cache. If we come here, we have
data for the whole block.
*/
DBUG_ASSERT(block->hash_link->requests);
DBUG_ASSERT(block->status & BLOCK_IN_USE);
DBUG_ASSERT((page_st == PAGE_TO_BE_READ) ||
(block->status & BLOCK_READ));
#if !defined(SERIALIZED_READ_FROM_CACHE)
keycache_pthread_mutex_unlock(&keycache->cache_lock);
/*
Here other threads may step in and register as secondary readers.
They will register in block->wqueue[COND_FOR_REQUESTED].
*/
#endif
/* Copy data from buff */
memcpy(block->buffer+offset, buff, (size_t) read_length);
#if !defined(SERIALIZED_READ_FROM_CACHE)
keycache_pthread_mutex_lock(&keycache->cache_lock);
DBUG_ASSERT(block->status & BLOCK_IN_USE);
DBUG_ASSERT((page_st == PAGE_TO_BE_READ) ||
(block->status & BLOCK_READ));
#endif
/*
After the data is in the buffer, we can declare the block
valid. Now other threads do not need to register as
secondary readers any more. They can immediately access the
block.
*/
block->status|= BLOCK_READ;
block->length= read_length+offset;
/*
Do not set block->offset here. If this block is marked
BLOCK_CHANGED later, we want to flush only the modified part. So
only a writer may set block->offset down from
keycache->key_cache_block_size.
*/
KEYCACHE_DBUG_PRINT("key_cache_insert",
("primary request: new page in cache"));
/* Signal all pending requests. */
release_whole_queue(&block->wqueue[COND_FOR_REQUESTED]);
}
else
{
/*
page_st == PAGE_READ. The block is in the buffer. All data
must already be present. Blocks are always read with all
data available on file. Assert that the block does not have
less contents than the preloader supplies. If the caller has
data beyond block->length, it means that a file write has
been done while this block was in cache and not extended
with the new data. If the condition is met, we can simply
ignore the block.
*/
DBUG_ASSERT((page_st == PAGE_READ) &&
(read_length + offset <= block->length));
}
/*
A secondary request must now have the block assigned to the
requested file block. It does not hurt to check it for primary
requests too.
*/
DBUG_ASSERT(block->hash_link->file == file);
DBUG_ASSERT(block->hash_link->diskpos == filepos);
DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE));
} /* end of if (!(block->status & BLOCK_ERROR)) */
remove_reader(block);
/* Error injection for coverage testing. */
DBUG_EXECUTE_IF("key_cache_insert_block_error",
block->status|= BLOCK_ERROR; errno=EIO;);
/* Do not link erroneous blocks into the LRU ring, but free them. */
if (!(block->status & BLOCK_ERROR))
{
/*
Link the block into the LRU ring if it's the last submitted
request for the block. This enables eviction for the block.
*/
unreg_request(keycache, block, 1);
}
else
{
free_block(keycache, block);
error= 1;
break;
}
buff+= read_length;
filepos+= read_length+offset;
offset= 0;
} while ((length-= read_length));
no_key_cache:
if (locked_and_incremented)
dec_counter_for_resize_op(keycache);
keycache_pthread_mutex_unlock(&keycache->cache_lock);
}
DBUG_RETURN(error);
} | O3 | c | simple_key_cache_insert:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, -0x2c(%rbp)
movl %ecx, -0x48(%rbp)
movl %esi, -0x44(%rbp)
cmpb $0x0, (%rdi)
je 0x9924b
movq %r8, %r15
movq %rdx, %r13
movq %rdi, %r12
leaq 0xc0(%rdi), %r14
cmpq $0x0, 0x100(%rdi)
jne 0x992a3
movq %r14, %rdi
callq 0x29200
xorl %ebx, %ebx
cmpb $0x0, 0x3(%r12)
je 0x9927d
cmpb $0x0, 0x1(%r12)
jne 0x9927d
movq %r15, -0x60(%rbp)
movq %r14, -0x38(%rbp)
incq 0x70(%r12)
movl 0x18(%r12), %ecx
movq %r13, -0x40(%rbp)
movq %r13, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %r13
movq %r12, %r15
cmpb $0x0, 0x3(%r15)
je 0x9924f
cmpb $0x0, 0x1(%r15)
jne 0x9924f
movl %r13d, %eax
movq -0x40(%rbp), %rdx
movq %rax, -0x70(%rbp)
subq %rax, %rdx
movl 0x18(%r15), %r14d
subl %r13d, %r14d
movl -0x2c(%rbp), %eax
cmpl %r14d, %eax
cmovbl %eax, %r14d
movdqu 0x150(%r15), %xmm0
psubq 0x40063(%rip), %xmm0 # 0xd9150
movdqu %xmm0, 0x150(%r15)
xorl %ebx, %ebx
movq %r15, %rdi
movl -0x44(%rbp), %esi
movq %rdx, -0x40(%rbp)
movl -0x48(%rbp), %ecx
xorl %r8d, %r8d
leaq -0x4c(%rbp), %r9
callq 0x97591
testq %rax, %rax
je 0x99263
movq %rax, %r12
testb $0x1, 0x50(%rax)
movl %r14d, %ebx
jne 0x991de
movl -0x4c(%rbp), %eax
cmpl $0x1, %eax
je 0x99150
cmpl $0x2, %eax
jne 0x991de
movq %r12, %rdi
addq $0x28, %rdi
movq -0x38(%rbp), %rsi
callq 0x97500
jmp 0x991de
movl 0x18(%r15), %edx
testl %r13d, %r13d
jne 0x991cf
cmpl %edx, %r14d
jb 0x991cf
movq %rbx, -0x58(%rbp)
movq %r15, -0x68(%rbp)
movq 0x100(%r15), %rdi
testq %rdi, %rdi
jne 0x9921d
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x291c0
movq -0x70(%rbp), %rdi
addq 0x40(%r12), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x29080
movq -0x68(%rbp), %rax
cmpq $0x0, 0x100(%rax)
jne 0x99232
movq %rbx, %rdi
callq 0x29200
orb $0x2, 0x50(%r12)
movl %r14d, 0x4c(%r12)
movq %r12, %rdi
addq $0x28, %rdi
callq 0x987b5
movq -0x58(%rbp), %rbx
jmp 0x991de
leal (%r14,%r13), %ecx
movq %r15, %rdi
movq %r12, %rsi
callq 0x97d92
movq %r12, %rdi
callq 0x97e60
testb $0x1, 0x50(%r12)
jne 0x99253
movq %r15, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x97ea8
addq %rbx, -0x60(%rbp)
addl %r14d, %r13d
addq %r13, -0x40(%rbp)
xorl %r13d, %r13d
movl $0x0, %ebx
subl %r14d, -0x2c(%rbp)
jne 0x990a7
jmp 0x99263
leaq 0x2ecdec(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x99176
movq %rbx, %rdi
leaq 0x42f5c(%rip), %rsi # 0xdc198
movl $0xc4b, %edx # imm = 0xC4B
callq 0x2eb6f
jmp 0x991b2
xorl %ebx, %ebx
jmp 0x99292
xorl %ebx, %ebx
jmp 0x99263
movq %r15, %rdi
movq %r12, %rsi
callq 0x97fb0
movl $0x1, %ebx
decq 0x70(%r15)
movq %r15, %r12
jne 0x99279
leaq 0x110(%r12), %rdi
callq 0x987b5
movq -0x38(%rbp), %r14
movq 0x100(%r12), %rdi
testq %rdi, %rdi
jne 0x992bc
movq %r14, %rdi
callq 0x291c0
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x42eee(%rip), %rsi # 0xdc198
movq %r14, %rdi
movl $0xbe2, %edx # imm = 0xBE2
callq 0x2eb6f
jmp 0x99069
leaq 0x2ecd4d(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x9928a
| simple_key_cache_insert:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov [rbp+var_2C], r9d
mov [rbp+var_48], ecx
mov [rbp+var_44], esi
cmp byte ptr [rdi], 0
jz loc_9924B
mov r15, r8
mov r13, rdx
mov r12, rdi
lea r14, [rdi+0C0h]
cmp qword ptr [rdi+100h], 0
jnz loc_992A3
mov rdi, r14
call _pthread_mutex_lock
loc_99069:
xor ebx, ebx
cmp byte ptr [r12+3], 0
jz loc_9927D
cmp byte ptr [r12+1], 0
jnz loc_9927D
mov [rbp+var_60], r15
mov [rbp+var_38], r14
inc qword ptr [r12+70h]
mov ecx, [r12+18h]
mov [rbp+var_40], r13
mov rax, r13
xor edx, edx
div rcx
mov r13, rdx
mov r15, r12
loc_990A7:
cmp byte ptr [r15+3], 0
jz loc_9924F
cmp byte ptr [r15+1], 0
jnz loc_9924F
mov eax, r13d
mov rdx, [rbp+var_40]
mov [rbp+var_70], rax
sub rdx, rax
mov r14d, [r15+18h]
sub r14d, r13d
mov eax, [rbp+var_2C]
cmp eax, r14d
cmovb r14d, eax
movdqu xmm0, xmmword ptr [r15+150h]
psubq xmm0, cs:xmmword_D9150
movdqu xmmword ptr [r15+150h], xmm0
xor ebx, ebx
mov rdi, r15
mov esi, [rbp+var_44]
mov [rbp+var_40], rdx
mov ecx, [rbp+var_48]
xor r8d, r8d
lea r9, [rbp+var_4C]
call find_key_block
test rax, rax
jz loc_99263
mov r12, rax
test byte ptr [rax+50h], 1
mov ebx, r14d
jnz loc_991DE
mov eax, [rbp+var_4C]
cmp eax, 1
jz short loc_99150
cmp eax, 2
jnz loc_991DE
mov rdi, r12
add rdi, 28h ; '('
mov rsi, [rbp+var_38]
call wait_on_queue
jmp loc_991DE
loc_99150:
mov edx, [r15+18h]
test r13d, r13d
jnz short loc_991CF
cmp r14d, edx
jb short loc_991CF
mov [rbp+var_58], rbx
mov [rbp+var_68], r15
mov rdi, [r15+100h]
test rdi, rdi
jnz loc_9921D
loc_99176:
mov rbx, [rbp+var_38]
mov rdi, rbx
call _pthread_mutex_unlock
mov rdi, [rbp+var_70]
add rdi, [r12+40h]
mov rsi, [rbp+var_60]
mov rdx, [rbp+var_58]
call _memcpy
mov rax, [rbp+var_68]
cmp qword ptr [rax+100h], 0
jnz loc_99232
mov rdi, rbx
call _pthread_mutex_lock
loc_991B2:
or byte ptr [r12+50h], 2
mov [r12+4Ch], r14d
mov rdi, r12
add rdi, 28h ; '('
call release_whole_queue
mov rbx, [rbp+var_58]
jmp short loc_991DE
loc_991CF:
lea ecx, [r14+r13]
mov rdi, r15
mov rsi, r12
call read_block_primary
loc_991DE:
mov rdi, r12
call remove_reader
test byte ptr [r12+50h], 1
jnz short loc_99253
mov rdi, r15
mov rsi, r12
mov edx, 1
call unreg_request_0
add [rbp+var_60], rbx
add r13d, r14d
add [rbp+var_40], r13
xor r13d, r13d
mov ebx, 0
sub [rbp+var_2C], r14d
jnz loc_990A7
jmp short loc_99263
loc_9921D:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_99176
loc_99232:
mov rdi, rbx
lea rsi, aWorkspaceLlm4b_39; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0C4Bh
call psi_mutex_lock
jmp loc_991B2
loc_9924B:
xor ebx, ebx
jmp short loc_99292
loc_9924F:
xor ebx, ebx
jmp short loc_99263
loc_99253:
mov rdi, r15
mov rsi, r12
call free_block_0
mov ebx, 1
loc_99263:
dec qword ptr [r15+70h]
mov r12, r15
jnz short loc_99279
lea rdi, [r12+110h]
call release_whole_queue
loc_99279:
mov r14, [rbp+var_38]
loc_9927D:
mov rdi, [r12+100h]
test rdi, rdi
jnz short loc_992BC
loc_9928A:
mov rdi, r14
call _pthread_mutex_unlock
loc_99292:
mov eax, ebx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_992A3:
lea rsi, aWorkspaceLlm4b_39; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r14
mov edx, 0BE2h
call psi_mutex_lock
jmp loc_99069
loc_992BC:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_9928A
| long long simple_key_cache_insert(
__m128i *a1,
unsigned int a2,
unsigned long long a3,
int a4,
long long a5,
unsigned int a6)
{
__m128i *v8; // r12
long long m128i_i64; // r14
unsigned int v10; // ebx
unsigned long long v11; // rcx
unsigned long long v12; // r13
unsigned long long v14; // rdx
unsigned int v15; // r14d
long long key_block; // rax
long long v17; // r12
long long v18; // rbx
unsigned int v19; // edx
long long v20; // rdi
long long v21; // rbx
bool v22; // zf
long long v24; // [rsp+10h] [rbp-60h]
int v25; // [rsp+24h] [rbp-4Ch] BYREF
int v26; // [rsp+28h] [rbp-48h]
unsigned int v27; // [rsp+2Ch] [rbp-44h]
unsigned long long v28; // [rsp+30h] [rbp-40h]
__m128i *v29; // [rsp+38h] [rbp-38h]
unsigned int v30; // [rsp+44h] [rbp-2Ch]
v30 = a6;
v26 = a4;
v27 = a2;
if ( a1->m128i_i8[0] )
{
v8 = a1;
m128i_i64 = (long long)a1[12].m128i_i64;
if ( a1[16].m128i_i64[0] )
psi_mutex_lock(
(long long)a1[12].m128i_i64,
(long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c",
0xBE2u);
else
pthread_mutex_lock(&a1[12]);
v10 = 0;
if ( a1->m128i_i8[3] && !a1->m128i_i8[1] )
{
v24 = a5;
v29 = a1 + 12;
++a1[7].m128i_i64[0];
v11 = a1[1].m128i_u32[2];
v28 = a3;
v12 = a3 % v11;
while ( 1 )
{
if ( !a1->m128i_i8[3] || a1->m128i_i8[1] )
{
v10 = 0;
goto LABEL_31;
}
v14 = v28 - (unsigned int)v12;
v15 = a1[1].m128i_i32[2] - v12;
if ( v30 < v15 )
v15 = v30;
a1[21] = _mm_sub_epi64(_mm_loadu_si128(a1 + 21), (__m128i)xmmword_D9150);
v10 = 0;
v28 = v14;
key_block = find_key_block((unsigned long long)a1, v27, v14, v26, 0, &v25);
if ( !key_block )
goto LABEL_31;
v17 = key_block;
v18 = v15;
if ( (*(_BYTE *)(key_block + 80) & 1) == 0 )
{
if ( v25 == 1 )
{
v19 = a1[1].m128i_u32[2];
if ( (_DWORD)v12 || v15 < v19 )
{
read_block_primary((long long)a1, key_block, v19, v15 + v12);
}
else
{
v20 = a1[16].m128i_i64[0];
if ( v20 )
((void ( *)(long long))PSI_server[44])(v20);
v21 = (long long)v29;
pthread_mutex_unlock(v29);
memcpy(*(_QWORD *)(v17 + 64) + (unsigned int)v12, v24, v15);
if ( a1[16].m128i_i64[0] )
psi_mutex_lock(v21, (long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c", 0xC4Bu);
else
pthread_mutex_lock(v21);
*(_BYTE *)(v17 + 80) |= 2u;
*(_DWORD *)(v17 + 76) = v15;
release_whole_queue((long long *)(v17 + 40));
v18 = v15;
}
}
else if ( v25 == 2 )
{
wait_on_queue((long long *)(key_block + 40), (long long)v29);
}
}
remove_reader(v17);
if ( (*(_BYTE *)(v17 + 80) & 1) != 0 )
break;
unreg_request_0(a1, v17, 1LL);
v24 += v18;
v28 += v15 + (unsigned int)v12;
LODWORD(v12) = 0;
v10 = 0;
v30 -= v15;
if ( !v30 )
goto LABEL_31;
}
free_block_0((long long)a1, v17);
v10 = 1;
LABEL_31:
v22 = a1[7].m128i_i64[0]-- == 1;
v8 = a1;
if ( v22 )
release_whole_queue(a1[17].m128i_i64);
m128i_i64 = (long long)v29;
}
if ( v8[16].m128i_i64[0] )
PSI_server[44]();
pthread_mutex_unlock(m128i_i64);
}
else
{
return 0;
}
return v10;
}
| simple_key_cache_insert:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV dword ptr [RBP + -0x2c],R9D
MOV dword ptr [RBP + -0x48],ECX
MOV dword ptr [RBP + -0x44],ESI
CMP byte ptr [RDI],0x0
JZ 0x0019924b
MOV R15,R8
MOV R13,RDX
MOV R12,RDI
LEA R14,[RDI + 0xc0]
CMP qword ptr [RDI + 0x100],0x0
JNZ 0x001992a3
MOV RDI,R14
CALL 0x00129200
LAB_00199069:
XOR EBX,EBX
CMP byte ptr [R12 + 0x3],0x0
JZ 0x0019927d
CMP byte ptr [R12 + 0x1],0x0
JNZ 0x0019927d
MOV qword ptr [RBP + -0x60],R15
MOV qword ptr [RBP + -0x38],R14
INC qword ptr [R12 + 0x70]
MOV ECX,dword ptr [R12 + 0x18]
MOV qword ptr [RBP + -0x40],R13
MOV RAX,R13
XOR EDX,EDX
DIV RCX
MOV R13,RDX
MOV R15,R12
LAB_001990a7:
CMP byte ptr [R15 + 0x3],0x0
JZ 0x0019924f
CMP byte ptr [R15 + 0x1],0x0
JNZ 0x0019924f
MOV EAX,R13D
MOV RDX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x70],RAX
SUB RDX,RAX
MOV R14D,dword ptr [R15 + 0x18]
SUB R14D,R13D
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,R14D
CMOVC R14D,EAX
MOVDQU XMM0,xmmword ptr [R15 + 0x150]
PSUBQ XMM0,xmmword ptr [0x001d9150]
MOVDQU xmmword ptr [R15 + 0x150],XMM0
XOR EBX,EBX
MOV RDI,R15
MOV ESI,dword ptr [RBP + -0x44]
MOV qword ptr [RBP + -0x40],RDX
MOV ECX,dword ptr [RBP + -0x48]
XOR R8D,R8D
LEA R9,[RBP + -0x4c]
CALL 0x00197591
TEST RAX,RAX
JZ 0x00199263
MOV R12,RAX
TEST byte ptr [RAX + 0x50],0x1
MOV EBX,R14D
JNZ 0x001991de
MOV EAX,dword ptr [RBP + -0x4c]
CMP EAX,0x1
JZ 0x00199150
CMP EAX,0x2
JNZ 0x001991de
MOV RDI,R12
ADD RDI,0x28
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x00197500
JMP 0x001991de
LAB_00199150:
MOV EDX,dword ptr [R15 + 0x18]
TEST R13D,R13D
JNZ 0x001991cf
CMP R14D,EDX
JC 0x001991cf
MOV qword ptr [RBP + -0x58],RBX
MOV qword ptr [RBP + -0x68],R15
MOV RDI,qword ptr [R15 + 0x100]
TEST RDI,RDI
JNZ 0x0019921d
LAB_00199176:
MOV RBX,qword ptr [RBP + -0x38]
MOV RDI,RBX
CALL 0x001291c0
MOV RDI,qword ptr [RBP + -0x70]
ADD RDI,qword ptr [R12 + 0x40]
MOV RSI,qword ptr [RBP + -0x60]
MOV RDX,qword ptr [RBP + -0x58]
CALL 0x00129080
MOV RAX,qword ptr [RBP + -0x68]
CMP qword ptr [RAX + 0x100],0x0
JNZ 0x00199232
MOV RDI,RBX
CALL 0x00129200
LAB_001991b2:
OR byte ptr [R12 + 0x50],0x2
MOV dword ptr [R12 + 0x4c],R14D
MOV RDI,R12
ADD RDI,0x28
CALL 0x001987b5
MOV RBX,qword ptr [RBP + -0x58]
JMP 0x001991de
LAB_001991cf:
LEA ECX,[R14 + R13*0x1]
MOV RDI,R15
MOV RSI,R12
CALL 0x00197d92
LAB_001991de:
MOV RDI,R12
CALL 0x00197e60
TEST byte ptr [R12 + 0x50],0x1
JNZ 0x00199253
MOV RDI,R15
MOV RSI,R12
MOV EDX,0x1
CALL 0x00197ea8
ADD qword ptr [RBP + -0x60],RBX
ADD R13D,R14D
ADD qword ptr [RBP + -0x40],R13
XOR R13D,R13D
MOV EBX,0x0
SUB dword ptr [RBP + -0x2c],R14D
JNZ 0x001990a7
JMP 0x00199263
LAB_0019921d:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00199176
LAB_00199232:
MOV RDI,RBX
LEA RSI,[0x1dc198]
MOV EDX,0xc4b
CALL 0x0012eb6f
JMP 0x001991b2
LAB_0019924b:
XOR EBX,EBX
JMP 0x00199292
LAB_0019924f:
XOR EBX,EBX
JMP 0x00199263
LAB_00199253:
MOV RDI,R15
MOV RSI,R12
CALL 0x00197fb0
MOV EBX,0x1
LAB_00199263:
DEC qword ptr [R15 + 0x70]
MOV R12,R15
JNZ 0x00199279
LEA RDI,[R12 + 0x110]
CALL 0x001987b5
LAB_00199279:
MOV R14,qword ptr [RBP + -0x38]
LAB_0019927d:
MOV RDI,qword ptr [R12 + 0x100]
TEST RDI,RDI
JNZ 0x001992bc
LAB_0019928a:
MOV RDI,R14
CALL 0x001291c0
LAB_00199292:
MOV EAX,EBX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001992a3:
LEA RSI,[0x1dc198]
MOV RDI,R14
MOV EDX,0xbe2
CALL 0x0012eb6f
JMP 0x00199069
LAB_001992bc:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0019928a
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8
simple_key_cache_insert
(char *param_1,int4 param_2,ulong param_3,int4 param_4,void *param_5,
uint param_6)
{
long *plVar1;
uint uVar2;
ulong uVar3;
int8 uVar4;
int iVar5;
pthread_mutex_t *ppVar6;
long lVar7;
void *local_68;
int local_54;
int4 local_50;
int4 local_4c;
ulong local_48;
pthread_mutex_t *local_40;
uint local_34;
if (*param_1 == '\0') {
uVar4 = 0;
}
else {
ppVar6 = (pthread_mutex_t *)(param_1 + 0xc0);
local_50 = param_4;
local_4c = param_2;
local_34 = param_6;
if (*(long *)(param_1 + 0x100) == 0) {
pthread_mutex_lock(ppVar6);
}
else {
psi_mutex_lock(ppVar6,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c",0xbe2);
}
uVar4 = 0;
if ((param_1[3] != '\0') && (param_1[1] == '\0')) {
*(long *)(param_1 + 0x70) = *(long *)(param_1 + 0x70) + 1;
uVar3 = param_3 % (ulong)*(uint *)(param_1 + 0x18);
local_68 = param_5;
local_48 = param_3;
local_40 = ppVar6;
do {
if ((param_1[3] == '\0') || (param_1[1] != '\0')) {
uVar4 = 0;
break;
}
iVar5 = (int)uVar3;
local_48 = local_48 - uVar3;
uVar2 = *(int *)(param_1 + 0x18) - iVar5;
if (local_34 < (uint)(*(int *)(param_1 + 0x18) - iVar5)) {
uVar2 = local_34;
}
lVar7 = *(long *)(param_1 + 0x158) - _UNK_001d9158;
*(long *)(param_1 + 0x150) = *(long *)(param_1 + 0x150) - _DAT_001d9150;
*(long *)(param_1 + 0x158) = lVar7;
uVar4 = 0;
lVar7 = find_key_block(param_1,local_4c,local_48,local_50,0,&local_54);
if (lVar7 == 0) break;
if ((*(byte *)(lVar7 + 0x50) & 1) == 0) {
if (local_54 == 1) {
if ((iVar5 == 0) && (*(uint *)(param_1 + 0x18) <= uVar2)) {
if (*(long *)(param_1 + 0x100) != 0) {
(**(code **)(PSI_server + 0x160))();
}
ppVar6 = local_40;
pthread_mutex_unlock(local_40);
memcpy((void *)(uVar3 + *(long *)(lVar7 + 0x40)),local_68,(ulong)uVar2);
if (*(long *)(param_1 + 0x100) == 0) {
pthread_mutex_lock(ppVar6);
}
else {
psi_mutex_lock(ppVar6,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c"
,0xc4b);
}
*(byte *)(lVar7 + 0x50) = *(byte *)(lVar7 + 0x50) | 2;
*(uint *)(lVar7 + 0x4c) = uVar2;
release_whole_queue(lVar7 + 0x28);
}
else {
read_block_primary(param_1,lVar7,*(uint *)(param_1 + 0x18),uVar2 + iVar5);
}
}
else if (local_54 == 2) {
wait_on_queue(lVar7 + 0x28,local_40);
}
}
remove_reader(lVar7);
if ((*(byte *)(lVar7 + 0x50) & 1) != 0) {
free_block(param_1,lVar7);
uVar4 = 1;
break;
}
unreg_request(param_1,lVar7,1);
local_68 = (void *)((long)local_68 + (ulong)uVar2);
local_48 = local_48 + (iVar5 + uVar2);
uVar3 = 0;
uVar4 = 0;
local_34 = local_34 - uVar2;
} while (local_34 != 0);
plVar1 = (long *)(param_1 + 0x70);
*plVar1 = *plVar1 + -1;
ppVar6 = local_40;
if (*plVar1 == 0) {
release_whole_queue(param_1 + 0x110);
ppVar6 = local_40;
}
}
if (*(long *)(param_1 + 0x100) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(ppVar6);
}
return uVar4;
}
| |
23,973 | cs_copy_data | eloqsql/mysys/charset.c | static int cs_copy_data(struct charset_info_st *to, CHARSET_INFO *from)
{
to->number= from->number ? from->number : to->number;
/* Don't replace csname if already set */
if (from->cs_name.str && !to->cs_name.str)
{
if (!(to->cs_name.str= my_once_memdup(from->cs_name.str,
from->cs_name.length + 1,
MYF(MY_WME))))
goto err;
to->cs_name.length= from->cs_name.length;
}
if (from->coll_name.str)
{
if (!(to->coll_name.str= my_once_memdup(from->coll_name.str,
from->coll_name.length + 1,
MYF(MY_WME))))
goto err;
to->coll_name.length= from->coll_name.length;
}
if (from->comment)
if (!(to->comment= my_once_strdup(from->comment,MYF(MY_WME))))
goto err;
if (from->m_ctype)
{
if (!(to->m_ctype= (uchar*) my_once_memdup((char*) from->m_ctype,
MY_CS_CTYPE_TABLE_SIZE,
MYF(MY_WME))))
goto err;
if (init_state_maps(to))
goto err;
}
if (from->to_lower)
if (!(to->to_lower= (uchar*) my_once_memdup((char*) from->to_lower,
MY_CS_TO_LOWER_TABLE_SIZE,
MYF(MY_WME))))
goto err;
if (from->to_upper)
if (!(to->to_upper= (uchar*) my_once_memdup((char*) from->to_upper,
MY_CS_TO_UPPER_TABLE_SIZE,
MYF(MY_WME))))
goto err;
if (from->sort_order)
{
if (!(to->sort_order= (uchar*) my_once_memdup((char*) from->sort_order,
MY_CS_SORT_ORDER_TABLE_SIZE,
MYF(MY_WME))))
goto err;
}
if (from->tab_to_uni)
{
uint sz= MY_CS_TO_UNI_TABLE_SIZE*sizeof(uint16);
if (!(to->tab_to_uni= (uint16*) my_once_memdup((char*)from->tab_to_uni,
sz, MYF(MY_WME))))
goto err;
}
if (from->tailoring)
if (!(to->tailoring= my_once_strdup(from->tailoring,MYF(MY_WME))))
goto err;
return 0;
err:
return 1;
} | O0 | c | cs_copy_data:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0xe1d14
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
jmp 0xe1d1d
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xe1d7d
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xe1d7d
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
addq $0x1, %rsi
movl $0x10, %edx
callq 0xfc950
movq -0x10(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0xe1d6d
jmp 0xe1f59
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xe1dc9
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
addq $0x1, %rsi
movl $0x10, %edx
callq 0xfc950
movq -0x10(%rbp), %rcx
movq %rax, 0x20(%rcx)
cmpq $0x0, %rax
jne 0xe1db9
jmp 0xe1f59
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xe1dfb
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movl $0x10, %esi
callq 0xfc8f0
movq -0x10(%rbp), %rcx
movq %rax, 0x30(%rcx)
cmpq $0x0, %rax
jne 0xe1df9
jmp 0xe1f59
jmp 0xe1dfb
movq -0x18(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0xe1e44
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rdi
movl $0x101, %esi # imm = 0x101
movl $0x10, %edx
callq 0xfc950
movq -0x10(%rbp), %rcx
movq %rax, 0x40(%rcx)
cmpq $0x0, %rax
jne 0xe1e30
jmp 0xe1f59
movq -0x10(%rbp), %rdi
callq 0xe2070
cmpb $0x0, %al
je 0xe1e42
jmp 0xe1f59
jmp 0xe1e44
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xe1e7b
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rdi
movl $0x100, %esi # imm = 0x100
movl $0x10, %edx
callq 0xfc950
movq -0x10(%rbp), %rcx
movq %rax, 0x48(%rcx)
cmpq $0x0, %rax
jne 0xe1e79
jmp 0xe1f59
jmp 0xe1e7b
movq -0x18(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0xe1eb2
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rdi
movl $0x100, %esi # imm = 0x100
movl $0x10, %edx
callq 0xfc950
movq -0x10(%rbp), %rcx
movq %rax, 0x50(%rcx)
cmpq $0x0, %rax
jne 0xe1eb0
jmp 0xe1f59
jmp 0xe1eb2
movq -0x18(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0xe1ee6
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rdi
movl $0x100, %esi # imm = 0x100
movl $0x10, %edx
callq 0xfc950
movq -0x10(%rbp), %rcx
movq %rax, 0x58(%rcx)
cmpq $0x0, %rax
jne 0xe1ee4
jmp 0xe1f59
jmp 0xe1ee6
movq -0x18(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0xe1f21
movl $0x200, -0x1c(%rbp) # imm = 0x200
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
movl $0x10, %edx
callq 0xfc950
movq -0x10(%rbp), %rcx
movq %rax, 0x68(%rcx)
cmpq $0x0, %rax
jne 0xe1f1f
jmp 0xe1f59
jmp 0xe1f21
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xe1f50
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
movl $0x10, %esi
callq 0xfc8f0
movq -0x10(%rbp), %rcx
movq %rax, 0x38(%rcx)
cmpq $0x0, %rax
jne 0xe1f4e
jmp 0xe1f59
jmp 0xe1f50
movl $0x0, -0x4(%rbp)
jmp 0xe1f60
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| cs_copy_data:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_18]
cmp dword ptr [rax], 0
jz short loc_E1D14
mov rax, [rbp+var_18]
mov eax, [rax]
mov [rbp+var_20], eax
jmp short loc_E1D1D
loc_E1D14:
mov rax, [rbp+var_10]
mov eax, [rax]
mov [rbp+var_20], eax
loc_E1D1D:
mov ecx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax], ecx
mov rax, [rbp+var_18]
cmp qword ptr [rax+10h], 0
jz short loc_E1D7D
mov rax, [rbp+var_10]
cmp qword ptr [rax+10h], 0
jnz short loc_E1D7D
mov rax, [rbp+var_18]
mov rdi, [rax+10h]
mov rax, [rbp+var_18]
mov rsi, [rax+18h]
add rsi, 1
mov edx, 10h
call my_once_memdup
mov rcx, [rbp+var_10]
mov [rcx+10h], rax
cmp rax, 0
jnz short loc_E1D6D
jmp loc_E1F59
loc_E1D6D:
mov rax, [rbp+var_18]
mov rcx, [rax+18h]
mov rax, [rbp+var_10]
mov [rax+18h], rcx
loc_E1D7D:
mov rax, [rbp+var_18]
cmp qword ptr [rax+20h], 0
jz short loc_E1DC9
mov rax, [rbp+var_18]
mov rdi, [rax+20h]
mov rax, [rbp+var_18]
mov rsi, [rax+28h]
add rsi, 1
mov edx, 10h
call my_once_memdup
mov rcx, [rbp+var_10]
mov [rcx+20h], rax
cmp rax, 0
jnz short loc_E1DB9
jmp loc_E1F59
loc_E1DB9:
mov rax, [rbp+var_18]
mov rcx, [rax+28h]
mov rax, [rbp+var_10]
mov [rax+28h], rcx
loc_E1DC9:
mov rax, [rbp+var_18]
cmp qword ptr [rax+30h], 0
jz short loc_E1DFB
mov rax, [rbp+var_18]
mov rdi, [rax+30h]
mov esi, 10h
call my_once_strdup
mov rcx, [rbp+var_10]
mov [rcx+30h], rax
cmp rax, 0
jnz short loc_E1DF9
jmp loc_E1F59
loc_E1DF9:
jmp short $+2
loc_E1DFB:
mov rax, [rbp+var_18]
cmp qword ptr [rax+40h], 0
jz short loc_E1E44
mov rax, [rbp+var_18]
mov rdi, [rax+40h]
mov esi, 101h
mov edx, 10h
call my_once_memdup
mov rcx, [rbp+var_10]
mov [rcx+40h], rax
cmp rax, 0
jnz short loc_E1E30
jmp loc_E1F59
loc_E1E30:
mov rdi, [rbp+var_10]
call init_state_maps
cmp al, 0
jz short loc_E1E42
jmp loc_E1F59
loc_E1E42:
jmp short $+2
loc_E1E44:
mov rax, [rbp+var_18]
cmp qword ptr [rax+48h], 0
jz short loc_E1E7B
mov rax, [rbp+var_18]
mov rdi, [rax+48h]
mov esi, 100h
mov edx, 10h
call my_once_memdup
mov rcx, [rbp+var_10]
mov [rcx+48h], rax
cmp rax, 0
jnz short loc_E1E79
jmp loc_E1F59
loc_E1E79:
jmp short $+2
loc_E1E7B:
mov rax, [rbp+var_18]
cmp qword ptr [rax+50h], 0
jz short loc_E1EB2
mov rax, [rbp+var_18]
mov rdi, [rax+50h]
mov esi, 100h
mov edx, 10h
call my_once_memdup
mov rcx, [rbp+var_10]
mov [rcx+50h], rax
cmp rax, 0
jnz short loc_E1EB0
jmp loc_E1F59
loc_E1EB0:
jmp short $+2
loc_E1EB2:
mov rax, [rbp+var_18]
cmp qword ptr [rax+58h], 0
jz short loc_E1EE6
mov rax, [rbp+var_18]
mov rdi, [rax+58h]
mov esi, 100h
mov edx, 10h
call my_once_memdup
mov rcx, [rbp+var_10]
mov [rcx+58h], rax
cmp rax, 0
jnz short loc_E1EE4
jmp short loc_E1F59
loc_E1EE4:
jmp short $+2
loc_E1EE6:
mov rax, [rbp+var_18]
cmp qword ptr [rax+68h], 0
jz short loc_E1F21
mov [rbp+var_1C], 200h
mov rax, [rbp+var_18]
mov rdi, [rax+68h]
mov eax, [rbp+var_1C]
mov esi, eax
mov edx, 10h
call my_once_memdup
mov rcx, [rbp+var_10]
mov [rcx+68h], rax
cmp rax, 0
jnz short loc_E1F1F
jmp short loc_E1F59
loc_E1F1F:
jmp short $+2
loc_E1F21:
mov rax, [rbp+var_18]
cmp qword ptr [rax+38h], 0
jz short loc_E1F50
mov rax, [rbp+var_18]
mov rdi, [rax+38h]
mov esi, 10h
call my_once_strdup
mov rcx, [rbp+var_10]
mov [rcx+38h], rax
cmp rax, 0
jnz short loc_E1F4E
jmp short loc_E1F59
loc_E1F4E:
jmp short $+2
loc_E1F50:
mov [rbp+var_4], 0
jmp short loc_E1F60
loc_E1F59:
mov [rbp+var_4], 1
loc_E1F60:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long cs_copy_data(int *a1, int *a2)
{
long long v2; // rax
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
int v12; // [rsp+0h] [rbp-20h]
if ( *a2 )
v12 = *a2;
else
v12 = *a1;
*a1 = v12;
if ( *((_QWORD *)a2 + 2) && !*((_QWORD *)a1 + 2) )
{
v2 = my_once_memdup(*((_QWORD *)a2 + 2), *((_QWORD *)a2 + 3) + 1LL, 16LL);
*((_QWORD *)a1 + 2) = v2;
if ( !v2 )
return 1;
*((_QWORD *)a1 + 3) = *((_QWORD *)a2 + 3);
}
if ( !*((_QWORD *)a2 + 4) )
goto LABEL_11;
v3 = my_once_memdup(*((_QWORD *)a2 + 4), *((_QWORD *)a2 + 5) + 1LL, 16LL);
*((_QWORD *)a1 + 4) = v3;
if ( !v3 )
return 1;
*((_QWORD *)a1 + 5) = *((_QWORD *)a2 + 5);
LABEL_11:
if ( *((_QWORD *)a2 + 6) )
{
v4 = my_once_strdup(*((_QWORD *)a2 + 6), 16LL);
*((_QWORD *)a1 + 6) = v4;
if ( !v4 )
return 1;
}
if ( *((_QWORD *)a2 + 8) )
{
v5 = my_once_memdup(*((_QWORD *)a2 + 8), 257LL, 16LL);
*((_QWORD *)a1 + 8) = v5;
if ( !v5 || (unsigned __int8)init_state_maps(a1) )
return 1;
}
if ( *((_QWORD *)a2 + 9) )
{
v6 = my_once_memdup(*((_QWORD *)a2 + 9), 256LL, 16LL);
*((_QWORD *)a1 + 9) = v6;
if ( !v6 )
return 1;
}
if ( *((_QWORD *)a2 + 10) )
{
v7 = my_once_memdup(*((_QWORD *)a2 + 10), 256LL, 16LL);
*((_QWORD *)a1 + 10) = v7;
if ( !v7 )
return 1;
}
if ( *((_QWORD *)a2 + 11) )
{
v8 = my_once_memdup(*((_QWORD *)a2 + 11), 256LL, 16LL);
*((_QWORD *)a1 + 11) = v8;
if ( !v8 )
return 1;
}
if ( *((_QWORD *)a2 + 13) )
{
v9 = my_once_memdup(*((_QWORD *)a2 + 13), 512LL, 16LL);
*((_QWORD *)a1 + 13) = v9;
if ( !v9 )
return 1;
}
if ( *((_QWORD *)a2 + 7) )
{
v10 = my_once_strdup(*((_QWORD *)a2 + 7), 16LL);
*((_QWORD *)a1 + 7) = v10;
if ( !v10 )
return 1;
}
return 0;
}
| cs_copy_data:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX],0x0
JZ 0x001e1d14
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x20],EAX
JMP 0x001e1d1d
LAB_001e1d14:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x20],EAX
LAB_001e1d1d:
MOV ECX,dword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x10],0x0
JZ 0x001e1d7d
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x10],0x0
JNZ 0x001e1d7d
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RAX + 0x18]
ADD RSI,0x1
MOV EDX,0x10
CALL 0x001fc950
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x10],RAX
CMP RAX,0x0
JNZ 0x001e1d6d
JMP 0x001e1f59
LAB_001e1d6d:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],RCX
LAB_001e1d7d:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x20],0x0
JZ 0x001e1dc9
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RAX + 0x28]
ADD RSI,0x1
MOV EDX,0x10
CALL 0x001fc950
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x20],RAX
CMP RAX,0x0
JNZ 0x001e1db9
JMP 0x001e1f59
LAB_001e1db9:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX + 0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x28],RCX
LAB_001e1dc9:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x30],0x0
JZ 0x001e1dfb
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x30]
MOV ESI,0x10
CALL 0x001fc8f0
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x30],RAX
CMP RAX,0x0
JNZ 0x001e1df9
JMP 0x001e1f59
LAB_001e1df9:
JMP 0x001e1dfb
LAB_001e1dfb:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x40],0x0
JZ 0x001e1e44
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x40]
MOV ESI,0x101
MOV EDX,0x10
CALL 0x001fc950
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x40],RAX
CMP RAX,0x0
JNZ 0x001e1e30
JMP 0x001e1f59
LAB_001e1e30:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001e2070
CMP AL,0x0
JZ 0x001e1e42
JMP 0x001e1f59
LAB_001e1e42:
JMP 0x001e1e44
LAB_001e1e44:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x48],0x0
JZ 0x001e1e7b
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x48]
MOV ESI,0x100
MOV EDX,0x10
CALL 0x001fc950
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x48],RAX
CMP RAX,0x0
JNZ 0x001e1e79
JMP 0x001e1f59
LAB_001e1e79:
JMP 0x001e1e7b
LAB_001e1e7b:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x50],0x0
JZ 0x001e1eb2
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x50]
MOV ESI,0x100
MOV EDX,0x10
CALL 0x001fc950
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x50],RAX
CMP RAX,0x0
JNZ 0x001e1eb0
JMP 0x001e1f59
LAB_001e1eb0:
JMP 0x001e1eb2
LAB_001e1eb2:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x58],0x0
JZ 0x001e1ee6
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x58]
MOV ESI,0x100
MOV EDX,0x10
CALL 0x001fc950
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x58],RAX
CMP RAX,0x0
JNZ 0x001e1ee4
JMP 0x001e1f59
LAB_001e1ee4:
JMP 0x001e1ee6
LAB_001e1ee6:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x68],0x0
JZ 0x001e1f21
MOV dword ptr [RBP + -0x1c],0x200
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x68]
MOV EAX,dword ptr [RBP + -0x1c]
MOV ESI,EAX
MOV EDX,0x10
CALL 0x001fc950
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x68],RAX
CMP RAX,0x0
JNZ 0x001e1f1f
JMP 0x001e1f59
LAB_001e1f1f:
JMP 0x001e1f21
LAB_001e1f21:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x38],0x0
JZ 0x001e1f50
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x38]
MOV ESI,0x10
CALL 0x001fc8f0
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x38],RAX
CMP RAX,0x0
JNZ 0x001e1f4e
JMP 0x001e1f59
LAB_001e1f4e:
JMP 0x001e1f50
LAB_001e1f50:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001e1f60
LAB_001e1f59:
MOV dword ptr [RBP + -0x4],0x1
LAB_001e1f60:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 cs_copy_data(int *param_1,int *param_2)
{
char cVar1;
long lVar2;
int local_28;
int4 local_c;
if (*param_2 == 0) {
local_28 = *param_1;
}
else {
local_28 = *param_2;
}
*param_1 = local_28;
if ((*(long *)(param_2 + 4) == 0) || (*(long *)(param_1 + 4) != 0)) {
LAB_001e1d7d:
if (*(long *)(param_2 + 8) != 0) {
lVar2 = my_once_memdup(*(int8 *)(param_2 + 8),*(long *)(param_2 + 10) + 1,0x10);
*(long *)(param_1 + 8) = lVar2;
if (lVar2 == 0) goto LAB_001e1f59;
*(int8 *)(param_1 + 10) = *(int8 *)(param_2 + 10);
}
if (*(long *)(param_2 + 0xc) != 0) {
lVar2 = my_once_strdup(*(int8 *)(param_2 + 0xc),0x10);
*(long *)(param_1 + 0xc) = lVar2;
if (lVar2 == 0) goto LAB_001e1f59;
}
if (*(long *)(param_2 + 0x10) != 0) {
lVar2 = my_once_memdup(*(int8 *)(param_2 + 0x10),0x101,0x10);
*(long *)(param_1 + 0x10) = lVar2;
if ((lVar2 == 0) || (cVar1 = init_state_maps(param_1), cVar1 != '\0')) goto LAB_001e1f59;
}
if (*(long *)(param_2 + 0x12) != 0) {
lVar2 = my_once_memdup(*(int8 *)(param_2 + 0x12),0x100,0x10);
*(long *)(param_1 + 0x12) = lVar2;
if (lVar2 == 0) goto LAB_001e1f59;
}
if (*(long *)(param_2 + 0x14) != 0) {
lVar2 = my_once_memdup(*(int8 *)(param_2 + 0x14),0x100,0x10);
*(long *)(param_1 + 0x14) = lVar2;
if (lVar2 == 0) goto LAB_001e1f59;
}
if (*(long *)(param_2 + 0x16) != 0) {
lVar2 = my_once_memdup(*(int8 *)(param_2 + 0x16),0x100,0x10);
*(long *)(param_1 + 0x16) = lVar2;
if (lVar2 == 0) goto LAB_001e1f59;
}
if (*(long *)(param_2 + 0x1a) != 0) {
lVar2 = my_once_memdup(*(int8 *)(param_2 + 0x1a),0x200,0x10);
*(long *)(param_1 + 0x1a) = lVar2;
if (lVar2 == 0) goto LAB_001e1f59;
}
if (*(long *)(param_2 + 0xe) != 0) {
lVar2 = my_once_strdup(*(int8 *)(param_2 + 0xe),0x10);
*(long *)(param_1 + 0xe) = lVar2;
if (lVar2 == 0) goto LAB_001e1f59;
}
local_c = 0;
}
else {
lVar2 = my_once_memdup(*(int8 *)(param_2 + 4),*(long *)(param_2 + 6) + 1,0x10);
*(long *)(param_1 + 4) = lVar2;
if (lVar2 != 0) {
*(int8 *)(param_1 + 6) = *(int8 *)(param_2 + 6);
goto LAB_001e1d7d;
}
LAB_001e1f59:
local_c = 1;
}
return local_c;
}
| |
23,974 | uf_blob | eloqsql/storage/maria/ma_packrec.c | static void uf_blob(MARIA_COLUMNDEF *rec, MARIA_BIT_BUFF *bit_buff,
uchar *to, uchar *end)
{
if (get_bit(bit_buff))
bzero(to, (uint) (end-to));
else
{
ulong length=get_bits(bit_buff,rec->space_length_bits);
uint pack_length=(uint) (end-to)-portable_sizeof_char_ptr;
if (bit_buff->blob_pos+length > bit_buff->blob_end)
{
bit_buff->error=1;
bzero(to, (end-to));
return;
}
decode_bytes(rec, bit_buff, bit_buff->blob_pos,
bit_buff->blob_pos + length);
_ma_store_blob_length(to, pack_length, length);
memcpy(to+pack_length, &bit_buff->blob_pos, sizeof(uchar*));
bit_buff->blob_pos+=length;
}
} | O0 | c | uf_blob:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x4b357
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rdx
movl 0x4(%rdx), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rdx)
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x4b37b
jmp 0x4b39a
movq -0x10(%rbp), %rdi
callq 0x49fa0
movq -0x10(%rbp), %rax
movl $0x1f, 0x4(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x0, %eax
je 0x4b39a
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movl %eax, %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x2a2a0
jmp 0x4b499
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x24(%rcx), %eax
jb 0x4b3dd
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x24(%rcx), %esi
movq -0x10(%rbp), %rdx
movl 0x4(%rdx), %ecx
subl %esi, %ecx
movl %ecx, 0x4(%rdx)
shrl %cl, %eax
movq -0x8(%rbp), %rcx
movl 0x24(%rcx), %ecx
movl %ecx, %edx
leaq 0x2806cb(%rip), %rcx # 0x2cbaa0
andl (%rcx,%rdx,4), %eax
movl %eax, -0x30(%rbp)
jmp 0x4b3f0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x24(%rax), %esi
callq 0x49750
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, %eax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
subl $0x8, %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
addq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jbe 0x4b443
movq -0x10(%rbp), %rax
movl $0x1, 0x28(%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
subq %rax, %rdx
xorl %esi, %esi
callq 0x2a2a0
jmp 0x4b499
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
addq -0x28(%rbp), %rcx
callq 0x4a2e0
movq -0x18(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x28(%rbp), %rax
movl %eax, %edx
callq 0x50500
movq -0x18(%rbp), %rax
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rdx
movq 0x18(%rdx), %rdx
movq %rdx, (%rax,%rcx)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
| uf_blob:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov rax, [rbp+var_10]
cmp dword ptr [rax+4], 0
jz short loc_4B357
mov rax, [rbp+var_10]
mov eax, [rax]
mov rdx, [rbp+var_10]
mov ecx, [rdx+4]
add ecx, 0FFFFFFFFh
mov [rdx+4], ecx
mov edx, 1
shl edx, cl
mov ecx, edx
and eax, ecx
cmp eax, 0
jnz short loc_4B37B
jmp short loc_4B39A
loc_4B357:
mov rdi, [rbp+var_10]
call fill_buffer
mov rax, [rbp+var_10]
mov dword ptr [rax+4], 1Fh
mov rax, [rbp+var_10]
mov eax, [rax]
and eax, 80000000h
cmp eax, 0
jz short loc_4B39A
loc_4B37B:
mov rdi, [rbp+var_18]
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
sub rax, rcx
mov eax, eax
mov edx, eax
xor esi, esi
call _memset
jmp loc_4B499
loc_4B39A:
mov rax, [rbp+var_10]
mov eax, [rax+4]
mov rcx, [rbp+var_8]
cmp eax, [rcx+24h]
jb short loc_4B3DD
mov rax, [rbp+var_10]
mov eax, [rax]
mov rcx, [rbp+var_8]
mov esi, [rcx+24h]
mov rdx, [rbp+var_10]
mov ecx, [rdx+4]
sub ecx, esi
mov [rdx+4], ecx
shr eax, cl
mov rcx, [rbp+var_8]
mov ecx, [rcx+24h]
mov edx, ecx
lea rcx, mask
and eax, [rcx+rdx*4]
mov [rbp+var_30], eax
jmp short loc_4B3F0
loc_4B3DD:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_8]
mov esi, [rax+24h]
call fill_and_get_bits
mov [rbp+var_30], eax
loc_4B3F0:
mov eax, [rbp+var_30]
mov eax, eax
mov [rbp+var_28], rax
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
sub rax, rcx
sub eax, 8
mov [rbp+var_2C], eax
mov rax, [rbp+var_10]
mov rax, [rax+18h]
add rax, [rbp+var_28]
mov rcx, [rbp+var_10]
cmp rax, [rcx+20h]
jbe short loc_4B443
mov rax, [rbp+var_10]
mov dword ptr [rax+28h], 1
mov rdi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov rax, [rbp+var_18]
sub rdx, rax
xor esi, esi
call _memset
jmp short loc_4B499
loc_4B443:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rax, [rbp+var_10]
mov rdx, [rax+18h]
mov rax, [rbp+var_10]
mov rcx, [rax+18h]
add rcx, [rbp+var_28]
call decode_bytes
mov rdi, [rbp+var_18]
mov esi, [rbp+var_2C]
mov rax, [rbp+var_28]
mov edx, eax
call _ma_store_blob_length
mov rax, [rbp+var_18]
mov ecx, [rbp+var_2C]
mov rdx, [rbp+var_10]
mov rdx, [rdx+18h]
mov [rax+rcx], rdx
mov rcx, [rbp+var_28]
mov rax, [rbp+var_10]
add rcx, [rax+18h]
mov [rax+18h], rcx
loc_4B499:
add rsp, 30h
pop rbp
retn
| long long uf_blob(long long a1, long long a2, long long a3, long long a4)
{
int v4; // eax
int v5; // ecx
long long result; // rax
unsigned int v7; // eax
int v8; // ecx
unsigned int bits; // [rsp+0h] [rbp-30h]
unsigned int v10; // [rsp+4h] [rbp-2Ch]
if ( *(_DWORD *)(a2 + 4) )
{
v4 = *(_DWORD *)a2;
v5 = *(_DWORD *)(a2 + 4) - 1;
*(_DWORD *)(a2 + 4) = v5;
if ( ((1 << v5) & v4) == 0 )
goto LABEL_6;
return memset(a3, 0LL, (unsigned int)(a4 - a3));
}
fill_buffer(a2);
*(_DWORD *)(a2 + 4) = 31;
if ( *(int *)a2 < 0 )
return memset(a3, 0LL, (unsigned int)(a4 - a3));
LABEL_6:
if ( *(_DWORD *)(a2 + 4) < *(_DWORD *)(a1 + 36) )
{
bits = fill_and_get_bits((_DWORD *)a2, *(_DWORD *)(a1 + 36));
}
else
{
v7 = *(_DWORD *)a2;
v8 = *(_DWORD *)(a2 + 4) - *(_DWORD *)(a1 + 36);
*(_DWORD *)(a2 + 4) = v8;
bits = mask[*(unsigned int *)(a1 + 36)] & (v7 >> v8);
}
v10 = a4 - a3 - 8;
if ( (unsigned long long)bits + *(_QWORD *)(a2 + 24) <= *(_QWORD *)(a2 + 32) )
{
decode_bytes(a1, a2, *(_BYTE **)(a2 + 24), (_BYTE *)(bits + *(_QWORD *)(a2 + 24)));
ma_store_blob_length(a3, v10, bits);
*(_QWORD *)(a3 + v10) = *(_QWORD *)(a2 + 24);
result = a2;
*(_QWORD *)(a2 + 24) += bits;
}
else
{
*(_DWORD *)(a2 + 40) = 1;
return memset(a3, 0LL, a4 - a3);
}
return result;
}
| uf_blob:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x4],0x0
JZ 0x0014b357
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RDX + 0x4]
ADD ECX,-0x1
MOV dword ptr [RDX + 0x4],ECX
MOV EDX,0x1
SHL EDX,CL
MOV ECX,EDX
AND EAX,ECX
CMP EAX,0x0
JNZ 0x0014b37b
JMP 0x0014b39a
LAB_0014b357:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00149fa0
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x4],0x1f
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
AND EAX,0x80000000
CMP EAX,0x0
JZ 0x0014b39a
LAB_0014b37b:
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
SUB RAX,RCX
MOV EAX,EAX
MOV EDX,EAX
XOR ESI,ESI
CALL 0x0012a2a0
JMP 0x0014b499
LAB_0014b39a:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x4]
MOV RCX,qword ptr [RBP + -0x8]
CMP EAX,dword ptr [RCX + 0x24]
JC 0x0014b3dd
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RCX + 0x24]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RDX + 0x4]
SUB ECX,ESI
MOV dword ptr [RDX + 0x4],ECX
SHR EAX,CL
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x24]
MOV EDX,ECX
LEA RCX,[0x3cbaa0]
AND EAX,dword ptr [RCX + RDX*0x4]
MOV dword ptr [RBP + -0x30],EAX
JMP 0x0014b3f0
LAB_0014b3dd:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RAX + 0x24]
CALL 0x00149750
MOV dword ptr [RBP + -0x30],EAX
LAB_0014b3f0:
MOV EAX,dword ptr [RBP + -0x30]
MOV EAX,EAX
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
SUB RAX,RCX
SUB EAX,0x8
MOV dword ptr [RBP + -0x2c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x18]
ADD RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x20]
JBE 0x0014b443
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x28],0x1
MOV RDI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
SUB RDX,RAX
XOR ESI,ESI
CALL 0x0012a2a0
JMP 0x0014b499
LAB_0014b443:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x18]
ADD RCX,qword ptr [RBP + -0x28]
CALL 0x0014a2e0
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x28]
MOV EDX,EAX
CALL 0x00150500
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x2c]
MOV RDX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RDX + 0x18]
MOV qword ptr [RAX + RCX*0x1],RDX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RAX + 0x18]
MOV qword ptr [RAX + 0x18],RCX
LAB_0014b499:
ADD RSP,0x30
POP RBP
RET
|
void uf_blob(long param_1,uint *param_2,void *param_3,long param_4)
{
uint uVar1;
ulong uVar2;
uint local_38;
if (param_2[1] == 0) {
fill_buffer(param_2);
param_2[1] = 0x1f;
uVar1 = *param_2 & 0x80000000;
}
else {
uVar1 = param_2[1];
param_2[1] = uVar1 - 1;
uVar1 = *param_2 & 1 << ((byte)(uVar1 - 1) & 0x1f);
}
if (uVar1 == 0) {
if (param_2[1] < *(uint *)(param_1 + 0x24)) {
local_38 = fill_and_get_bits(param_2);
}
else {
uVar1 = param_2[1] - *(int *)(param_1 + 0x24);
param_2[1] = uVar1;
local_38 = *param_2 >> ((byte)uVar1 & 0x1f) &
*(uint *)(mask + (ulong)*(uint *)(param_1 + 0x24) * 4);
}
uVar2 = (ulong)local_38;
uVar1 = ((int)param_4 - (int)param_3) - 8;
if (*(ulong *)(param_2 + 8) < *(long *)(param_2 + 6) + uVar2) {
param_2[10] = 1;
memset(param_3,0,param_4 - (long)param_3);
}
else {
decode_bytes(param_1,param_2,*(int8 *)(param_2 + 6),*(long *)(param_2 + 6) + uVar2);
_ma_store_blob_length(param_3,uVar1,uVar2);
*(int8 *)((long)param_3 + (ulong)uVar1) = *(int8 *)(param_2 + 6);
*(ulong *)(param_2 + 6) = uVar2 + *(long *)(param_2 + 6);
}
}
else {
memset(param_3,0,(ulong)(uint)((int)param_4 - (int)param_3));
}
return;
}
| |
23,975 | mysql_hex_string | eloqsql/libmariadb/libmariadb/mariadb_lib.c | ulong STDCALL mysql_hex_string(char *to, const char *from, unsigned long len)
{
char *start= to;
char hexdigits[]= "0123456789ABCDEF";
while (len--)
{
*to++= hexdigits[((unsigned char)*from) >> 4];
*to++= hexdigits[((unsigned char)*from) & 0x0F];
from++;
}
*to= 0;
return (ulong)(to - start);
} | O0 | c | mysql_hex_string:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x92a00(%rip), %rax # 0xe65d0
movq %rax, -0x20(%rbp)
movq 0x929fd(%rip), %rax # 0xe65d8
movq %rax, -0x18(%rbp)
movb 0x929fb(%rip), %al # 0xe65e0
movb %al, -0x10(%rbp)
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x38(%rbp)
cmpq $0x0, %rax
je 0x53c4d
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
sarl $0x4, %eax
cltq
movb -0x20(%rbp,%rax), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
andl $0xf, %eax
cltq
movb -0x20(%rbp,%rax), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x53be8
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x48(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x53c7f
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
callq 0x382c0
nopw %cs:(%rax,%rax)
| mysql_hex_string:
push rbp
mov rbp, rsp
sub rsp, 50h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov [rbp+var_38], rdx
mov rax, [rbp+var_28]
mov [rbp+var_40], rax
mov rax, cs:qword_E65D0
mov [rbp+var_20], rax
mov rax, cs:qword_E65D8
mov [rbp+var_18], rax
mov al, cs:byte_E65E0
mov [rbp+var_10], al
loc_53BE8:
mov rax, [rbp+var_38]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_38], rcx
cmp rax, 0
jz short loc_53C4D
mov rax, [rbp+var_30]
movzx eax, byte ptr [rax]
sar eax, 4
cdqe
mov cl, byte ptr [rbp+rax+var_20]
mov rax, [rbp+var_28]
mov rdx, rax
add rdx, 1
mov [rbp+var_28], rdx
mov [rax], cl
mov rax, [rbp+var_30]
movzx eax, byte ptr [rax]
and eax, 0Fh
cdqe
mov cl, byte ptr [rbp+rax+var_20]
mov rax, [rbp+var_28]
mov rdx, rax
add rdx, 1
mov [rbp+var_28], rdx
mov [rax], cl
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
jmp short loc_53BE8
loc_53C4D:
mov rax, [rbp+var_28]
mov byte ptr [rax], 0
mov rax, [rbp+var_28]
mov rcx, [rbp+var_40]
sub rax, rcx
mov [rbp+var_48], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_53C7F
mov rax, [rbp+var_48]
add rsp, 50h
pop rbp
retn
loc_53C7F:
call ___stack_chk_fail
| _BYTE * mysql_hex_string(_BYTE *a1, unsigned __int8 *a2, long long a3)
{
_BYTE *v4; // rax
_BYTE *v8; // [rsp+28h] [rbp-28h]
char v9[24]; // [rsp+30h] [rbp-20h] BYREF
unsigned long long v10; // [rsp+48h] [rbp-8h]
v10 = __readfsqword(0x28u);
v8 = a1;
strcpy(v9, "0123456789ABCDEF");
while ( a3-- )
{
*v8 = v9[(int)*a2 >> 4];
v4 = v8 + 1;
v8 += 2;
*v4 = v9[*a2++ & 0xF];
}
*v8 = 0;
return (_BYTE *)(v8 - a1);
}
| mysql_hex_string:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV qword ptr [RBP + -0x38],RDX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [0x001e65d0]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [0x001e65d8]
MOV qword ptr [RBP + -0x18],RAX
MOV AL,byte ptr [0x001e65e0]
MOV byte ptr [RBP + -0x10],AL
LAB_00153be8:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,RAX
ADD RCX,-0x1
MOV qword ptr [RBP + -0x38],RCX
CMP RAX,0x0
JZ 0x00153c4d
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX]
SAR EAX,0x4
CDQE
MOV CL,byte ptr [RBP + RAX*0x1 + -0x20]
MOV RAX,qword ptr [RBP + -0x28]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x28],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX]
AND EAX,0xf
CDQE
MOV CL,byte ptr [RBP + RAX*0x1 + -0x20]
MOV RAX,qword ptr [RBP + -0x28]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x28],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00153be8
LAB_00153c4d:
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x40]
SUB RAX,RCX
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00153c7f
MOV RAX,qword ptr [RBP + -0x48]
ADD RSP,0x50
POP RBP
RET
LAB_00153c7f:
CALL 0x001382c0
|
long mysql_hex_string(char *param_1,byte *param_2,long param_3)
{
char *pcVar1;
long in_FS_OFFSET;
long local_40;
byte *local_38;
char *local_30;
char local_28 [16];
char local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_28._0_8_ = s_0123456789ABCDEF_001e65d0._0_8_;
local_28._8_8_ = s_0123456789ABCDEF_001e65d0._8_8_;
local_18 = s_0123456789ABCDEF_001e65d0[0x10];
local_40 = param_3;
local_38 = param_2;
local_30 = param_1;
while (local_40 != 0) {
pcVar1 = local_30 + 1;
*local_30 = local_28[(int)(uint)*local_38 >> 4];
local_30 = local_30 + 2;
*pcVar1 = local_28[(int)(*local_38 & 0xf)];
local_38 = local_38 + 1;
local_40 = local_40 + -1;
}
*local_30 = '\0';
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return (long)local_30 - (long)param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
23,976 | mysql_hex_string | eloqsql/libmariadb/libmariadb/mariadb_lib.c | ulong STDCALL mysql_hex_string(char *to, const char *from, unsigned long len)
{
char *start= to;
char hexdigits[]= "0123456789ABCDEF";
while (len--)
{
*to++= hexdigits[((unsigned char)*from) >> 4];
*to++= hexdigits[((unsigned char)*from) & 0x0F];
from++;
}
*to= 0;
return (ulong)(to - start);
} | O3 | c | mysql_hex_string:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
testq %rdx, %rdx
je 0x4b597
xorl %ecx, %ecx
leaq 0x60009(%rip), %r8 # 0xab570
movq %rdi, %rax
movzbl (%rsi,%rcx), %r9d
shrl $0x4, %r9d
movb (%r9,%r8), %r9b
movb %r9b, (%rax)
movzbl (%rsi,%rcx), %r9d
andl $0xf, %r9d
movb (%r9,%r8), %r9b
movb %r9b, 0x1(%rax)
addq $0x2, %rax
incq %rcx
cmpq %rcx, %rdx
jne 0x4b56a
movb $0x0, (%rax)
subq %rdi, %rax
popq %rbp
retq
| mysql_hex_string:
push rbp
mov rbp, rsp
mov rax, rdi
test rdx, rdx
jz short loc_4B597
xor ecx, ecx
lea r8, a0123456789abcd; "0123456789ABCDEF"
mov rax, rdi
loc_4B56A:
movzx r9d, byte ptr [rsi+rcx]
shr r9d, 4
mov r9b, [r9+r8]
mov [rax], r9b
movzx r9d, byte ptr [rsi+rcx]
and r9d, 0Fh
mov r9b, [r9+r8]
mov [rax+1], r9b
add rax, 2
inc rcx
cmp rdx, rcx
jnz short loc_4B56A
loc_4B597:
mov byte ptr [rax], 0
sub rax, rdi
pop rbp
retn
| _BYTE * mysql_hex_string(_BYTE *a1, long long a2, long long a3)
{
_BYTE *v3; // rax
long long v4; // rcx
v3 = a1;
if ( a3 )
{
v4 = 0LL;
v3 = a1;
do
{
*v3 = a0123456789abcd[*(unsigned __int8 *)(a2 + v4) >> 4];
v3[1] = a0123456789abcd[*(_BYTE *)(a2 + v4) & 0xF];
v3 += 2;
++v4;
}
while ( a3 != v4 );
}
*v3 = 0;
return (_BYTE *)(v3 - a1);
}
| mysql_hex_string:
PUSH RBP
MOV RBP,RSP
MOV RAX,RDI
TEST RDX,RDX
JZ 0x0014b597
XOR ECX,ECX
LEA R8,[0x1ab570]
MOV RAX,RDI
LAB_0014b56a:
MOVZX R9D,byte ptr [RSI + RCX*0x1]
SHR R9D,0x4
MOV R9B,byte ptr [R9 + R8*0x1]
MOV byte ptr [RAX],R9B
MOVZX R9D,byte ptr [RSI + RCX*0x1]
AND R9D,0xf
MOV R9B,byte ptr [R9 + R8*0x1]
MOV byte ptr [RAX + 0x1],R9B
ADD RAX,0x2
INC RCX
CMP RDX,RCX
JNZ 0x0014b56a
LAB_0014b597:
MOV byte ptr [RAX],0x0
SUB RAX,RDI
POP RBP
RET
|
long mysql_hex_string(char *param_1,long param_2,long param_3)
{
char *pcVar1;
long lVar2;
pcVar1 = param_1;
if (param_3 != 0) {
lVar2 = 0;
do {
*pcVar1 = "0123456789ABCDEF"[*(byte *)(param_2 + lVar2) >> 4];
pcVar1[1] = "0123456789ABCDEF"[*(byte *)(param_2 + lVar2) & 0xf];
pcVar1 = pcVar1 + 2;
lVar2 = lVar2 + 1;
} while (param_3 != lVar2);
}
*pcVar1 = '\0';
return (long)pcVar1 - (long)param_1;
}
| |
23,977 | Catch::TestCaseTracking::SectionTracker::acquire(Catch::TestCaseTracking::TrackerContext&, Catch::TestCaseTracking::NameAndLocationRef const&) | AlayaLite/build_O3/_deps/libcoro-src/test/catch_amalgamated.cpp | SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocationRef const& nameAndLocation ) {
SectionTracker* tracker;
ITracker& currentTracker = ctx.currentTracker();
if ( ITracker* childTracker =
currentTracker.findChild( nameAndLocation ) ) {
assert( childTracker );
assert( childTracker->isSectionTracker() );
tracker = static_cast<SectionTracker*>( childTracker );
} else {
auto newTracker = Catch::Detail::make_unique<SectionTracker>(
NameAndLocation{ static_cast<std::string>(nameAndLocation.name),
nameAndLocation.location },
ctx,
¤tTracker );
tracker = newTracker.get();
currentTracker.addChild( CATCH_MOVE( newTracker ) );
}
if ( !ctx.completedCycle() ) {
tracker->tryOpen();
}
return *tracker;
} | O3 | cpp | Catch::TestCaseTracking::SectionTracker::acquire(Catch::TestCaseTracking::TrackerContext&, Catch::TestCaseTracking::NameAndLocationRef const&):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x62454
movq %rax, %r15
testq %rax, %rax
jne 0x5efb0
movq (%r12), %rsi
leaq 0x18(%rsp), %r13
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %r13, -0x10(%r13)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x37312
addq $0x10, %r12
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x62406
leaq 0x58(%rsp), %rcx
movq %r14, (%rcx)
movq %rsp, %rdi
leaq 0x28(%rsp), %rsi
movq %rbx, %rdx
callq 0x78de3
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5ef5a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x17150
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x5ef71
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x17150
movq (%rsp), %r15
movq $0x0, (%rsp)
leaq 0x28(%rsp), %rsi
movq %r15, (%rsi)
addq $0x40, %r14
movq %r14, %rdi
callq 0x88c82
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x5efa1
movq (%rdi), %rax
callq *0x8(%rax)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5efb0
movq (%rdi), %rax
callq *0x8(%rax)
cmpl $0x2, 0x10(%rbx)
je 0x5efbe
movq %r15, %rdi
callq 0x62aac
movq %r15, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x5efe2
movq (%rdi), %rax
callq *0x8(%rax)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5f02d
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x5f02d
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5f016
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x17150
jmp 0x5f016
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x5f02d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x17150
movq %rbx, %rdi
callq 0x17740
nop
| _ZN5Catch16TestCaseTracking14SectionTracker7acquireERNS0_14TrackerContextERKNS0_18NameAndLocationRefE:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 60h
mov r12, rsi
mov rbx, rdi
mov r14, [rdi+8]
mov rdi, r14
call _ZN5Catch16TestCaseTracking8ITracker9findChildERKNS0_18NameAndLocationRefE; Catch::TestCaseTracking::ITracker::findChild(Catch::TestCaseTracking::NameAndLocationRef const&)
mov r15, rax
test rax, rax
jnz loc_5EFB0
mov rsi, [r12]
lea r13, [rsp+88h+var_70]
mov rdx, [r12+8]
add rdx, rsi
mov [r13-10h], r13
lea r15, [rsp+88h+var_80]
mov rdi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
add r12, 10h
lea rdi, [rsp+88h+var_60]
mov rsi, r15
mov rdx, r12
call _ZN5Catch16TestCaseTracking15NameAndLocationC2EONSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_14SourceLineInfoE; Catch::TestCaseTracking::NameAndLocation::NameAndLocation(std::string &&,Catch::SourceLineInfo const&)
lea rcx, [rsp+88h+var_30]
mov [rcx], r14
mov rdi, rsp
lea rsi, [rsp+88h+var_60]
mov rdx, rbx
call _ZN5Catch6Detail11make_uniqueINS_16TestCaseTracking14SectionTrackerEJNS2_15NameAndLocationERNS2_14TrackerContextEPNS2_8ITrackerEEEENS0_10unique_ptrIT_EEDpOT0_; Catch::Detail::make_unique<Catch::TestCaseTracking::SectionTracker,Catch::TestCaseTracking::NameAndLocation,Catch::TestCaseTracking::TrackerContext &,Catch::TestCaseTracking::ITracker *>(Catch::TestCaseTracking::NameAndLocation,Catch::TestCaseTracking::TrackerContext &,Catch::TestCaseTracking::ITracker * &&)
lea rax, [rsp+88h+var_50]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_5EF5A
mov rsi, [rsp+88h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5EF5A:
mov rdi, [rsp+88h+var_80]; void *
cmp rdi, r13
jz short loc_5EF71
mov rsi, [rsp+88h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5EF71:
mov r15, [rsp+88h+var_88]
mov [rsp+88h+var_88], 0
lea rsi, [rsp+88h+var_60]
mov [rsi], r15
add r14, 40h ; '@'
mov rdi, r14
call _ZNSt6vectorIN5Catch6Detail10unique_ptrINS0_16TestCaseTracking8ITrackerEEESaIS5_EE12emplace_backIJS5_EEERS5_DpOT_; std::vector<Catch::Detail::unique_ptr<Catch::TestCaseTracking::ITracker>>::emplace_back<Catch::Detail::unique_ptr<Catch::TestCaseTracking::ITracker>>(Catch::Detail::unique_ptr<Catch::TestCaseTracking::ITracker> &&)
mov rdi, [rsp+88h+var_60]
test rdi, rdi
jz short loc_5EFA1
mov rax, [rdi]
call qword ptr [rax+8]
loc_5EFA1:
mov rdi, [rsp+88h+var_88]
test rdi, rdi
jz short loc_5EFB0
mov rax, [rdi]
call qword ptr [rax+8]
loc_5EFB0:
cmp dword ptr [rbx+10h], 2
jz short loc_5EFBE
mov rdi, r15; this
call _ZN5Catch16TestCaseTracking14SectionTracker7tryOpenEv; Catch::TestCaseTracking::SectionTracker::tryOpen(void)
loc_5EFBE:
mov rax, r15
add rsp, 60h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov rbx, rax
mov rdi, [rsp+arg_20]
test rdi, rdi
jz short loc_5EFE2
mov rax, [rdi]
call qword ptr [rax+8]
loc_5EFE2:
mov rdi, [rsp+0]
test rdi, rdi
jz short loc_5F02D
mov rax, [rdi]
call qword ptr [rax+8]
jmp short loc_5F02D
mov rbx, rax
lea rax, [rsp+arg_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_5F016
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_5F016
mov rbx, rax
loc_5F016:
mov rdi, [rsp+arg_0]; void *
cmp rdi, r13
jz short loc_5F02D
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5F02D:
mov rdi, rbx
call __Unwind_Resume
| void * Catch::TestCaseTracking::SectionTracker::acquire(long long a1, long long a2)
{
long long v3; // r14
void *Child; // r15
_BYTE *v5; // rsi
long long v6; // rdx
void *v8; // [rsp+0h] [rbp-88h] BYREF
void *v9[2]; // [rsp+8h] [rbp-80h] BYREF
_QWORD v10[2]; // [rsp+18h] [rbp-70h] BYREF
void *v11[2]; // [rsp+28h] [rbp-60h] BYREF
_QWORD v12[10]; // [rsp+38h] [rbp-50h] BYREF
v3 = *(_QWORD *)(a1 + 8);
Child = (void *)Catch::TestCaseTracking::ITracker::findChild(v3);
if ( !Child )
{
v5 = *(_BYTE **)a2;
v6 = *(_QWORD *)a2 + *(_QWORD *)(a2 + 8);
v9[0] = v10;
std::string::_M_construct<char const*>(v9, v5, v6);
Catch::TestCaseTracking::NameAndLocation::NameAndLocation(v11, v9);
v12[4] = v3;
Catch::Detail::make_unique<Catch::TestCaseTracking::SectionTracker,Catch::TestCaseTracking::NameAndLocation,Catch::TestCaseTracking::TrackerContext &,Catch::TestCaseTracking::ITracker *>(
&v8,
v11,
a1);
if ( v11[0] != v12 )
operator delete(v11[0], v12[0] + 1LL);
if ( v9[0] != v10 )
operator delete(v9[0], v10[0] + 1LL);
Child = v8;
v8 = 0LL;
v11[0] = Child;
std::vector<Catch::Detail::unique_ptr<Catch::TestCaseTracking::ITracker>>::emplace_back<Catch::Detail::unique_ptr<Catch::TestCaseTracking::ITracker>>(v3 + 64);
if ( v11[0] )
(*(void ( **)(void *))(*(_QWORD *)v11[0] + 8LL))(v11[0]);
if ( v8 )
(*(void ( **)(void *))(*(_QWORD *)v8 + 8LL))(v8);
}
if ( *(_DWORD *)(a1 + 16) != 2 )
Catch::TestCaseTracking::SectionTracker::tryOpen((Catch::TestCaseTracking::SectionTracker *)Child);
return Child;
}
| acquire:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x60
MOV R12,RSI
MOV RBX,RDI
MOV R14,qword ptr [RDI + 0x8]
MOV RDI,R14
CALL 0x00162454
MOV R15,RAX
TEST RAX,RAX
JNZ 0x0015efb0
MOV RSI,qword ptr [R12]
LEA R13,[RSP + 0x18]
MOV RDX,qword ptr [R12 + 0x8]
ADD RDX,RSI
MOV qword ptr [R13 + -0x10],R13
LEA R15,[RSP + 0x8]
MOV RDI,R15
CALL 0x00137312
ADD R12,0x10
LAB_0015ef17:
LEA RDI,[RSP + 0x28]
MOV RSI,R15
MOV RDX,R12
CALL 0x00162406
LEA RCX,[RSP + 0x58]
MOV qword ptr [RCX],R14
LAB_0015ef2f:
MOV RDI,RSP
LEA RSI,[RSP + 0x28]
MOV RDX,RBX
CALL 0x00178de3
LEA RAX,[RSP + 0x38]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0015ef5a
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x00117150
LAB_0015ef5a:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R13
JZ 0x0015ef71
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00117150
LAB_0015ef71:
MOV R15,qword ptr [RSP]
MOV qword ptr [RSP],0x0
LEA RSI,[RSP + 0x28]
MOV qword ptr [RSI],R15
ADD R14,0x40
LAB_0015ef89:
MOV RDI,R14
CALL 0x00188c82
LAB_0015ef91:
MOV RDI,qword ptr [RSP + 0x28]
TEST RDI,RDI
JZ 0x0015efa1
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0015efa1:
MOV RDI,qword ptr [RSP]
TEST RDI,RDI
JZ 0x0015efb0
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0015efb0:
CMP dword ptr [RBX + 0x10],0x2
JZ 0x0015efbe
MOV RDI,R15
CALL 0x00162aac
LAB_0015efbe:
MOV RAX,R15
ADD RSP,0x60
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* Catch::TestCaseTracking::SectionTracker::acquire(Catch::TestCaseTracking::TrackerContext&,
Catch::TestCaseTracking::NameAndLocationRef const&) */
SectionTracker *
Catch::TestCaseTracking::SectionTracker::acquire
(TrackerContext *param_1,NameAndLocationRef *param_2)
{
ITracker *this;
SectionTracker *this_00;
SectionTracker *local_88;
long *local_80 [2];
long local_70 [2];
SectionTracker *local_60 [2];
long local_50 [4];
ITracker *local_30;
this = *(ITracker **)(param_1 + 8);
this_00 = (SectionTracker *)ITracker::findChild(this,param_2);
if (this_00 == (SectionTracker *)0x0) {
local_80[0] = local_70;
std::__cxx11::string::_M_construct<char_const*>
((string *)local_80,*(long *)param_2,*(long *)(param_2 + 8) + *(long *)param_2);
/* try { // try from 0015ef17 to 0015ef26 has its CatchHandler @ 0015f013 */
NameAndLocation::NameAndLocation
((NameAndLocation *)local_60,(string *)local_80,(SourceLineInfo *)(param_2 + 0x10));
/* try { // try from 0015ef2f to 0015ef3e has its CatchHandler @ 0015eff3 */
local_30 = this;
Detail::
make_unique<Catch::TestCaseTracking::SectionTracker,Catch::TestCaseTracking::NameAndLocation,Catch::TestCaseTracking::TrackerContext&,Catch::TestCaseTracking::ITracker*>
((Detail *)&local_88,(NameAndLocation *)local_60,param_1,&local_30);
if (local_60[0] != (SectionTracker *)local_50) {
operator_delete(local_60[0],local_50[0] + 1);
}
if (local_80[0] != local_70) {
operator_delete(local_80[0],local_70[0] + 1);
}
this_00 = local_88;
local_88 = (SectionTracker *)0x0;
local_60[0] = this_00;
/* try { // try from 0015ef89 to 0015ef90 has its CatchHandler @ 0015efcf */
std::
vector<Catch::Detail::unique_ptr<Catch::TestCaseTracking::ITracker>,std::allocator<Catch::Detail::unique_ptr<Catch::TestCaseTracking::ITracker>>>
::emplace_back<Catch::Detail::unique_ptr<Catch::TestCaseTracking::ITracker>>
((vector<Catch::Detail::unique_ptr<Catch::TestCaseTracking::ITracker>,std::allocator<Catch::Detail::unique_ptr<Catch::TestCaseTracking::ITracker>>>
*)(this + 0x40),(unique_ptr *)local_60);
if (local_60[0] != (SectionTracker *)0x0) {
(**(code **)(*(long *)local_60[0] + 8))();
}
if (local_88 != (SectionTracker *)0x0) {
(**(code **)(*(long *)local_88 + 8))();
}
}
if (*(int *)(param_1 + 0x10) != 2) {
tryOpen(this_00);
}
return this_00;
}
| |
23,978 | my_strntoull_8bit | eloqsql/strings/ctype-simple.c | ulonglong my_strntoull_8bit(CHARSET_INFO *cs,
const char *nptr, size_t l, int base,
char **endptr, int *err)
{
int negative;
register ulonglong cutoff;
register uint cutlim;
register ulonglong i;
register const char *s, *e;
const char *save;
int overflow;
*err= 0; /* Initialize error indicator */
s = nptr;
e = nptr+l;
for(; s<e && my_isspace(cs,*s); s++);
if (s == e)
{
goto noconv;
}
if (*s == '-')
{
negative = 1;
++s;
}
else if (*s == '+')
{
negative = 0;
++s;
}
else
negative = 0;
save = s;
cutoff = (~(ulonglong) 0) / (unsigned long int) base;
cutlim = (uint) ((~(ulonglong) 0) % (unsigned long int) base);
overflow = 0;
i = 0;
for ( ; s != e; s++)
{
register uchar c= *s;
if (c>='0' && c<='9')
c -= '0';
else if (c>='A' && c<='Z')
c = c - 'A' + 10;
else if (c>='a' && c<='z')
c = c - 'a' + 10;
else
break;
if (c >= base)
break;
if (i > cutoff || (i == cutoff && c > cutlim))
overflow = 1;
else
{
i *= (ulonglong) base;
i += c;
}
}
if (s == save)
goto noconv;
if (endptr != NULL)
*endptr = (char *) s;
if (overflow)
{
err[0]= ERANGE;
return (~(ulonglong) 0);
}
return (negative ? -((longlong) i) : (longlong) i);
noconv:
err[0]= EDOM;
if (endptr != NULL)
*endptr = (char *) nptr;
return 0L;
} | O0 | c | my_strntoull_8bit:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rcx
xorl %eax, %eax
cmpq -0x68(%rbp), %rcx
movb %al, -0x76(%rbp)
jae 0x3bd28
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x60(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl 0x1(%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x76(%rbp)
movb -0x76(%rbp), %al
testb $0x1, %al
jne 0x3bd31
jmp 0x3bd41
jmp 0x3bd33
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x3bcf9
movq -0x60(%rbp), %rax
cmpq -0x68(%rbp), %rax
jne 0x3bd50
jmp 0x3bf11
movq -0x60(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x3bd71
movl $0x1, -0x3c(%rbp)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x3bd9b
movq -0x60(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x3bd92
movl $0x0, -0x3c(%rbp)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x3bd99
movl $0x0, -0x3c(%rbp)
jmp 0x3bd9b
movq -0x60(%rbp), %rax
movq %rax, -0x70(%rbp)
movslq -0x24(%rbp), %rcx
movq $-0x1, %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x48(%rbp)
movslq -0x24(%rbp), %rcx
movq $-0x1, %rax
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x4c(%rbp)
movl $0x0, -0x74(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x60(%rbp), %rax
cmpq -0x68(%rbp), %rax
je 0x3beb5
movq -0x60(%rbp), %rax
movb (%rax), %al
movb %al, -0x75(%rbp)
movzbl -0x75(%rbp), %eax
cmpl $0x30, %eax
jl 0x3be10
movzbl -0x75(%rbp), %eax
cmpl $0x39, %eax
jg 0x3be10
movzbl -0x75(%rbp), %eax
subl $0x30, %eax
movb %al, -0x75(%rbp)
jmp 0x3be58
movzbl -0x75(%rbp), %eax
cmpl $0x41, %eax
jl 0x3be31
movzbl -0x75(%rbp), %eax
cmpl $0x5a, %eax
jg 0x3be31
movzbl -0x75(%rbp), %eax
subl $0x41, %eax
addl $0xa, %eax
movb %al, -0x75(%rbp)
jmp 0x3be56
movzbl -0x75(%rbp), %eax
cmpl $0x61, %eax
jl 0x3be52
movzbl -0x75(%rbp), %eax
cmpl $0x7a, %eax
jg 0x3be52
movzbl -0x75(%rbp), %eax
subl $0x61, %eax
addl $0xa, %eax
movb %al, -0x75(%rbp)
jmp 0x3be54
jmp 0x3beb5
jmp 0x3be56
jmp 0x3be58
movzbl -0x75(%rbp), %eax
cmpl -0x24(%rbp), %eax
jl 0x3be63
jmp 0x3beb5
movq -0x58(%rbp), %rax
cmpq -0x48(%rbp), %rax
ja 0x3be80
movq -0x58(%rbp), %rax
cmpq -0x48(%rbp), %rax
jne 0x3be89
movzbl -0x75(%rbp), %eax
cmpl -0x4c(%rbp), %eax
jbe 0x3be89
movl $0x1, -0x74(%rbp)
jmp 0x3bea2
movslq -0x24(%rbp), %rax
imulq -0x58(%rbp), %rax
movq %rax, -0x58(%rbp)
movzbl -0x75(%rbp), %eax
addq -0x58(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x3bea4
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x3bddb
movq -0x60(%rbp), %rax
cmpq -0x70(%rbp), %rax
jne 0x3bec1
jmp 0x3bf11
cmpq $0x0, -0x30(%rbp)
je 0x3bed3
movq -0x60(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
cmpl $0x0, -0x74(%rbp)
je 0x3beed
movq -0x38(%rbp), %rax
movl $0x22, (%rax)
movq $-0x1, -0x8(%rbp)
jmp 0x3bf35
cmpl $0x0, -0x3c(%rbp)
je 0x3beff
xorl %eax, %eax
subq -0x58(%rbp), %rax
movq %rax, -0x80(%rbp)
jmp 0x3bf07
movq -0x58(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3bf35
movq -0x38(%rbp), %rax
movl $0x21, (%rax)
cmpq $0x0, -0x30(%rbp)
je 0x3bf2d
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
| my_strntoull_8bit:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
mov rax, [rbp+var_38]
mov dword ptr [rax], 0
mov rax, [rbp+var_18]
mov [rbp+var_60], rax
mov rax, [rbp+var_18]
add rax, [rbp+var_20]
mov [rbp+var_68], rax
loc_3BCF9:
mov rcx, [rbp+var_60]
xor eax, eax
cmp rcx, [rbp+var_68]
mov [rbp+var_76], al
jnb short loc_3BD28
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rcx, [rbp+var_60]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx+1]
and eax, 8
cmp eax, 0
setnz al
mov [rbp+var_76], al
loc_3BD28:
mov al, [rbp+var_76]
test al, 1
jnz short loc_3BD31
jmp short loc_3BD41
loc_3BD31:
jmp short $+2
loc_3BD33:
mov rax, [rbp+var_60]
add rax, 1
mov [rbp+var_60], rax
jmp short loc_3BCF9
loc_3BD41:
mov rax, [rbp+var_60]
cmp rax, [rbp+var_68]
jnz short loc_3BD50
jmp loc_3BF11
loc_3BD50:
mov rax, [rbp+var_60]
movsx eax, byte ptr [rax]
cmp eax, 2Dh ; '-'
jnz short loc_3BD71
mov [rbp+var_3C], 1
mov rax, [rbp+var_60]
add rax, 1
mov [rbp+var_60], rax
jmp short loc_3BD9B
loc_3BD71:
mov rax, [rbp+var_60]
movsx eax, byte ptr [rax]
cmp eax, 2Bh ; '+'
jnz short loc_3BD92
mov [rbp+var_3C], 0
mov rax, [rbp+var_60]
add rax, 1
mov [rbp+var_60], rax
jmp short loc_3BD99
loc_3BD92:
mov [rbp+var_3C], 0
loc_3BD99:
jmp short $+2
loc_3BD9B:
mov rax, [rbp+var_60]
mov [rbp+var_70], rax
movsxd rcx, [rbp+var_24]
mov rax, 0FFFFFFFFFFFFFFFFh
xor edx, edx
div rcx
mov [rbp+var_48], rax
movsxd rcx, [rbp+var_24]
mov rax, 0FFFFFFFFFFFFFFFFh
xor edx, edx
div rcx
mov eax, edx
mov [rbp+var_4C], eax
mov [rbp+var_74], 0
mov [rbp+var_58], 0
loc_3BDDB:
mov rax, [rbp+var_60]
cmp rax, [rbp+var_68]
jz loc_3BEB5
mov rax, [rbp+var_60]
mov al, [rax]
mov [rbp+var_75], al
movzx eax, [rbp+var_75]
cmp eax, 30h ; '0'
jl short loc_3BE10
movzx eax, [rbp+var_75]
cmp eax, 39h ; '9'
jg short loc_3BE10
movzx eax, [rbp+var_75]
sub eax, 30h ; '0'
mov [rbp+var_75], al
jmp short loc_3BE58
loc_3BE10:
movzx eax, [rbp+var_75]
cmp eax, 41h ; 'A'
jl short loc_3BE31
movzx eax, [rbp+var_75]
cmp eax, 5Ah ; 'Z'
jg short loc_3BE31
movzx eax, [rbp+var_75]
sub eax, 41h ; 'A'
add eax, 0Ah
mov [rbp+var_75], al
jmp short loc_3BE56
loc_3BE31:
movzx eax, [rbp+var_75]
cmp eax, 61h ; 'a'
jl short loc_3BE52
movzx eax, [rbp+var_75]
cmp eax, 7Ah ; 'z'
jg short loc_3BE52
movzx eax, [rbp+var_75]
sub eax, 61h ; 'a'
add eax, 0Ah
mov [rbp+var_75], al
jmp short loc_3BE54
loc_3BE52:
jmp short loc_3BEB5
loc_3BE54:
jmp short $+2
loc_3BE56:
jmp short $+2
loc_3BE58:
movzx eax, [rbp+var_75]
cmp eax, [rbp+var_24]
jl short loc_3BE63
jmp short loc_3BEB5
loc_3BE63:
mov rax, [rbp+var_58]
cmp rax, [rbp+var_48]
ja short loc_3BE80
mov rax, [rbp+var_58]
cmp rax, [rbp+var_48]
jnz short loc_3BE89
movzx eax, [rbp+var_75]
cmp eax, [rbp+var_4C]
jbe short loc_3BE89
loc_3BE80:
mov [rbp+var_74], 1
jmp short loc_3BEA2
loc_3BE89:
movsxd rax, [rbp+var_24]
imul rax, [rbp+var_58]
mov [rbp+var_58], rax
movzx eax, [rbp+var_75]
add rax, [rbp+var_58]
mov [rbp+var_58], rax
loc_3BEA2:
jmp short $+2
loc_3BEA4:
mov rax, [rbp+var_60]
add rax, 1
mov [rbp+var_60], rax
jmp loc_3BDDB
loc_3BEB5:
mov rax, [rbp+var_60]
cmp rax, [rbp+var_70]
jnz short loc_3BEC1
jmp short loc_3BF11
loc_3BEC1:
cmp [rbp+var_30], 0
jz short loc_3BED3
mov rcx, [rbp+var_60]
mov rax, [rbp+var_30]
mov [rax], rcx
loc_3BED3:
cmp [rbp+var_74], 0
jz short loc_3BEED
mov rax, [rbp+var_38]
mov dword ptr [rax], 22h ; '"'
mov [rbp+var_8], 0FFFFFFFFFFFFFFFFh
jmp short loc_3BF35
loc_3BEED:
cmp [rbp+var_3C], 0
jz short loc_3BEFF
xor eax, eax
sub rax, [rbp+var_58]
mov [rbp+var_80], rax
jmp short loc_3BF07
loc_3BEFF:
mov rax, [rbp+var_58]
mov [rbp+var_80], rax
loc_3BF07:
mov rax, [rbp+var_80]
mov [rbp+var_8], rax
jmp short loc_3BF35
loc_3BF11:
mov rax, [rbp+var_38]
mov dword ptr [rax], 21h ; '!'
cmp [rbp+var_30], 0
jz short loc_3BF2D
mov rcx, [rbp+var_18]
mov rax, [rbp+var_30]
mov [rax], rcx
loc_3BF2D:
mov [rbp+var_8], 0
loc_3BF35:
mov rax, [rbp+var_8]
pop rbp
retn
| long long my_strntoull_8bit(long long a1, _BYTE *a2, long long a3, int a4, _QWORD *a5, _DWORD *a6)
{
bool v8; // [rsp+Ah] [rbp-76h]
unsigned __int8 v9; // [rsp+Bh] [rbp-75h]
unsigned __int8 v10; // [rsp+Bh] [rbp-75h]
int v11; // [rsp+Ch] [rbp-74h]
_BYTE *v12; // [rsp+10h] [rbp-70h]
_BYTE *v13; // [rsp+18h] [rbp-68h]
_BYTE *v14; // [rsp+20h] [rbp-60h]
unsigned long long v15; // [rsp+28h] [rbp-58h]
unsigned long long v16; // [rsp+38h] [rbp-48h]
int v17; // [rsp+44h] [rbp-3Ch]
*a6 = 0;
v14 = a2;
v13 = &a2[a3];
while ( 1 )
{
v8 = 0;
if ( v14 < v13 )
v8 = (*(_BYTE *)(*(_QWORD *)(a1 + 64) + (unsigned __int8)*v14 + 1LL) & 8) != 0;
if ( !v8 )
break;
++v14;
}
if ( v14 == v13 )
goto LABEL_39;
if ( *v14 == 45 )
{
v17 = 1;
++v14;
}
else
{
v17 = 0;
if ( *v14 == 43 )
++v14;
}
v12 = v14;
v16 = 0xFFFFFFFFFFFFFFFFLL / a4;
v11 = 0;
v15 = 0LL;
while ( v14 != v13 )
{
v9 = *v14;
if ( (unsigned __int8)*v14 < 0x30u || v9 > 0x39u )
{
if ( v9 < 0x41u || v9 > 0x5Au )
{
if ( v9 < 0x61u || v9 > 0x7Au )
break;
v10 = v9 - 97 + 10;
}
else
{
v10 = v9 - 65 + 10;
}
}
else
{
v10 = v9 - 48;
}
if ( v10 >= a4 )
break;
if ( v15 > v16 || v15 == v16 && v10 > (unsigned int)(0xFFFFFFFFFFFFFFFFLL % a4) )
v11 = 1;
else
v15 = v15 * a4 + v10;
++v14;
}
if ( v14 == v12 )
{
LABEL_39:
*a6 = 33;
if ( a5 )
*a5 = a2;
return 0LL;
}
else
{
if ( a5 )
*a5 = v14;
if ( v11 )
{
*a6 = 34;
return -1LL;
}
else if ( v17 )
{
return -(long long)v15;
}
else
{
return v15;
}
}
}
| my_strntoull_8bit:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x68],RAX
LAB_0013bcf9:
MOV RCX,qword ptr [RBP + -0x60]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x68]
MOV byte ptr [RBP + -0x76],AL
JNC 0x0013bd28
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x60]
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x1]
AND EAX,0x8
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x76],AL
LAB_0013bd28:
MOV AL,byte ptr [RBP + -0x76]
TEST AL,0x1
JNZ 0x0013bd31
JMP 0x0013bd41
LAB_0013bd31:
JMP 0x0013bd33
LAB_0013bd33:
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x1
MOV qword ptr [RBP + -0x60],RAX
JMP 0x0013bcf9
LAB_0013bd41:
MOV RAX,qword ptr [RBP + -0x60]
CMP RAX,qword ptr [RBP + -0x68]
JNZ 0x0013bd50
JMP 0x0013bf11
LAB_0013bd50:
MOV RAX,qword ptr [RBP + -0x60]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2d
JNZ 0x0013bd71
MOV dword ptr [RBP + -0x3c],0x1
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x1
MOV qword ptr [RBP + -0x60],RAX
JMP 0x0013bd9b
LAB_0013bd71:
MOV RAX,qword ptr [RBP + -0x60]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2b
JNZ 0x0013bd92
MOV dword ptr [RBP + -0x3c],0x0
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x1
MOV qword ptr [RBP + -0x60],RAX
JMP 0x0013bd99
LAB_0013bd92:
MOV dword ptr [RBP + -0x3c],0x0
LAB_0013bd99:
JMP 0x0013bd9b
LAB_0013bd9b:
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x70],RAX
MOVSXD RCX,dword ptr [RBP + -0x24]
MOV RAX,-0x1
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x48],RAX
MOVSXD RCX,dword ptr [RBP + -0x24]
MOV RAX,-0x1
XOR EDX,EDX
DIV RCX
MOV EAX,EDX
MOV dword ptr [RBP + -0x4c],EAX
MOV dword ptr [RBP + -0x74],0x0
MOV qword ptr [RBP + -0x58],0x0
LAB_0013bddb:
MOV RAX,qword ptr [RBP + -0x60]
CMP RAX,qword ptr [RBP + -0x68]
JZ 0x0013beb5
MOV RAX,qword ptr [RBP + -0x60]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x75],AL
MOVZX EAX,byte ptr [RBP + -0x75]
CMP EAX,0x30
JL 0x0013be10
MOVZX EAX,byte ptr [RBP + -0x75]
CMP EAX,0x39
JG 0x0013be10
MOVZX EAX,byte ptr [RBP + -0x75]
SUB EAX,0x30
MOV byte ptr [RBP + -0x75],AL
JMP 0x0013be58
LAB_0013be10:
MOVZX EAX,byte ptr [RBP + -0x75]
CMP EAX,0x41
JL 0x0013be31
MOVZX EAX,byte ptr [RBP + -0x75]
CMP EAX,0x5a
JG 0x0013be31
MOVZX EAX,byte ptr [RBP + -0x75]
SUB EAX,0x41
ADD EAX,0xa
MOV byte ptr [RBP + -0x75],AL
JMP 0x0013be56
LAB_0013be31:
MOVZX EAX,byte ptr [RBP + -0x75]
CMP EAX,0x61
JL 0x0013be52
MOVZX EAX,byte ptr [RBP + -0x75]
CMP EAX,0x7a
JG 0x0013be52
MOVZX EAX,byte ptr [RBP + -0x75]
SUB EAX,0x61
ADD EAX,0xa
MOV byte ptr [RBP + -0x75],AL
JMP 0x0013be54
LAB_0013be52:
JMP 0x0013beb5
LAB_0013be54:
JMP 0x0013be56
LAB_0013be56:
JMP 0x0013be58
LAB_0013be58:
MOVZX EAX,byte ptr [RBP + -0x75]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x0013be63
JMP 0x0013beb5
LAB_0013be63:
MOV RAX,qword ptr [RBP + -0x58]
CMP RAX,qword ptr [RBP + -0x48]
JA 0x0013be80
MOV RAX,qword ptr [RBP + -0x58]
CMP RAX,qword ptr [RBP + -0x48]
JNZ 0x0013be89
MOVZX EAX,byte ptr [RBP + -0x75]
CMP EAX,dword ptr [RBP + -0x4c]
JBE 0x0013be89
LAB_0013be80:
MOV dword ptr [RBP + -0x74],0x1
JMP 0x0013bea2
LAB_0013be89:
MOVSXD RAX,dword ptr [RBP + -0x24]
IMUL RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x58],RAX
MOVZX EAX,byte ptr [RBP + -0x75]
ADD RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x58],RAX
LAB_0013bea2:
JMP 0x0013bea4
LAB_0013bea4:
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x1
MOV qword ptr [RBP + -0x60],RAX
JMP 0x0013bddb
LAB_0013beb5:
MOV RAX,qword ptr [RBP + -0x60]
CMP RAX,qword ptr [RBP + -0x70]
JNZ 0x0013bec1
JMP 0x0013bf11
LAB_0013bec1:
CMP qword ptr [RBP + -0x30],0x0
JZ 0x0013bed3
MOV RCX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
LAB_0013bed3:
CMP dword ptr [RBP + -0x74],0x0
JZ 0x0013beed
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x22
MOV qword ptr [RBP + -0x8],-0x1
JMP 0x0013bf35
LAB_0013beed:
CMP dword ptr [RBP + -0x3c],0x0
JZ 0x0013beff
XOR EAX,EAX
SUB RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x80],RAX
JMP 0x0013bf07
LAB_0013beff:
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x80],RAX
LAB_0013bf07:
MOV RAX,qword ptr [RBP + -0x80]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0013bf35
LAB_0013bf11:
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x21
CMP qword ptr [RBP + -0x30],0x0
JZ 0x0013bf2d
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
LAB_0013bf2d:
MOV qword ptr [RBP + -0x8],0x0
LAB_0013bf35:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
ulong my_strntoull_8bit(long param_1,byte *param_2,long param_3,int param_4,int8 *param_5,
int4 *param_6)
{
int1 auVar1 [16];
int1 auVar2 [16];
bool bVar3;
byte *pbVar4;
byte *pbVar5;
ulong uVar6;
bool bVar7;
ulong local_88;
byte local_7d;
byte *local_68;
ulong local_60;
*param_6 = 0;
pbVar5 = param_2 + param_3;
local_68 = param_2;
while( true ) {
bVar7 = false;
if (local_68 < pbVar5) {
bVar7 = (*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)*local_68) & 8) != 0;
}
if (!bVar7) break;
local_68 = local_68 + 1;
}
if (local_68 != pbVar5) {
if (*local_68 == 0x2d) {
bVar7 = true;
local_68 = local_68 + 1;
}
else {
if (*local_68 == 0x2b) {
local_68 = local_68 + 1;
}
bVar7 = false;
}
pbVar4 = local_68;
auVar1._8_8_ = 0;
auVar1._0_8_ = (long)param_4;
uVar6 = SUB168((ZEXT816(0) << 0x40 | ZEXT816(0xffffffffffffffff)) / auVar1,0);
auVar2._8_8_ = 0;
auVar2._0_8_ = (long)param_4;
bVar3 = false;
local_60 = 0;
for (; local_68 != pbVar5; local_68 = local_68 + 1) {
local_7d = *local_68;
if ((local_7d < 0x30) || (0x39 < local_7d)) {
if ((local_7d < 0x41) || (0x5a < local_7d)) {
if ((local_7d < 0x61) || (0x7a < local_7d)) break;
local_7d = local_7d + 0xa9;
}
else {
local_7d = local_7d - 0x37;
}
}
else {
local_7d = local_7d - 0x30;
}
if (param_4 <= (int)(uint)local_7d) break;
if ((uVar6 < local_60) ||
((local_60 == uVar6 &&
(SUB164((ZEXT816(0) << 0x40 | ZEXT816(0xffffffffffffffff)) % auVar2,0) < (uint)local_7d)))
) {
bVar3 = true;
}
else {
local_60 = (ulong)local_7d + (long)param_4 * local_60;
}
}
if (local_68 != pbVar4) {
if (param_5 != (int8 *)0x0) {
*param_5 = local_68;
}
if (bVar3) {
*param_6 = 0x22;
return 0xffffffffffffffff;
}
if (bVar7) {
local_88 = -local_60;
}
else {
local_88 = local_60;
}
return local_88;
}
}
*param_6 = 0x21;
if (param_5 != (int8 *)0x0) {
*param_5 = param_2;
}
return 0;
}
| |
23,979 | my_strntoull_8bit | eloqsql/strings/ctype-simple.c | ulonglong my_strntoull_8bit(CHARSET_INFO *cs,
const char *nptr, size_t l, int base,
char **endptr, int *err)
{
int negative;
register ulonglong cutoff;
register uint cutlim;
register ulonglong i;
register const char *s, *e;
const char *save;
int overflow;
*err= 0; /* Initialize error indicator */
s = nptr;
e = nptr+l;
for(; s<e && my_isspace(cs,*s); s++);
if (s == e)
{
goto noconv;
}
if (*s == '-')
{
negative = 1;
++s;
}
else if (*s == '+')
{
negative = 0;
++s;
}
else
negative = 0;
save = s;
cutoff = (~(ulonglong) 0) / (unsigned long int) base;
cutlim = (uint) ((~(ulonglong) 0) % (unsigned long int) base);
overflow = 0;
i = 0;
for ( ; s != e; s++)
{
register uchar c= *s;
if (c>='0' && c<='9')
c -= '0';
else if (c>='A' && c<='Z')
c = c - 'A' + 10;
else if (c>='a' && c<='z')
c = c - 'a' + 10;
else
break;
if (c >= base)
break;
if (i > cutoff || (i == cutoff && c > cutlim))
overflow = 1;
else
{
i *= (ulonglong) base;
i += c;
}
}
if (s == save)
goto noconv;
if (endptr != NULL)
*endptr = (char *) s;
if (overflow)
{
err[0]= ERANGE;
return (~(ulonglong) 0);
}
return (negative ? -((longlong) i) : (longlong) i);
noconv:
err[0]= EDOM;
if (endptr != NULL)
*endptr = (char *) nptr;
return 0L;
} | O3 | c | my_strntoull_8bit:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl $0x0, (%r9)
leaq (%rsi,%rdx), %r11
movq %rsi, %r10
testq %rdx, %rdx
jle 0x36d15
movq 0x40(%rdi), %rax
movq %rsi, %r10
movzbl (%r10), %edx
testb $0x8, 0x1(%rax,%rdx)
je 0x36d15
incq %r10
cmpq %r11, %r10
jb 0x36d02
cmpq %r11, %r10
je 0x36dfd
movb (%r10), %dil
leal -0x2b(%rdi), %eax
andb $-0x3, %al
cmpb $0x1, %al
adcq $0x0, %r10
movslq %ecx, %rbx
movq $-0x1, %rax
xorl %edx, %edx
movq %rbx, -0x38(%rbp)
divq %rbx
xorl %r12d, %r12d
cmpq %r11, %r10
je 0x36dda
movq %rdi, -0x30(%rbp)
movq %r10, %r14
xorl %r15d, %r15d
movq %r15, %rdi
movl %r12d, %r13d
movb (%r14), %r12b
leal -0x30(%r12), %ebx
cmpb $0xa, %bl
jb 0x36d89
leal -0x41(%r12), %ebx
cmpb $0x19, %bl
ja 0x36d78
addb $-0x37, %r12b
jmp 0x36d86
leal -0x61(%r12), %ebx
cmpb $0x19, %bl
ja 0x36dc8
addb $-0x57, %r12b
movl %r12d, %ebx
movzbl %bl, %ebx
cmpl %ecx, %ebx
jge 0x36dc8
movl $0x1, %r12d
cmpq %rax, %rdi
jbe 0x36da0
movq %rdi, %r15
jmp 0x36db7
jne 0x36da9
movq %rax, %r15
cmpl %edx, %ebx
ja 0x36db7
imulq -0x38(%rbp), %rdi
movl %ebx, %r15d
addq %rdi, %r15
movl %r13d, %r12d
incq %r14
cmpq %r11, %r14
jne 0x36d55
movq %r15, %rdi
movq %r11, %r14
movl %r12d, %r13d
testl %r13d, %r13d
sete %al
movq %rdi, %r12
movq %r14, %r11
movq -0x30(%rbp), %rdi
jmp 0x36ddc
movb $0x1, %al
cmpq %r10, %r11
je 0x36dfd
testq %r8, %r8
je 0x36de9
movq %r11, (%r8)
testb %al, %al
je 0x36e10
movq %r12, %rax
negq %rax
cmpb $0x2d, %dil
cmovneq %r12, %rax
jmp 0x36e1e
movl $0x21, (%r9)
testq %r8, %r8
je 0x36e0c
movq %rsi, (%r8)
xorl %eax, %eax
jmp 0x36e1e
movl $0x22, (%r9)
movq $-0x1, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_strntoull_8bit:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
mov dword ptr [r9], 0
lea r11, [rsi+rdx]
mov r10, rsi
test rdx, rdx
jle short loc_36D15
mov rax, [rdi+40h]
mov r10, rsi
loc_36D02:
movzx edx, byte ptr [r10]
test byte ptr [rax+rdx+1], 8
jz short loc_36D15
inc r10
cmp r10, r11
jb short loc_36D02
loc_36D15:
cmp r10, r11
jz loc_36DFD
mov dil, [r10]
lea eax, [rdi-2Bh]
and al, 0FDh
cmp al, 1
adc r10, 0
movsxd rbx, ecx
mov rax, 0FFFFFFFFFFFFFFFFh
xor edx, edx
mov [rbp+var_38], rbx
div rbx
xor r12d, r12d
cmp r10, r11
jz loc_36DDA
mov [rbp+var_30], rdi
mov r14, r10
xor r15d, r15d
loc_36D55:
mov rdi, r15
mov r13d, r12d
mov r12b, [r14]
lea ebx, [r12-30h]
cmp bl, 0Ah
jb short loc_36D89
lea ebx, [r12-41h]
cmp bl, 19h
ja short loc_36D78
add r12b, 0C9h
jmp short loc_36D86
loc_36D78:
lea ebx, [r12-61h]
cmp bl, 19h
ja short loc_36DC8
add r12b, 0A9h
loc_36D86:
mov ebx, r12d
loc_36D89:
movzx ebx, bl
cmp ebx, ecx
jge short loc_36DC8
mov r12d, 1
cmp rdi, rax
jbe short loc_36DA0
mov r15, rdi
jmp short loc_36DB7
loc_36DA0:
jnz short loc_36DA9
mov r15, rax
cmp ebx, edx
ja short loc_36DB7
loc_36DA9:
imul rdi, [rbp+var_38]
mov r15d, ebx
add r15, rdi
mov r12d, r13d
loc_36DB7:
inc r14
cmp r14, r11
jnz short loc_36D55
mov rdi, r15
mov r14, r11
mov r13d, r12d
loc_36DC8:
test r13d, r13d
setz al
mov r12, rdi
mov r11, r14
mov rdi, [rbp+var_30]
jmp short loc_36DDC
loc_36DDA:
mov al, 1
loc_36DDC:
cmp r11, r10
jz short loc_36DFD
test r8, r8
jz short loc_36DE9
mov [r8], r11
loc_36DE9:
test al, al
jz short loc_36E10
mov rax, r12
neg rax
cmp dil, 2Dh ; '-'
cmovnz rax, r12
jmp short loc_36E1E
loc_36DFD:
mov dword ptr [r9], 21h ; '!'
test r8, r8
jz short loc_36E0C
mov [r8], rsi
loc_36E0C:
xor eax, eax
jmp short loc_36E1E
loc_36E10:
mov dword ptr [r9], 22h ; '"'
mov rax, 0FFFFFFFFFFFFFFFFh
loc_36E1E:
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_strntoull_8bit(
long long a1,
unsigned __int8 *a2,
long long a3,
int a4,
unsigned __int8 **a5,
_DWORD *a6)
{
unsigned __int8 *v6; // r11
unsigned __int8 *v7; // r10
unsigned __int8 v8; // di
unsigned __int8 *v9; // r10
unsigned long long v10; // rax
unsigned long long v11; // r12
unsigned __int8 *v12; // r14
unsigned long long v13; // r15
unsigned long long v14; // rdi
int v15; // r13d
unsigned __int8 v16; // r12
unsigned __int8 v17; // bl
unsigned __int8 v18; // r12
bool v19; // al
long long result; // rax
unsigned __int8 v21; // [rsp+8h] [rbp-30h]
*a6 = 0;
v6 = &a2[a3];
v7 = a2;
if ( a3 > 0 )
{
v7 = a2;
do
{
if ( (*(_BYTE *)(*(_QWORD *)(a1 + 64) + *v7 + 1LL) & 8) == 0 )
break;
++v7;
}
while ( v7 < v6 );
}
if ( v7 == v6 )
goto LABEL_30;
v8 = *v7;
v9 = &v7[((*v7 - 43) & 0xFD) == 0];
v10 = 0xFFFFFFFFFFFFFFFFLL / a4;
v11 = 0LL;
if ( v9 == v6 )
{
v19 = 1;
}
else
{
v21 = v8;
v12 = v9;
v13 = 0LL;
while ( 1 )
{
v14 = v13;
v15 = v11;
v16 = *v12;
v17 = *v12 - 48;
if ( v17 >= 0xAu )
{
if ( (unsigned __int8)(v16 - 65) > 0x19u )
{
if ( (unsigned __int8)(v16 - 97) > 0x19u )
break;
v18 = v16 - 87;
}
else
{
v18 = v16 - 55;
}
v17 = v18;
}
if ( v17 >= a4 )
break;
LODWORD(v11) = 1;
if ( v13 <= v10 )
{
if ( v13 != v10 || (v13 = 0xFFFFFFFFFFFFFFFFLL / a4, v17 <= (unsigned int)(0xFFFFFFFFFFFFFFFFLL % a4)) )
{
v13 = a4 * v14 + v17;
LODWORD(v11) = v15;
}
}
if ( ++v12 == v6 )
{
v14 = v13;
v12 = &a2[a3];
v15 = v11;
break;
}
}
v19 = v15 == 0;
v11 = v14;
v6 = v12;
v8 = v21;
}
if ( v6 == v9 )
{
LABEL_30:
*a6 = 33;
if ( a5 )
*a5 = a2;
return 0LL;
}
else
{
if ( a5 )
*a5 = v6;
if ( v19 )
{
result = -(long long)v11;
if ( v8 != 45 )
return v11;
}
else
{
*a6 = 34;
return -1LL;
}
}
return result;
}
| my_strntoull_8bit:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV dword ptr [R9],0x0
LEA R11,[RSI + RDX*0x1]
MOV R10,RSI
TEST RDX,RDX
JLE 0x00136d15
MOV RAX,qword ptr [RDI + 0x40]
MOV R10,RSI
LAB_00136d02:
MOVZX EDX,byte ptr [R10]
TEST byte ptr [RAX + RDX*0x1 + 0x1],0x8
JZ 0x00136d15
INC R10
CMP R10,R11
JC 0x00136d02
LAB_00136d15:
CMP R10,R11
JZ 0x00136dfd
MOV DIL,byte ptr [R10]
LEA EAX,[RDI + -0x2b]
AND AL,0xfd
CMP AL,0x1
ADC R10,0x0
MOVSXD RBX,ECX
MOV RAX,-0x1
XOR EDX,EDX
MOV qword ptr [RBP + -0x38],RBX
DIV RBX
XOR R12D,R12D
CMP R10,R11
JZ 0x00136dda
MOV qword ptr [RBP + -0x30],RDI
MOV R14,R10
XOR R15D,R15D
LAB_00136d55:
MOV RDI,R15
MOV R13D,R12D
MOV R12B,byte ptr [R14]
LEA EBX,[R12 + -0x30]
CMP BL,0xa
JC 0x00136d89
LEA EBX,[R12 + -0x41]
CMP BL,0x19
JA 0x00136d78
ADD R12B,0xc9
JMP 0x00136d86
LAB_00136d78:
LEA EBX,[R12 + -0x61]
CMP BL,0x19
JA 0x00136dc8
ADD R12B,0xa9
LAB_00136d86:
MOV EBX,R12D
LAB_00136d89:
MOVZX EBX,BL
CMP EBX,ECX
JGE 0x00136dc8
MOV R12D,0x1
CMP RDI,RAX
JBE 0x00136da0
MOV R15,RDI
JMP 0x00136db7
LAB_00136da0:
JNZ 0x00136da9
MOV R15,RAX
CMP EBX,EDX
JA 0x00136db7
LAB_00136da9:
IMUL RDI,qword ptr [RBP + -0x38]
MOV R15D,EBX
ADD R15,RDI
MOV R12D,R13D
LAB_00136db7:
INC R14
CMP R14,R11
JNZ 0x00136d55
MOV RDI,R15
MOV R14,R11
MOV R13D,R12D
LAB_00136dc8:
TEST R13D,R13D
SETZ AL
MOV R12,RDI
MOV R11,R14
MOV RDI,qword ptr [RBP + -0x30]
JMP 0x00136ddc
LAB_00136dda:
MOV AL,0x1
LAB_00136ddc:
CMP R11,R10
JZ 0x00136dfd
TEST R8,R8
JZ 0x00136de9
MOV qword ptr [R8],R11
LAB_00136de9:
TEST AL,AL
JZ 0x00136e10
MOV RAX,R12
NEG RAX
CMP DIL,0x2d
CMOVNZ RAX,R12
JMP 0x00136e1e
LAB_00136dfd:
MOV dword ptr [R9],0x21
TEST R8,R8
JZ 0x00136e0c
MOV qword ptr [R8],RSI
LAB_00136e0c:
XOR EAX,EAX
JMP 0x00136e1e
LAB_00136e10:
MOV dword ptr [R9],0x22
MOV RAX,-0x1
LAB_00136e1e:
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong my_strntoull_8bit(long param_1,byte *param_2,long param_3,int param_4,ulong *param_5,
int4 *param_6)
{
byte bVar1;
byte bVar2;
int1 auVar3 [16];
int1 auVar4 [16];
ulong uVar5;
ulong uVar6;
ulong uVar7;
byte *pbVar8;
byte *pbVar9;
byte bVar10;
ulong uVar11;
ulong uVar12;
int iVar13;
byte *pbVar14;
bool bVar15;
*param_6 = 0;
pbVar9 = param_2 + param_3;
pbVar8 = param_2;
if (0 < param_3) {
do {
if ((*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)*pbVar8) & 8) == 0) break;
pbVar8 = pbVar8 + 1;
} while (pbVar8 < pbVar9);
}
if (pbVar8 != pbVar9) {
bVar1 = *pbVar8;
pbVar8 = pbVar8 + ((bVar1 - 0x2b & 0xfd) == 0);
auVar3._8_8_ = 0;
auVar3._0_8_ = (long)param_4;
auVar4 = ZEXT816(0) << 0x40 | ZEXT816(0xffffffffffffffff);
uVar6 = SUB168(auVar4 / auVar3,0);
uVar7 = 0;
if (pbVar8 == pbVar9) {
bVar15 = true;
}
else {
uVar11 = uVar7;
pbVar14 = pbVar8;
uVar7 = 0;
do {
iVar13 = (int)uVar11;
bVar2 = *pbVar14;
bVar10 = bVar2 - 0x30;
if (9 < bVar10) {
if ((byte)(bVar2 + 0xbf) < 0x1a) {
bVar10 = bVar2 - 0x37;
}
else {
if (0x19 < (byte)(bVar2 + 0x9f)) goto LAB_00136dc8;
bVar10 = bVar2 + 0xa9;
}
}
if (param_4 <= (int)(uint)bVar10) goto LAB_00136dc8;
uVar12 = 1;
uVar5 = uVar7;
if ((uVar7 <= uVar6) &&
((uVar7 != uVar6 || (uVar5 = uVar6, (uint)bVar10 <= SUB164(auVar4 % auVar3,0))))) {
uVar12 = uVar11;
uVar5 = (ulong)bVar10 + uVar7 * (long)param_4;
}
uVar7 = uVar5;
pbVar14 = pbVar14 + 1;
uVar11 = uVar12;
} while (pbVar14 != pbVar9);
iVar13 = (int)uVar12;
pbVar14 = pbVar9;
LAB_00136dc8:
pbVar9 = pbVar14;
bVar15 = iVar13 == 0;
}
if (pbVar9 != pbVar8) {
if (param_5 != (ulong *)0x0) {
*param_5 = (ulong)pbVar9;
}
if (bVar15) {
if (bVar1 == 0x2d) {
return -uVar7;
}
return uVar7;
}
*param_6 = 0x22;
return 0xffffffffffffffff;
}
}
*param_6 = 0x21;
if (param_5 != (ulong *)0x0) {
*param_5 = (ulong)param_2;
}
return 0;
}
| |
23,980 | js_instantiate_prototype | bluesky950520[P]quickjs/quickjs.c | static JSValue js_instantiate_prototype(JSContext *ctx, JSObject *p, JSAtom atom, void *opaque)
{
JSValue obj, this_val;
int ret;
this_val = JS_MKPTR(JS_TAG_OBJECT, p);
obj = JS_NewObject(ctx);
if (JS_IsException(obj))
return JS_EXCEPTION;
set_cycle_flag(ctx, obj);
set_cycle_flag(ctx, this_val);
ret = JS_DefinePropertyValue(ctx, obj, JS_ATOM_constructor,
js_dup(this_val),
JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
if (ret < 0) {
JS_FreeValue(ctx, obj);
return JS_EXCEPTION;
}
return obj;
} | O1 | c | js_instantiate_prototype:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
movq %rsi, 0x8(%rsp)
movq 0x40(%rdi), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
movl $0x1, %ecx
callq 0x20f05
movq %rdx, %r14
movl $0x6, %ebx
cmpl $0x6, %r14d
je 0x3de62
movq %rax, %r12
movq 0x8(%rsp), %xmm0
movq %xmm0, %r8
movq %xmm0, 0x10(%rsp)
movq 0x10(%rsp), %rax
incl (%rax)
movl $0x3, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movl $0x3d, %ecx
movq $-0x1, %r9
callq 0x26abb
testl %eax, %eax
js 0x3de53
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %r12, %rcx
andq %rax, %rcx
movl %r12d, %eax
movq %r14, %rbx
jmp 0x3de66
movq 0x18(%r15), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x1d8c6
xorl %eax, %eax
xorl %ecx, %ecx
orq %rcx, %rax
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| js_instantiate_prototype:
push r15
push r14
push r12
push rbx
sub rsp, 18h
mov r15, rdi
mov [rsp+38h+var_30], rsi
mov rax, [rdi+40h]
mov rsi, [rax+10h]
mov rdx, [rax+18h]
mov ecx, 1
call JS_NewObjectProtoClass
mov r14, rdx
mov ebx, 6
cmp r14d, 6
jz short loc_3DE62
mov r12, rax
movq xmm0, [rsp+38h+var_30]
movq r8, xmm0
movq [rsp+38h+var_28], xmm0
mov rax, [rsp+38h+var_28]
inc dword ptr [rax]
mov [rsp+38h+var_38], 3
mov rdi, r15
mov rsi, r12
mov rdx, r14
mov ecx, 3Dh ; '='
mov r9, 0FFFFFFFFFFFFFFFFh
call JS_DefinePropertyValue
test eax, eax
js short loc_3DE53
mov rax, 0FFFFFFFF00000000h
mov rcx, r12
and rcx, rax
mov eax, r12d
mov rbx, r14
jmp short loc_3DE66
loc_3DE53:
mov rdi, [r15+18h]
mov rsi, r12
mov rdx, r14
call JS_FreeValueRT
loc_3DE62:
xor eax, eax
xor ecx, ecx
loc_3DE66:
or rax, rcx
mov rdx, rbx
add rsp, 18h
pop rbx
pop r12
pop r14
pop r15
retn
| unsigned long long js_instantiate_prototype(
long long a1,
_DWORD *a2,
double a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
unsigned long long v10; // rax
long long v11; // rdx
__m128 v12; // xmm4
__m128 v13; // xmm5
long long v14; // r14
unsigned long long v15; // r12
_DWORD *v16; // xmm0_8
unsigned long long v17; // rcx
long long v18; // rax
_DWORD *v20; // [rsp+8h] [rbp-30h]
_DWORD *v21; // [rsp+10h] [rbp-28h]
v20 = a2;
v10 = JS_NewObjectProtoClass(
a1,
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 16LL),
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 24LL),
1u);
v14 = v11;
if ( (_DWORD)v11 == 6 )
goto LABEL_5;
v15 = v10;
v16 = v20;
v21 = v20;
++*v20;
if ( (int)JS_DefinePropertyValue(a1, v10, v11, 61LL, v16, -1LL, *(double *)&v16, a4, a5, a6, v12, v13, a9, a10, 3) < 0 )
{
JS_FreeValueRT(*(_QWORD *)(a1 + 24), (_DWORD *)v15, v14);
LABEL_5:
v18 = 0LL;
v17 = 0LL;
return v17 | v18;
}
v17 = v15 & 0xFFFFFFFF00000000LL;
v18 = (unsigned int)v15;
return v17 | v18;
}
| js_instantiate_prototype:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R15,RDI
MOV qword ptr [RSP + 0x8],RSI
MOV RAX,qword ptr [RDI + 0x40]
MOV RSI,qword ptr [RAX + 0x10]
MOV RDX,qword ptr [RAX + 0x18]
MOV ECX,0x1
CALL 0x00120f05
MOV R14,RDX
MOV EBX,0x6
CMP R14D,0x6
JZ 0x0013de62
MOV R12,RAX
MOVQ XMM0,qword ptr [RSP + 0x8]
MOVQ R8,XMM0
MOVQ qword ptr [RSP + 0x10],XMM0
MOV RAX,qword ptr [RSP + 0x10]
INC dword ptr [RAX]
MOV dword ptr [RSP],0x3
MOV RDI,R15
MOV RSI,R12
MOV RDX,R14
MOV ECX,0x3d
MOV R9,-0x1
CALL 0x00126abb
TEST EAX,EAX
JS 0x0013de53
MOV RAX,-0x100000000
MOV RCX,R12
AND RCX,RAX
MOV EAX,R12D
MOV RBX,R14
JMP 0x0013de66
LAB_0013de53:
MOV RDI,qword ptr [R15 + 0x18]
MOV RSI,R12
MOV RDX,R14
CALL 0x0011d8c6
LAB_0013de62:
XOR EAX,EAX
XOR ECX,ECX
LAB_0013de66:
OR RAX,RCX
MOV RDX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R14
POP R15
RET
|
int1 [16] js_instantiate_prototype(long param_1,int *param_2)
{
int iVar1;
ulong uVar2;
ulong uVar3;
int8 uVar5;
int1 auVar6 [16];
int8 uVar4;
auVar6 = JS_NewObjectProtoClass
(param_1,*(int8 *)(*(long *)(param_1 + 0x40) + 0x10),
*(int8 *)(*(long *)(param_1 + 0x40) + 0x18),1);
uVar4 = auVar6._8_8_;
uVar2 = auVar6._0_8_;
uVar5 = 6;
if (auVar6._8_4_ != 6) {
*param_2 = *param_2 + 1;
iVar1 = JS_DefinePropertyValue(param_1,uVar2,uVar4,0x3d,param_2,0xffffffffffffffff,3);
if (-1 < iVar1) {
uVar3 = uVar2 & 0xffffffff00000000;
uVar2 = uVar2 & 0xffffffff;
uVar5 = uVar4;
goto LAB_0013de66;
}
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),uVar2,uVar4);
}
uVar2 = 0;
uVar3 = 0;
LAB_0013de66:
auVar6._0_8_ = uVar2 | uVar3;
auVar6._8_8_ = uVar5;
return auVar6;
}
| |
23,981 | js_instantiate_prototype | bluesky950520[P]quickjs/quickjs.c | static JSValue js_instantiate_prototype(JSContext *ctx, JSObject *p, JSAtom atom, void *opaque)
{
JSValue obj, this_val;
int ret;
this_val = JS_MKPTR(JS_TAG_OBJECT, p);
obj = JS_NewObject(ctx);
if (JS_IsException(obj))
return JS_EXCEPTION;
set_cycle_flag(ctx, obj);
set_cycle_flag(ctx, this_val);
ret = JS_DefinePropertyValue(ctx, obj, JS_ATOM_constructor,
js_dup(this_val),
JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
if (ret < 0) {
JS_FreeValue(ctx, obj);
return JS_EXCEPTION;
}
return obj;
} | O3 | c | js_instantiate_prototype:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r13
movq %rdi, %r12
movq 0x40(%rdi), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
movl $0x1, %ecx
callq 0x21651
movq %rdx, %r14
movl $0x6, %ebx
cmpl $0x6, %r14d
jne 0x3f440
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x3f485
movq %rax, %r15
incl (%r13)
movl $0x3, (%rsp)
movq %r12, %rdi
movq %rax, %rsi
movq %r14, %rdx
movl $0x3d, %ecx
movq %r13, %r8
movq $-0x1, %r9
callq 0x2717d
testl %eax, %eax
js 0x3f499
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %r15, %rcx
andq %rax, %rcx
movl %r15d, %eax
movq %r14, %rbx
orq %rcx, %rax
movq %rbx, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
cmpl $-0x9, %r14d
jb 0x3f43a
movq 0x18(%r12), %rdi
movl (%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r15)
cmpl $0x1, %eax
jg 0x3f43a
movq %r15, %rsi
movq %r14, %rdx
callq 0x219cc
jmp 0x3f43a
| js_instantiate_prototype:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov r13, rsi
mov r12, rdi
mov rax, [rdi+40h]
mov rsi, [rax+10h]
mov rdx, [rax+18h]
mov ecx, 1
call JS_NewObjectProtoClass
mov r14, rdx
mov ebx, 6
cmp r14d, 6
jnz short loc_3F440
loc_3F43A:
xor eax, eax
xor ecx, ecx
jmp short loc_3F485
loc_3F440:
mov r15, rax
inc dword ptr [r13+0]
mov [rsp+38h+var_38], 3
mov rdi, r12
mov rsi, rax
mov rdx, r14
mov ecx, 3Dh ; '='
mov r8, r13
mov r9, 0FFFFFFFFFFFFFFFFh
call JS_DefinePropertyValue
test eax, eax
js short loc_3F499
mov rax, 0FFFFFFFF00000000h
mov rcx, r15
and rcx, rax
mov eax, r15d
mov rbx, r14
loc_3F485:
or rax, rcx
mov rdx, rbx
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_3F499:
cmp r14d, 0FFFFFFF7h
jb short loc_3F43A
mov rdi, [r12+18h]
mov eax, [r15]
lea ecx, [rax-1]
mov [r15], ecx
cmp eax, 1
jg short loc_3F43A
mov rsi, r15
mov rdx, r14
call js_free_value_rt
jmp loc_3F43A
| unsigned long long js_instantiate_prototype(
long long a1,
_DWORD *a2,
double a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
long long v10; // rax
long long v11; // rdx
__m128 v12; // xmm4
__m128 v13; // xmm5
unsigned int v14; // r14d
long long v15; // rax
unsigned long long v16; // rcx
long long v17; // r15
long long v19; // rdi
int v20; // eax
v10 = JS_NewObjectProtoClass(
a1,
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 16LL),
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 24LL),
1u);
v14 = v11;
if ( (_DWORD)v11 != 6 )
{
v17 = v10;
++*a2;
if ( (int)JS_DefinePropertyValue(a1, v10, v11, 61LL, a2, -1LL, a3, a4, a5, a6, v12, v13, a9, a10, 3) >= 0 )
{
v16 = v17 & 0xFFFFFFFF00000000LL;
v15 = (unsigned int)v17;
return v16 | v15;
}
if ( v14 >= 0xFFFFFFF7 )
{
v19 = *(_QWORD *)(a1 + 24);
v20 = (*(_DWORD *)v17)--;
if ( v20 <= 1 )
js_free_value_rt(v19, (_QWORD *)v17, v14);
}
}
v15 = 0LL;
v16 = 0LL;
return v16 | v15;
}
| js_instantiate_prototype:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R13,RSI
MOV R12,RDI
MOV RAX,qword ptr [RDI + 0x40]
MOV RSI,qword ptr [RAX + 0x10]
MOV RDX,qword ptr [RAX + 0x18]
MOV ECX,0x1
CALL 0x00121651
MOV R14,RDX
MOV EBX,0x6
CMP R14D,0x6
JNZ 0x0013f440
LAB_0013f43a:
XOR EAX,EAX
XOR ECX,ECX
JMP 0x0013f485
LAB_0013f440:
MOV R15,RAX
INC dword ptr [R13]
MOV dword ptr [RSP],0x3
MOV RDI,R12
MOV RSI,RAX
MOV RDX,R14
MOV ECX,0x3d
MOV R8,R13
MOV R9,-0x1
CALL 0x0012717d
TEST EAX,EAX
JS 0x0013f499
MOV RAX,-0x100000000
MOV RCX,R15
AND RCX,RAX
MOV EAX,R15D
MOV RBX,R14
LAB_0013f485:
OR RAX,RCX
MOV RDX,RBX
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_0013f499:
CMP R14D,-0x9
JC 0x0013f43a
MOV RDI,qword ptr [R12 + 0x18]
MOV EAX,dword ptr [R15]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R15],ECX
CMP EAX,0x1
JG 0x0013f43a
MOV RSI,R15
MOV RDX,R14
CALL 0x001219cc
JMP 0x0013f43a
|
int1 [16] js_instantiate_prototype(long param_1,int *param_2)
{
int8 uVar1;
int iVar2;
int *piVar3;
ulong uVar4;
ulong uVar5;
int8 uVar6;
int1 auVar7 [16];
auVar7 = JS_NewObjectProtoClass
(param_1,*(int8 *)(*(long *)(param_1 + 0x40) + 0x10),
*(int8 *)(*(long *)(param_1 + 0x40) + 0x18),1);
uVar6 = auVar7._8_8_;
piVar3 = auVar7._0_8_;
if (auVar7._8_4_ != 6) {
*param_2 = *param_2 + 1;
iVar2 = JS_DefinePropertyValue(param_1,piVar3,uVar6,0x3d,param_2,0xffffffffffffffff,3);
if (-1 < iVar2) {
uVar5 = (ulong)piVar3 & 0xffffffff00000000;
uVar4 = (ulong)piVar3 & 0xffffffff;
goto LAB_0013f485;
}
if (0xfffffff6 < auVar7._8_4_) {
uVar1 = *(int8 *)(param_1 + 0x18);
iVar2 = *piVar3;
*piVar3 = iVar2 + -1;
if (iVar2 < 2) {
js_free_value_rt(uVar1,piVar3,uVar6);
}
}
}
uVar4 = 0;
uVar5 = 0;
uVar6 = 6;
LAB_0013f485:
auVar7._0_8_ = uVar4 | uVar5;
auVar7._8_8_ = uVar6;
return auVar7;
}
| |
23,982 | nglog::CaptureTestOutput(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | ng-log[P]ng-log/src/googletest.h | static inline void CaptureTestOutput(int fd, const string& filename) {
CHECK((fd == fileno(stdout)) || (fd == fileno(stderr)));
CHECK(s_captured_streams.find(fd) == s_captured_streams.end());
s_captured_streams[fd] = std::make_unique<CapturedStream>(fd, filename);
} | O0 | c | nglog::CaptureTestOutput(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x120(%rbp)
movq 0x6af1e(%rip), %rax # 0x76f30
movq (%rax), %rdi
callq 0x9770
movl -0x120(%rbp), %ecx
movl %eax, %edx
movb $0x0, -0x79(%rbp)
movb $0x1, %al
cmpl %edx, %ecx
movb %al, -0x119(%rbp)
je 0xc05d
movl -0x4(%rbp), %eax
movl %eax, -0x124(%rbp)
movq 0x6af6e(%rip), %rax # 0x76fb0
movq (%rax), %rdi
callq 0x9770
movl %eax, %ecx
movl -0x124(%rbp), %eax
cmpl %ecx, %eax
sete %al
movb %al, -0x119(%rbp)
movb -0x119(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xc06b
jmp 0xc0cc
leaq 0x450f0(%rip), %rsi # 0x51162
leaq -0x78(%rbp), %rdi
movq %rdi, -0x138(%rbp)
movl $0x16b, %edx # imm = 0x16B
callq 0x18e60
movq -0x138(%rbp), %rdi
movb $0x1, -0x79(%rbp)
callq 0x14990
movq %rax, -0x130(%rbp)
jmp 0xc0a0
movq -0x130(%rbp), %rdi
leaq 0x450fd(%rip), %rsi # 0x511ab
callq 0x9700
movq %rax, -0x140(%rbp)
jmp 0xc0bc
movq -0x140(%rbp), %rsi
leaq -0x11(%rbp), %rdi
callq 0xed10
testb $0x1, -0x79(%rbp)
jne 0xc0d4
jmp 0xc0fe
leaq -0x78(%rbp), %rdi
callq 0x18ed0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
testb $0x1, -0x79(%rbp)
jne 0xc1cb
jmp 0xc1d6
leaq 0x6bb4b(%rip), %rdi # 0x77c50
leaq -0x4(%rbp), %rsi
callq 0xed50
movq %rax, -0x98(%rbp)
leaq 0x6bb34(%rip), %rdi # 0x77c50
callq 0xed80
movq %rax, -0xa0(%rbp)
leaq -0x98(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0xed20
xorb $-0x1, %al
movb $0x0, -0x109(%rbp)
testb $0x1, %al
jne 0xc14a
jmp 0xc1b4
leaq 0x45011(%rip), %rsi # 0x51162
leaq -0x108(%rbp), %rdi
movq %rdi, -0x150(%rbp)
movl $0x16c, %edx # imm = 0x16C
callq 0x18e60
movq -0x150(%rbp), %rdi
movb $0x1, -0x109(%rbp)
callq 0x14990
movq %rax, -0x148(%rbp)
jmp 0xc185
movq -0x148(%rbp), %rdi
leaq 0x45058(%rip), %rsi # 0x511eb
callq 0x9700
movq %rax, -0x158(%rbp)
jmp 0xc1a1
movq -0x158(%rbp), %rsi
leaq -0xa1(%rbp), %rdi
callq 0xed10
testb $0x1, -0x109(%rbp)
jne 0xc1bf
jmp 0xc1f8
leaq -0x108(%rbp), %rdi
callq 0x18ed0
leaq -0x78(%rbp), %rdi
callq 0x18ed0
jmp 0xc1d6
jmp 0xc285
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
testb $0x1, -0x109(%rbp)
jne 0xc257
jmp 0xc265
movq -0x10(%rbp), %rdx
leaq -0x118(%rbp), %rdi
leaq -0x4(%rbp), %rsi
movq %rsi, -0x168(%rbp)
callq 0xedb0
movq -0x168(%rbp), %rsi
leaq 0x6ba2f(%rip), %rdi # 0x77c50
callq 0xee80
movq %rax, -0x160(%rbp)
jmp 0xc22f
movq -0x160(%rbp), %rdi
leaq -0x118(%rbp), %rsi
callq 0xef60
leaq -0x118(%rbp), %rdi
callq 0xdc80
addq $0x170, %rsp # imm = 0x170
popq %rbp
retq
leaq -0x108(%rbp), %rdi
callq 0x18ed0
jmp 0xc265
jmp 0xc285
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x118(%rbp), %rdi
callq 0xdc80
movq -0x88(%rbp), %rdi
callq 0x9d40
movq %rax, %rdi
callq 0xcc30
nopl (%rax)
| _ZN5nglogL17CaptureTestOutputEiRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
mov rbp, rsp
sub rsp, 170h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov eax, [rbp+var_4]
mov [rbp+var_120], eax
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fileno
mov ecx, [rbp+var_120]
mov edx, eax
mov [rbp+var_79], 0
mov al, 1
cmp ecx, edx
mov [rbp+var_119], al
jz short loc_C05D
mov eax, [rbp+var_4]
mov [rbp+var_124], eax
mov rax, cs:stderr_ptr
mov rdi, [rax]
call _fileno
mov ecx, eax
mov eax, [rbp+var_124]
cmp eax, ecx
setz al
mov [rbp+var_119], al
loc_C05D:
mov al, [rbp+var_119]
xor al, 0FFh
test al, 1
jnz short loc_C06B
jmp short loc_C0CC
loc_C06B:
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdi, [rbp+var_78]; this
mov [rbp+var_138], rdi
mov edx, 16Bh; int
call _ZN5nglog15LogMessageFatalC2EPKci; nglog::LogMessageFatal::LogMessageFatal(char const*,int)
mov rdi, [rbp+var_138]; this
mov [rbp+var_79], 1
call _ZN5nglog10LogMessage6streamEv; nglog::LogMessage::stream(void)
mov [rbp+var_130], rax
jmp short $+2
loc_C0A0:
mov rdi, [rbp+var_130]
lea rsi, aCheckFailedFdF; "Check failed: (fd == fileno(stdout)) ||"...
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rbp+var_140], rax
jmp short $+2
loc_C0BC:
mov rsi, [rbp+var_140]
lea rdi, [rbp+var_11]
call _ZNK5nglog8internal17LogMessageVoidifyanERSo; nglog::internal::LogMessageVoidify::operator&(std::ostream &)
loc_C0CC:
test [rbp+var_79], 1
jnz short loc_C0D4
jmp short loc_C0FE
loc_C0D4:
lea rdi, [rbp+var_78]; this
call _ZN5nglog15LogMessageFatalD2Ev; nglog::LogMessageFatal::~LogMessageFatal()
mov rcx, rax
mov eax, edx
mov [rbp+var_88], rcx
mov [rbp+var_8C], eax
test [rbp+var_79], 1
jnz loc_C1CB
jmp loc_C1D6
loc_C0FE:
lea rdi, _ZN5nglogL18s_captured_streamsE; nglog::s_captured_streams
lea rsi, [rbp+var_4]
call _ZNSt3mapIiSt10unique_ptrIN5nglog14CapturedStreamESt14default_deleteIS2_EESt4lessIiESaISt4pairIKiS5_EEE4findERS9_; std::map<int,std::unique_ptr<nglog::CapturedStream>>::find(int const&)
mov [rbp+var_98], rax
lea rdi, _ZN5nglogL18s_captured_streamsE; nglog::s_captured_streams
call _ZNSt3mapIiSt10unique_ptrIN5nglog14CapturedStreamESt14default_deleteIS2_EESt4lessIiESaISt4pairIKiS5_EEE3endEv; std::map<int,std::unique_ptr<nglog::CapturedStream>>::end(void)
mov [rbp+var_A0], rax
lea rdi, [rbp+var_98]
lea rsi, [rbp+var_A0]
call _ZSteqRKSt17_Rb_tree_iteratorISt4pairIKiSt10unique_ptrIN5nglog14CapturedStreamESt14default_deleteIS4_EEEESB_; std::operator==(std::_Rb_tree_iterator<std::pair<int const,std::unique_ptr<nglog::CapturedStream>>> const&,std::_Rb_tree_iterator<std::pair<int const,std::unique_ptr<nglog::CapturedStream>>> const&)
xor al, 0FFh
mov [rbp+var_109], 0
test al, 1
jnz short loc_C14A
jmp short loc_C1B4
loc_C14A:
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdi, [rbp+var_108]; this
mov [rbp+var_150], rdi
mov edx, 16Ch; int
call _ZN5nglog15LogMessageFatalC2EPKci; nglog::LogMessageFatal::LogMessageFatal(char const*,int)
mov rdi, [rbp+var_150]; this
mov [rbp+var_109], 1
call _ZN5nglog10LogMessage6streamEv; nglog::LogMessage::stream(void)
mov [rbp+var_148], rax
jmp short $+2
loc_C185:
mov rdi, [rbp+var_148]
lea rsi, aCheckFailedSCa; "Check failed: s_captured_streams.find(f"...
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rbp+var_158], rax
jmp short $+2
loc_C1A1:
mov rsi, [rbp+var_158]
lea rdi, [rbp+var_A1]
call _ZNK5nglog8internal17LogMessageVoidifyanERSo; nglog::internal::LogMessageVoidify::operator&(std::ostream &)
loc_C1B4:
test [rbp+var_109], 1
jnz short loc_C1BF
jmp short loc_C1F8
loc_C1BF:
lea rdi, [rbp+var_108]; this
call _ZN5nglog15LogMessageFatalD2Ev; nglog::LogMessageFatal::~LogMessageFatal()
loc_C1CB:
lea rdi, [rbp+var_78]; this
call _ZN5nglog15LogMessageFatalD2Ev; nglog::LogMessageFatal::~LogMessageFatal()
jmp short $+2
loc_C1D6:
jmp loc_C285
mov rcx, rax
mov eax, edx
mov [rbp+var_88], rcx
mov [rbp+var_8C], eax
test [rbp+var_109], 1
jnz short loc_C257
jmp short loc_C265
loc_C1F8:
mov rdx, [rbp+var_10]
lea rdi, [rbp+var_118]
lea rsi, [rbp+var_4]
mov [rbp+var_168], rsi
call _ZSt11make_uniqueIN5nglog14CapturedStreamEJRiRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEENSt9_MakeUniqIT_E15__single_objectEDpOT0_; std::make_unique<nglog::CapturedStream,int &,std::string const&>(int &,std::string const&)
mov rsi, [rbp+var_168]
lea rdi, _ZN5nglogL18s_captured_streamsE; nglog::s_captured_streams
call _ZNSt3mapIiSt10unique_ptrIN5nglog14CapturedStreamESt14default_deleteIS2_EESt4lessIiESaISt4pairIKiS5_EEEixERS9_; std::map<int,std::unique_ptr<nglog::CapturedStream>>::operator[](int const&)
mov [rbp+var_160], rax
jmp short $+2
loc_C22F:
mov rdi, [rbp+var_160]
lea rsi, [rbp+var_118]
call _ZNSt10unique_ptrIN5nglog14CapturedStreamESt14default_deleteIS1_EEaSEOS4_; std::unique_ptr<nglog::CapturedStream>::operator=(std::unique_ptr<nglog::CapturedStream>&&)
lea rdi, [rbp+var_118]
call _ZNSt10unique_ptrIN5nglog14CapturedStreamESt14default_deleteIS1_EED2Ev; std::unique_ptr<nglog::CapturedStream>::~unique_ptr()
add rsp, 170h
pop rbp
retn
loc_C257:
lea rdi, [rbp+var_108]; this
call _ZN5nglog15LogMessageFatalD2Ev; nglog::LogMessageFatal::~LogMessageFatal()
jmp short $+2
loc_C265:
jmp short loc_C285
mov rcx, rax
mov eax, edx
mov [rbp+var_88], rcx
mov [rbp+var_8C], eax
lea rdi, [rbp+var_118]
call _ZNSt10unique_ptrIN5nglog14CapturedStreamESt14default_deleteIS1_EED2Ev; std::unique_ptr<nglog::CapturedStream>::~unique_ptr()
loc_C285:
mov rdi, [rbp+var_88]
call __Unwind_Resume
mov rdi, rax
call __clang_call_terminate
| long long nglog::CaptureTestOutput(int a1, long long a2)
{
long long v3; // [rsp+10h] [rbp-160h]
long long v4; // [rsp+18h] [rbp-158h]
long long v5; // [rsp+28h] [rbp-148h]
long long v6; // [rsp+30h] [rbp-140h]
long long v7; // [rsp+40h] [rbp-130h]
bool v8; // [rsp+57h] [rbp-119h]
_BYTE v9[15]; // [rsp+58h] [rbp-118h] BYREF
char v10; // [rsp+67h] [rbp-109h]
_BYTE v11[103]; // [rsp+68h] [rbp-108h] BYREF
char v12; // [rsp+CFh] [rbp-A1h] BYREF
long long v13; // [rsp+D0h] [rbp-A0h] BYREF
long long v14; // [rsp+D8h] [rbp-98h] BYREF
char v15; // [rsp+F7h] [rbp-79h]
_BYTE v16[103]; // [rsp+F8h] [rbp-78h] BYREF
char v17; // [rsp+15Fh] [rbp-11h] BYREF
long long v18; // [rsp+160h] [rbp-10h]
int v19; // [rsp+16Ch] [rbp-4h] BYREF
v19 = a1;
v18 = a2;
v15 = 0;
v8 = 1;
if ( a1 != (unsigned int)fileno(stdout) )
v8 = v19 == (unsigned int)fileno(stderr);
if ( !v8 )
{
nglog::LogMessageFatal::LogMessageFatal(
(nglog::LogMessageFatal *)v16,
"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/googletest.h",
363);
v15 = 1;
v7 = nglog::LogMessage::stream((nglog::LogMessage *)v16);
v6 = std::operator<<<std::char_traits<char>>(v7, "Check failed: (fd == fileno(stdout)) || (fd == fileno(stderr)) ");
nglog::internal::LogMessageVoidify::operator&(&v17, v6);
}
if ( (v15 & 1) != 0 )
nglog::LogMessageFatal::~LogMessageFatal((nglog::LogMessageFatal *)v16);
v14 = std::map<int,std::unique_ptr<nglog::CapturedStream>>::find(&nglog::s_captured_streams, &v19);
v13 = std::map<int,std::unique_ptr<nglog::CapturedStream>>::end(&nglog::s_captured_streams);
v10 = 0;
if ( (std::operator==(&v14, &v13) & 1) == 0 )
{
nglog::LogMessageFatal::LogMessageFatal(
(nglog::LogMessageFatal *)v11,
"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/googletest.h",
364);
v10 = 1;
v5 = nglog::LogMessage::stream((nglog::LogMessage *)v11);
v4 = std::operator<<<std::char_traits<char>>(
v5,
"Check failed: s_captured_streams.find(fd) == s_captured_streams.end() ");
nglog::internal::LogMessageVoidify::operator&(&v12, v4);
}
if ( (v10 & 1) != 0 )
nglog::LogMessageFatal::~LogMessageFatal((nglog::LogMessageFatal *)v11);
std::make_unique<nglog::CapturedStream,int &,std::string const&>(v9, &v19, v18);
v3 = std::map<int,std::unique_ptr<nglog::CapturedStream>>::operator[](&nglog::s_captured_streams, &v19);
std::unique_ptr<nglog::CapturedStream>::operator=(v3, v9);
return std::unique_ptr<nglog::CapturedStream>::~unique_ptr(v9);
}
| CaptureTestOutput:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x170
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x120],EAX
MOV RAX,qword ptr [0x00176f30]
MOV RDI,qword ptr [RAX]
CALL 0x00109770
MOV ECX,dword ptr [RBP + -0x120]
MOV EDX,EAX
MOV byte ptr [RBP + -0x79],0x0
MOV AL,0x1
CMP ECX,EDX
MOV byte ptr [RBP + -0x119],AL
JZ 0x0010c05d
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x124],EAX
MOV RAX,qword ptr [0x00176fb0]
MOV RDI,qword ptr [RAX]
CALL 0x00109770
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x124]
CMP EAX,ECX
SETZ AL
MOV byte ptr [RBP + -0x119],AL
LAB_0010c05d:
MOV AL,byte ptr [RBP + -0x119]
XOR AL,0xff
TEST AL,0x1
JNZ 0x0010c06b
JMP 0x0010c0cc
LAB_0010c06b:
LEA RSI,[0x151162]
LEA RDI,[RBP + -0x78]
MOV qword ptr [RBP + -0x138],RDI
MOV EDX,0x16b
CALL 0x00118e60
MOV RDI,qword ptr [RBP + -0x138]
MOV byte ptr [RBP + -0x79],0x1
LAB_0010c092:
CALL 0x00114990
MOV qword ptr [RBP + -0x130],RAX
JMP 0x0010c0a0
LAB_0010c0a0:
MOV RDI,qword ptr [RBP + -0x130]
LEA RSI,[0x1511ab]
CALL 0x00109700
LAB_0010c0b3:
MOV qword ptr [RBP + -0x140],RAX
JMP 0x0010c0bc
LAB_0010c0bc:
MOV RSI,qword ptr [RBP + -0x140]
LEA RDI,[RBP + -0x11]
CALL 0x0010ed10
LAB_0010c0cc:
TEST byte ptr [RBP + -0x79],0x1
JNZ 0x0010c0d4
JMP 0x0010c0fe
LAB_0010c0d4:
LEA RDI,[RBP + -0x78]
CALL 0x00118ed0
LAB_0010c0dd:
MOV RCX,RAX
MOV EAX,EDX
MOV qword ptr [RBP + -0x88],RCX
MOV dword ptr [RBP + -0x8c],EAX
TEST byte ptr [RBP + -0x79],0x1
JNZ 0x0010c1cb
JMP 0x0010c1d6
LAB_0010c0fe:
LEA RDI,[0x177c50]
LEA RSI,[RBP + -0x4]
CALL 0x0010ed50
MOV qword ptr [RBP + -0x98],RAX
LEA RDI,[0x177c50]
CALL 0x0010ed80
MOV qword ptr [RBP + -0xa0],RAX
LEA RDI,[RBP + -0x98]
LEA RSI,[RBP + -0xa0]
CALL 0x0010ed20
XOR AL,0xff
MOV byte ptr [RBP + -0x109],0x0
TEST AL,0x1
JNZ 0x0010c14a
JMP 0x0010c1b4
LAB_0010c14a:
LEA RSI,[0x151162]
LEA RDI,[RBP + -0x108]
MOV qword ptr [RBP + -0x150],RDI
MOV EDX,0x16c
CALL 0x00118e60
MOV RDI,qword ptr [RBP + -0x150]
MOV byte ptr [RBP + -0x109],0x1
LAB_0010c177:
CALL 0x00114990
MOV qword ptr [RBP + -0x148],RAX
JMP 0x0010c185
LAB_0010c185:
MOV RDI,qword ptr [RBP + -0x148]
LEA RSI,[0x1511eb]
CALL 0x00109700
LAB_0010c198:
MOV qword ptr [RBP + -0x158],RAX
JMP 0x0010c1a1
LAB_0010c1a1:
MOV RSI,qword ptr [RBP + -0x158]
LEA RDI,[RBP + -0xa1]
CALL 0x0010ed10
LAB_0010c1b4:
TEST byte ptr [RBP + -0x109],0x1
JNZ 0x0010c1bf
JMP 0x0010c1f8
LAB_0010c1bf:
LEA RDI,[RBP + -0x108]
CALL 0x00118ed0
LAB_0010c1cb:
LEA RDI,[RBP + -0x78]
CALL 0x00118ed0
LAB_0010c1d4:
JMP 0x0010c1d6
LAB_0010c1d6:
JMP 0x0010c285
LAB_0010c1f8:
MOV RDX,qword ptr [RBP + -0x10]
LEA RDI,[RBP + -0x118]
LEA RSI,[RBP + -0x4]
MOV qword ptr [RBP + -0x168],RSI
CALL 0x0010edb0
MOV RSI,qword ptr [RBP + -0x168]
LAB_0010c21a:
LEA RDI,[0x177c50]
CALL 0x0010ee80
MOV qword ptr [RBP + -0x160],RAX
JMP 0x0010c22f
LAB_0010c22f:
MOV RDI,qword ptr [RBP + -0x160]
LEA RSI,[RBP + -0x118]
CALL 0x0010ef60
LEA RDI,[RBP + -0x118]
CALL 0x0010dc80
ADD RSP,0x170
POP RBP
RET
LAB_0010c285:
MOV RDI,qword ptr [RBP + -0x88]
CALL 0x00109d40
|
/* nglog::CaptureTestOutput(int, std::__cxx11::string const&) */
void nglog::CaptureTestOutput(int param_1,string *param_2)
{
int iVar1;
byte bVar2;
int iVar3;
ostream *poVar4;
unique_ptr<nglog::CapturedStream,std::default_delete<nglog::CapturedStream>> *this;
bool bVar5;
int1 auVar6 [12];
unique_ptr local_120 [15];
byte local_111;
LogMessageFatal local_110 [103];
LogMessageVoidify local_a9;
int8 local_a8;
int8 local_a0;
int4 local_94;
int8 local_90;
byte local_81;
LogMessageFatal local_80 [103];
LogMessageVoidify local_19;
string *local_18;
int local_c;
local_18 = param_2;
local_c = param_1;
iVar3 = fileno(*(FILE **)PTR_stdout_00176f30);
iVar1 = local_c;
local_81 = 0;
bVar5 = true;
if (param_1 != iVar3) {
iVar3 = fileno(*(FILE **)PTR_stderr_00176fb0);
bVar5 = iVar1 == iVar3;
}
if (!bVar5) {
LogMessageFatal::LogMessageFatal
(local_80,"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/googletest.h",
0x16b);
local_81 = 1;
/* try { // try from 0010c092 to 0010c0b2 has its CatchHandler @ 0010c0dd */
poVar4 = (ostream *)LogMessage::stream((LogMessage *)local_80);
poVar4 = std::operator<<(poVar4,
"Check failed: (fd == fileno(stdout)) || (fd == fileno(stderr)) ");
internal::LogMessageVoidify::operator&(&local_19,poVar4);
}
if ((local_81 & 1) == 0) {
local_a0 = std::
map<int,std::unique_ptr<nglog::CapturedStream,std::default_delete<nglog::CapturedStream>>,std::less<int>,std::allocator<std::pair<int_const,std::unique_ptr<nglog::CapturedStream,std::default_delete<nglog::CapturedStream>>>>>
::find((map<int,std::unique_ptr<nglog::CapturedStream,std::default_delete<nglog::CapturedStream>>,std::less<int>,std::allocator<std::pair<int_const,std::unique_ptr<nglog::CapturedStream,std::default_delete<nglog::CapturedStream>>>>>
*)s_captured_streams,&local_c);
local_a8 = std::
map<int,std::unique_ptr<nglog::CapturedStream,std::default_delete<nglog::CapturedStream>>,std::less<int>,std::allocator<std::pair<int_const,std::unique_ptr<nglog::CapturedStream,std::default_delete<nglog::CapturedStream>>>>>
::end((map<int,std::unique_ptr<nglog::CapturedStream,std::default_delete<nglog::CapturedStream>>,std::less<int>,std::allocator<std::pair<int_const,std::unique_ptr<nglog::CapturedStream,std::default_delete<nglog::CapturedStream>>>>>
*)s_captured_streams);
bVar2 = std::operator==((_Rb_tree_iterator *)&local_a0,(_Rb_tree_iterator *)&local_a8);
local_111 = 0;
if (((bVar2 ^ 0xff) & 1) != 0) {
LogMessageFatal::LogMessageFatal
(local_110,
"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/googletest.h",0x16c);
local_111 = 1;
/* try { // try from 0010c177 to 0010c197 has its CatchHandler @ 0010c1db */
poVar4 = (ostream *)LogMessage::stream((LogMessage *)local_110);
poVar4 = std::operator<<(poVar4,
"Check failed: s_captured_streams.find(fd) == s_captured_streams.end() "
);
internal::LogMessageVoidify::operator&(&local_a9,poVar4);
}
if ((local_111 & 1) == 0) {
std::make_unique<nglog::CapturedStream,int&,std::__cxx11::string_const&>
((int *)local_120,(string *)&local_c);
/* try { // try from 0010c21a to 0010c225 has its CatchHandler @ 0010c267 */
this = (unique_ptr<nglog::CapturedStream,std::default_delete<nglog::CapturedStream>> *)
std::
map<int,std::unique_ptr<nglog::CapturedStream,std::default_delete<nglog::CapturedStream>>,std::less<int>,std::allocator<std::pair<int_const,std::unique_ptr<nglog::CapturedStream,std::default_delete<nglog::CapturedStream>>>>>
::operator[]((map<int,std::unique_ptr<nglog::CapturedStream,std::default_delete<nglog::CapturedStream>>,std::less<int>,std::allocator<std::pair<int_const,std::unique_ptr<nglog::CapturedStream,std::default_delete<nglog::CapturedStream>>>>>
*)s_captured_streams,&local_c);
std::unique_ptr<nglog::CapturedStream,std::default_delete<nglog::CapturedStream>>::operator=
(this,local_120);
std::unique_ptr<nglog::CapturedStream,std::default_delete<nglog::CapturedStream>>::~unique_ptr
((unique_ptr<nglog::CapturedStream,std::default_delete<nglog::CapturedStream>> *)
local_120);
return;
}
LogMessageFatal::~LogMessageFatal(local_110);
auVar6._8_4_ = local_94;
auVar6._0_8_ = local_90;
}
else {
auVar6 = LogMessageFatal::~LogMessageFatal(local_80);
/* catch(type#1 @ 00000000) { ... } // from try @ 0010c092 with catch @ 0010c0dd
*/
if ((local_81 & 1) == 0) goto LAB_0010c1d6;
}
/* try { // try from 0010c1cb to 0010c1d3 has its CatchHandler @ 0010c291 */
local_94 = auVar6._8_4_;
local_90 = auVar6._0_8_;
LogMessageFatal::~LogMessageFatal(local_80);
auVar6._8_4_ = local_94;
auVar6._0_8_ = local_90;
LAB_0010c1d6:
local_94 = auVar6._8_4_;
local_90 = auVar6._0_8_;
/* WARNING: Subroutine does not return */
_Unwind_Resume(local_90);
}
| |
23,983 | strmake | eloqsql/strings/strmake.c | char *strmake(register char *dst, register const char *src, size_t length)
{
while (length--)
{
if (! (*dst++ = *src++))
{
#ifdef EXTRA_DEBUG
/*
'length' is the maximum length of the string; the buffer needs
to be one character larger to accommodate the terminating
'\0'. This is easy to get wrong, so we make sure we write to
the entire length of the buffer to identify incorrect
buffer-sizes. We only initialism the "unused" part of the
buffer here, a) for efficiency, and b) because dst==src is
allowed, so initializing the entire buffer would overwrite the
source-string. Also, we write a character rather than '\0' as
this makes spotting these problems in the results easier.
If we are using purify/valgrind, we only set one character at
end to be able to detect also wrong accesses after the end of
dst.
*/
if (length)
{
#ifdef HAVE_valgrind
dst[length-1]= 'Z';
#else
bfill(dst, length-1, (int) 'Z');
#endif /* HAVE_valgrind */
}
#endif /* EXTRA_DEBUG */
return dst-1;
}
}
*dst=0;
return dst;
} | O3 | c | strmake:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
xorl %edi, %edi
movq %rdi, %rcx
cmpq %rdi, %rdx
je 0x7a970
movb (%rsi,%rcx), %r8b
movb %r8b, (%rax,%rcx)
leaq 0x1(%rcx), %rdi
testb %r8b, %r8b
jne 0x7a955
jmp 0x7a974
movb $0x0, (%rax,%rcx)
addq %rcx, %rax
popq %rbp
retq
nopl (%rax)
| strmake:
push rbp
mov rbp, rsp
mov rax, rdi
xor edi, edi
loc_7A955:
mov rcx, rdi
cmp rdx, rdi
jz short loc_7A970
mov r8b, [rsi+rcx]
mov [rax+rcx], r8b
lea rdi, [rcx+1]
test r8b, r8b
jnz short loc_7A955
jmp short loc_7A974
loc_7A970:
mov byte ptr [rax+rcx], 0
loc_7A974:
add rax, rcx
pop rbp
retn
| long long strmake(long long a1, long long a2, long long a3)
{
long long v4; // rdi
long long v5; // rcx
char v6; // r8
v4 = 0LL;
while ( 1 )
{
v5 = v4;
if ( a3 == v4 )
break;
v6 = *(_BYTE *)(a2 + v4);
*(_BYTE *)(a1 + v4++) = v6;
if ( !v6 )
return v5 + a1;
}
*(_BYTE *)(a1 + v4) = 0;
return v5 + a1;
}
| strmake:
PUSH RBP
MOV RBP,RSP
MOV RAX,RDI
XOR EDI,EDI
LAB_0017a955:
MOV RCX,RDI
CMP RDX,RDI
JZ 0x0017a970
MOV R8B,byte ptr [RSI + RCX*0x1]
MOV byte ptr [RAX + RCX*0x1],R8B
LEA RDI,[RCX + 0x1]
TEST R8B,R8B
JNZ 0x0017a955
JMP 0x0017a974
LAB_0017a970:
MOV byte ptr [RAX + RCX*0x1],0x0
LAB_0017a974:
ADD RAX,RCX
POP RBP
RET
|
long strmake(long param_1,long param_2,long param_3)
{
char cVar1;
long lVar2;
long lVar3;
lVar2 = 0;
do {
lVar3 = lVar2;
if (param_3 == lVar3) {
*(int1 *)(param_1 + lVar3) = 0;
break;
}
cVar1 = *(char *)(param_2 + lVar3);
*(char *)(param_1 + lVar3) = cVar1;
lVar2 = lVar3 + 1;
} while (cVar1 != '\0');
return param_1 + lVar3;
}
| |
23,984 | pvio_socket_fast_send | eloqsql/libmariadb/plugins/pvio/pvio_socket.c | int pvio_socket_fast_send(MARIADB_PVIO *pvio)
{
int r= 0;
struct st_pvio_socket *csock= NULL;
if (!pvio || !pvio->data)
return 1;
csock= (struct st_pvio_socket *)pvio->data;
/* Setting IP_TOS is not recommended on Windows. See
http://msdn.microsoft.com/en-us/library/windows/desktop/ms738586(v=vs.85).aspx
*/
#if !defined(_WIN32) && defined(IPTOS_THROUGHPUT)
{
int tos = IPTOS_THROUGHPUT;
r= setsockopt(csock->socket, IPPROTO_IP, IP_TOS,
(const void *)&tos, sizeof(tos));
}
#endif /* !_WIN32 && IPTOS_THROUGHPUT */
if (!r)
{
int opt = 1;
/* turn off nagle algorithm */
r= setsockopt(csock->socket, IPPROTO_TCP, TCP_NODELAY,
#ifdef _WIN32
(const char *)&opt, (int)sizeof(opt));
#else
(const void *)&opt, sizeof(opt));
#endif
}
return r;
} | O0 | c | pvio_socket_fast_send:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4218c
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x42195
movl $0x1, -0x4(%rbp)
jmp 0x421fb
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x8, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %edi
xorl %esi, %esi
movl $0x1, %edx
leaq -0x24(%rbp), %rcx
movl $0x4, %r8d
callq 0x13770
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x421f5
movl $0x1, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %edi
movl $0x6, %esi
movl $0x1, %edx
leaq -0x28(%rbp), %rcx
movl $0x4, %r8d
callq 0x13770
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| pvio_socket_fast_send:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_14], 0
mov [rbp+var_20], 0
cmp [rbp+var_10], 0
jz short loc_4218C
mov rax, [rbp+var_10]
cmp qword ptr [rax], 0
jnz short loc_42195
loc_4218C:
mov [rbp+var_4], 1
jmp short loc_421FB
loc_42195:
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_20], rax
mov [rbp+var_24], 8
mov rax, [rbp+var_20]
mov edi, [rax]
xor esi, esi
mov edx, 1
lea rcx, [rbp+var_24]
mov r8d, 4
call _setsockopt
mov [rbp+var_14], eax
cmp [rbp+var_14], 0
jnz short loc_421F5
mov [rbp+var_28], 1
mov rax, [rbp+var_20]
mov edi, [rax]
mov esi, 6
mov edx, 1
lea rcx, [rbp+var_28]
mov r8d, 4
call _setsockopt
mov [rbp+var_14], eax
loc_421F5:
mov eax, [rbp+var_14]
mov [rbp+var_4], eax
loc_421FB:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long pvio_socket_fast_send(unsigned int **a1)
{
int v2; // [rsp+8h] [rbp-28h] BYREF
int v3; // [rsp+Ch] [rbp-24h] BYREF
unsigned int *v4; // [rsp+10h] [rbp-20h]
unsigned int v5; // [rsp+1Ch] [rbp-14h]
unsigned int **v6; // [rsp+20h] [rbp-10h]
v6 = a1;
v5 = 0;
v4 = 0LL;
if ( a1 && *v6 )
{
v4 = *v6;
v3 = 8;
v5 = setsockopt(*v4, 0LL, 1LL, &v3, 4LL);
if ( !v5 )
{
v2 = 1;
return (unsigned int)setsockopt(*v4, 6LL, 1LL, &v2, 4LL);
}
return v5;
}
else
{
return 1;
}
}
| pvio_socket_fast_send:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],0x0
MOV qword ptr [RBP + -0x20],0x0
CMP qword ptr [RBP + -0x10],0x0
JZ 0x0014218c
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX],0x0
JNZ 0x00142195
LAB_0014218c:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001421fb
LAB_00142195:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x24],0x8
MOV RAX,qword ptr [RBP + -0x20]
MOV EDI,dword ptr [RAX]
XOR ESI,ESI
MOV EDX,0x1
LEA RCX,[RBP + -0x24]
MOV R8D,0x4
CALL 0x00113770
MOV dword ptr [RBP + -0x14],EAX
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x001421f5
MOV dword ptr [RBP + -0x28],0x1
MOV RAX,qword ptr [RBP + -0x20]
MOV EDI,dword ptr [RAX]
MOV ESI,0x6
MOV EDX,0x1
LEA RCX,[RBP + -0x28]
MOV R8D,0x4
CALL 0x00113770
MOV dword ptr [RBP + -0x14],EAX
LAB_001421f5:
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x4],EAX
LAB_001421fb:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int pvio_socket_fast_send(long *param_1)
{
int4 local_30;
int4 local_2c;
int *local_28;
int local_1c;
long *local_18;
int local_c;
local_1c = 0;
if ((param_1 == (long *)0x0) || (*param_1 == 0)) {
local_c = 1;
}
else {
local_28 = (int *)*param_1;
local_2c = 8;
local_18 = param_1;
local_1c = setsockopt(*local_28,0,1,&local_2c,4);
if (local_1c == 0) {
local_30 = 1;
local_1c = setsockopt(*local_28,6,1,&local_30,4);
}
local_c = local_1c;
}
return local_c;
}
| |
23,985 | my_casefold_ujis | eloqsql/strings/ctype-ujis.c | static size_t
my_casefold_ujis(CHARSET_INFO *cs,
const char *src, size_t srclen,
char *dst, size_t dstlen __attribute__((unused)),
const uchar * const map,
size_t is_upper)
{
const char *srcend= src + srclen, *dst0= dst;
while (src < srcend)
{
size_t mblen= my_ismbchar(cs, src, srcend);
if (mblen)
{
MY_UNICASE_CHARACTER *ch;
ch= (mblen == 2) ?
get_case_info_for_ch(cs, 0, (uchar) src[0], (uchar) src[1]) :
get_case_info_for_ch(cs, 1, (uchar) src[1], (uchar) src[2]);
if (ch)
{
int code= is_upper ? ch->toupper : ch->tolower;
src+= mblen;
if (code > 0xFFFF)
*dst++= (char) (uchar) ((code >> 16) & 0xFF);
if (code > 0xFF)
*dst++= (char) (uchar) ((code >> 8) & 0xFF);
*dst++= (char) (uchar) (code & 0xFF);
}
else
{
if (mblen == 3)
*dst++= *src++;
*dst++= *src++;
*dst++= *src++;
}
}
else
{
*dst++= (char) map[(uchar) *src++];
}
}
return (size_t) (dst - dst0);
} | O3 | c | my_casefold_ujis:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, -0x40(%rbp)
movq %rcx, %rbx
movq %rcx, -0x30(%rbp)
testq %rdx, %rdx
jle 0x850db
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
addq %rsi, %r15
xorl %eax, %eax
testq %r9, %r9
sete %al
shll $0x2, %eax
movq %rax, -0x38(%rbp)
xorl %r14d, %r14d
movq -0x30(%rbp), %rbx
movq 0xb8(%r13), %rax
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0xc0(%rax)
cmpl $0x2, %eax
cmovll %r14d, %eax
testl %eax, %eax
je 0x85035
cmpl $0x2, %eax
jne 0x8504b
movzbl (%r12), %ecx
movq 0x78(%r13), %rdx
movq 0x8(%rdx), %rdx
movq (%rdx,%rcx,8), %rcx
testq %rcx, %rcx
je 0x850a5
movzbl 0x1(%r12), %edx
jmp 0x8506c
movzbl (%r12), %eax
incq %r12
movq -0x40(%rbp), %rcx
movb (%rcx,%rax), %al
movb %al, (%rbx)
jmp 0x850cf
movzbl 0x1(%r12), %ecx
movq 0x78(%r13), %rdx
movq 0x8(%rdx), %rdx
movq 0x800(%rdx,%rcx,8), %rcx
testq %rcx, %rcx
je 0x85094
movzbl 0x2(%r12), %edx
leaq (%rdx,%rdx,2), %rdx
leaq (%rcx,%rdx,4), %rcx
testq %rcx, %rcx
je 0x85094
movq -0x38(%rbp), %rdx
movl (%rcx,%rdx), %ecx
cmpl $0x10000, %ecx # imm = 0x10000
jl 0x850bd
movl %ecx, %edx
shrl $0x10, %edx
movb %dl, (%rbx)
incq %rbx
jmp 0x850c5
cmpl $0x3, %eax
jne 0x850a5
movb (%r12), %al
incq %r12
movb %al, (%rbx)
incq %rbx
movb (%r12), %al
movb %al, (%rbx)
movb 0x1(%r12), %al
addq $0x2, %r12
movb %al, 0x1(%rbx)
addq $0x2, %rbx
jmp 0x850d2
cmpl $0x100, %ecx # imm = 0x100
jl 0x850ca
movb %ch, (%rbx)
incq %rbx
addq %rax, %r12
movb %cl, (%rbx)
incq %rbx
cmpq %r15, %r12
jb 0x84ff1
subq -0x30(%rbp), %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_casefold_ujis:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov [rbp+var_40], r8
mov rbx, rcx
mov [rbp+var_30], rcx
test rdx, rdx
jle loc_850DB
mov r15, rdx
mov r12, rsi
mov r13, rdi
add r15, rsi
xor eax, eax
test r9, r9
setz al
shl eax, 2
mov [rbp+var_38], rax
xor r14d, r14d
mov rbx, [rbp+var_30]
loc_84FF1:
mov rax, [r13+0B8h]
mov rdi, r13
mov rsi, r12
mov rdx, r15
call qword ptr [rax+0C0h]
cmp eax, 2
cmovl eax, r14d
test eax, eax
jz short loc_85035
cmp eax, 2
jnz short loc_8504B
movzx ecx, byte ptr [r12]
mov rdx, [r13+78h]
mov rdx, [rdx+8]
mov rcx, [rdx+rcx*8]
test rcx, rcx
jz short loc_850A5
movzx edx, byte ptr [r12+1]
jmp short loc_8506C
loc_85035:
movzx eax, byte ptr [r12]
inc r12
mov rcx, [rbp+var_40]
mov al, [rcx+rax]
mov [rbx], al
jmp loc_850CF
loc_8504B:
movzx ecx, byte ptr [r12+1]
mov rdx, [r13+78h]
mov rdx, [rdx+8]
mov rcx, [rdx+rcx*8+800h]
test rcx, rcx
jz short loc_85094
movzx edx, byte ptr [r12+2]
loc_8506C:
lea rdx, [rdx+rdx*2]
lea rcx, [rcx+rdx*4]
test rcx, rcx
jz short loc_85094
mov rdx, [rbp+var_38]
mov ecx, [rcx+rdx]
cmp ecx, 10000h
jl short loc_850BD
mov edx, ecx
shr edx, 10h
mov [rbx], dl
inc rbx
jmp short loc_850C5
loc_85094:
cmp eax, 3
jnz short loc_850A5
mov al, [r12]
inc r12
mov [rbx], al
inc rbx
loc_850A5:
mov al, [r12]
mov [rbx], al
mov al, [r12+1]
add r12, 2
mov [rbx+1], al
add rbx, 2
jmp short loc_850D2
loc_850BD:
cmp ecx, 100h
jl short loc_850CA
loc_850C5:
mov [rbx], ch
inc rbx
loc_850CA:
add r12, rax
mov [rbx], cl
loc_850CF:
inc rbx
loc_850D2:
cmp r12, r15
jb loc_84FF1
loc_850DB:
sub rbx, [rbp+var_30]
mov rax, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| _BYTE * my_casefold_ujis(
long long a1,
unsigned __int8 *a2,
long long a3,
unsigned __int8 *a4,
long long a5,
long long a6)
{
unsigned __int8 *v6; // rbx
unsigned __int8 *v7; // r12
unsigned long long v8; // r15
long long v9; // rax
long long v10; // rcx
long long v11; // rdx
long long v12; // rax
long long v13; // rcx
int v14; // ecx
unsigned __int8 v15; // al
unsigned __int8 v16; // al
long long v19; // [rsp+8h] [rbp-38h]
v6 = a4;
if ( a3 > 0 )
{
v7 = a2;
v8 = (unsigned long long)&a2[a3];
v19 = 4 * (unsigned int)(a6 == 0);
v6 = a4;
while ( 1 )
{
v9 = (*(long long ( **)(long long, unsigned __int8 *, unsigned long long))(*(_QWORD *)(a1 + 184) + 192LL))(
a1,
v7,
v8);
if ( (int)v9 < 2 )
v9 = 0LL;
if ( !(_DWORD)v9 )
{
v12 = *v7++;
*v6 = *(_BYTE *)(a5 + v12);
goto LABEL_21;
}
if ( (_DWORD)v9 != 2 )
break;
v10 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 120) + 8LL) + 8LL * *v7);
if ( v10 )
{
v11 = v7[1];
LABEL_12:
v13 = v10 + 12 * v11;
if ( v13 )
{
v14 = *(_DWORD *)(v13 + v19);
if ( v14 >= 0x10000 )
{
*v6++ = BYTE2(v14);
goto LABEL_19;
}
if ( v14 >= 256 )
LABEL_19:
*v6++ = BYTE1(v14);
v7 += v9;
*v6 = v14;
LABEL_21:
++v6;
goto LABEL_22;
}
goto LABEL_15;
}
LABEL_17:
*v6 = *v7;
v16 = v7[1];
v7 += 2;
v6[1] = v16;
v6 += 2;
LABEL_22:
if ( (unsigned long long)v7 >= v8 )
return (_BYTE *)(v6 - a4);
}
v10 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 120) + 8LL) + 8LL * v7[1] + 2048);
if ( v10 )
{
v11 = v7[2];
goto LABEL_12;
}
LABEL_15:
if ( (_DWORD)v9 == 3 )
{
v15 = *v7++;
*v6++ = v15;
}
goto LABEL_17;
}
return (_BYTE *)(v6 - a4);
}
| my_casefold_ujis:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RBP + -0x40],R8
MOV RBX,RCX
MOV qword ptr [RBP + -0x30],RCX
TEST RDX,RDX
JLE 0x001850db
MOV R15,RDX
MOV R12,RSI
MOV R13,RDI
ADD R15,RSI
XOR EAX,EAX
TEST R9,R9
SETZ AL
SHL EAX,0x2
MOV qword ptr [RBP + -0x38],RAX
XOR R14D,R14D
MOV RBX,qword ptr [RBP + -0x30]
LAB_00184ff1:
MOV RAX,qword ptr [R13 + 0xb8]
MOV RDI,R13
MOV RSI,R12
MOV RDX,R15
CALL qword ptr [RAX + 0xc0]
CMP EAX,0x2
CMOVL EAX,R14D
TEST EAX,EAX
JZ 0x00185035
CMP EAX,0x2
JNZ 0x0018504b
MOVZX ECX,byte ptr [R12]
MOV RDX,qword ptr [R13 + 0x78]
MOV RDX,qword ptr [RDX + 0x8]
MOV RCX,qword ptr [RDX + RCX*0x8]
TEST RCX,RCX
JZ 0x001850a5
MOVZX EDX,byte ptr [R12 + 0x1]
JMP 0x0018506c
LAB_00185035:
MOVZX EAX,byte ptr [R12]
INC R12
MOV RCX,qword ptr [RBP + -0x40]
MOV AL,byte ptr [RCX + RAX*0x1]
MOV byte ptr [RBX],AL
JMP 0x001850cf
LAB_0018504b:
MOVZX ECX,byte ptr [R12 + 0x1]
MOV RDX,qword ptr [R13 + 0x78]
MOV RDX,qword ptr [RDX + 0x8]
MOV RCX,qword ptr [RDX + RCX*0x8 + 0x800]
TEST RCX,RCX
JZ 0x00185094
MOVZX EDX,byte ptr [R12 + 0x2]
LAB_0018506c:
LEA RDX,[RDX + RDX*0x2]
LEA RCX,[RCX + RDX*0x4]
TEST RCX,RCX
JZ 0x00185094
MOV RDX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RCX + RDX*0x1]
CMP ECX,0x10000
JL 0x001850bd
MOV EDX,ECX
SHR EDX,0x10
MOV byte ptr [RBX],DL
INC RBX
JMP 0x001850c5
LAB_00185094:
CMP EAX,0x3
JNZ 0x001850a5
MOV AL,byte ptr [R12]
INC R12
MOV byte ptr [RBX],AL
INC RBX
LAB_001850a5:
MOV AL,byte ptr [R12]
MOV byte ptr [RBX],AL
MOV AL,byte ptr [R12 + 0x1]
ADD R12,0x2
MOV byte ptr [RBX + 0x1],AL
ADD RBX,0x2
JMP 0x001850d2
LAB_001850bd:
CMP ECX,0x100
JL 0x001850ca
LAB_001850c5:
MOV byte ptr [RBX],CH
INC RBX
LAB_001850ca:
ADD R12,RAX
MOV byte ptr [RBX],CL
LAB_001850cf:
INC RBX
LAB_001850d2:
CMP R12,R15
JC 0x00184ff1
LAB_001850db:
SUB RBX,qword ptr [RBP + -0x30]
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_casefold_ujis(long param_1,byte *param_2,long param_3,byte *param_4,long param_5,
long param_6)
{
byte *pbVar1;
byte bVar2;
uint uVar3;
int iVar4;
long lVar6;
byte *pbVar7;
byte *pbVar8;
ulong uVar5;
pbVar7 = param_4;
if (0 < param_3) {
pbVar8 = param_2 + param_3;
do {
uVar3 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))(param_1,param_2,pbVar8);
uVar5 = (ulong)uVar3;
if ((int)uVar3 < 2) {
uVar5 = 0;
}
iVar4 = (int)uVar5;
if (iVar4 == 0) {
bVar2 = *param_2;
param_2 = param_2 + 1;
*pbVar7 = *(byte *)(param_5 + (ulong)bVar2);
LAB_001850cf:
pbVar7 = pbVar7 + 1;
}
else {
if (iVar4 == 2) {
lVar6 = *(long *)(*(long *)(*(long *)(param_1 + 0x78) + 8) + (ulong)*param_2 * 8);
if (lVar6 != 0) {
bVar2 = param_2[1];
LAB_0018506c:
lVar6 = lVar6 + (ulong)bVar2 * 0xc;
if (lVar6 == 0) goto LAB_00185094;
iVar4 = *(int *)(lVar6 + (ulong)(param_6 == 0) * 4);
if (iVar4 < 0x10000) {
if (0xff < iVar4) goto LAB_001850c5;
}
else {
*pbVar7 = (byte)((uint)iVar4 >> 0x10);
pbVar7 = pbVar7 + 1;
LAB_001850c5:
*pbVar7 = (byte)((uint)iVar4 >> 8);
pbVar7 = pbVar7 + 1;
}
param_2 = param_2 + uVar5;
*pbVar7 = (byte)iVar4;
goto LAB_001850cf;
}
}
else {
lVar6 = *(long *)(*(long *)(*(long *)(param_1 + 0x78) + 8) + 0x800 + (ulong)param_2[1] * 8
);
if (lVar6 != 0) {
bVar2 = param_2[2];
goto LAB_0018506c;
}
LAB_00185094:
if (iVar4 == 3) {
bVar2 = *param_2;
param_2 = param_2 + 1;
*pbVar7 = bVar2;
pbVar7 = pbVar7 + 1;
}
}
*pbVar7 = *param_2;
pbVar1 = param_2 + 1;
param_2 = param_2 + 2;
pbVar7[1] = *pbVar1;
pbVar7 = pbVar7 + 2;
}
} while (param_2 < pbVar8);
}
return (long)pbVar7 - (long)param_4;
}
| |
23,986 | LefDefParser::defiShield::addPath(LefDefParser::defiPath*, int, int, int*) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiNet.cpp | void defiShield::addPath(defiPath* p, int reset, int netOsnet, int *needCbk) {
int i;
size_t incNumber;
if (reset) {
for (i = 0; i < numPaths_; i++) {
delete paths_[i];
}
numPaths_ = 0;
}
if (numPaths_ >= pathsAllocated_) {
// 6/17/2003 - don't want to allocate too large memory just in case
// a net has many wires with only 1 or 2 paths
if (pathsAllocated_ <= maxLimit) {
incNumber = pathsAllocated_*2;
if (incNumber > maxLimit) {
incNumber = pathsAllocated_ + maxLimit;
}
} else {
incNumber = pathsAllocated_ + maxLimit;
}
switch (netOsnet) {
case 2:
bumpPaths(
pathsAllocated_ ? incNumber : 1000);
break;
default:
bumpPaths(
pathsAllocated_ ? incNumber : 8);
break;
}
}
paths_[numPaths_++] = new defiPath(p);
if (numPaths_ == pathsAllocated_)
*needCbk = 1; // pre-warn the parser it needs to realloc next time
} | O3 | cpp | LefDefParser::defiShield::addPath(LefDefParser::defiPath*, int, int, int*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rdi), %ecx
testl %edx, %edx
je 0x235c4
testl %ecx, %ecx
jle 0x235ba
xorl %r13d, %r13d
movq 0x10(%r14), %rax
movq (%rax,%r13,8), %r12
testq %r12, %r12
je 0x235a1
movq %r12, %rdi
callq 0x14132
movl $0x48, %esi
movq %r12, %rdi
callq 0x71c0
incq %r13
movslq 0x8(%r14), %rax
cmpq %rax, %r13
jl 0x2358c
movl $0x0, 0x8(%r14)
xorl %ecx, %ecx
movl 0xc(%r14), %eax
cmpl %eax, %ecx
jl 0x2360a
cmpl $0x10000, %eax # imm = 0x10000
jg 0x235e7
leal (%rax,%rax), %edx
leal 0x10000(%rax), %ecx
cmpl $0x10001, %edx # imm = 0x10001
cmovbl %edx, %ecx
jmp 0x235ed
leal 0x10000(%rax), %ecx
cmpl $0x2, %ebp
movl $0x3e8, %edx # imm = 0x3E8
movl $0x8, %esi
cmovel %edx, %esi
testl %eax, %eax
cmovnel %ecx, %esi
movq %r14, %rdi
callq 0x23668
movl $0x48, %edi
callq 0x71b0
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x14118
movq 0x10(%r14), %rax
movslq 0x8(%r14), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%r14)
movq %r12, (%rax,%rcx,8)
cmpl 0xc(%r14), %edx
jne 0x23641
movl $0x1, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x48, %esi
movq %r12, %rdi
callq 0x71c0
movq %rbx, %rdi
callq 0x7300
| _ZN12LefDefParser10defiShield7addPathEPNS_8defiPathEiiPi:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, r8
mov ebp, ecx
mov r15, rsi
mov r14, rdi
mov ecx, [rdi+8]
test edx, edx
jz short loc_235C4
test ecx, ecx
jle short loc_235BA
xor r13d, r13d
loc_2358C:
mov rax, [r14+10h]
mov r12, [rax+r13*8]
test r12, r12
jz short loc_235A1
mov rdi, r12; this
call _ZN12LefDefParser8defiPathD2Ev; LefDefParser::defiPath::~defiPath()
loc_235A1:
mov esi, 48h ; 'H'; unsigned __int64
mov rdi, r12; void *
call __ZdlPvm; operator delete(void *,ulong)
inc r13
movsxd rax, dword ptr [r14+8]
cmp r13, rax
jl short loc_2358C
loc_235BA:
mov dword ptr [r14+8], 0
xor ecx, ecx
loc_235C4:
mov eax, [r14+0Ch]
cmp ecx, eax
jl short loc_2360A
cmp eax, offset loc_10000
jg short loc_235E7
lea edx, [rax+rax]
lea ecx, loc_10000[rax]
cmp edx, 10001h
cmovb ecx, edx
jmp short loc_235ED
loc_235E7:
lea ecx, loc_10000[rax]
loc_235ED:
cmp ebp, 2
mov edx, 3E8h
mov esi, 8
cmovz esi, edx
test eax, eax
cmovnz esi, ecx; int
mov rdi, r14; this
call _ZN12LefDefParser10defiShield9bumpPathsEi; LefDefParser::defiShield::bumpPaths(int)
loc_2360A:
mov edi, 48h ; 'H'; unsigned __int64
call __Znwm; operator new(ulong)
mov r12, rax
mov rdi, rax
mov rsi, r15
call _ZN12LefDefParser8defiPathC2EPS0_; LefDefParser::defiPath::defiPath(LefDefParser::defiPath*)
mov rax, [r14+10h]
movsxd rcx, dword ptr [r14+8]
lea edx, [rcx+1]
mov [r14+8], edx
mov [rax+rcx*8], r12
cmp edx, [r14+0Ch]
jnz short loc_23641
mov dword ptr [rbx], 1
loc_23641:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov esi, 48h ; 'H'; unsigned __int64
mov rdi, r12; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, rbx
call __Unwind_Resume
| long long LefDefParser::defiShield::addPath(
LefDefParser::defiShield *this,
LefDefParser::defiPath *a2,
int a3,
int a4,
int *a5)
{
int v8; // ecx
long long v9; // r13
long long v10; // rax
void *v11; // r12
long long v12; // rax
int v13; // ecx
int v14; // esi
LefDefParser::defiPath *v15; // r12
long long result; // rax
long long v17; // rcx
v8 = *((_DWORD *)this + 2);
if ( a3 )
{
if ( v8 > 0 )
{
v9 = 0LL;
do
{
v10 = *((_QWORD *)this + 2);
v11 = *(void **)(v10 + 8 * v9);
if ( v11 )
LefDefParser::defiPath::~defiPath(*(LefDefParser::defiPath **)(v10 + 8 * v9));
operator delete(v11, 0x48uLL);
++v9;
}
while ( v9 < *((int *)this + 2) );
}
*((_DWORD *)this + 2) = 0;
v8 = 0;
}
v12 = *((unsigned int *)this + 3);
if ( v8 >= (int)v12 )
{
if ( (int)v12 > (int)&loc_10000 )
{
v13 = (unsigned int)&loc_10000 + v12;
}
else
{
v13 = (unsigned int)&loc_10000 + v12;
if ( (unsigned int)(2 * v12) < 0x10001 )
v13 = 2 * v12;
}
v14 = 8;
if ( a4 == 2 )
v14 = 1000;
if ( (_DWORD)v12 )
v14 = v13;
LefDefParser::defiShield::bumpPaths(this, v14);
}
v15 = (LefDefParser::defiPath *)operator new(0x48uLL);
LefDefParser::defiPath::defiPath(v15, a2);
result = *((_QWORD *)this + 2);
v17 = *((int *)this + 2);
*((_DWORD *)this + 2) = v17 + 1;
*(_QWORD *)(result + 8 * v17) = v15;
if ( (_DWORD)v17 + 1 == *((_DWORD *)this + 3) )
*a5 = 1;
return result;
}
| addPath:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,R8
MOV EBP,ECX
MOV R15,RSI
MOV R14,RDI
MOV ECX,dword ptr [RDI + 0x8]
TEST EDX,EDX
JZ 0x001235c4
TEST ECX,ECX
JLE 0x001235ba
XOR R13D,R13D
LAB_0012358c:
MOV RAX,qword ptr [R14 + 0x10]
MOV R12,qword ptr [RAX + R13*0x8]
TEST R12,R12
JZ 0x001235a1
MOV RDI,R12
CALL 0x00114132
LAB_001235a1:
MOV ESI,0x48
MOV RDI,R12
CALL 0x001071c0
INC R13
MOVSXD RAX,dword ptr [R14 + 0x8]
CMP R13,RAX
JL 0x0012358c
LAB_001235ba:
MOV dword ptr [R14 + 0x8],0x0
XOR ECX,ECX
LAB_001235c4:
MOV EAX,dword ptr [R14 + 0xc]
CMP ECX,EAX
JL 0x0012360a
CMP EAX,0x10000
JG 0x001235e7
LEA EDX,[RAX + RAX*0x1]
LEA ECX,[RAX + 0x10000]
CMP EDX,0x10001
CMOVC ECX,EDX
JMP 0x001235ed
LAB_001235e7:
LEA ECX,[RAX + 0x10000]
LAB_001235ed:
CMP EBP,0x2
MOV EDX,0x3e8
MOV ESI,0x8
CMOVZ ESI,EDX
TEST EAX,EAX
CMOVNZ ESI,ECX
MOV RDI,R14
CALL 0x00123668
LAB_0012360a:
MOV EDI,0x48
CALL 0x001071b0
MOV R12,RAX
LAB_00123617:
MOV RDI,RAX
MOV RSI,R15
CALL 0x00114118
LAB_00123622:
MOV RAX,qword ptr [R14 + 0x10]
MOVSXD RCX,dword ptr [R14 + 0x8]
LEA EDX,[RCX + 0x1]
MOV dword ptr [R14 + 0x8],EDX
MOV qword ptr [RAX + RCX*0x8],R12
CMP EDX,dword ptr [R14 + 0xc]
JNZ 0x00123641
MOV dword ptr [RBX],0x1
LAB_00123641:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* LefDefParser::defiShield::addPath(LefDefParser::defiPath*, int, int, int*) */
void __thiscall
LefDefParser::defiShield::addPath
(defiShield *this,defiPath *param_1,int param_2,int param_3,int *param_4)
{
defiPath *pdVar1;
int iVar2;
uint uVar3;
int iVar4;
uint uVar5;
long lVar6;
iVar2 = *(int *)(this + 8);
if (param_2 != 0) {
if (0 < iVar2) {
lVar6 = 0;
do {
pdVar1 = *(defiPath **)(*(long *)(this + 0x10) + lVar6 * 8);
if (pdVar1 != (defiPath *)0x0) {
defiPath::~defiPath(pdVar1);
}
operator_delete(pdVar1,0x48);
lVar6 = lVar6 + 1;
} while (lVar6 < *(int *)(this + 8));
}
*(int4 *)(this + 8) = 0;
iVar2 = 0;
}
iVar4 = *(int *)(this + 0xc);
if (iVar4 <= iVar2) {
if (iVar4 < 0x10001) {
uVar3 = iVar4 + 0x10000;
if ((uint)(iVar4 * 2) < 0x10001) {
uVar3 = iVar4 * 2;
}
}
else {
uVar3 = iVar4 + 0x10000;
}
uVar5 = 8;
if (param_3 == 2) {
uVar5 = 1000;
}
if (iVar4 != 0) {
uVar5 = uVar3;
}
bumpPaths(this,uVar5);
}
pdVar1 = (defiPath *)operator_new(0x48);
/* try { // try from 00123617 to 00123621 has its CatchHandler @ 00123650 */
defiPath::defiPath(pdVar1,param_1);
iVar2 = *(int *)(this + 8);
iVar4 = iVar2 + 1;
*(int *)(this + 8) = iVar4;
*(defiPath **)(*(long *)(this + 0x10) + (long)iVar2 * 8) = pdVar1;
if (iVar4 == *(int *)(this + 0xc)) {
*param_4 = 1;
}
return;
}
| |
23,987 | my_strntol_8bit | eloqsql/strings/ctype-simple.c | long my_strntol_8bit(CHARSET_INFO *cs,
const char *nptr, size_t l, int base,
char **endptr, int *err)
{
int negative;
register uint32 cutoff;
register uint cutlim;
register uint32 i;
register const char *s;
register uchar c;
const char *save, *e;
int overflow;
*err= 0; /* Initialize error indicator */
s = nptr;
e = nptr+l;
for ( ; s<e && my_isspace(cs, *s) ; s++);
if (s == e)
{
goto noconv;
}
/* Check for a sign. */
if (*s == '-')
{
negative = 1;
++s;
}
else if (*s == '+')
{
negative = 0;
++s;
}
else
negative = 0;
save = s;
cutoff = ((uint32)~0L) / (uint32) base;
cutlim = (uint) (((uint32)~0L) % (uint32) base);
overflow = 0;
i = 0;
for (c = *s; s != e; c = *++s)
{
if (c>='0' && c<='9')
c -= '0';
else if (c>='A' && c<='Z')
c = c - 'A' + 10;
else if (c>='a' && c<='z')
c = c - 'a' + 10;
else
break;
if (c >= base)
break;
if (i > cutoff || (i == cutoff && c > cutlim))
overflow = 1;
else
{
i *= (uint32) base;
i += c;
}
}
if (s == save)
goto noconv;
if (endptr != NULL)
*endptr = (char *) s;
if (negative)
{
if (i > (uint32) INT_MIN32)
overflow = 1;
}
else if (i > INT_MAX32)
overflow = 1;
if (overflow)
{
err[0]= ERANGE;
return negative ? INT_MIN32 : INT_MAX32;
}
return (negative ? -((long) i) : (long) i);
noconv:
err[0]= EDOM;
if (endptr != NULL)
*endptr = (char *) nptr;
return 0L;
} | O3 | c | my_strntol_8bit:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl $0x0, (%r9)
leaq (%rsi,%rdx), %r11
movq %rsi, %r10
testq %rdx, %rdx
jle 0x3d66b
movq 0x40(%rdi), %rax
movq %rsi, %r10
movzbl (%r10), %edx
testb $0x8, 0x1(%rax,%rdx)
je 0x3d66b
incq %r10
cmpq %r11, %r10
jb 0x3d658
cmpq %r11, %r10
je 0x3d770
movb (%r10), %dil
leal -0x2b(%rdi), %eax
andb $-0x3, %al
cmpb $0x1, %al
adcq $0x0, %r10
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
xorl %edx, %edx
divl %ecx
xorl %ebx, %ebx
cmpq %r11, %r10
je 0x3d71c
movq %rdi, -0x30(%rbp)
xorl %r12d, %r12d
movq %r10, %r14
xorl %r13d, %r13d
movl %r13d, %ebx
movl %r12d, %r15d
movb (%r14), %r12b
leal -0x30(%r12), %edi
cmpb $0xa, %dil
jb 0x3d6da
leal -0x41(%r12), %edi
cmpb $0x19, %dil
ja 0x3d6c8
addb $-0x37, %r12b
jmp 0x3d6d7
leal -0x61(%r12), %edi
cmpb $0x19, %dil
ja 0x3d716
addb $-0x57, %r12b
movl %r12d, %edi
movzbl %dil, %edi
cmpl %ecx, %edi
jge 0x3d716
movl $0x1, %r12d
cmpl %eax, %ebx
jbe 0x3d6f1
movl %ebx, %r13d
jmp 0x3d705
jne 0x3d6fa
movl %eax, %r13d
cmpl %edi, %edx
jb 0x3d705
imull %ecx, %ebx
addl %edi, %ebx
movl %ebx, %r13d
movl %r15d, %r12d
incq %r14
cmpq %r11, %r14
jne 0x3d6a3
movl %r13d, %ebx
movq %r11, %r14
movl %r12d, %r15d
movq -0x30(%rbp), %rdi
jmp 0x3d722
movq %r11, %r14
xorl %r15d, %r15d
cmpq %r10, %r14
je 0x3d770
testq %r8, %r8
je 0x3d72f
movq %r14, (%r8)
cmpl $0x80000001, %ebx # imm = 0x80000001
movl $0x1, %eax
movl %r15d, %ecx
cmovael %eax, %ecx
testl %ebx, %ebx
cmovsl %eax, %r15d
cmpb $0x2d, %dil
cmovel %ecx, %r15d
testl %r15d, %r15d
je 0x3d78c
cmpb $0x2d, %dil
movl $0x22, (%r9)
movq $-0x80000000, %rcx # imm = 0x80000000
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
cmoveq %rcx, %rax
jmp 0x3d781
movl $0x21, (%r9)
testq %r8, %r8
je 0x3d77f
movq %rsi, (%r8)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ebx, %ecx
movq %rcx, %rax
negq %rax
cmpb $0x2d, %dil
cmovneq %rcx, %rax
jmp 0x3d781
| my_strntol_8bit:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
mov dword ptr [r9], 0
lea r11, [rsi+rdx]
mov r10, rsi
test rdx, rdx
jle short loc_3D66B
mov rax, [rdi+40h]
mov r10, rsi
loc_3D658:
movzx edx, byte ptr [r10]
test byte ptr [rax+rdx+1], 8
jz short loc_3D66B
inc r10
cmp r10, r11
jb short loc_3D658
loc_3D66B:
cmp r10, r11
jz loc_3D770
mov dil, [r10]
lea eax, [rdi-2Bh]
and al, 0FDh
cmp al, 1
adc r10, 0
mov eax, 0FFFFFFFFh
xor edx, edx
div ecx
xor ebx, ebx
cmp r10, r11
jz loc_3D71C
mov [rbp+var_30], rdi
xor r12d, r12d
mov r14, r10
xor r13d, r13d
loc_3D6A3:
mov ebx, r13d
mov r15d, r12d
mov r12b, [r14]
lea edi, [r12-30h]
cmp dil, 0Ah
jb short loc_3D6DA
lea edi, [r12-41h]
cmp dil, 19h
ja short loc_3D6C8
add r12b, 0C9h
jmp short loc_3D6D7
loc_3D6C8:
lea edi, [r12-61h]
cmp dil, 19h
ja short loc_3D716
add r12b, 0A9h
loc_3D6D7:
mov edi, r12d
loc_3D6DA:
movzx edi, dil
cmp edi, ecx
jge short loc_3D716
mov r12d, 1
cmp ebx, eax
jbe short loc_3D6F1
mov r13d, ebx
jmp short loc_3D705
loc_3D6F1:
jnz short loc_3D6FA
mov r13d, eax
cmp edx, edi
jb short loc_3D705
loc_3D6FA:
imul ebx, ecx
add ebx, edi
mov r13d, ebx
mov r12d, r15d
loc_3D705:
inc r14
cmp r14, r11
jnz short loc_3D6A3
mov ebx, r13d
mov r14, r11
mov r15d, r12d
loc_3D716:
mov rdi, [rbp+var_30]
jmp short loc_3D722
loc_3D71C:
mov r14, r11
xor r15d, r15d
loc_3D722:
cmp r14, r10
jz short loc_3D770
test r8, r8
jz short loc_3D72F
mov [r8], r14
loc_3D72F:
cmp ebx, 80000001h
mov eax, 1
mov ecx, r15d
cmovnb ecx, eax
test ebx, ebx
cmovs r15d, eax
cmp dil, 2Dh ; '-'
cmovz r15d, ecx
test r15d, r15d
jz short loc_3D78C
cmp dil, 2Dh ; '-'
mov dword ptr [r9], 22h ; '"'
mov rcx, 0FFFFFFFF80000000h
mov eax, 7FFFFFFFh
cmovz rax, rcx
jmp short loc_3D781
loc_3D770:
mov dword ptr [r9], 21h ; '!'
test r8, r8
jz short loc_3D77F
mov [r8], rsi
loc_3D77F:
xor eax, eax
loc_3D781:
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3D78C:
mov ecx, ebx
mov rax, rcx
neg rax
cmp dil, 2Dh ; '-'
cmovnz rax, rcx
jmp short loc_3D781
| long long my_strntol_8bit(
long long a1,
unsigned __int8 *a2,
long long a3,
unsigned int a4,
unsigned __int8 **a5,
_DWORD *a6)
{
unsigned __int8 *v6; // r11
unsigned __int8 *v7; // r10
unsigned __int8 v8; // di
unsigned __int8 *v9; // r10
unsigned int v10; // eax
unsigned int v11; // ebx
int v12; // r12d
unsigned __int8 *v13; // r14
unsigned int v14; // r13d
int v15; // r15d
unsigned __int8 v16; // r12
unsigned __int8 v17; // di
unsigned __int8 v18; // r12
int v19; // ecx
long long result; // rax
unsigned __int8 v21; // [rsp+0h] [rbp-30h]
*a6 = 0;
v6 = &a2[a3];
v7 = a2;
if ( a3 > 0 )
{
v7 = a2;
do
{
if ( (*(_BYTE *)(*(_QWORD *)(a1 + 64) + *v7 + 1LL) & 8) == 0 )
break;
++v7;
}
while ( v7 < v6 );
}
if ( v7 == v6 )
goto LABEL_36;
v8 = *v7;
v9 = &v7[((*v7 - 43) & 0xFD) == 0];
v10 = 0xFFFFFFFF / a4;
v11 = 0;
if ( v9 == v6 )
{
v13 = &a2[a3];
v15 = 0;
}
else
{
v21 = v8;
v12 = 0;
v13 = v9;
v14 = 0;
while ( 1 )
{
v11 = v14;
v15 = v12;
v16 = *v13;
v17 = *v13 - 48;
if ( v17 >= 0xAu )
{
if ( (unsigned __int8)(v16 - 65) > 0x19u )
{
if ( (unsigned __int8)(v16 - 97) > 0x19u )
break;
v18 = v16 - 87;
}
else
{
v18 = v16 - 55;
}
v17 = v18;
}
if ( v17 >= (int)a4 )
break;
v12 = 1;
if ( v14 <= v10 )
{
if ( v14 != v10 || (v14 = 0xFFFFFFFF / a4, 0xFFFFFFFF % a4 >= v17) )
{
v14 = v17 + a4 * v11;
v12 = v15;
}
}
if ( ++v13 == v6 )
{
v11 = v14;
v13 = &a2[a3];
v15 = v12;
break;
}
}
v8 = v21;
}
if ( v13 == v9 )
{
LABEL_36:
*a6 = 33;
if ( a5 )
*a5 = a2;
return 0LL;
}
else
{
if ( a5 )
*a5 = v13;
v19 = v15;
if ( v11 >= 0x80000001 )
v19 = 1;
if ( (v11 & 0x80000000) != 0 )
v15 = 1;
if ( v8 == 45 )
v15 = v19;
if ( v15 )
{
*a6 = 34;
result = 0x7FFFFFFFLL;
if ( v8 == 45 )
return 0xFFFFFFFF80000000LL;
}
else
{
result = -(long long)v11;
if ( v8 != 45 )
return v11;
}
}
return result;
}
| my_strntol_8bit:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV dword ptr [R9],0x0
LEA R11,[RSI + RDX*0x1]
MOV R10,RSI
TEST RDX,RDX
JLE 0x0013d66b
MOV RAX,qword ptr [RDI + 0x40]
MOV R10,RSI
LAB_0013d658:
MOVZX EDX,byte ptr [R10]
TEST byte ptr [RAX + RDX*0x1 + 0x1],0x8
JZ 0x0013d66b
INC R10
CMP R10,R11
JC 0x0013d658
LAB_0013d66b:
CMP R10,R11
JZ 0x0013d770
MOV DIL,byte ptr [R10]
LEA EAX,[RDI + -0x2b]
AND AL,0xfd
CMP AL,0x1
ADC R10,0x0
MOV EAX,0xffffffff
XOR EDX,EDX
DIV ECX
XOR EBX,EBX
CMP R10,R11
JZ 0x0013d71c
MOV qword ptr [RBP + -0x30],RDI
XOR R12D,R12D
MOV R14,R10
XOR R13D,R13D
LAB_0013d6a3:
MOV EBX,R13D
MOV R15D,R12D
MOV R12B,byte ptr [R14]
LEA EDI,[R12 + -0x30]
CMP DIL,0xa
JC 0x0013d6da
LEA EDI,[R12 + -0x41]
CMP DIL,0x19
JA 0x0013d6c8
ADD R12B,0xc9
JMP 0x0013d6d7
LAB_0013d6c8:
LEA EDI,[R12 + -0x61]
CMP DIL,0x19
JA 0x0013d716
ADD R12B,0xa9
LAB_0013d6d7:
MOV EDI,R12D
LAB_0013d6da:
MOVZX EDI,DIL
CMP EDI,ECX
JGE 0x0013d716
MOV R12D,0x1
CMP EBX,EAX
JBE 0x0013d6f1
MOV R13D,EBX
JMP 0x0013d705
LAB_0013d6f1:
JNZ 0x0013d6fa
MOV R13D,EAX
CMP EDX,EDI
JC 0x0013d705
LAB_0013d6fa:
IMUL EBX,ECX
ADD EBX,EDI
MOV R13D,EBX
MOV R12D,R15D
LAB_0013d705:
INC R14
CMP R14,R11
JNZ 0x0013d6a3
MOV EBX,R13D
MOV R14,R11
MOV R15D,R12D
LAB_0013d716:
MOV RDI,qword ptr [RBP + -0x30]
JMP 0x0013d722
LAB_0013d71c:
MOV R14,R11
XOR R15D,R15D
LAB_0013d722:
CMP R14,R10
JZ 0x0013d770
TEST R8,R8
JZ 0x0013d72f
MOV qword ptr [R8],R14
LAB_0013d72f:
CMP EBX,0x80000001
MOV EAX,0x1
MOV ECX,R15D
CMOVNC ECX,EAX
TEST EBX,EBX
CMOVS R15D,EAX
CMP DIL,0x2d
CMOVZ R15D,ECX
TEST R15D,R15D
JZ 0x0013d78c
CMP DIL,0x2d
MOV dword ptr [R9],0x22
MOV RCX,-0x80000000
MOV EAX,0x7fffffff
CMOVZ RAX,RCX
JMP 0x0013d781
LAB_0013d770:
MOV dword ptr [R9],0x21
TEST R8,R8
JZ 0x0013d77f
MOV qword ptr [R8],RSI
LAB_0013d77f:
XOR EAX,EAX
LAB_0013d781:
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013d78c:
MOV ECX,EBX
MOV RAX,RCX
NEG RAX
CMP DIL,0x2d
CMOVNZ RAX,RCX
JMP 0x0013d781
|
ulong my_strntol_8bit(long param_1,byte *param_2,long param_3,uint param_4,ulong *param_5,
int4 *param_6)
{
byte *pbVar1;
byte bVar2;
byte bVar3;
bool bVar4;
bool bVar5;
uint uVar6;
uint uVar7;
byte *pbVar8;
byte bVar9;
uint uVar10;
byte *pbVar11;
byte *pbVar12;
*param_6 = 0;
pbVar1 = param_2 + param_3;
pbVar8 = param_2;
if (0 < param_3) {
do {
if ((*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)*pbVar8) & 8) == 0) break;
pbVar8 = pbVar8 + 1;
} while (pbVar8 < pbVar1);
}
if (pbVar8 != pbVar1) {
bVar2 = *pbVar8;
pbVar8 = pbVar8 + ((bVar2 - 0x2b & 0xfd) == 0);
uVar10 = 0;
if (pbVar8 == pbVar1) {
bVar4 = false;
pbVar12 = pbVar1;
}
else {
bVar4 = false;
uVar10 = 0;
pbVar11 = pbVar8;
do {
bVar3 = *pbVar11;
bVar9 = bVar3 - 0x30;
pbVar12 = pbVar11;
if (9 < bVar9) {
if ((byte)(bVar3 + 0xbf) < 0x1a) {
bVar9 = bVar3 - 0x37;
}
else {
if (0x19 < (byte)(bVar3 + 0x9f)) break;
bVar9 = bVar3 + 0xa9;
}
}
if ((int)param_4 <= (int)(uint)bVar9) break;
uVar7 = (uint)(0xffffffff / (ulong)param_4);
uVar6 = uVar10;
bVar5 = true;
if ((uVar10 <= uVar7) &&
((uVar10 != uVar7 || (uVar6 = uVar7, (uint)bVar9 <= (uint)(0xffffffff % (ulong)param_4)))
)) {
uVar6 = uVar10 * param_4 + (uint)bVar9;
bVar5 = bVar4;
}
bVar4 = bVar5;
uVar10 = uVar6;
pbVar11 = pbVar11 + 1;
pbVar12 = pbVar1;
} while (pbVar11 != pbVar1);
}
if (pbVar12 != pbVar8) {
if (param_5 != (ulong *)0x0) {
*param_5 = (ulong)pbVar12;
}
bVar5 = bVar4;
if (0x80000000 < uVar10) {
bVar5 = true;
}
if ((int)uVar10 < 0) {
bVar4 = true;
}
if (bVar2 == 0x2d) {
bVar4 = bVar5;
}
if (bVar4) {
*param_6 = 0x22;
if (bVar2 != 0x2d) {
return 0x7fffffff;
}
return 0xffffffff80000000;
}
if (bVar2 == 0x2d) {
return -(ulong)uVar10;
}
return (ulong)uVar10;
}
}
*param_6 = 0x21;
if (param_5 != (ulong *)0x0) {
*param_5 = (ulong)param_2;
}
return 0;
}
| |
23,988 | nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<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>>::end_array() | monkey531[P]llama/common/json.hpp | bool end_array()
{
bool keep = true;
if (ref_stack.back())
{
keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
if (keep)
{
ref_stack.back()->set_parents();
}
else
{
// discard array
*ref_stack.back() = discarded;
}
}
JSON_ASSERT(!ref_stack.empty());
JSON_ASSERT(!keep_stack.empty());
ref_stack.pop_back();
keep_stack.pop_back();
// remove discarded value
if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
{
ref_stack.back()->m_data.m_value.array->pop_back();
}
return true;
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<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>>::end_array():
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq -0x8(%rax), %rcx
movb $0x1, %bpl
testq %rcx, %rcx
je 0x5f505
subq 0x8(%rbx), %rax
shrq $0x3, %rax
decl %eax
movl %eax, 0xc(%rsp)
movb $0x3, 0xb(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0x5f5cd
leaq 0x80(%rbx), %rdi
leaq 0xc(%rsp), %rsi
leaq 0xb(%rsp), %rdx
callq *0x98(%rbx)
testb %al, %al
jne 0x5f505
leaq 0xa8(%rbx), %rsi
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x602f6
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rdi
movq %r14, %rsi
callq 0x5da76
xorl %ebp, %ebp
movq %r14, %rdi
xorl %esi, %esi
callq 0x5b2d4
movq %r14, %rdi
callq 0x607c2
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rax
cmpq %rax, %rcx
je 0x5f590
movq 0x30(%rbx), %rdx
movl 0x38(%rbx), %esi
cmpq %rdx, 0x20(%rbx)
sete %dil
testl %esi, %esi
sete %r8b
andb %dil, %r8b
cmpb $0x1, %r8b
je 0x5f5ac
leaq -0x8(%rax), %rdi
movq %rdi, 0x10(%rbx)
subl $0x1, %esi
movl %esi, 0x38(%rbx)
jae 0x5f54f
movl $0x3f, 0x38(%rbx)
addq $-0x8, %rdx
movq %rdx, 0x30(%rbx)
cmpq %rdi, %rcx
sete %cl
orb %cl, %bpl
jne 0x5f585
movq -0x10(%rax), %rax
cmpb $0x2, (%rax)
jne 0x5f585
movq 0x8(%rax), %rax
movq 0x8(%rax), %rbx
addq $-0x10, %rbx
movq %rbx, 0x8(%rax)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5b2d4
movq %rbx, %rdi
callq 0x607c2
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x8ee42(%rip), %rdi # 0xee3d9
leaq 0x88dc0(%rip), %rdx # 0xe835e
leaq 0x8fe1f(%rip), %rcx # 0xef3c4
movl $0x1bf5, %esi # imm = 0x1BF5
jmp 0x5f5c6
leaq 0x8ee26(%rip), %rdi # 0xee3d9
leaq 0x88da4(%rip), %rdx # 0xe835e
leaq 0x8fd7d(%rip), %rcx # 0xef33e
movl $0x1bf6, %esi # imm = 0x1BF6
xorl %eax, %eax
callq 0x1bf40
callq 0x1b320
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE9end_arrayEv:
push rbp
push r14
push rbx
sub rsp, 20h
mov rbx, rdi
mov rax, [rdi+10h]
mov rcx, [rax-8]
mov bpl, 1
test rcx, rcx
jz short loc_5F505
sub rax, [rbx+8]
shr rax, 3
dec eax
mov [rsp+38h+var_2C], eax
mov [rsp+38h+var_2D], 3
cmp qword ptr [rbx+90h], 0
jz loc_5F5CD
lea rdi, [rbx+80h]
lea rsi, [rsp+38h+var_2C]
lea rdx, [rsp+38h+var_2D]
call qword ptr [rbx+98h]
test al, al
jnz short loc_5F505
lea rsi, [rbx+0A8h]
lea r14, [rsp+38h+var_28]
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; 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(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rax, [rbx+10h]
mov rdi, [rax-8]
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; 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>::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>)
xor ebp, ebp
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_5F505:
mov rcx, [rbx+8]
mov rax, [rbx+10h]
cmp rcx, rax
jz short loc_5F590
mov rdx, [rbx+30h]
mov esi, [rbx+38h]
cmp [rbx+20h], rdx
setz dil
test esi, esi
setz r8b
and r8b, dil
cmp r8b, 1
jz short loc_5F5AC
lea rdi, [rax-8]
mov [rbx+10h], rdi
sub esi, 1
mov [rbx+38h], esi
jnb short loc_5F54F
mov dword ptr [rbx+38h], 3Fh ; '?'
add rdx, 0FFFFFFFFFFFFFFF8h
mov [rbx+30h], rdx
loc_5F54F:
cmp rcx, rdi
setz cl
or bpl, cl
jnz short loc_5F585
mov rax, [rax-10h]
cmp byte ptr [rax], 2
jnz short loc_5F585
mov rax, [rax+8]
mov rbx, [rax+8]
add rbx, 0FFFFFFFFFFFFFFF0h
mov [rax+8], rbx
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_5F585:
mov al, 1
add rsp, 20h
pop rbx
pop r14
pop rbp
retn
loc_5F590:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aRefStackEmpty; "!ref_stack.empty()"
mov esi, 1BF5h
jmp short loc_5F5C6
loc_5F5AC:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeepStackEmpty; "!keep_stack.empty()"
mov esi, 1BF6h
loc_5F5C6:
xor eax, eax
call _ggml_abort
loc_5F5CD:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
| char nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<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>>::end_array(
long long a1)
{
long long v1; // rax
char v2; // bp
long long v3; // rcx
long long v4; // rax
long long v5; // rdx
int v6; // esi
long long v7; // rax
long long v8; // rax
char *v9; // rbx
char v11; // [rsp+Bh] [rbp-2Dh] BYREF
int v12; // [rsp+Ch] [rbp-2Ch] BYREF
char v13[40]; // [rsp+10h] [rbp-28h] BYREF
v1 = *(_QWORD *)(a1 + 16);
v2 = 1;
if ( *(_QWORD *)(v1 - 8) )
{
v12 = ((unsigned long long)(v1 - *(_QWORD *)(a1 + 8)) >> 3) - 1;
v11 = 3;
if ( !*(_QWORD *)(a1 + 144) )
goto LABEL_15;
if ( !(*(unsigned __int8 ( **)(long long, int *, char *))(a1 + 152))(a1 + 128, &v12, &v11) )
{
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(
v13,
a1 + 168);
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=(
*(_QWORD *)(*(_QWORD *)(a1 + 16) - 8LL),
(long long)v13);
v2 = 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(v13);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v13);
}
}
v3 = *(_QWORD *)(a1 + 8);
v4 = *(_QWORD *)(a1 + 16);
if ( v3 == v4 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7157LL,
"GGML_ASSERT(%s) failed",
"!ref_stack.empty()");
goto LABEL_15;
}
v5 = *(_QWORD *)(a1 + 48);
v6 = *(_DWORD *)(a1 + 56);
if ( *(_QWORD *)(a1 + 32) == v5 && v6 == 0 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7158LL,
"GGML_ASSERT(%s) failed",
"!keep_stack.empty()");
LABEL_15:
std::__throw_bad_function_call();
}
*(_QWORD *)(a1 + 16) = v4 - 8;
*(_DWORD *)(a1 + 56) = v6 - 1;
if ( !v6 )
{
*(_DWORD *)(a1 + 56) = 63;
*(_QWORD *)(a1 + 48) = v5 - 8;
}
if ( !((v3 == v4 - 8) | (unsigned __int8)v2) )
{
v7 = *(_QWORD *)(v4 - 16);
if ( *(_BYTE *)v7 == 2 )
{
v8 = *(_QWORD *)(v7 + 8);
v9 = (char *)(*(_QWORD *)(v8 + 8) - 16LL);
*(_QWORD *)(v8 + 8) = v9;
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(v9);
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(v9);
}
}
return 1;
}
| end_array:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x20
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x10]
MOV RCX,qword ptr [RAX + -0x8]
MOV BPL,0x1
TEST RCX,RCX
JZ 0x0015f505
SUB RAX,qword ptr [RBX + 0x8]
SHR RAX,0x3
DEC EAX
MOV dword ptr [RSP + 0xc],EAX
MOV byte ptr [RSP + 0xb],0x3
CMP qword ptr [RBX + 0x90],0x0
JZ 0x0015f5cd
LEA RDI,[RBX + 0x80]
LEA RSI,[RSP + 0xc]
LEA RDX,[RSP + 0xb]
CALL qword ptr [RBX + 0x98]
TEST AL,AL
JNZ 0x0015f505
LEA RSI,[RBX + 0xa8]
LEA R14,[RSP + 0x10]
MOV RDI,R14
CALL 0x001602f6
MOV RAX,qword ptr [RBX + 0x10]
MOV RDI,qword ptr [RAX + -0x8]
MOV RSI,R14
CALL 0x0015da76
XOR EBP,EBP
MOV RDI,R14
XOR ESI,ESI
CALL 0x0015b2d4
MOV RDI,R14
CALL 0x001607c2
LAB_0015f505:
MOV RCX,qword ptr [RBX + 0x8]
MOV RAX,qword ptr [RBX + 0x10]
CMP RCX,RAX
JZ 0x0015f590
MOV RDX,qword ptr [RBX + 0x30]
MOV ESI,dword ptr [RBX + 0x38]
CMP qword ptr [RBX + 0x20],RDX
SETZ DIL
TEST ESI,ESI
SETZ R8B
AND R8B,DIL
CMP R8B,0x1
JZ 0x0015f5ac
LEA RDI,[RAX + -0x8]
MOV qword ptr [RBX + 0x10],RDI
SUB ESI,0x1
MOV dword ptr [RBX + 0x38],ESI
JNC 0x0015f54f
MOV dword ptr [RBX + 0x38],0x3f
ADD RDX,-0x8
MOV qword ptr [RBX + 0x30],RDX
LAB_0015f54f:
CMP RCX,RDI
SETZ CL
OR BPL,CL
JNZ 0x0015f585
MOV RAX,qword ptr [RAX + -0x10]
CMP byte ptr [RAX],0x2
JNZ 0x0015f585
MOV RAX,qword ptr [RAX + 0x8]
MOV RBX,qword ptr [RAX + 0x8]
ADD RBX,-0x10
MOV qword ptr [RAX + 0x8],RBX
MOV RDI,RBX
XOR ESI,ESI
CALL 0x0015b2d4
MOV RDI,RBX
CALL 0x001607c2
LAB_0015f585:
MOV AL,0x1
ADD RSP,0x20
POP RBX
POP R14
POP RBP
RET
LAB_0015f590:
LEA RDI,[0x1ee3d9]
LEA RDX,[0x1e835e]
LEA RCX,[0x1ef3c4]
MOV ESI,0x1bf5
JMP 0x0015f5c6
LAB_0015f5ac:
LEA RDI,[0x1ee3d9]
LEA RDX,[0x1e835e]
LEA RCX,[0x1ef33e]
MOV ESI,0x1bf6
LAB_0015f5c6:
XOR EAX,EAX
CALL 0x0011bf40
LAB_0015f5cd:
CALL 0x0011b320
|
/* nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<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> >::end_array() */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<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>>
::end_array(json_sax_dom_callback_parser<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)
{
int iVar1;
long lVar2;
byte bVar3;
char cVar4;
char *pcVar5;
data *this_00;
int8 uVar6;
int1 local_2d;
int local_2c;
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 [16];
bVar3 = 1;
if (*(long *)(*(long *)(this + 0x10) + -8) != 0) {
local_2c = (int)((ulong)(*(long *)(this + 0x10) - *(long *)(this + 8)) >> 3) + -1;
local_2d = 3;
if (*(long *)(this + 0x90) == 0) {
/* WARNING: Subroutine does not return */
std::__throw_bad_function_call();
}
cVar4 = (**(code **)(this + 0x98))(this + 0x80,&local_2c,&local_2d);
if (cVar4 == '\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>
::basic_json(local_28,(basic_json *)(this + 0xa8));
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=(*(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>
**)(*(long *)(this + 0x10) + -8),local_28);
bVar3 = 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(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>
::data::~data((data *)local_28);
}
}
lVar2 = *(long *)(this + 0x10);
if (*(long *)(this + 8) == lVar2) {
pcVar5 = "!ref_stack.empty()";
uVar6 = 0x1bf5;
}
else {
iVar1 = *(int *)(this + 0x38);
if (iVar1 != 0 || *(long *)(this + 0x20) != *(long *)(this + 0x30)) {
*(long *)(this + 0x10) = lVar2 + -8;
*(int *)(this + 0x38) = iVar1 + -1;
if (iVar1 == 0) {
*(int4 *)(this + 0x38) = 0x3f;
*(long *)(this + 0x30) = *(long *)(this + 0x30) + -8;
}
if ((!(bool)(bVar3 | *(long *)(this + 8) == lVar2 + -8)) &&
(**(char **)(lVar2 + -0x10) == '\x02')) {
lVar2 = *(long *)(*(char **)(lVar2 + -0x10) + 8);
this_00 = (data *)(*(long *)(lVar2 + 8) + -0x10);
*(data **)(lVar2 + 8) = 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>
::assert_invariant(SUB81(this_00,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>
::data::~data(this_00);
}
return 1;
}
pcVar5 = "!keep_stack.empty()";
uVar6 = 0x1bf6;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",uVar6,
"GGML_ASSERT(%s) failed",pcVar5);
}
| |
23,989 | PhiloxRNG::uint32(std::vector<unsigned long, std::allocator<unsigned long>> const&) | 7CodeWizard[P]stablediffusion/rng_philox.hpp | std::vector<std::vector<uint32_t>> uint32(const std::vector<uint64_t>& x) {
uint32_t N = (uint32_t)x.size();
std::vector<std::vector<uint32_t>> result(2, std::vector<uint32_t>(N));
for (uint32_t i = 0; i < N; ++i) {
result[0][i] = static_cast<uint32_t>(x[i] & 0xFFFFFFFF);
result[1][i] = static_cast<uint32_t>(x[i] >> 32);
}
return result;
} | O0 | cpp | PhiloxRNG::uint32(std::vector<unsigned long, std::allocator<unsigned long>> const&):
subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x70(%rsp), %rdi
callq 0x50450
movl %eax, 0x6c(%rsp)
movb $0x0, 0x6b(%rsp)
movl 0x6c(%rsp), %eax
movq %rax, 0x20(%rsp)
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x4db00
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x50(%rsp), %rdi
callq 0x50470
jmp 0x4eb37
leaq 0x3b(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4e950
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rcx
movl $0x2, %esi
leaq 0x50(%rsp), %rdx
callq 0x4e960
jmp 0x4eb61
leaq 0x3b(%rsp), %rdi
callq 0x4e9e0
leaq 0x50(%rsp), %rdi
callq 0x4dbb0
leaq 0x4f(%rsp), %rdi
callq 0x4dba0
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x6c(%rsp), %eax
jae 0x4ec65
movq 0x70(%rsp), %rdi
movl 0x34(%rsp), %eax
movl %eax, %esi
callq 0x504f0
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq (%rcx), %rax
movl %eax, (%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x4e9f0
movq %rax, %rdi
movl 0x34(%rsp), %eax
movl %eax, %esi
callq 0x4ea10
movl (%rsp), %ecx
movl %ecx, (%rax)
movq 0x70(%rsp), %rdi
movl 0x34(%rsp), %eax
movl %eax, %esi
callq 0x504f0
movq 0x10(%rsp), %rdi
movq (%rax), %rax
shrq $0x20, %rax
movl %eax, 0x4(%rsp)
movl $0x1, %esi
callq 0x4e9f0
movq %rax, %rdi
movl 0x34(%rsp), %eax
movl %eax, %esi
callq 0x4ea10
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x4eb87
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x4ec59
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x3b(%rsp), %rdi
callq 0x4e9e0
leaq 0x50(%rsp), %rdi
callq 0x4dbb0
leaq 0x4f(%rsp), %rdi
callq 0x4dba0
jmp 0x4ec88
movb $0x1, 0x6b(%rsp)
testb $0x1, 0x6b(%rsp)
jne 0x4ec7b
movq 0x10(%rsp), %rdi
callq 0x4eee0
movq 0x18(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0xbd30
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZN9PhiloxRNG6uint32ERKSt6vectorImSaImEE:
sub rsp, 88h
mov [rsp+88h+var_78], rdi
mov rax, rdi
mov [rsp+88h+var_70], rax
mov [rsp+88h+var_8], rdi
mov [rsp+88h+var_10], rsi
mov [rsp+88h+var_18], rdx
mov rdi, [rsp+88h+var_18]
call _ZNKSt6vectorImSaImEE4sizeEv; std::vector<ulong>::size(void)
mov [rsp+88h+var_1C], eax
mov [rsp+88h+var_1D], 0
mov eax, [rsp+88h+var_1C]
mov [rsp+88h+var_68], rax
lea rdi, [rsp+88h+var_39]
mov [rsp+88h+var_60], rdi
call _ZNSaIjEC2Ev; std::allocator<uint>::allocator(void)
mov rsi, [rsp+88h+var_68]
mov rdx, [rsp+88h+var_60]
lea rdi, [rsp+88h+var_38]
call _ZNSt6vectorIjSaIjEEC2EmRKS0_; std::vector<uint>::vector(ulong,std::allocator<uint> const&)
jmp short $+2
loc_4EB37:
lea rdi, [rsp+88h+var_4D]
mov [rsp+88h+var_80], rdi
call _ZNSaISt6vectorIjSaIjEEEC2Ev; std::allocator<std::vector<uint>>::allocator(void)
mov rdi, [rsp+88h+var_78]
mov rcx, [rsp+88h+var_80]
mov esi, 2
lea rdx, [rsp+88h+var_38]
call _ZNSt6vectorIS_IjSaIjEESaIS1_EEC2EmRKS1_RKS2_; std::vector<std::vector<uint>>::vector(ulong,std::vector<uint> const&,std::allocator<std::vector<uint>> const&)
jmp short $+2
loc_4EB61:
lea rdi, [rsp+88h+var_4D]
call _ZNSaISt6vectorIjSaIjEEED2Ev; std::allocator<std::vector<uint>>::~allocator()
lea rdi, [rsp+88h+var_38]
call _ZNSt6vectorIjSaIjEED2Ev; std::vector<uint>::~vector()
lea rdi, [rsp+88h+var_39]
call _ZNSaIjED2Ev; std::allocator<uint>::~allocator()
mov [rsp+88h+var_54], 0
loc_4EB87:
mov eax, [rsp+88h+var_54]
cmp eax, [rsp+88h+var_1C]
jnb loc_4EC65
mov rdi, [rsp+88h+var_18]
mov eax, [rsp+88h+var_54]
mov esi, eax
call _ZNKSt6vectorImSaImEEixEm; std::vector<ulong>::operator[](ulong)
mov rdi, [rsp+88h+var_78]
mov rcx, rax
mov rax, 0FFFFFFFFh
and rax, [rcx]
mov [rsp+88h+var_88], eax
xor eax, eax
mov esi, eax
call _ZNSt6vectorIS_IjSaIjEESaIS1_EEixEm; std::vector<std::vector<uint>>::operator[](ulong)
mov rdi, rax
mov eax, [rsp+88h+var_54]
mov esi, eax
call _ZNSt6vectorIjSaIjEEixEm; std::vector<uint>::operator[](ulong)
mov ecx, [rsp+88h+var_88]
mov [rax], ecx
mov rdi, [rsp+88h+var_18]
mov eax, [rsp+88h+var_54]
mov esi, eax
call _ZNKSt6vectorImSaImEEixEm; std::vector<ulong>::operator[](ulong)
mov rdi, [rsp+88h+var_78]
mov rax, [rax]
shr rax, 20h
mov [rsp+88h+var_84], eax
mov esi, 1
call _ZNSt6vectorIS_IjSaIjEESaIS1_EEixEm; std::vector<std::vector<uint>>::operator[](ulong)
mov rdi, rax
mov eax, [rsp+88h+var_54]
mov esi, eax
call _ZNSt6vectorIjSaIjEEixEm; std::vector<uint>::operator[](ulong)
mov ecx, [rsp+88h+var_84]
mov [rax], ecx
mov eax, [rsp+88h+var_54]
add eax, 1
mov [rsp+88h+var_54], eax
jmp loc_4EB87
mov rcx, rax
mov eax, edx
mov [rsp+arg_38], rcx
mov [rsp+arg_34], eax
jmp short loc_4EC59
mov rcx, rax
mov eax, edx
mov [rsp+arg_38], rcx
mov [rsp+arg_34], eax
lea rdi, [rsp+arg_33]
call _ZNSaISt6vectorIjSaIjEEED2Ev; std::allocator<std::vector<uint>>::~allocator()
lea rdi, [rsp+arg_48]
call _ZNSt6vectorIjSaIjEED2Ev; std::vector<uint>::~vector()
loc_4EC59:
lea rdi, [rsp+arg_47]
call _ZNSaIjED2Ev; std::allocator<uint>::~allocator()
jmp short loc_4EC88
loc_4EC65:
mov [rsp+88h+var_1D], 1
test [rsp+88h+var_1D], 1
jnz short loc_4EC7B
mov rdi, [rsp+88h+var_78]
call _ZNSt6vectorIS_IjSaIjEESaIS1_EED2Ev; std::vector<std::vector<uint>>::~vector()
loc_4EC7B:
mov rax, [rsp+88h+var_70]
add rsp, 88h
retn
loc_4EC88:
mov rdi, [rsp+arg_38]
call __Unwind_Resume
| _QWORD * PhiloxRNG::uint32(_QWORD *a1, long long a2, long long a3)
{
int v3; // ecx
int v4; // r8d
int v5; // r9d
_QWORD *v6; // rax
_QWORD *v7; // rax
int v9; // [rsp+0h] [rbp-88h]
int v10; // [rsp+4h] [rbp-84h]
unsigned int v11; // [rsp+20h] [rbp-68h]
unsigned int i; // [rsp+34h] [rbp-54h]
_BYTE v13[20]; // [rsp+3Bh] [rbp-4Dh] BYREF
char v14; // [rsp+4Fh] [rbp-39h] BYREF
long long v15[3]; // [rsp+50h] [rbp-38h] BYREF
char v16; // [rsp+6Bh] [rbp-1Dh]
unsigned int v17; // [rsp+6Ch] [rbp-1Ch]
long long v18; // [rsp+70h] [rbp-18h]
long long v19; // [rsp+78h] [rbp-10h]
_QWORD *v20; // [rsp+80h] [rbp-8h]
v20 = a1;
v19 = a2;
v18 = a3;
v17 = std::vector<unsigned long>::size(a3);
v16 = 0;
v11 = v17;
std::allocator<unsigned int>::allocator((long long)&v14);
std::vector<unsigned int>::vector((unsigned int)v15, v11, (unsigned int)&v14, v3, v4, v5);
std::allocator<std::vector<unsigned int>>::allocator((long long)v13);
std::vector<std::vector<unsigned int>>::vector((long long)a1, 2LL, (long long)v15, (long long)v13);
std::allocator<std::vector<unsigned int>>::~allocator((long long)v13);
std::vector<unsigned int>::~vector(v15);
std::allocator<unsigned int>::~allocator((long long)&v14);
for ( i = 0; i < v17; ++i )
{
v9 = *(_QWORD *)std::vector<unsigned long>::operator[](v18, i);
v6 = (_QWORD *)std::vector<std::vector<unsigned int>>::operator[](a1, 0LL);
*(_DWORD *)std::vector<unsigned int>::operator[](v6, i) = v9;
v10 = HIDWORD(*(_QWORD *)std::vector<unsigned long>::operator[](v18, i));
v7 = (_QWORD *)std::vector<std::vector<unsigned int>>::operator[](a1, 1LL);
*(_DWORD *)std::vector<unsigned int>::operator[](v7, i) = v10;
}
return a1;
}
| uint32:
SUB RSP,0x88
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x80],RDI
MOV qword ptr [RSP + 0x78],RSI
MOV qword ptr [RSP + 0x70],RDX
MOV RDI,qword ptr [RSP + 0x70]
CALL 0x00150450
MOV dword ptr [RSP + 0x6c],EAX
MOV byte ptr [RSP + 0x6b],0x0
MOV EAX,dword ptr [RSP + 0x6c]
MOV qword ptr [RSP + 0x20],RAX
LEA RDI,[RSP + 0x4f]
MOV qword ptr [RSP + 0x28],RDI
CALL 0x0014db00
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
LAB_0014eb2b:
LEA RDI,[RSP + 0x50]
CALL 0x00150470
JMP 0x0014eb37
LAB_0014eb37:
LEA RDI,[RSP + 0x3b]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x0014e950
MOV RDI,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x8]
LAB_0014eb50:
MOV ESI,0x2
LEA RDX,[RSP + 0x50]
CALL 0x0014e960
LAB_0014eb5f:
JMP 0x0014eb61
LAB_0014eb61:
LEA RDI,[RSP + 0x3b]
CALL 0x0014e9e0
LEA RDI,[RSP + 0x50]
CALL 0x0014dbb0
LEA RDI,[RSP + 0x4f]
CALL 0x0014dba0
MOV dword ptr [RSP + 0x34],0x0
LAB_0014eb87:
MOV EAX,dword ptr [RSP + 0x34]
CMP EAX,dword ptr [RSP + 0x6c]
JNC 0x0014ec65
MOV RDI,qword ptr [RSP + 0x70]
MOV EAX,dword ptr [RSP + 0x34]
MOV ESI,EAX
CALL 0x001504f0
MOV RDI,qword ptr [RSP + 0x10]
MOV RCX,RAX
MOV RAX,0xffffffff
AND RAX,qword ptr [RCX]
MOV dword ptr [RSP],EAX
XOR EAX,EAX
MOV ESI,EAX
CALL 0x0014e9f0
MOV RDI,RAX
MOV EAX,dword ptr [RSP + 0x34]
MOV ESI,EAX
CALL 0x0014ea10
MOV ECX,dword ptr [RSP]
MOV dword ptr [RAX],ECX
MOV RDI,qword ptr [RSP + 0x70]
MOV EAX,dword ptr [RSP + 0x34]
MOV ESI,EAX
CALL 0x001504f0
MOV RDI,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RAX]
SHR RAX,0x20
MOV dword ptr [RSP + 0x4],EAX
MOV ESI,0x1
CALL 0x0014e9f0
MOV RDI,RAX
MOV EAX,dword ptr [RSP + 0x34]
MOV ESI,EAX
CALL 0x0014ea10
MOV ECX,dword ptr [RSP + 0x4]
MOV dword ptr [RAX],ECX
MOV EAX,dword ptr [RSP + 0x34]
ADD EAX,0x1
MOV dword ptr [RSP + 0x34],EAX
JMP 0x0014eb87
LAB_0014ec65:
MOV byte ptr [RSP + 0x6b],0x1
TEST byte ptr [RSP + 0x6b],0x1
JNZ 0x0014ec7b
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x0014eee0
LAB_0014ec7b:
MOV RAX,qword ptr [RSP + 0x18]
ADD RSP,0x88
RET
|
/* WARNING: Removing unreachable block (ram,0x0014ec71) */
/* PhiloxRNG::uint32(std::vector<unsigned long, std::allocator<unsigned long> > const&) */
vector * PhiloxRNG::uint32(vector *param_1)
{
int8 uVar1;
ulong uVar2;
int8 *puVar3;
vector<unsigned_int,std::allocator<unsigned_int>> *pvVar4;
int4 *puVar5;
vector<unsigned_long,std::allocator<unsigned_long>> *in_RDX;
uint local_54;
allocator<std::vector<unsigned_int,std::allocator<unsigned_int>>> local_4d [20];
allocator<unsigned_int> local_39;
vector<unsigned_int,std::allocator<unsigned_int>> local_38 [27];
int1 local_1d;
uint local_1c;
vector<unsigned_long,std::allocator<unsigned_long>> *local_18;
vector *local_8;
local_18 = in_RDX;
local_8 = param_1;
local_1c = std::vector<unsigned_long,std::allocator<unsigned_long>>::size(in_RDX);
local_1d = 0;
uVar2 = (ulong)local_1c;
std::allocator<unsigned_int>::allocator(&local_39);
/* try { // try from 0014eb2b to 0014eb34 has its CatchHandler @ 0014ec27 */
std::vector<unsigned_int,std::allocator<unsigned_int>>::vector
(local_38,uVar2,(allocator *)&local_39);
std::allocator<std::vector<unsigned_int,std::allocator<unsigned_int>>>::allocator(local_4d);
/* try { // try from 0014eb50 to 0014eb5e has its CatchHandler @ 0014ec37 */
std::
vector<std::vector<unsigned_int,std::allocator<unsigned_int>>,std::allocator<std::vector<unsigned_int,std::allocator<unsigned_int>>>>
::vector((vector<std::vector<unsigned_int,std::allocator<unsigned_int>>,std::allocator<std::vector<unsigned_int,std::allocator<unsigned_int>>>>
*)param_1,2,(vector *)local_38,(allocator *)local_4d);
std::allocator<std::vector<unsigned_int,std::allocator<unsigned_int>>>::~allocator(local_4d);
std::vector<unsigned_int,std::allocator<unsigned_int>>::~vector(local_38);
std::allocator<unsigned_int>::~allocator(&local_39);
for (local_54 = 0; local_54 < local_1c; local_54 = local_54 + 1) {
puVar3 = (int8 *)
std::vector<unsigned_long,std::allocator<unsigned_long>>::operator[]
(local_18,(ulong)local_54);
uVar1 = *puVar3;
pvVar4 = (vector<unsigned_int,std::allocator<unsigned_int>> *)
std::
vector<std::vector<unsigned_int,std::allocator<unsigned_int>>,std::allocator<std::vector<unsigned_int,std::allocator<unsigned_int>>>>
::operator[]((vector<std::vector<unsigned_int,std::allocator<unsigned_int>>,std::allocator<std::vector<unsigned_int,std::allocator<unsigned_int>>>>
*)param_1,0);
puVar5 = (int4 *)
std::vector<unsigned_int,std::allocator<unsigned_int>>::operator[]
(pvVar4,(ulong)local_54);
*puVar5 = (int)uVar1;
puVar3 = (int8 *)
std::vector<unsigned_long,std::allocator<unsigned_long>>::operator[]
(local_18,(ulong)local_54);
uVar1 = *puVar3;
pvVar4 = (vector<unsigned_int,std::allocator<unsigned_int>> *)
std::
vector<std::vector<unsigned_int,std::allocator<unsigned_int>>,std::allocator<std::vector<unsigned_int,std::allocator<unsigned_int>>>>
::operator[]((vector<std::vector<unsigned_int,std::allocator<unsigned_int>>,std::allocator<std::vector<unsigned_int,std::allocator<unsigned_int>>>>
*)param_1,1);
puVar5 = (int4 *)
std::vector<unsigned_int,std::allocator<unsigned_int>>::operator[]
(pvVar4,(ulong)local_54);
*puVar5 = (int)((ulong)uVar1 >> 0x20);
}
return param_1;
}
| |
23,990 | PhiloxRNG::uint32(std::vector<unsigned long, std::allocator<unsigned long>> const&) | 7CodeWizard[P]stablediffusion/rng_philox.hpp | std::vector<std::vector<uint32_t>> uint32(const std::vector<uint64_t>& x) {
uint32_t N = (uint32_t)x.size();
std::vector<std::vector<uint32_t>> result(2, std::vector<uint32_t>(N));
for (uint32_t i = 0; i < N; ++i) {
result[0][i] = static_cast<uint32_t>(x[i] & 0xFFFFFFFF);
result[1][i] = static_cast<uint32_t>(x[i] >> 32);
}
return result;
} | O1 | cpp | PhiloxRNG::uint32(std::vector<unsigned long, std::allocator<unsigned long>> const&):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq 0x8(%rdx), %r13
subq (%rdx), %r13
movq %rdi, %rbx
movq %r13, %r12
sarq $0x3, %r12
movl %r12d, %esi
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
callq 0x3c458
leaq 0x6(%rsp), %rcx
movl $0x2, %esi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3bf6c
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3c17e
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0xa5e0
shrq $0x3, %r13
testl %r13d, %r13d
je 0x3c1b1
movq (%r14), %rax
movq (%rbx), %rdx
movq (%rdx), %rcx
movq 0x18(%rdx), %rdx
movl %r12d, %esi
xorl %edi, %edi
movq (%rax,%rdi,8), %r8
movl %r8d, (%rcx,%rdi,4)
shrq $0x20, %r8
movl %r8d, (%rdx,%rdi,4)
incq %rdi
cmpq %rdi, %rsi
jne 0x3c199
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3c1dc
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0xa5e0
movq %rbx, %rdi
callq 0xaae0
| _ZN9PhiloxRNG6uint32ERKSt6vectorImSaImEE:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 20h
mov r14, rdx
mov r13, [rdx+8]
sub r13, [rdx]
mov rbx, rdi
mov r12, r13
sar r12, 3
mov esi, r12d
lea r15, [rsp+48h+var_40]
lea rdx, [rsp+48h+var_41]
mov rdi, r15
call _ZNSt6vectorIjSaIjEEC2EmRKS0_; std::vector<uint>::vector(ulong,std::allocator<uint> const&)
lea rcx, [rsp+48h+var_42]
mov esi, 2
mov rdi, rbx
mov rdx, r15
call _ZNSt6vectorIS_IjSaIjEESaIS1_EEC2EmRKS1_RKS2_; std::vector<std::vector<uint>>::vector(ulong,std::vector<uint> const&,std::allocator<std::vector<uint>> const&)
mov rdi, [rsp+48h+var_40]; void *
test rdi, rdi
jz short loc_3C17E
mov rsi, [rsp+48h+var_30]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3C17E:
shr r13, 3
test r13d, r13d
jz short loc_3C1B1
mov rax, [r14]
mov rdx, [rbx]
mov rcx, [rdx]
mov rdx, [rdx+18h]
mov esi, r12d
xor edi, edi
loc_3C199:
mov r8, [rax+rdi*8]
mov [rcx+rdi*4], r8d
shr r8, 20h
mov [rdx+rdi*4], r8d
inc rdi
cmp rsi, rdi
jnz short loc_3C199
loc_3C1B1:
mov rax, rbx
add rsp, 20h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov rbx, rax
mov rdi, [rsp+arg_0]; void *
test rdi, rdi
jz short loc_3C1DC
mov rsi, [rsp+arg_10]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3C1DC:
mov rdi, rbx
call __Unwind_Resume
| long long ** PhiloxRNG::uint32(long long **a1, int a2, long long *a3)
{
long long v4; // r13
long long v6; // rax
long long v7; // rcx
long long v8; // rdx
long long v9; // rdi
long long v10; // r8
char v12; // [rsp+7h] [rbp-41h] BYREF
void *v13[8]; // [rsp+8h] [rbp-40h] BYREF
v4 = a3[1] - *a3;
std::vector<unsigned int>::vector(v13, (unsigned int)(v4 >> 3), &v12);
std::vector<std::vector<unsigned int>>::vector((long long)a1, 2uLL, (long long)v13);
if ( v13[0] )
operator delete(v13[0], (char *)v13[2] - (char *)v13[0]);
if ( (unsigned int)((unsigned long long)v4 >> 3) )
{
v6 = *a3;
v7 = **a1;
v8 = (*a1)[3];
v9 = 0LL;
do
{
v10 = *(_QWORD *)(v6 + 8 * v9);
*(_DWORD *)(v7 + 4 * v9) = v10;
*(_DWORD *)(v8 + 4 * v9++) = HIDWORD(v10);
}
while ( (unsigned int)(v4 >> 3) != v9 );
}
return a1;
}
| |||
23,991 | PhiloxRNG::uint32(std::vector<unsigned long, std::allocator<unsigned long>> const&) | 7CodeWizard[P]stablediffusion/rng_philox.hpp | std::vector<std::vector<uint32_t>> uint32(const std::vector<uint64_t>& x) {
uint32_t N = (uint32_t)x.size();
std::vector<std::vector<uint32_t>> result(2, std::vector<uint32_t>(N));
for (uint32_t i = 0; i < N; ++i) {
result[0][i] = static_cast<uint32_t>(x[i] & 0xFFFFFFFF);
result[1][i] = static_cast<uint32_t>(x[i] >> 32);
}
return result;
} | O2 | cpp | PhiloxRNG::uint32(std::vector<unsigned long, std::allocator<unsigned long>> const&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rdx), %r12
subq (%rdx), %r12
sarq $0x3, %r12
movl %r12d, %esi
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x2597c
pushq $0x2
popq %rsi
leaq 0xe(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rdx
callq 0x253f0
leaq 0x10(%rsp), %rdi
callq 0x25310
movq (%r14), %rax
movq (%rbx), %rcx
movl %r12d, %edx
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x25516
movq (%rax,%rsi,8), %rdi
movq (%rcx), %r8
movl %edi, (%r8,%rsi,4)
shrq $0x20, %rdi
movq 0x18(%rcx), %r8
movl %edi, (%r8,%rsi,4)
incq %rsi
jmp 0x254f5
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x25310
movq %rbx, %rdi
callq 0xaab0
| _ZN9PhiloxRNG6uint32ERKSt6vectorImSaImEE:
push r15
push r14
push r12
push rbx
sub rsp, 28h
mov r14, rdx
mov rbx, rdi
mov r12, [rdx+8]
sub r12, [rdx]
sar r12, 3
mov esi, r12d
lea r15, [rsp+48h+var_38]
lea rdx, [rsp+48h+var_39]
mov rdi, r15
call _ZNSt6vectorIjSaIjEEC2EmRKS0_; std::vector<uint>::vector(ulong,std::allocator<uint> const&)
push 2
pop rsi
lea rcx, [rsp+48h+var_3A]
mov rdi, rbx
mov rdx, r15
call _ZNSt6vectorIS_IjSaIjEESaIS1_EEC2EmRKS1_RKS2_; std::vector<std::vector<uint>>::vector(ulong,std::vector<uint> const&,std::allocator<std::vector<uint>> const&)
lea rdi, [rsp+48h+var_38]
call _ZNSt12_Vector_baseIjSaIjEED2Ev; std::_Vector_base<uint>::~_Vector_base()
mov rax, [r14]
mov rcx, [rbx]
mov edx, r12d
xor esi, esi
loc_254F5:
cmp rdx, rsi
jz short loc_25516
mov rdi, [rax+rsi*8]
mov r8, [rcx]
mov [r8+rsi*4], edi
shr rdi, 20h
mov r8, [rcx+18h]
mov [r8+rsi*4], edi
inc rsi
jmp short loc_254F5
loc_25516:
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_8]
call _ZNSt12_Vector_baseIjSaIjEED2Ev; std::_Vector_base<uint>::~_Vector_base()
mov rdi, rbx
call __Unwind_Resume
| _QWORD * PhiloxRNG::uint32(_QWORD *a1, _DWORD a2, long long *a3)
{
long long v5; // r12
long long v6; // rax
_QWORD *v7; // rcx
long long i; // rsi
long long v9; // rdi
char v11; // [rsp+Eh] [rbp-3Ah] BYREF
char v12; // [rsp+Fh] [rbp-39h] BYREF
_QWORD v13[7]; // [rsp+10h] [rbp-38h] BYREF
v5 = (a3[1] - *a3) >> 3;
std::vector<unsigned int>::vector(v13, (unsigned int)v5, &v12);
std::vector<std::vector<unsigned int>>::vector((long long)a1, 2LL, (long long)v13, (long long)&v11);
std::_Vector_base<unsigned int>::~_Vector_base(v13);
v6 = *a3;
v7 = (_QWORD *)*a1;
for ( i = 0LL; (unsigned int)v5 != i; ++i )
{
v9 = *(_QWORD *)(v6 + 8 * i);
*(_DWORD *)(*v7 + 4 * i) = v9;
*(_DWORD *)(v7[3] + 4 * i) = HIDWORD(v9);
}
return a1;
}
| uint32:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RDX
MOV RBX,RDI
MOV R12,qword ptr [RDX + 0x8]
SUB R12,qword ptr [RDX]
SAR R12,0x3
MOV ESI,R12D
LEA R15,[RSP + 0x10]
LEA RDX,[RSP + 0xf]
MOV RDI,R15
CALL 0x0012597c
LAB_001254cd:
PUSH 0x2
POP RSI
LEA RCX,[RSP + 0xe]
MOV RDI,RBX
MOV RDX,R15
CALL 0x001253f0
LAB_001254e0:
LEA RDI,[RSP + 0x10]
CALL 0x00125310
MOV RAX,qword ptr [R14]
MOV RCX,qword ptr [RBX]
MOV EDX,R12D
XOR ESI,ESI
LAB_001254f5:
CMP RDX,RSI
JZ 0x00125516
MOV RDI,qword ptr [RAX + RSI*0x8]
MOV R8,qword ptr [RCX]
MOV dword ptr [R8 + RSI*0x4],EDI
SHR RDI,0x20
MOV R8,qword ptr [RCX + 0x18]
MOV dword ptr [R8 + RSI*0x4],EDI
INC RSI
JMP 0x001254f5
LAB_00125516:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R14
POP R15
RET
|
/* PhiloxRNG::uint32(std::vector<unsigned long, std::allocator<unsigned long> > const&) */
vector * PhiloxRNG::uint32(vector *param_1)
{
long lVar1;
long *plVar2;
int8 uVar3;
long *in_RDX;
ulong uVar4;
ulong uVar5;
allocator local_3a;
allocator local_39;
vector<unsigned_int,std::allocator<unsigned_int>> local_38 [24];
uVar5 = in_RDX[1] - *in_RDX >> 3;
std::vector<unsigned_int,std::allocator<unsigned_int>>::vector
(local_38,uVar5 & 0xffffffff,&local_39);
/* try { // try from 001254cd to 001254df has its CatchHandler @ 00125525 */
std::
vector<std::vector<unsigned_int,std::allocator<unsigned_int>>,std::allocator<std::vector<unsigned_int,std::allocator<unsigned_int>>>>
::vector((vector<std::vector<unsigned_int,std::allocator<unsigned_int>>,std::allocator<std::vector<unsigned_int,std::allocator<unsigned_int>>>>
*)param_1,2,(vector *)local_38,&local_3a);
std::_Vector_base<unsigned_int,std::allocator<unsigned_int>>::~_Vector_base
((_Vector_base<unsigned_int,std::allocator<unsigned_int>> *)local_38);
lVar1 = *in_RDX;
plVar2 = *(long **)param_1;
for (uVar4 = 0; (uVar5 & 0xffffffff) != uVar4; uVar4 = uVar4 + 1) {
uVar3 = *(int8 *)(lVar1 + uVar4 * 8);
*(int *)(*plVar2 + uVar4 * 4) = (int)uVar3;
*(int *)(plVar2[3] + uVar4 * 4) = (int)((ulong)uVar3 >> 0x20);
}
return param_1;
}
| |
23,992 | PhiloxRNG::uint32(std::vector<unsigned long, std::allocator<unsigned long>> const&) | 7CodeWizard[P]stablediffusion/rng_philox.hpp | std::vector<std::vector<uint32_t>> uint32(const std::vector<uint64_t>& x) {
uint32_t N = (uint32_t)x.size();
std::vector<std::vector<uint32_t>> result(2, std::vector<uint32_t>(N));
for (uint32_t i = 0; i < N; ++i) {
result[0][i] = static_cast<uint32_t>(x[i] & 0xFFFFFFFF);
result[1][i] = static_cast<uint32_t>(x[i] >> 32);
}
return result;
} | O3 | cpp | PhiloxRNG::uint32(std::vector<unsigned long, std::allocator<unsigned long>> const&):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq 0x8(%rdx), %r13
subq (%rdx), %r13
movq %rdi, %rbx
movq %r13, %r12
sarq $0x3, %r12
movl %r12d, %esi
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
callq 0x3b90e
leaq 0x6(%rsp), %rcx
movl $0x2, %esi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3b414
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3b62e
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0xa5d0
shrq $0x3, %r13
testl %r13d, %r13d
je 0x3b661
movq (%r14), %rax
movq (%rbx), %rdx
movq (%rdx), %rcx
movq 0x18(%rdx), %rdx
movl %r12d, %esi
xorl %edi, %edi
movq (%rax,%rdi,8), %r8
movl %r8d, (%rcx,%rdi,4)
shrq $0x20, %r8
movl %r8d, (%rdx,%rdi,4)
incq %rdi
cmpq %rdi, %rsi
jne 0x3b649
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3b68c
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0xa5d0
movq %rbx, %rdi
callq 0xaad0
| _ZN9PhiloxRNG6uint32ERKSt6vectorImSaImEE:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 20h
mov r14, rdx
mov r13, [rdx+8]
sub r13, [rdx]
mov rbx, rdi
mov r12, r13
sar r12, 3
mov esi, r12d
lea r15, [rsp+48h+var_40]
lea rdx, [rsp+48h+var_41]
mov rdi, r15
call _ZNSt6vectorIjSaIjEEC2EmRKS0_; std::vector<uint>::vector(ulong,std::allocator<uint> const&)
lea rcx, [rsp+48h+var_42]
mov esi, 2
mov rdi, rbx
mov rdx, r15
call _ZNSt6vectorIS_IjSaIjEESaIS1_EEC2EmRKS1_RKS2_; std::vector<std::vector<uint>>::vector(ulong,std::vector<uint> const&,std::allocator<std::vector<uint>> const&)
mov rdi, [rsp+48h+var_40]; void *
test rdi, rdi
jz short loc_3B62E
mov rsi, [rsp+48h+var_30]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3B62E:
shr r13, 3
test r13d, r13d
jz short loc_3B661
mov rax, [r14]
mov rdx, [rbx]
mov rcx, [rdx]
mov rdx, [rdx+18h]
mov esi, r12d
xor edi, edi
loc_3B649:
mov r8, [rax+rdi*8]
mov [rcx+rdi*4], r8d
shr r8, 20h
mov [rdx+rdi*4], r8d
inc rdi
cmp rsi, rdi
jnz short loc_3B649
loc_3B661:
mov rax, rbx
add rsp, 20h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov rbx, rax
mov rdi, [rsp+arg_0]; void *
test rdi, rdi
jz short loc_3B68C
mov rsi, [rsp+arg_10]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3B68C:
mov rdi, rbx
call __Unwind_Resume
| long long ** PhiloxRNG::uint32(long long **a1, int a2, long long *a3)
{
long long v4; // r13
long long v6; // rax
long long v7; // rcx
long long v8; // rdx
long long v9; // rdi
long long v10; // r8
char v12; // [rsp+7h] [rbp-41h] BYREF
void *v13[8]; // [rsp+8h] [rbp-40h] BYREF
v4 = a3[1] - *a3;
std::vector<unsigned int>::vector(v13, (unsigned int)(v4 >> 3), &v12);
std::vector<std::vector<unsigned int>>::vector((long long)a1, 2uLL, (long long)v13);
if ( v13[0] )
operator delete(v13[0], (char *)v13[2] - (char *)v13[0]);
if ( (unsigned int)((unsigned long long)v4 >> 3) )
{
v6 = *a3;
v7 = **a1;
v8 = (*a1)[3];
v9 = 0LL;
do
{
v10 = *(_QWORD *)(v6 + 8 * v9);
*(_DWORD *)(v7 + 4 * v9) = v10;
*(_DWORD *)(v8 + 4 * v9++) = HIDWORD(v10);
}
while ( (unsigned int)(v4 >> 3) != v9 );
}
return a1;
}
| |||
23,993 | lf_hash_insert | eloqsql/mysys/lf_hash.cc | int lf_hash_insert(LF_HASH *hash, LF_PINS *pins, const void *data)
{
int csize, bucket, hashnr;
LF_SLIST *node, **el;
node= (LF_SLIST *)lf_alloc_new(pins);
if (unlikely(!node))
return -1;
hash->initializer(hash, node + 1, data);
node->key= hash_key(hash, (uchar *)(node+1), &node->keylen);
hashnr= hash->hash_function(hash->charset, node->key, node->keylen) & INT_MAX32;
bucket= hashnr % hash->size;
el= (LF_SLIST **)lf_dynarray_lvalue(&hash->array, bucket);
if (unlikely(!el))
return -1;
if (*el == NULL && unlikely(initialize_bucket(hash, el, bucket, pins)))
return -1;
node->hashnr= my_reverse_bits(hashnr) | 1; /* normal node */
if (l_insert(el, hash->charset, node, pins, hash->flags))
{
lf_alloc_free(pins, node);
return 1;
}
csize= hash->size;
if ((my_atomic_add32(&hash->count, 1)+1.0) / csize > MAX_LOAD)
my_atomic_cas32(&hash->size, &csize, csize*2);
return 0;
} | O0 | cpp | lf_hash_insert:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xfc970
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0xfd5a1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xfd76d
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x20, %rsi
movq -0x20(%rbp), %rdx
callq *%rax
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x20, %rsi
movq -0x38(%rbp), %rdx
addq $0x10, %rdx
callq 0xfd780
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0xa8(%rcx), %rdi
movq -0x38(%rbp), %rcx
movq 0x8(%rcx), %rsi
movq -0x38(%rbp), %rcx
movq 0x10(%rcx), %rdx
callq *%rax
movl %eax, %eax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0xc0(%rcx), %ecx
cltd
idivl %ecx
movl %edx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0xfcdc0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0xfd658
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xfd76d
movq -0x40(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xfd687
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl -0x28(%rbp), %edx
movq -0x18(%rbp), %rcx
callq 0xfd800
cmpl $0x0, %eax
je 0xfd687
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xfd76d
movl -0x2c(%rbp), %edi
callq 0xfd980
movl %eax, %ecx
orl $0x1, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rsi
movq -0x38(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movl 0xbc(%rax), %r8d
callq 0xfda00
cmpq $0x0, %rax
je 0xfd6e1
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xfc770
movl $0x1, -0x4(%rbp)
jmp 0xfd76d
movq -0x10(%rbp), %rax
movl 0xc0(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rcx
movl $0x1, -0x44(%rbp)
movl -0x44(%rbp), %eax
lock
xaddl %eax, 0xc4(%rcx)
movl %eax, -0x48(%rbp)
cvtsi2sdl -0x48(%rbp), %xmm0
movsd 0x5b54c(%rip), %xmm1 # 0x158c60
addsd %xmm1, %xmm0
cvtsi2sdl -0x24(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd 0x5b537(%rip), %xmm1 # 0x158c60
ucomisd %xmm1, %xmm0
jbe 0xfd766
movq -0x10(%rbp), %rcx
movl -0x24(%rbp), %eax
addl %eax, %eax
movl %eax, -0x4c(%rbp)
movl -0x24(%rbp), %eax
movl -0x4c(%rbp), %edx
lock
cmpxchgl %edx, 0xc0(%rcx)
movl %eax, %ecx
sete %al
movb %al, -0x55(%rbp)
movl %ecx, -0x54(%rbp)
testb $0x1, %al
jne 0xfd75e
movl -0x54(%rbp), %eax
movl %eax, -0x24(%rbp)
movb -0x55(%rbp), %al
andb $0x1, %al
movb %al, -0x4d(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| lf_hash_insert:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rdi, [rbp+var_18]
call lf_alloc_new
mov [rbp+var_38], rax
cmp [rbp+var_38], 0
setnz al
xor al, 0FFh
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_FD5A1
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_FD76D
loc_FD5A1:
mov rax, [rbp+var_10]
mov rax, [rax+98h]
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
add rsi, 20h ; ' '
mov rdx, [rbp+var_20]
call rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
add rsi, 20h ; ' '
mov rdx, [rbp+var_38]
add rdx, 10h
call _ZL8hash_keyPK10st_lf_hashPKhPm; hash_key(st_lf_hash const*,uchar const*,ulong *)
mov rcx, rax
mov rax, [rbp+var_38]
mov [rax+8], rcx
mov rax, [rbp+var_10]
mov rax, [rax+0A0h]
mov rcx, [rbp+var_10]
mov rdi, [rcx+0A8h]
mov rcx, [rbp+var_38]
mov rsi, [rcx+8]
mov rcx, [rbp+var_38]
mov rdx, [rcx+10h]
call rax
mov eax, eax
and rax, 7FFFFFFFh
mov [rbp+var_2C], eax
mov eax, [rbp+var_2C]
mov rcx, [rbp+var_10]
mov ecx, [rcx+0C0h]
cdq
idiv ecx
mov [rbp+var_28], edx
mov rdi, [rbp+var_10]
mov esi, [rbp+var_28]
call lf_dynarray_lvalue
mov [rbp+var_40], rax
cmp [rbp+var_40], 0
setnz al
xor al, 0FFh
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_FD658
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_FD76D
loc_FD658:
mov rax, [rbp+var_40]
cmp qword ptr [rax], 0
jnz short loc_FD687
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_40]
mov edx, [rbp+var_28]
mov rcx, [rbp+var_18]
call _ZL17initialize_bucketP10st_lf_hashPP8LF_SLISTjP7LF_PINS; initialize_bucket(st_lf_hash *,LF_SLIST **,uint,LF_PINS *)
cmp eax, 0
jz short loc_FD687
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_FD76D
loc_FD687:
mov edi, [rbp+var_2C]; unsigned int
call _ZL15my_reverse_bitsj; my_reverse_bits(uint)
mov ecx, eax
or ecx, 1
mov rax, [rbp+var_38]
mov [rax+18h], ecx
mov rdi, [rbp+var_40]
mov rax, [rbp+var_10]
mov rsi, [rax+0A8h]
mov rdx, [rbp+var_38]
mov rcx, [rbp+var_18]
mov rax, [rbp+var_10]
mov r8d, [rax+0BCh]
call _ZL8l_insertPP8LF_SLISTPK15charset_info_stS0_P7LF_PINSj; l_insert(LF_SLIST **,charset_info_st const*,LF_SLIST *,LF_PINS *,uint)
cmp rax, 0
jz short loc_FD6E1
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_38]
call lf_pinbox_free
mov [rbp+var_4], 1
jmp loc_FD76D
loc_FD6E1:
mov rax, [rbp+var_10]
mov eax, [rax+0C0h]
mov [rbp+var_24], eax
mov rcx, [rbp+var_10]
mov [rbp+var_44], 1
mov eax, [rbp+var_44]
lock xadd [rcx+0C4h], eax
mov [rbp+var_48], eax
cvtsi2sd xmm0, [rbp+var_48]
movsd xmm1, cs:qword_158C60
addsd xmm0, xmm1
cvtsi2sd xmm1, [rbp+var_24]
divsd xmm0, xmm1
movsd xmm1, cs:qword_158C60
ucomisd xmm0, xmm1
jbe short loc_FD766
mov rcx, [rbp+var_10]
mov eax, [rbp+var_24]
add eax, eax
mov [rbp+var_4C], eax
mov eax, [rbp+var_24]
mov edx, [rbp+var_4C]
lock cmpxchg [rcx+0C0h], edx
mov ecx, eax
setz al
mov [rbp+var_55], al
mov [rbp+var_54], ecx
test al, 1
jnz short loc_FD75E
mov eax, [rbp+var_54]
mov [rbp+var_24], eax
loc_FD75E:
mov al, [rbp+var_55]
and al, 1
mov [rbp+var_4D], al
loc_FD766:
mov [rbp+var_4], 0
loc_FD76D:
mov eax, [rbp+var_4]
add rsp, 60h
pop rbp
retn
| long long lf_hash_insert(long long a1, long long a2, long long a3)
{
_QWORD *v4; // [rsp+20h] [rbp-40h]
long long v5; // [rsp+28h] [rbp-38h]
signed int v6; // [rsp+34h] [rbp-2Ch]
unsigned int v7; // [rsp+38h] [rbp-28h]
signed __int32 v8; // [rsp+3Ch] [rbp-24h]
v5 = lf_alloc_new(a2);
if ( v5 )
{
(*(void ( **)(long long, long long, long long))(a1 + 152))(a1, v5 + 32, a3);
*(_QWORD *)(v5 + 8) = hash_key(a1, v5 + 32, v5 + 16);
v6 = (*(long long ( **)(_QWORD, _QWORD, _QWORD))(a1 + 160))(
*(_QWORD *)(a1 + 168),
*(_QWORD *)(v5 + 8),
*(_QWORD *)(v5 + 16)) & 0x7FFFFFFF;
v7 = v6 % *(_DWORD *)(a1 + 192);
v4 = (_QWORD *)lf_dynarray_lvalue(a1, v7);
if ( v4 )
{
if ( *v4 || !(unsigned int)initialize_bucket(a1, v4, v7, a2) )
{
*(_DWORD *)(v5 + 24) = my_reverse_bits(v6) | 1;
if ( l_insert(v4, *(_QWORD *)(a1 + 168), v5, a2, *(unsigned int *)(a1 + 188)) )
{
lf_pinbox_free(a2, (const char *)v5);
return 1;
}
else
{
v8 = *(_DWORD *)(a1 + 192);
if ( ((double)_InterlockedExchangeAdd((volatile signed __int32 *)(a1 + 196), 1u) + 1.0) / (double)v8 > 1.0 )
_InterlockedCompareExchange((volatile signed __int32 *)(a1 + 192), 2 * v8, v8);
return 0;
}
}
else
{
return (unsigned int)-1;
}
}
else
{
return (unsigned int)-1;
}
}
else
{
return (unsigned int)-1;
}
}
| lf_hash_insert:
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 RDI,qword ptr [RBP + -0x18]
CALL 0x001fc970
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x38],0x0
SETNZ AL
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x001fd5a1
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001fd76d
LAB_001fd5a1:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x98]
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
ADD RSI,0x20
MOV RDX,qword ptr [RBP + -0x20]
CALL RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
ADD RSI,0x20
MOV RDX,qword ptr [RBP + -0x38]
ADD RDX,0x10
CALL 0x001fd780
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xa0]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RCX + 0xa8]
MOV RCX,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RCX + 0x8]
MOV RCX,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RCX + 0x10]
CALL RAX
MOV EAX,EAX
AND RAX,0x7fffffff
MOV dword ptr [RBP + -0x2c],EAX
MOV EAX,dword ptr [RBP + -0x2c]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0xc0]
CDQ
IDIV ECX
MOV dword ptr [RBP + -0x28],EDX
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x28]
CALL 0x001fcdc0
MOV qword ptr [RBP + -0x40],RAX
CMP qword ptr [RBP + -0x40],0x0
SETNZ AL
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x001fd658
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001fd76d
LAB_001fd658:
MOV RAX,qword ptr [RBP + -0x40]
CMP qword ptr [RAX],0x0
JNZ 0x001fd687
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x40]
MOV EDX,dword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x18]
CALL 0x001fd800
CMP EAX,0x0
JZ 0x001fd687
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001fd76d
LAB_001fd687:
MOV EDI,dword ptr [RBP + -0x2c]
CALL 0x001fd980
MOV ECX,EAX
OR ECX,0x1
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x18],ECX
MOV RDI,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0xa8]
MOV RDX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV R8D,dword ptr [RAX + 0xbc]
CALL 0x001fda00
CMP RAX,0x0
JZ 0x001fd6e1
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x001fc770
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001fd76d
LAB_001fd6e1:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0xc0]
MOV dword ptr [RBP + -0x24],EAX
MOV RCX,qword ptr [RBP + -0x10]
MOV dword ptr [RBP + -0x44],0x1
MOV EAX,dword ptr [RBP + -0x44]
XADD.LOCK dword ptr [RCX + 0xc4],EAX
MOV dword ptr [RBP + -0x48],EAX
CVTSI2SD XMM0,dword ptr [RBP + -0x48]
MOVSD XMM1,qword ptr [0x00258c60]
ADDSD XMM0,XMM1
CVTSI2SD XMM1,dword ptr [RBP + -0x24]
DIVSD XMM0,XMM1
MOVSD XMM1,qword ptr [0x00258c60]
UCOMISD XMM0,XMM1
JBE 0x001fd766
MOV RCX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,EAX
MOV dword ptr [RBP + -0x4c],EAX
MOV EAX,dword ptr [RBP + -0x24]
MOV EDX,dword ptr [RBP + -0x4c]
CMPXCHG.LOCK dword ptr [RCX + 0xc0],EDX
MOV ECX,EAX
SETZ AL
MOV byte ptr [RBP + -0x55],AL
MOV dword ptr [RBP + -0x54],ECX
TEST AL,0x1
JNZ 0x001fd75e
MOV EAX,dword ptr [RBP + -0x54]
MOV dword ptr [RBP + -0x24],EAX
LAB_001fd75e:
MOV AL,byte ptr [RBP + -0x55]
AND AL,0x1
MOV byte ptr [RBP + -0x4d],AL
LAB_001fd766:
MOV dword ptr [RBP + -0x4],0x0
LAB_001fd76d:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x60
POP RBP
RET
|
int4 lf_hash_insert(st_lf_hash *param_1,LF_PINS *param_2,int8 param_3)
{
st_lf_hash *psVar1;
int iVar2;
uint uVar3;
int iVar4;
LF_SLIST *pLVar5;
int8 uVar6;
LF_SLIST **ppLVar7;
long lVar8;
uint uVar9;
int4 local_c;
pLVar5 = (LF_SLIST *)lf_alloc_new(param_2);
if (pLVar5 == (LF_SLIST *)0x0) {
local_c = 0xffffffff;
}
else {
(**(code **)(param_1 + 0x98))(param_1,pLVar5 + 0x20,param_3);
uVar6 = hash_key(param_1,(uchar *)(pLVar5 + 0x20),(ulong *)(pLVar5 + 0x10));
*(int8 *)(pLVar5 + 8) = uVar6;
uVar3 = (**(code **)(param_1 + 0xa0))
(*(int8 *)(param_1 + 0xa8),*(int8 *)(pLVar5 + 8),
*(int8 *)(pLVar5 + 0x10));
uVar9 = (int)(uVar3 & 0x7fffffff) % *(int *)(param_1 + 0xc0);
ppLVar7 = (LF_SLIST **)lf_dynarray_lvalue(param_1,uVar9);
if (ppLVar7 == (LF_SLIST **)0x0) {
local_c = 0xffffffff;
}
else if ((*ppLVar7 == (LF_SLIST *)0x0) &&
(iVar4 = initialize_bucket(param_1,ppLVar7,uVar9,param_2), iVar4 != 0)) {
local_c = 0xffffffff;
}
else {
uVar3 = my_reverse_bits(uVar3 & 0x7fffffff);
*(uint *)(pLVar5 + 0x18) = uVar3 | 1;
lVar8 = l_insert(ppLVar7,*(charset_info_st **)(param_1 + 0xa8),pLVar5,param_2,
*(uint *)(param_1 + 0xbc));
if (lVar8 == 0) {
iVar2 = *(int *)(param_1 + 0xc0);
LOCK();
psVar1 = param_1 + 0xc4;
iVar4 = *(int *)psVar1;
*(int *)psVar1 = *(int *)psVar1 + 1;
UNLOCK();
if (DAT_00258c60 < ((double)iVar4 + DAT_00258c60) / (double)iVar2) {
LOCK();
if (iVar2 == *(int *)(param_1 + 0xc0)) {
*(int *)(param_1 + 0xc0) = iVar2 * 2;
}
UNLOCK();
}
local_c = 0;
}
else {
lf_pinbox_free(param_2,pLVar5);
local_c = 1;
}
}
}
return local_c;
}
| |
23,994 | minja::TemplateToken::typeToString[abi:cxx11](minja::TemplateToken::Type) | monkey531[P]llama/common/minja.hpp | static std::string typeToString(Type t) {
switch (t) {
case Type::Text: return "text";
case Type::Expression: return "expression";
case Type::If: return "if";
case Type::Else: return "else";
case Type::Elif: return "elif";
case Type::EndIf: return "endif";
case Type::For: return "for";
case Type::EndFor: return "endfor";
case Type::Set: return "set";
case Type::EndSet: return "endset";
case Type::Comment: return "comment";
case Type::Macro: return "macro";
case Type::EndMacro: return "endmacro";
case Type::Filter: return "filter";
case Type::EndFilter: return "endfilter";
case Type::Generation: return "generation";
case Type::EndGeneration: return "endgeneration";
case Type::Break: return "break";
case Type::Continue: return "continue";
}
return "Unknown";
} | O2 | cpp | minja::TemplateToken::typeToString[abi:cxx11](minja::TemplateToken::Type):
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x12, %esi
ja 0xdab67
movl %esi, %eax
leaq 0x289dc(%rip), %rcx # 0x103480
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1b3d2(%rip), %rsi # 0xf5e86
jmp 0xdab6e
leaq 0x299c5(%rip), %rsi # 0x104485
jmp 0xdab6e
leaq 0x2998c(%rip), %rsi # 0x104458
jmp 0xdab6e
leaq 0x29956(%rip), %rsi # 0x10442e
jmp 0xdab6e
leaq 0x29854(%rip), %rsi # 0x104338
jmp 0xdab6e
leaq 0x2a718(%rip), %rsi # 0x105208
jmp 0xdab6e
leaq 0x298ca(%rip), %rsi # 0x1043c3
jmp 0xdab6e
leaq 0x20ef9(%rip), %rsi # 0xfb9fb
jmp 0xdab6e
leaq 0x2997d(%rip), %rsi # 0x104488
jmp 0xdab6e
leaq 0x2984a(%rip), %rsi # 0x10435e
jmp 0xdab6e
leaq 0x2989f(%rip), %rsi # 0x1043bc
jmp 0xdab6e
leaq 0x29a00(%rip), %rsi # 0x104526
jmp 0xdab6e
leaq 0x29960(%rip), %rsi # 0x10448f
jmp 0xdab6e
leaq 0x2982b(%rip), %rsi # 0x104363
jmp 0xdab6e
leaq 0x2991a(%rip), %rsi # 0x10445b
jmp 0xdab6e
leaq 0x29875(%rip), %rsi # 0x1043bf
jmp 0xdab6e
leaq 0x1844a(%rip), %rsi # 0xf2f9d
jmp 0xdab6e
leaq 0x2c80a(%rip), %rsi # 0x107366
jmp 0xdab6e
leaq 0x1c0bd(%rip), %rsi # 0xf6c22
jmp 0xdab6e
leaq 0x2a6a2(%rip), %rsi # 0x105210
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x3bddc
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
| _ZN5minja13TemplateToken12typeToStringB5cxx11ENS0_4TypeE:
push rbx
sub rsp, 10h
mov rbx, rdi
cmp esi, 12h; switch 19 cases
ja def_DAAAB; jumptable 00000000000DAAAB default case
mov eax, esi
lea rcx, jpt_DAAAB
movsxd rax, ds:(jpt_DAAAB - 103480h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_DAAAD:
lea rsi, aText; jumptable 00000000000DAAAB case 0
jmp loc_DAB6E
loc_DAAB9:
lea rsi, aEndfilter; jumptable 00000000000DAAAB case 16
jmp loc_DAB6E
loc_DAAC5:
lea rsi, aEndmacro; jumptable 00000000000DAAAB case 14
jmp loc_DAB6E
loc_DAAD1:
lea rsi, aEndset; jumptable 00000000000DAAAB case 11
jmp loc_DAB6E
loc_DAADD:
lea rsi, aElif; jumptable 00000000000DAAAB case 4
jmp loc_DAB6E
loc_DAAE9:
lea rsi, aComment; jumptable 00000000000DAAAB case 12
jmp short loc_DAB6E
loc_DAAF2:
lea rsi, aEndgeneration; jumptable 00000000000DAAAB case 9
jmp short loc_DAB6E
loc_DAAFB:
lea rsi, aIf+1; jumptable 00000000000DAAAB case 2
jmp short loc_DAB6E
loc_DAB04:
lea rsi, aEndfilter+3; jumptable 00000000000DAAAB case 15
jmp short loc_DAB6E
loc_DAB0D:
lea rsi, aElse; jumptable 00000000000DAAAB case 3
jmp short loc_DAB6E
loc_DAB16:
lea rsi, aEndfor; jumptable 00000000000DAAAB case 7
jmp short loc_DAB6E
loc_DAB1F:
lea rsi, aExpectedLeftSi_0+24h; jumptable 00000000000DAAAB case 1
jmp short loc_DAB6E
loc_DAB28:
lea rsi, aBreak; jumptable 00000000000DAAAB case 17
jmp short loc_DAB6E
loc_DAB31:
lea rsi, aEndif; jumptable 00000000000DAAAB case 5
jmp short loc_DAB6E
loc_DAB3A:
lea rsi, aEndmacro+3; jumptable 00000000000DAAAB case 13
jmp short loc_DAB6E
loc_DAB43:
lea rsi, aEndfor+3; jumptable 00000000000DAAAB case 6
jmp short loc_DAB6E
loc_DAB4C:
lea rsi, a100Continue+4; jumptable 00000000000DAAAB case 18
jmp short loc_DAB6E
loc_DAB55:
lea rsi, aAtLeastOneOfMi+2Fh; jumptable 00000000000DAAAB case 10
jmp short loc_DAB6E
loc_DAB5E:
lea rsi, aTTokensGenerat_0+9; jumptable 00000000000DAAAB case 8
jmp short loc_DAB6E
def_DAAAB:
lea rsi, aUnknown_0; jumptable 00000000000DAAAB default case
loc_DAB6E:
lea rdx, [rsp+18h+var_9]
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov rax, rbx
add rsp, 10h
pop rbx
retn
| _QWORD * minja::TemplateToken::typeToString[abi:cxx11](_QWORD *a1, int a2)
{
char *v2; // rsi
switch ( a2 )
{
case 0:
v2 = "text";
break;
case 1:
v2 = (char *)"expression";
break;
case 2:
v2 = "if";
break;
case 3:
v2 = "else";
break;
case 4:
v2 = "elif";
break;
case 5:
v2 = "endif";
break;
case 6:
v2 = "for";
break;
case 7:
v2 = "endfor";
break;
case 8:
v2 = "generation";
break;
case 9:
v2 = "endgeneration";
break;
case 10:
v2 = (char *)"set";
break;
case 11:
v2 = "endset";
break;
case 12:
v2 = "comment";
break;
case 13:
v2 = "macro";
break;
case 14:
v2 = "endmacro";
break;
case 15:
v2 = "filter";
break;
case 16:
v2 = "endfilter";
break;
case 17:
v2 = "break";
break;
case 18:
v2 = "continue";
break;
default:
v2 = "Unknown";
break;
}
std::string::basic_string<std::allocator<char>>(a1, (long long)v2);
return a1;
}
| typeToString[abi:cxx11]:
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
CMP ESI,0x12
JA 0x001dab67
MOV EAX,ESI
LEA RCX,[0x203480]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
LEA RSI,[0x1f5e86]
JMP 0x001dab6e
caseD_10:
LEA RSI,[0x204485]
JMP 0x001dab6e
caseD_e:
LEA RSI,[0x204458]
JMP 0x001dab6e
caseD_b:
LEA RSI,[0x20442e]
JMP 0x001dab6e
caseD_4:
LEA RSI,[0x204338]
JMP 0x001dab6e
caseD_c:
LEA RSI,[0x205208]
JMP 0x001dab6e
caseD_9:
LEA RSI,[0x2043c3]
JMP 0x001dab6e
caseD_2:
LEA RSI,[0x1fb9fb]
JMP 0x001dab6e
caseD_f:
LEA RSI,[0x204488]
JMP 0x001dab6e
caseD_3:
LEA RSI,[0x20435e]
JMP 0x001dab6e
caseD_7:
LEA RSI,[0x2043bc]
JMP 0x001dab6e
caseD_1:
LEA RSI,[0x204526]
JMP 0x001dab6e
caseD_11:
LEA RSI,[0x20448f]
JMP 0x001dab6e
caseD_5:
LEA RSI,[0x204363]
JMP 0x001dab6e
caseD_d:
LEA RSI,[0x20445b]
JMP 0x001dab6e
caseD_6:
LEA RSI,[0x2043bf]
JMP 0x001dab6e
caseD_12:
LEA RSI,[0x1f2f9d]
JMP 0x001dab6e
caseD_a:
LEA RSI,[0x207366]
JMP 0x001dab6e
caseD_8:
LEA RSI,[0x1f6c22]
JMP 0x001dab6e
default:
LEA RSI,[0x205210]
LAB_001dab6e:
LEA RDX,[RSP + 0xf]
MOV RDI,RBX
CALL 0x0013bddc
MOV RAX,RBX
ADD RSP,0x10
POP RBX
RET
|
/* minja::TemplateToken::typeToString[abi:cxx11](minja::TemplateToken::Type) */
TemplateToken * __thiscall
minja::TemplateToken::typeToString_abi_cxx11_(TemplateToken *this,int4 param_2)
{
char *pcVar1;
allocator local_9;
switch(param_2) {
case 0:
pcVar1 = "text";
break;
case 1:
pcVar1 = "expression";
break;
case 2:
pcVar1 = "if";
break;
case 3:
pcVar1 = "else";
break;
case 4:
pcVar1 = "elif";
break;
case 5:
pcVar1 = "endif";
break;
case 6:
pcVar1 = "for";
break;
case 7:
pcVar1 = "endfor";
break;
case 8:
pcVar1 = "generation";
break;
case 9:
pcVar1 = "endgeneration";
break;
case 10:
pcVar1 = "set";
break;
case 0xb:
pcVar1 = "endset";
break;
case 0xc:
pcVar1 = "comment";
break;
case 0xd:
pcVar1 = "macro";
break;
case 0xe:
pcVar1 = "endmacro";
break;
case 0xf:
pcVar1 = "filter";
break;
case 0x10:
pcVar1 = "endfilter";
break;
case 0x11:
pcVar1 = "break";
break;
case 0x12:
pcVar1 = "continue";
break;
default:
pcVar1 = "Unknown";
}
std::__cxx11::string::string<std::allocator<char>>((string *)this,pcVar1,&local_9);
return this;
}
| |
23,995 | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::iter_impl(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*) | hkr04[P]cpp-mcp/common/json.hpp | explicit iter_impl(pointer object) noexcept : m_object(object)
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_data.m_type)
{
case value_t::object:
{
m_it.object_iterator = typename object_t::iterator();
break;
}
case value_t::array:
{
m_it.array_iterator = typename array_t::iterator();
break;
}
case value_t::null:
case value_t::string:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::binary:
case value_t::discarded:
default:
{
m_it.primitive_iterator = primitive_iterator_t();
break;
}
}
} | O0 | cpp | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::iter_impl(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*):
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0xac580
movq (%rsp), %rdi
addq $0x10, %rdi
callq 0xac5a0
movq (%rsp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movq $0x0, 0x18(%rax)
callq 0xac5c0
movq (%rsp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
movq %rax, 0x8(%rsp)
subq $0x9, %rax
ja 0xac48b
movq 0x8(%rsp), %rax
leaq 0x25dea(%rip), %rcx # 0xd2238
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x20(%rsp), %rdi
callq 0xac580
movq (%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rax)
jmp 0xac4b3
leaq 0x18(%rsp), %rdi
callq 0xac5a0
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rax)
jmp 0xac4b3
jmp 0xac48b
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0xb420
leaq 0x10(%rsp), %rdi
callq 0xac5c0
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x18(%rax)
addq $0x38, %rsp
retq
nopl (%rax,%rax)
| _ZN8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEC2EPSF_:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov [rsp+38h+var_10], rsi
mov rdi, [rsp+38h+var_8]
mov [rsp+38h+var_38], rdi
mov rax, [rsp+38h+var_10]
mov [rdi], rax
add rdi, 8
call _ZN9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEC2Ev; __gnu_cxx::__normal_iterator<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>> *,std::vector<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>>>>::__normal_iterator(void)
mov rdi, [rsp+38h+var_38]
add rdi, 10h
call _ZN9__gnu_cxx17__normal_iteratorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEES5_ISF_SaISF_EEEC2Ev; __gnu_cxx::__normal_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::vector<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>>>::__normal_iterator(void)
mov rax, [rsp+38h+var_38]
mov rdi, rax
add rdi, 18h; this
mov qword ptr [rax+18h], 0
call _ZN8nlohmann16json_abi_v3_11_36detail20primitive_iterator_tC2Ev; nlohmann::json_abi_v3_11_3::detail::primitive_iterator_t::primitive_iterator_t(void)
mov rax, [rsp+38h+var_38]
mov rax, [rax]
movzx eax, byte ptr [rax]
mov [rsp+38h+var_30], rax
sub rax, 9; switch 10 cases
ja short def_AC455; jumptable 00000000000AC455 default case
mov rax, [rsp+38h+var_30]
lea rcx, jpt_AC455
movsxd rax, ds:(jpt_AC455 - 0D2238h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_AC457:
lea rdi, [rsp+38h+var_18]; jumptable 00000000000AC455 case 1
call _ZN9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEC2Ev; __gnu_cxx::__normal_iterator<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>> *,std::vector<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>>>>::__normal_iterator(void)
mov rax, [rsp+38h+var_38]
mov rcx, [rsp+38h+var_18]
mov [rax+8], rcx
jmp short loc_AC4B3
loc_AC470:
lea rdi, [rsp+38h+var_20]; jumptable 00000000000AC455 case 2
call _ZN9__gnu_cxx17__normal_iteratorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEES5_ISF_SaISF_EEEC2Ev; __gnu_cxx::__normal_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::vector<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>>>::__normal_iterator(void)
mov rax, [rsp+38h+var_38]
mov rcx, [rsp+38h+var_20]
mov [rax+10h], rcx
jmp short loc_AC4B3
loc_AC489:
jmp short $+2; jumptable 00000000000AC455 cases 0,3-9
def_AC455:
lea rdi, [rsp+38h+var_28]; jumptable 00000000000AC455 default case
xor esi, esi
mov edx, 8
call _memset
lea rdi, [rsp+38h+var_28]; this
call _ZN8nlohmann16json_abi_v3_11_36detail20primitive_iterator_tC2Ev; nlohmann::json_abi_v3_11_3::detail::primitive_iterator_t::primitive_iterator_t(void)
mov rax, [rsp+38h+var_38]
mov rcx, [rsp+38h+var_28]
mov [rax+18h], rcx
loc_AC4B3:
add rsp, 38h
retn
| _QWORD * nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::iter_impl(
_QWORD *a1,
long long a2)
{
_QWORD *result; // rax
long long v3; // [rsp+10h] [rbp-28h] BYREF
long long v4; // [rsp+18h] [rbp-20h] BYREF
_QWORD v5[3]; // [rsp+20h] [rbp-18h] BYREF
v5[2] = a1;
v5[1] = a2;
*a1 = a2;
__gnu_cxx::__normal_iterator<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>> *,std::vector<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>>>>::__normal_iterator(a1 + 1);
__gnu_cxx::__normal_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::vector<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>>>::__normal_iterator(a1 + 2);
a1[3] = 0LL;
nlohmann::json_abi_v3_11_3::detail::primitive_iterator_t::primitive_iterator_t((nlohmann::json_abi_v3_11_3::detail::primitive_iterator_t *)(a1 + 3));
switch ( *(_BYTE *)*a1 )
{
case 1:
__gnu_cxx::__normal_iterator<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>> *,std::vector<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>>>>::__normal_iterator(v5);
result = a1;
a1[1] = v5[0];
break;
case 2:
__gnu_cxx::__normal_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::vector<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>>>::__normal_iterator(&v4);
result = a1;
a1[2] = v4;
break;
default:
memset(&v3, 0LL, sizeof(v3));
nlohmann::json_abi_v3_11_3::detail::primitive_iterator_t::primitive_iterator_t((nlohmann::json_abi_v3_11_3::detail::primitive_iterator_t *)&v3);
result = a1;
a1[3] = v3;
break;
}
return result;
}
| iter_impl:
SUB RSP,0x38
MOV qword ptr [RSP + 0x30],RDI
MOV qword ptr [RSP + 0x28],RSI
MOV RDI,qword ptr [RSP + 0x30]
MOV qword ptr [RSP],RDI
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RDI],RAX
ADD RDI,0x8
CALL 0x001ac580
MOV RDI,qword ptr [RSP]
ADD RDI,0x10
CALL 0x001ac5a0
MOV RAX,qword ptr [RSP]
MOV RDI,RAX
ADD RDI,0x18
MOV qword ptr [RAX + 0x18],0x0
CALL 0x001ac5c0
MOV RAX,qword ptr [RSP]
MOV RAX,qword ptr [RAX]
MOVZX EAX,byte ptr [RAX]
MOV qword ptr [RSP + 0x8],RAX
SUB RAX,0x9
JA 0x001ac48b
MOV RAX,qword ptr [RSP + 0x8]
LEA RCX,[0x1d2238]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
LEA RDI,[RSP + 0x20]
CALL 0x001ac580
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x001ac4b3
caseD_2:
LEA RDI,[RSP + 0x18]
CALL 0x001ac5a0
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + 0x10],RCX
JMP 0x001ac4b3
caseD_0:
JMP 0x001ac48b
default:
LEA RDI,[RSP + 0x10]
XOR ESI,ESI
MOV EDX,0x8
CALL 0x0010b420
LEA RDI,[RSP + 0x10]
CALL 0x001ac5c0
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + 0x18],RCX
LAB_001ac4b3:
ADD RSP,0x38
RET
|
/* nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>
>::iter_impl(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>*) */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::iter_impl(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this,basic_json *param_1)
{
int8 local_28;
int8 local_20;
int8 local_18;
basic_json *local_10;
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*local_8;
*(basic_json **)this = param_1;
local_10 = param_1;
local_8 = this;
__gnu_cxx::
__normal_iterator<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>>*,std::vector<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>>,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>>>>>
::__normal_iterator((__normal_iterator<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>>*,std::vector<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>>,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 + 8));
__gnu_cxx::
__normal_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::vector<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<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>>>>
::__normal_iterator((__normal_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::vector<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<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 + 0x10));
*(int8 *)(this + 0x18) = 0;
primitive_iterator_t::primitive_iterator_t((primitive_iterator_t *)(this + 0x18));
switch(**(int1 **)this) {
case 0:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
default:
memset(&local_28,0,8);
primitive_iterator_t::primitive_iterator_t((primitive_iterator_t *)&local_28);
*(int8 *)(this + 0x18) = local_28;
break;
case 1:
__gnu_cxx::
__normal_iterator<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>>*,std::vector<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>>,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>>>>>
::__normal_iterator((__normal_iterator<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>>*,std::vector<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>>,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>>>>>
*)&local_18);
*(int8 *)(this + 8) = local_18;
break;
case 2:
__gnu_cxx::
__normal_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::vector<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<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>>>>
::__normal_iterator((__normal_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::vector<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<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_20);
*(int8 *)(this + 0x10) = local_20;
}
return;
}
| |
23,996 | js_load_file | bluesky950520[P]quickjs/quickjs-libc.c | uint8_t *js_load_file(JSContext *ctx, size_t *pbuf_len, const char *filename)
{
FILE *f;
uint8_t *buf;
size_t buf_len;
long lret;
f = fopen(filename, "rb");
if (!f)
return NULL;
if (fseek(f, 0, SEEK_END) < 0)
goto fail;
lret = ftell(f);
if (lret < 0)
goto fail;
/* XXX: on Linux, ftell() return LONG_MAX for directories */
if (lret == LONG_MAX) {
errno = EISDIR;
goto fail;
}
buf_len = lret;
if (fseek(f, 0, SEEK_SET) < 0)
goto fail;
if (ctx)
buf = js_malloc(ctx, buf_len + 1);
else
buf = malloc(buf_len + 1);
if (!buf)
goto fail;
if (fread(buf, 1, buf_len, f) != buf_len) {
errno = EIO;
if (ctx)
js_free(ctx, buf);
else
free(buf);
fail:
fclose(f);
return NULL;
}
buf[buf_len] = '\0';
fclose(f);
*pbuf_len = buf_len;
return buf;
} | O0 | c | js_load_file:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x28(%rsp), %rdi
leaq 0xf9b6d(%rip), %rsi # 0x109a5c
callq 0xe7c0
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0xff0f
movq $0x0, 0x40(%rsp)
jmp 0x10060
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0xe6c0
cmpl $0x0, %eax
jge 0xff2c
jmp 0x1001c
movq 0x20(%rsp), %rdi
callq 0xe560
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jge 0xff48
jmp 0x1001c
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, 0x8(%rsp)
jne 0xff69
callq 0xe0b0
movl $0x15, (%rax)
jmp 0x1001c
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0xe6c0
cmpl $0x0, %eax
jge 0xff8d
jmp 0x1001c
cmpq $0x0, 0x38(%rsp)
je 0xffaf
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x1, %rsi
callq 0x21cb0
movq %rax, 0x18(%rsp)
jmp 0xffc2
movq 0x10(%rsp), %rdi
addq $0x1, %rdi
callq 0xe660
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xffcc
jmp 0x1001c
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rcx
movl $0x1, %esi
callq 0xe170
cmpq 0x10(%rsp), %rax
je 0x10031
callq 0xe0b0
movl $0x5, (%rax)
cmpq $0x0, 0x38(%rsp)
je 0x10010
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x21db0
jmp 0x1001a
movq 0x18(%rsp), %rdi
callq 0xe060
jmp 0x1001c
movq 0x20(%rsp), %rdi
callq 0xe220
movq $0x0, 0x40(%rsp)
jmp 0x10060
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x20(%rsp), %rdi
callq 0xe220
movq 0x10(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
| js_load_file:
sub rsp, 48h
mov [rsp+48h+var_10], rdi
mov [rsp+48h+var_18], rsi
mov [rsp+48h+var_20], rdx
mov rdi, [rsp+48h+var_20]
lea rsi, unk_109A5C
call _fopen
mov [rsp+48h+var_28], rax
cmp [rsp+48h+var_28], 0
jnz short loc_FF0F
mov [rsp+48h+var_8], 0
jmp loc_10060
loc_FF0F:
mov rdi, [rsp+48h+var_28]
xor eax, eax
mov esi, eax
mov edx, 2
call _fseek
cmp eax, 0
jge short loc_FF2C
jmp loc_1001C
loc_FF2C:
mov rdi, [rsp+48h+var_28]
call _ftell
mov [rsp+48h+var_40], rax
cmp [rsp+48h+var_40], 0
jge short loc_FF48
jmp loc_1001C
loc_FF48:
mov rax, 7FFFFFFFFFFFFFFFh
cmp [rsp+48h+var_40], rax
jnz short loc_FF69
call ___errno_location
mov dword ptr [rax], 15h
jmp loc_1001C
loc_FF69:
mov rax, [rsp+48h+var_40]
mov [rsp+48h+var_38], rax
mov rdi, [rsp+48h+var_28]
xor eax, eax
mov esi, eax
xor edx, edx
call _fseek
cmp eax, 0
jge short loc_FF8D
jmp loc_1001C
loc_FF8D:
cmp [rsp+48h+var_10], 0
jz short loc_FFAF
mov rdi, [rsp+48h+var_10]
mov rsi, [rsp+48h+var_38]
add rsi, 1
call js_malloc
mov [rsp+48h+var_30], rax
jmp short loc_FFC2
loc_FFAF:
mov rdi, [rsp+48h+var_38]
add rdi, 1
call _malloc
mov [rsp+48h+var_30], rax
loc_FFC2:
cmp [rsp+48h+var_30], 0
jnz short loc_FFCC
jmp short loc_1001C
loc_FFCC:
mov rdi, [rsp+48h+var_30]
mov rdx, [rsp+48h+var_38]
mov rcx, [rsp+48h+var_28]
mov esi, 1
call _fread
cmp rax, [rsp+48h+var_38]
jz short loc_10031
call ___errno_location
mov dword ptr [rax], 5
cmp [rsp+48h+var_10], 0
jz short loc_10010
mov rdi, [rsp+48h+var_10]
mov rsi, [rsp+48h+var_30]
call js_free
jmp short loc_1001A
loc_10010:
mov rdi, [rsp+48h+var_30]
call _free
loc_1001A:
jmp short $+2
loc_1001C:
mov rdi, [rsp+48h+var_28]
call _fclose
mov [rsp+48h+var_8], 0
jmp short loc_10060
loc_10031:
mov rax, [rsp+48h+var_30]
mov rcx, [rsp+48h+var_38]
mov byte ptr [rax+rcx], 0
mov rdi, [rsp+48h+var_28]
call _fclose
mov rcx, [rsp+48h+var_38]
mov rax, [rsp+48h+var_18]
mov [rax], rcx
mov rax, [rsp+48h+var_30]
mov [rsp+48h+var_8], rax
loc_10060:
mov rax, [rsp+48h+var_8]
add rsp, 48h
retn
| long long js_load_file(long long a1, long long *a2, long long a3)
{
long long v4; // [rsp+8h] [rbp-40h]
long long v5; // [rsp+18h] [rbp-30h]
long long v6; // [rsp+20h] [rbp-28h]
v6 = fopen(a3, &unk_109A5C);
if ( !v6 )
return 0LL;
if ( (int)fseek(v6, 0LL, 2LL) >= 0 )
{
v4 = ftell(v6);
if ( v4 >= 0 )
{
if ( v4 == 0x7FFFFFFFFFFFFFFFLL )
{
*(_DWORD *)__errno_location() = 21;
}
else if ( (int)fseek(v6, 0LL, 0LL) >= 0 )
{
v5 = a1 ? js_malloc(a1, v4 + 1) : malloc(v4 + 1);
if ( v5 )
{
if ( fread(v5, 1LL, v4, v6) == v4 )
{
*(_BYTE *)(v5 + v4) = 0;
fclose(v6);
*a2 = v4;
return v5;
}
*(_DWORD *)__errno_location() = 5;
if ( a1 )
js_free(a1, v5);
else
free(v5);
}
}
}
}
fclose(v6);
return 0LL;
}
| init_mul_mod_fast:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,0x2000000000000000
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP],0x0
MOV RDI,qword ptr [RSP]
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
XOR EAX,EAX
MOV ECX,EAX
CALL 0x0020c2e0
ADD RSP,0x18
RET
|
void init_mul_mod_fast(int8 param_1)
{
__udivti3(0,0x2000000000000000,param_1,0);
return;
}
| |
23,997 | js_load_file | bluesky950520[P]quickjs/quickjs-libc.c | uint8_t *js_load_file(JSContext *ctx, size_t *pbuf_len, const char *filename)
{
FILE *f;
uint8_t *buf;
size_t buf_len;
long lret;
f = fopen(filename, "rb");
if (!f)
return NULL;
if (fseek(f, 0, SEEK_END) < 0)
goto fail;
lret = ftell(f);
if (lret < 0)
goto fail;
/* XXX: on Linux, ftell() return LONG_MAX for directories */
if (lret == LONG_MAX) {
errno = EISDIR;
goto fail;
}
buf_len = lret;
if (fseek(f, 0, SEEK_SET) < 0)
goto fail;
if (ctx)
buf = js_malloc(ctx, buf_len + 1);
else
buf = malloc(buf_len + 1);
if (!buf)
goto fail;
if (fread(buf, 1, buf_len, f) != buf_len) {
errno = EIO;
if (ctx)
js_free(ctx, buf);
else
free(buf);
fail:
fclose(f);
return NULL;
}
buf[buf_len] = '\0';
fclose(f);
*pbuf_len = buf_len;
return buf;
} | O1 | c | js_load_file:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x871ee(%rip), %rsi # 0x9b94c
movq %rdx, %rdi
callq 0xe7d0
testq %rax, %rax
je 0x14848
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0xe6d0
testl %eax, %eax
js 0x14840
movq %rbx, %rdi
callq 0xe560
testq %rax, %rax
js 0x14840
movq %rax, %r12
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, %r12
jne 0x147bc
callq 0xe0b0
movl $0x15, (%rax)
jmp 0x14840
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xe6d0
testl %eax, %eax
js 0x14840
leaq 0x1(%r12), %rsi
testq %r14, %r14
je 0x147e0
movq %r14, %rdi
callq 0xede6
jmp 0x147e8
movq %rsi, %rdi
callq 0xe660
movq %rax, %r13
testq %rax, %rax
je 0x14840
movl $0x1, %esi
movq %r13, %rdi
movq %r12, %rdx
movq %rbx, %rcx
callq 0xe170
cmpq %r12, %rax
jne 0x1481b
movb $0x0, (%r13,%r12)
movq %rbx, %rdi
callq 0xe220
movq %r12, (%r15)
jmp 0x1484b
callq 0xe0b0
movl $0x5, (%rax)
testq %r14, %r14
je 0x14838
movq %r14, %rdi
movq %r13, %rsi
callq 0x1cb99
jmp 0x14840
movq %r13, %rdi
callq 0xe060
movq %rbx, %rdi
callq 0xe220
xorl %r13d, %r13d
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| js_load_file:
push r15
push r14
push r13
push r12
push rbx
mov r15, rsi
mov r14, rdi
lea rsi, unk_9B94C
mov rdi, rdx
call _fopen
test rax, rax
jz loc_14848
mov rbx, rax
mov rdi, rax
xor esi, esi
mov edx, 2
call _fseek
test eax, eax
js loc_14840
mov rdi, rbx
call _ftell
test rax, rax
js loc_14840
mov r12, rax
mov rax, 7FFFFFFFFFFFFFFFh
cmp r12, rax
jnz short loc_147BC
call ___errno_location
mov dword ptr [rax], 15h
jmp loc_14840
loc_147BC:
mov rdi, rbx
xor esi, esi
xor edx, edx
call _fseek
test eax, eax
js short loc_14840
lea rsi, [r12+1]
test r14, r14
jz short loc_147E0
mov rdi, r14
call js_malloc
jmp short loc_147E8
loc_147E0:
mov rdi, rsi
call _malloc
loc_147E8:
mov r13, rax
test rax, rax
jz short loc_14840
mov esi, 1
mov rdi, r13
mov rdx, r12
mov rcx, rbx
call _fread
cmp rax, r12
jnz short loc_1481B
mov byte ptr [r13+r12+0], 0
mov rdi, rbx
call _fclose
mov [r15], r12
jmp short loc_1484B
loc_1481B:
call ___errno_location
mov dword ptr [rax], 5
test r14, r14
jz short loc_14838
mov rdi, r14
mov rsi, r13
call js_free
jmp short loc_14840
loc_14838:
mov rdi, r13
call _free
loc_14840:
mov rdi, rbx
call _fclose
loc_14848:
xor r13d, r13d
loc_1484B:
mov rax, r13
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| long long js_load_file(long long a1, long long *a2, long long a3)
{
long long v3; // rax
long long v4; // rbx
long long v5; // rax
long long v6; // r12
long long v7; // rax
long long v8; // r13
v3 = fopen(a3, &unk_9B94C);
if ( !v3 )
return 0LL;
v4 = v3;
if ( (int)fseek(v3, 0LL, 2LL) < 0 || (v5 = ftell(v4), v5 < 0) )
{
LABEL_16:
fclose(v4);
return 0LL;
}
v6 = v5;
if ( v5 == 0x7FFFFFFFFFFFFFFFLL )
{
*(_DWORD *)__errno_location() = 21;
goto LABEL_16;
}
if ( (int)fseek(v4, 0LL, 0LL) < 0 )
goto LABEL_16;
v7 = a1 ? js_malloc(a1, v6 + 1) : malloc(v6 + 1);
v8 = v7;
if ( !v7 )
goto LABEL_16;
if ( fread(v7, 1LL, v6, v4) != v6 )
{
*(_DWORD *)__errno_location() = 5;
if ( a1 )
js_free(a1, v8);
else
free(v8);
goto LABEL_16;
}
*(_BYTE *)(v8 + v6) = 0;
fclose(v4);
*a2 = v6;
return v8;
}
| |||
23,998 | my_strntol_mb2_or_mb4 | eloqsql/strings/ctype-ucs2.c | static long
my_strntol_mb2_or_mb4(CHARSET_INFO *cs,
const char *nptr, size_t l, int base,
char **endptr, int *err)
{
int negative= 0;
int overflow;
int cnv;
my_wc_t wc;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
register unsigned int cutlim;
register uint32 cutoff;
register uint32 res;
register const uchar *s= (const uchar*) nptr;
register const uchar *e= (const uchar*) nptr+l;
const uchar *save;
*err= 0;
do
{
if ((cnv= mb_wc(cs, &wc, s, e)) > 0)
{
switch (wc)
{
case ' ' : break;
case '\t': break;
case '-' : negative= !negative; break;
case '+' : break;
default : goto bs;
}
}
else /* No more characters or bad multibyte sequence */
{
if (endptr != NULL )
*endptr= (char*) s;
err[0]= (cnv==MY_CS_ILSEQ) ? EILSEQ : EDOM;
return 0;
}
s+= cnv;
} while (1);
bs:
overflow= 0;
res= 0;
save= s;
cutoff= ((uint32)~0L) / (uint32) base;
cutlim= (uint) (((uint32)~0L) % (uint32) base);
do {
if ((cnv= mb_wc(cs, &wc, s, e)) > 0)
{
s+= cnv;
if (wc >= '0' && wc <= '9')
wc-= '0';
else if (wc >= 'A' && wc <= 'Z')
wc= wc - 'A' + 10;
else if (wc >= 'a' && wc <= 'z')
wc= wc - 'a' + 10;
else
break;
if ((int)wc >= base)
break;
if (res > cutoff || (res == cutoff && wc > cutlim))
overflow= 1;
else
{
res*= (uint32) base;
res+= wc;
}
}
else if (cnv == MY_CS_ILSEQ)
{
if (endptr !=NULL )
*endptr = (char*) s;
err[0]= EILSEQ;
return 0;
}
else
{
/* No more characters */
break;
}
} while(1);
if (endptr != NULL)
*endptr = (char *) s;
if (s == save)
{
err[0]= EDOM;
return 0L;
}
if (negative)
{
if (res > (uint32) INT_MIN32)
overflow= 1;
}
else if (res > INT_MAX32)
overflow= 1;
if (overflow)
{
err[0]= ERANGE;
return negative ? INT_MIN32 : INT_MAX32;
}
return (negative ? -((long) res) : (long) res);
} | O0 | c | my_strntol_mb2_or_mb4:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
movq -0x58(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x70(%rbp), %rdx
movq -0x78(%rbp), %rcx
leaq -0x50(%rbp), %rsi
callq *%rax
movl %eax, -0x44(%rbp)
cmpl $0x0, %eax
jle 0x5f981
movq -0x50(%rbp), %rax
addq $-0x9, %rax
movq %rax, -0x88(%rbp)
subq $0x24, %rax
ja 0x5f97d
movq -0x88(%rbp), %rax
leaq 0x157e05(%rip), %rcx # 0x1b7760
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x5f97f
jmp 0x5f97f
cmpl $0x0, -0x3c(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x3c(%rbp)
jmp 0x5f97f
jmp 0x5f97f
jmp 0x5f9d8
jmp 0x5f9b9
cmpq $0x0, -0x30(%rbp)
je 0x5f993
movq -0x70(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movl -0x44(%rbp), %edx
movl $0x21, %ecx
movl $0x54, %eax
cmpl $0x0, %edx
cmovel %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x5fbe1
movl -0x44(%rbp), %ecx
movq -0x70(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x70(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x5f91a
jmp 0x5f9d6
jmp 0x5f9d8
movl $0x0, -0x40(%rbp)
movl $0x0, -0x64(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
xorl %edx, %edx
divl -0x24(%rbp)
movl %eax, -0x60(%rbp)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
xorl %edx, %edx
divl -0x24(%rbp)
movl %edx, -0x5c(%rbp)
movq -0x58(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x70(%rbp), %rdx
movq -0x78(%rbp), %rcx
leaq -0x50(%rbp), %rsi
callq *%rax
movl %eax, -0x44(%rbp)
cmpl $0x0, %eax
jle 0x5fae9
movl -0x44(%rbp), %ecx
movq -0x70(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x70(%rbp)
cmpq $0x30, -0x50(%rbp)
jb 0x5fa57
cmpq $0x39, -0x50(%rbp)
ja 0x5fa57
movq -0x50(%rbp), %rax
subq $0x30, %rax
movq %rax, -0x50(%rbp)
jmp 0x5faa0
cmpq $0x41, -0x50(%rbp)
jb 0x5fa77
cmpq $0x5a, -0x50(%rbp)
ja 0x5fa77
movq -0x50(%rbp), %rax
subq $0x41, %rax
addq $0xa, %rax
movq %rax, -0x50(%rbp)
jmp 0x5fa9e
cmpq $0x61, -0x50(%rbp)
jb 0x5fa97
cmpq $0x7a, -0x50(%rbp)
ja 0x5fa97
movq -0x50(%rbp), %rax
subq $0x61, %rax
addq $0xa, %rax
movq %rax, -0x50(%rbp)
jmp 0x5fa9c
jmp 0x5fb28
jmp 0x5fa9e
jmp 0x5faa0
movq -0x50(%rbp), %rax
cmpl -0x24(%rbp), %eax
jl 0x5faab
jmp 0x5fb28
movl -0x64(%rbp), %eax
cmpl -0x60(%rbp), %eax
ja 0x5fac7
movl -0x64(%rbp), %eax
cmpl -0x60(%rbp), %eax
jne 0x5fad0
movq -0x50(%rbp), %rax
movl -0x5c(%rbp), %ecx
cmpq %rcx, %rax
jbe 0x5fad0
movl $0x1, -0x40(%rbp)
jmp 0x5fae7
movl -0x24(%rbp), %eax
imull -0x64(%rbp), %eax
movl %eax, -0x64(%rbp)
movq -0x50(%rbp), %rcx
movl -0x64(%rbp), %eax
addq %rcx, %rax
movl %eax, -0x64(%rbp)
jmp 0x5fb1a
cmpl $0x0, -0x44(%rbp)
jne 0x5fb18
cmpq $0x0, -0x30(%rbp)
je 0x5fb01
movq -0x70(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movl $0x54, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x5fbe1
jmp 0x5fb28
jmp 0x5fb1c
movb $0x1, %al
testb $0x1, %al
jne 0x5fa08
jmp 0x5fb28
cmpq $0x0, -0x30(%rbp)
je 0x5fb3a
movq -0x70(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x70(%rbp), %rax
cmpq -0x80(%rbp), %rax
jne 0x5fb5b
movq -0x38(%rbp), %rax
movl $0x21, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x5fbe1
cmpl $0x0, -0x3c(%rbp)
je 0x5fb73
cmpl $0x80000000, -0x64(%rbp) # imm = 0x80000000
jbe 0x5fb71
movl $0x1, -0x40(%rbp)
jmp 0x5fb87
movl -0x64(%rbp), %eax
cmpq $0x7fffffff, %rax # imm = 0x7FFFFFFF
jle 0x5fb85
movl $0x1, -0x40(%rbp)
jmp 0x5fb87
cmpl $0x0, -0x40(%rbp)
je 0x5fbb3
movq -0x38(%rbp), %rax
movl $0x22, (%rax)
movl -0x3c(%rbp), %edx
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
movq $-0x80000000, %rcx # imm = 0x80000000
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x5fbe1
cmpl $0x0, -0x3c(%rbp)
je 0x5fbcc
movl -0x64(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
movq %rax, -0x90(%rbp)
jmp 0x5fbd6
movl -0x64(%rbp), %eax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nop
| my_strntol_mb2_or_mb4:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
mov [rbp+var_3C], 0
mov rax, [rbp+var_10]
mov rax, [rax+0B8h]
mov rax, [rax+28h]
mov [rbp+var_58], rax
mov rax, [rbp+var_18]
mov [rbp+var_70], rax
mov rax, [rbp+var_18]
add rax, [rbp+var_20]
mov [rbp+var_78], rax
mov rax, [rbp+var_38]
mov dword ptr [rax], 0
loc_5F91A:
mov rax, [rbp+var_58]
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_70]
mov rcx, [rbp+var_78]
lea rsi, [rbp+var_50]
call rax
mov [rbp+var_44], eax
cmp eax, 0
jle short loc_5F981
mov rax, [rbp+var_50]
add rax, 0FFFFFFFFFFFFFFF7h; switch 37 cases
mov [rbp+var_88], rax
sub rax, 24h
ja short def_5F962; jumptable 000000000005F962 default case, cases 10-31,33-42,44
mov rax, [rbp+var_88]
lea rcx, jpt_5F962
movsxd rax, ds:(jpt_5F962 - 1B7760h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_5F964:
jmp short loc_5F97F; jumptable 000000000005F962 case 32
loc_5F966:
jmp short loc_5F97F; jumptable 000000000005F962 case 9
loc_5F968:
cmp [rbp+var_3C], 0; jumptable 000000000005F962 case 45
setnz al
xor al, 0FFh
and al, 1
movzx eax, al
mov [rbp+var_3C], eax
jmp short loc_5F97F
loc_5F97B:
jmp short loc_5F97F; jumptable 000000000005F962 case 43
def_5F962:
jmp short loc_5F9D8; jumptable 000000000005F962 default case, cases 10-31,33-42,44
loc_5F97F:
jmp short loc_5F9B9
loc_5F981:
cmp [rbp+var_30], 0
jz short loc_5F993
mov rcx, [rbp+var_70]
mov rax, [rbp+var_30]
mov [rax], rcx
loc_5F993:
mov edx, [rbp+var_44]
mov ecx, 21h ; '!'
mov eax, 54h ; 'T'
cmp edx, 0
cmovz ecx, eax
mov rax, [rbp+var_38]
mov [rax], ecx
mov [rbp+var_8], 0
jmp loc_5FBE1
loc_5F9B9:
mov ecx, [rbp+var_44]
mov rax, [rbp+var_70]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_70], rax
mov al, 1
test al, 1
jnz loc_5F91A
jmp short $+2
loc_5F9D6:
jmp short $+2
loc_5F9D8:
mov [rbp+var_40], 0
mov [rbp+var_64], 0
mov rax, [rbp+var_70]
mov [rbp+var_80], rax
mov eax, 0FFFFFFFFh
xor edx, edx
div [rbp+var_24]
mov [rbp+var_60], eax
mov eax, 0FFFFFFFFh
xor edx, edx
div [rbp+var_24]
mov [rbp+var_5C], edx
loc_5FA08:
mov rax, [rbp+var_58]
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_70]
mov rcx, [rbp+var_78]
lea rsi, [rbp+var_50]
call rax
mov [rbp+var_44], eax
cmp eax, 0
jle loc_5FAE9
mov ecx, [rbp+var_44]
mov rax, [rbp+var_70]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_70], rax
cmp [rbp+var_50], 30h ; '0'
jb short loc_5FA57
cmp [rbp+var_50], 39h ; '9'
ja short loc_5FA57
mov rax, [rbp+var_50]
sub rax, 30h ; '0'
mov [rbp+var_50], rax
jmp short loc_5FAA0
loc_5FA57:
cmp [rbp+var_50], 41h ; 'A'
jb short loc_5FA77
cmp [rbp+var_50], 5Ah ; 'Z'
ja short loc_5FA77
mov rax, [rbp+var_50]
sub rax, 41h ; 'A'
add rax, 0Ah
mov [rbp+var_50], rax
jmp short loc_5FA9E
loc_5FA77:
cmp [rbp+var_50], 61h ; 'a'
jb short loc_5FA97
cmp [rbp+var_50], 7Ah ; 'z'
ja short loc_5FA97
mov rax, [rbp+var_50]
sub rax, 61h ; 'a'
add rax, 0Ah
mov [rbp+var_50], rax
jmp short loc_5FA9C
loc_5FA97:
jmp loc_5FB28
loc_5FA9C:
jmp short $+2
loc_5FA9E:
jmp short $+2
loc_5FAA0:
mov rax, [rbp+var_50]
cmp eax, [rbp+var_24]
jl short loc_5FAAB
jmp short loc_5FB28
loc_5FAAB:
mov eax, [rbp+var_64]
cmp eax, [rbp+var_60]
ja short loc_5FAC7
mov eax, [rbp+var_64]
cmp eax, [rbp+var_60]
jnz short loc_5FAD0
mov rax, [rbp+var_50]
mov ecx, [rbp+var_5C]
cmp rax, rcx
jbe short loc_5FAD0
loc_5FAC7:
mov [rbp+var_40], 1
jmp short loc_5FAE7
loc_5FAD0:
mov eax, [rbp+var_24]
imul eax, [rbp+var_64]
mov [rbp+var_64], eax
mov rcx, [rbp+var_50]
mov eax, [rbp+var_64]
add rax, rcx
mov [rbp+var_64], eax
loc_5FAE7:
jmp short loc_5FB1A
loc_5FAE9:
cmp [rbp+var_44], 0
jnz short loc_5FB18
cmp [rbp+var_30], 0
jz short loc_5FB01
mov rcx, [rbp+var_70]
mov rax, [rbp+var_30]
mov [rax], rcx
loc_5FB01:
mov rax, [rbp+var_38]
mov dword ptr [rax], 54h ; 'T'
mov [rbp+var_8], 0
jmp loc_5FBE1
loc_5FB18:
jmp short loc_5FB28
loc_5FB1A:
jmp short $+2
loc_5FB1C:
mov al, 1
test al, 1
jnz loc_5FA08
jmp short $+2
loc_5FB28:
cmp [rbp+var_30], 0
jz short loc_5FB3A
mov rcx, [rbp+var_70]
mov rax, [rbp+var_30]
mov [rax], rcx
loc_5FB3A:
mov rax, [rbp+var_70]
cmp rax, [rbp+var_80]
jnz short loc_5FB5B
mov rax, [rbp+var_38]
mov dword ptr [rax], 21h ; '!'
mov [rbp+var_8], 0
jmp loc_5FBE1
loc_5FB5B:
cmp [rbp+var_3C], 0
jz short loc_5FB73
cmp [rbp+var_64], 80000000h
jbe short loc_5FB71
mov [rbp+var_40], 1
loc_5FB71:
jmp short loc_5FB87
loc_5FB73:
mov eax, [rbp+var_64]
cmp rax, 7FFFFFFFh
jle short loc_5FB85
mov [rbp+var_40], 1
loc_5FB85:
jmp short $+2
loc_5FB87:
cmp [rbp+var_40], 0
jz short loc_5FBB3
mov rax, [rbp+var_38]
mov dword ptr [rax], 22h ; '"'
mov edx, [rbp+var_3C]
mov eax, 7FFFFFFFh
mov rcx, 0FFFFFFFF80000000h
cmp edx, 0
cmovnz rax, rcx
mov [rbp+var_8], rax
jmp short loc_5FBE1
loc_5FBB3:
cmp [rbp+var_3C], 0
jz short loc_5FBCC
mov eax, [rbp+var_64]
mov ecx, eax
xor eax, eax
sub rax, rcx
mov [rbp+var_90], rax
jmp short loc_5FBD6
loc_5FBCC:
mov eax, [rbp+var_64]
mov [rbp+var_90], rax
loc_5FBD6:
mov rax, [rbp+var_90]
mov [rbp+var_8], rax
loc_5FBE1:
mov rax, [rbp+var_8]
add rsp, 90h
pop rbp
retn
| long long my_strntol_mb2_or_mb4(long long a1, long long a2, long long a3, unsigned int a4, _QWORD *a5, int *a6)
{
int v6; // ecx
long long v7; // rax
long long v10; // [rsp+10h] [rbp-80h]
long long v11; // [rsp+18h] [rbp-78h]
long long v12; // [rsp+20h] [rbp-70h]
unsigned int v13; // [rsp+2Ch] [rbp-64h]
unsigned int v14; // [rsp+30h] [rbp-60h]
unsigned int v15; // [rsp+34h] [rbp-5Ch]
long long ( *v16)(long long, unsigned long long *, long long, long long); // [rsp+38h] [rbp-58h]
unsigned long long v17; // [rsp+40h] [rbp-50h] BYREF
int v18; // [rsp+4Ch] [rbp-44h]
int v19; // [rsp+50h] [rbp-40h]
BOOL v20; // [rsp+54h] [rbp-3Ch]
int *v21; // [rsp+58h] [rbp-38h]
_QWORD *v22; // [rsp+60h] [rbp-30h]
unsigned int v23; // [rsp+6Ch] [rbp-24h]
long long v24; // [rsp+70h] [rbp-20h]
long long v25; // [rsp+78h] [rbp-18h]
long long v26; // [rsp+80h] [rbp-10h]
v26 = a1;
v25 = a2;
v24 = a3;
v23 = a4;
v22 = a5;
v21 = a6;
v20 = 0;
v16 = *(long long ( **)(long long, unsigned long long *, long long, long long))(*(_QWORD *)(a1 + 184) + 40LL);
v12 = a2;
v11 = a3 + a2;
*a6 = 0;
while ( 2 )
{
v18 = v16(v26, &v17, v12, v11);
if ( v18 <= 0 )
{
if ( v22 )
*v22 = v12;
v6 = 33;
if ( !v18 )
v6 = 84;
*v21 = v6;
return 0LL;
}
else
{
switch ( v17 )
{
case 9uLL:
case 0x20uLL:
case 0x2BuLL:
goto LABEL_10;
case 0x2DuLL:
v20 = !v20;
LABEL_10:
v12 += v18;
continue;
default:
v19 = 0;
v13 = 0;
v10 = v12;
v14 = 0xFFFFFFFF / v23;
v15 = 0xFFFFFFFF % v23;
break;
}
while ( 1 )
{
v18 = v16(v26, &v17, v12, v11);
if ( v18 <= 0 )
break;
v12 += v18;
if ( v17 < 0x30 || v17 > 0x39 )
{
if ( v17 < 0x41 || v17 > 0x5A )
{
if ( v17 < 0x61 || v17 > 0x7A )
goto LABEL_33;
v17 = v17 - 97 + 10;
}
else
{
v17 = v17 - 65 + 10;
}
}
else
{
v17 -= 48LL;
}
if ( (int)v17 >= (int)v23 )
goto LABEL_33;
if ( v13 > v14 || v13 == v14 && v17 > v15 )
v19 = 1;
else
v13 = v17 + v13 * v23;
}
if ( v18 )
{
LABEL_33:
if ( v22 )
*v22 = v12;
if ( v12 == v10 )
{
*v21 = 33;
return 0LL;
}
else
{
if ( v20 )
{
if ( v13 > 0x80000000 )
v19 = 1;
}
else if ( v13 > 0x7FFFFFFFuLL )
{
v19 = 1;
}
if ( v19 )
{
*v21 = 34;
v7 = 0x7FFFFFFFLL;
if ( v20 )
return 0xFFFFFFFF80000000LL;
return v7;
}
else if ( v20 )
{
return -(long long)v13;
}
else
{
return v13;
}
}
}
if ( v22 )
*v22 = v12;
*v21 = 84;
return 0LL;
}
}
}
| my_strntol_mb2_or_mb4:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
MOV dword ptr [RBP + -0x3c],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x70],RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x0
LAB_0015f91a:
MOV RAX,qword ptr [RBP + -0x58]
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x70]
MOV RCX,qword ptr [RBP + -0x78]
LEA RSI,[RBP + -0x50]
CALL RAX
MOV dword ptr [RBP + -0x44],EAX
CMP EAX,0x0
JLE 0x0015f981
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,-0x9
MOV qword ptr [RBP + -0x88],RAX
SUB RAX,0x24
JA 0x0015f97d
MOV RAX,qword ptr [RBP + -0x88]
LEA RCX,[0x2b7760]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_20:
JMP 0x0015f97f
caseD_9:
JMP 0x0015f97f
caseD_2d:
CMP dword ptr [RBP + -0x3c],0x0
SETNZ AL
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x0015f97f
caseD_2b:
JMP 0x0015f97f
caseD_a:
JMP 0x0015f9d8
LAB_0015f97f:
JMP 0x0015f9b9
LAB_0015f981:
CMP qword ptr [RBP + -0x30],0x0
JZ 0x0015f993
MOV RCX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
LAB_0015f993:
MOV EDX,dword ptr [RBP + -0x44]
MOV ECX,0x21
MOV EAX,0x54
CMP EDX,0x0
CMOVZ ECX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],ECX
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0015fbe1
LAB_0015f9b9:
MOV ECX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x70]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x70],RAX
MOV AL,0x1
TEST AL,0x1
JNZ 0x0015f91a
JMP 0x0015f9d6
LAB_0015f9d6:
JMP 0x0015f9d8
LAB_0015f9d8:
MOV dword ptr [RBP + -0x40],0x0
MOV dword ptr [RBP + -0x64],0x0
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x80],RAX
MOV EAX,0xffffffff
XOR EDX,EDX
DIV dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x60],EAX
MOV EAX,0xffffffff
XOR EDX,EDX
DIV dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x5c],EDX
LAB_0015fa08:
MOV RAX,qword ptr [RBP + -0x58]
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x70]
MOV RCX,qword ptr [RBP + -0x78]
LEA RSI,[RBP + -0x50]
CALL RAX
MOV dword ptr [RBP + -0x44],EAX
CMP EAX,0x0
JLE 0x0015fae9
MOV ECX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x70]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x70],RAX
CMP qword ptr [RBP + -0x50],0x30
JC 0x0015fa57
CMP qword ptr [RBP + -0x50],0x39
JA 0x0015fa57
MOV RAX,qword ptr [RBP + -0x50]
SUB RAX,0x30
MOV qword ptr [RBP + -0x50],RAX
JMP 0x0015faa0
LAB_0015fa57:
CMP qword ptr [RBP + -0x50],0x41
JC 0x0015fa77
CMP qword ptr [RBP + -0x50],0x5a
JA 0x0015fa77
MOV RAX,qword ptr [RBP + -0x50]
SUB RAX,0x41
ADD RAX,0xa
MOV qword ptr [RBP + -0x50],RAX
JMP 0x0015fa9e
LAB_0015fa77:
CMP qword ptr [RBP + -0x50],0x61
JC 0x0015fa97
CMP qword ptr [RBP + -0x50],0x7a
JA 0x0015fa97
MOV RAX,qword ptr [RBP + -0x50]
SUB RAX,0x61
ADD RAX,0xa
MOV qword ptr [RBP + -0x50],RAX
JMP 0x0015fa9c
LAB_0015fa97:
JMP 0x0015fb28
LAB_0015fa9c:
JMP 0x0015fa9e
LAB_0015fa9e:
JMP 0x0015faa0
LAB_0015faa0:
MOV RAX,qword ptr [RBP + -0x50]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x0015faab
JMP 0x0015fb28
LAB_0015faab:
MOV EAX,dword ptr [RBP + -0x64]
CMP EAX,dword ptr [RBP + -0x60]
JA 0x0015fac7
MOV EAX,dword ptr [RBP + -0x64]
CMP EAX,dword ptr [RBP + -0x60]
JNZ 0x0015fad0
MOV RAX,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RBP + -0x5c]
CMP RAX,RCX
JBE 0x0015fad0
LAB_0015fac7:
MOV dword ptr [RBP + -0x40],0x1
JMP 0x0015fae7
LAB_0015fad0:
MOV EAX,dword ptr [RBP + -0x24]
IMUL EAX,dword ptr [RBP + -0x64]
MOV dword ptr [RBP + -0x64],EAX
MOV RCX,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RBP + -0x64]
ADD RAX,RCX
MOV dword ptr [RBP + -0x64],EAX
LAB_0015fae7:
JMP 0x0015fb1a
LAB_0015fae9:
CMP dword ptr [RBP + -0x44],0x0
JNZ 0x0015fb18
CMP qword ptr [RBP + -0x30],0x0
JZ 0x0015fb01
MOV RCX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
LAB_0015fb01:
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x54
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0015fbe1
LAB_0015fb18:
JMP 0x0015fb28
LAB_0015fb1a:
JMP 0x0015fb1c
LAB_0015fb1c:
MOV AL,0x1
TEST AL,0x1
JNZ 0x0015fa08
JMP 0x0015fb28
LAB_0015fb28:
CMP qword ptr [RBP + -0x30],0x0
JZ 0x0015fb3a
MOV RCX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
LAB_0015fb3a:
MOV RAX,qword ptr [RBP + -0x70]
CMP RAX,qword ptr [RBP + -0x80]
JNZ 0x0015fb5b
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x21
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0015fbe1
LAB_0015fb5b:
CMP dword ptr [RBP + -0x3c],0x0
JZ 0x0015fb73
CMP dword ptr [RBP + -0x64],0x80000000
JBE 0x0015fb71
MOV dword ptr [RBP + -0x40],0x1
LAB_0015fb71:
JMP 0x0015fb87
LAB_0015fb73:
MOV EAX,dword ptr [RBP + -0x64]
CMP RAX,0x7fffffff
JLE 0x0015fb85
MOV dword ptr [RBP + -0x40],0x1
LAB_0015fb85:
JMP 0x0015fb87
LAB_0015fb87:
CMP dword ptr [RBP + -0x40],0x0
JZ 0x0015fbb3
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x22
MOV EDX,dword ptr [RBP + -0x3c]
MOV EAX,0x7fffffff
MOV RCX,-0x80000000
CMP EDX,0x0
CMOVNZ RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0015fbe1
LAB_0015fbb3:
CMP dword ptr [RBP + -0x3c],0x0
JZ 0x0015fbcc
MOV EAX,dword ptr [RBP + -0x64]
MOV ECX,EAX
XOR EAX,EAX
SUB RAX,RCX
MOV qword ptr [RBP + -0x90],RAX
JMP 0x0015fbd6
LAB_0015fbcc:
MOV EAX,dword ptr [RBP + -0x64]
MOV qword ptr [RBP + -0x90],RAX
LAB_0015fbd6:
MOV RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RBP + -0x8],RAX
LAB_0015fbe1:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x90
POP RBP
RET
|
/* WARNING: Removing unreachable block (ram,0x0015f9d4) */
/* WARNING: Removing unreachable block (ram,0x0015fb26) */
ulong my_strntol_mb2_or_mb4
(long param_1,long param_2,long param_3,uint param_4,long *param_5,
int4 *param_6)
{
code *pcVar1;
ulong uVar2;
long lVar3;
uint uVar4;
int4 uVar5;
ulong local_98;
long local_78;
uint local_6c;
ulong local_58;
int local_4c;
int local_48;
uint local_44;
int4 *local_40;
long *local_38;
uint local_2c;
long local_28;
long local_20;
long local_18;
ulong local_10;
local_44 = 0;
pcVar1 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
*param_6 = 0;
local_78 = param_2;
local_40 = param_6;
local_38 = param_5;
local_2c = param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
do {
lVar3 = local_78;
local_4c = (*pcVar1)(local_18,&local_58,local_78,param_2 + param_3);
if (local_4c < 1) {
if (local_38 != (long *)0x0) {
*local_38 = local_78;
}
uVar5 = 0x21;
if (local_4c == 0) {
uVar5 = 0x54;
}
*local_40 = uVar5;
return 0;
}
switch(local_58) {
case 9:
break;
default:
local_48 = 0;
local_6c = 0;
uVar4 = (uint)(0xffffffff / (ulong)local_2c);
uVar2 = (ulong)local_2c;
goto LAB_0015fa08;
case 0x20:
break;
case 0x2b:
break;
case 0x2d:
local_44 = (uint)((local_44 != 0 ^ 0xffU) & 1);
}
local_78 = local_78 + local_4c;
} while( true );
LAB_0015fa08:
local_4c = (*pcVar1)(local_18,&local_58,local_78,param_2 + param_3);
if (local_4c < 1) {
if (local_4c == 0) {
if (local_38 != (long *)0x0) {
*local_38 = local_78;
}
*local_40 = 0x54;
local_10 = 0;
}
else {
LAB_0015fb28:
if (local_38 != (long *)0x0) {
*local_38 = local_78;
}
if (local_78 == lVar3) {
*local_40 = 0x21;
local_10 = 0;
}
else {
if (local_44 == 0) {
if (0x7fffffff < local_6c) {
local_48 = 1;
}
}
else if (0x80000000 < local_6c) {
local_48 = 1;
}
if (local_48 == 0) {
if (local_44 == 0) {
local_98 = (ulong)local_6c;
}
else {
local_98 = -(ulong)local_6c;
}
local_10 = local_98;
}
else {
*local_40 = 0x22;
local_10 = 0x7fffffff;
if (local_44 != 0) {
local_10 = 0xffffffff80000000;
}
}
}
}
return local_10;
}
local_78 = local_78 + local_4c;
if ((local_58 < 0x30) || (0x39 < local_58)) {
if ((local_58 < 0x41) || (0x5a < local_58)) {
if ((local_58 < 0x61) || (0x7a < local_58)) goto LAB_0015fb28;
local_58 = local_58 - 0x57;
}
else {
local_58 = local_58 - 0x37;
}
}
else {
local_58 = local_58 - 0x30;
}
if ((int)local_2c <= (int)local_58) goto LAB_0015fb28;
if ((uVar4 < local_6c) || ((local_6c == uVar4 && (0xffffffffU % uVar2 < local_58)))) {
local_48 = 1;
}
else {
local_6c = local_2c * local_6c + (int)local_58;
}
goto LAB_0015fa08;
}
| |
23,999 | OpenSubdiv::v3_6_0::Tmr::SubdivisionPlan::~SubdivisionPlan() | NVIDIA-RTX[P]OSD-Lite/opensubdiv/tmr/subdivisionPlan.cpp | SubdivisionPlan::~SubdivisionPlan() {
// Plans own the lifespan of their neighborhoods : we need to
// delete them
clearNeighborhoods();
} | O1 | cpp | OpenSubdiv::v3_6_0::Tmr::SubdivisionPlan::~SubdivisionPlan():
pushq %rbx
movq %rdi, %rbx
callq 0x3a660
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0xa66cd
movq 0x80(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2d0
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0xa66e2
movq 0x68(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2d0
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0xa66f7
movq 0x50(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2d0
movq 0x38(%rbx), %rdi
callq 0x3a0c0
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
movl $0x4, 0x14(%rbx)
popq %rbx
retq
nop
| _ZN10OpenSubdiv6v3_6_03Tmr15SubdivisionPlanD2Ev:
push rbx; Alternative name is 'OpenSubdiv::v3_6_0::Tmr::SubdivisionPlan::~SubdivisionPlan()'
mov rbx, rdi
call __ZN10OpenSubdiv6v3_6_03Tmr15SubdivisionPlan18clearNeighborhoodsEv; OpenSubdiv::v3_6_0::Tmr::SubdivisionPlan::clearNeighborhoods(void)
mov rdi, [rbx+70h]; void *
test rdi, rdi
jz short loc_A66CD
mov rsi, [rbx+80h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A66CD:
mov rdi, [rbx+58h]; void *
test rdi, rdi
jz short loc_A66E2
mov rsi, [rbx+68h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A66E2:
mov rdi, [rbx+40h]; void *
test rdi, rdi
jz short loc_A66F7
mov rsi, [rbx+50h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A66F7:
mov rdi, [rbx+38h]; void *
call __ZdlPv; operator delete(void *)
lea rax, [rbx+18h]
mov [rbx+8], rax
mov dword ptr [rbx+14h], 4
pop rbx
retn
| void OpenSubdiv::v3_6_0::Tmr::SubdivisionPlan::~SubdivisionPlan(void **this)
{
void *v2; // rdi
void *v3; // rdi
void *v4; // rdi
OpenSubdiv::v3_6_0::Tmr::SubdivisionPlan::clearNeighborhoods((OpenSubdiv::v3_6_0::Tmr::SubdivisionPlan *)this);
v2 = this[14];
if ( v2 )
operator delete(v2, (_BYTE *)this[16] - (_BYTE *)v2);
v3 = this[11];
if ( v3 )
operator delete(v3, (_BYTE *)this[13] - (_BYTE *)v3);
v4 = this[8];
if ( v4 )
operator delete(v4, (_BYTE *)this[10] - (_BYTE *)v4);
operator delete(this[7]);
this[1] = this + 3;
*((_DWORD *)this + 5) = 4;
}
| ~SubdivisionPlan:
PUSH RBX
MOV RBX,RDI
CALL 0x0013a660
MOV RDI,qword ptr [RBX + 0x70]
TEST RDI,RDI
JZ 0x001a66cd
MOV RSI,qword ptr [RBX + 0x80]
SUB RSI,RDI
CALL 0x0013a2d0
LAB_001a66cd:
MOV RDI,qword ptr [RBX + 0x58]
TEST RDI,RDI
JZ 0x001a66e2
MOV RSI,qword ptr [RBX + 0x68]
SUB RSI,RDI
CALL 0x0013a2d0
LAB_001a66e2:
MOV RDI,qword ptr [RBX + 0x40]
TEST RDI,RDI
JZ 0x001a66f7
MOV RSI,qword ptr [RBX + 0x50]
SUB RSI,RDI
CALL 0x0013a2d0
LAB_001a66f7:
MOV RDI,qword ptr [RBX + 0x38]
CALL 0x0013a0c0
LEA RAX,[RBX + 0x18]
MOV qword ptr [RBX + 0x8],RAX
MOV dword ptr [RBX + 0x14],0x4
POP RBX
RET
|
/* OpenSubdiv::v3_6_0::Tmr::SubdivisionPlan::~SubdivisionPlan() */
void __thiscall OpenSubdiv::v3_6_0::Tmr::SubdivisionPlan::~SubdivisionPlan(SubdivisionPlan *this)
{
void *pvVar1;
clearNeighborhoods(this);
pvVar1 = *(void **)(this + 0x70);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x80) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x58);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x68) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x40);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x50) - (long)pvVar1);
}
operator_delete(*(void **)(this + 0x38));
*(SubdivisionPlan **)(this + 8) = this + 0x18;
*(int4 *)(this + 0x14) = 4;
return;
}
|
Subsets and Splits
C++ Functions Using STL
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ STL Function Queries
Filters C++ code examples that use standard library containers and algorithms, helping identify common programming patterns and library usage in code generation tasks.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.