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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
66,000 |
ma_split_page
|
eloqsql/storage/maria/ma_write.c
|
int _ma_split_page(MARIA_HA *info, MARIA_KEY *key, MARIA_PAGE *split_page,
uint org_split_length,
uchar *inserted_key_pos, uint changed_length,
int move_length,
uchar *key_buff, my_bool insert_last_key)
{
uint keynr;
uint length,a_length,key_ref_length,t_length,nod_flag,key_length;
uint page_length, split_length, page_flag;
uchar *key_pos, *pos, *UNINIT_VAR(after_key);
MARIA_KEY_PARAM s_temp;
MARIA_PINNED_PAGE tmp_page_link, *page_link= &tmp_page_link;
MARIA_SHARE *share= info->s;
MARIA_KEYDEF *keyinfo= key->keyinfo;
MARIA_KEY tmp_key;
MARIA_PAGE new_page;
int res;
DBUG_ENTER("_ma_split_page");
DBUG_DUMP("buff", split_page->buff, split_page->size);
info->page_changed=1; /* Info->buff is used */
info->keyread_buff_used=1;
page_flag= split_page->flag;
nod_flag= split_page->node;
key_ref_length= share->keypage_header + nod_flag;
new_page.info= info;
new_page.buff= info->buff;
new_page.keyinfo= keyinfo;
tmp_key.data= key_buff;
tmp_key.keyinfo= keyinfo;
if (insert_last_key)
key_pos= _ma_find_last_pos(&tmp_key, split_page, &after_key);
else
key_pos= _ma_find_half_pos(&tmp_key, split_page, &after_key);
if (!key_pos)
DBUG_RETURN(-1);
key_length= tmp_key.data_length + tmp_key.ref_length;
split_length= (uint) (key_pos - split_page->buff);
a_length= split_page->size;
split_page->size= split_length;
page_store_size(share, split_page);
key_pos=after_key;
if (nod_flag)
{
DBUG_PRINT("test",("Splitting nod"));
pos=key_pos-nod_flag;
memcpy(new_page.buff + share->keypage_header, pos, (size_t) nod_flag);
}
/* Move middle item to key and pointer to new page */
if ((new_page.pos= _ma_new(info, PAGECACHE_PRIORITY_HIGH, &page_link)) ==
HA_OFFSET_ERROR)
DBUG_RETURN(-1);
_ma_copy_key(key, &tmp_key);
_ma_kpointer(info, key->data + key_length, new_page.pos);
/* Store new page */
if (!(*keyinfo->get_key)(&tmp_key, page_flag, nod_flag, &key_pos))
DBUG_RETURN(-1);
t_length=(*keyinfo->pack_key)(&tmp_key, nod_flag, (uchar *) 0,
(uchar*) 0, (uchar*) 0, &s_temp);
length=(uint) ((split_page->buff + a_length) - key_pos);
memcpy(new_page.buff + key_ref_length + t_length, key_pos,
(size_t) length);
(*keyinfo->store_key)(keyinfo,new_page.buff+key_ref_length,&s_temp);
page_length= length + t_length + key_ref_length;
bzero(new_page.buff, share->keypage_header);
/* Copy KEYFLAG_FLAG_ISNODE and KEYPAGE_FLAG_HAS_TRANSID from parent page */
new_page.flag= page_flag;
new_page.size= page_length;
page_store_info(share, &new_page);
/* Copy key number */
keynr= _ma_get_keynr(share, split_page->buff);
_ma_store_keynr(share, new_page.buff, keynr);
res= 2; /* Middle key up */
if (share->now_transactional && _ma_log_new(&new_page, 0))
res= -1;
/*
Clear unitialized part of page to avoid valgrind/purify warnings
and to get a clean page that is easier to compress and compare with
pages generated with redo
*/
bzero(new_page.buff + page_length, share->block_size - page_length);
if (_ma_write_keypage(&new_page, page_link->write_lock,
DFLT_INIT_HITS))
res= -1;
/* Save changes to split pages */
if (share->now_transactional &&
_ma_log_split(split_page, org_split_length, split_length,
inserted_key_pos, changed_length, move_length,
KEY_OP_NONE, (uchar*) 0, 0, 0))
res= -1;
DBUG_DUMP_KEY("middle_key", key);
DBUG_RETURN(res);
}
|
O3
|
c
|
ma_split_page:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xaf8, %rsp # imm = 0xAF8
movl %r9d, -0xa50(%rbp)
movq %r8, -0xa98(%rbp)
movl %ecx, -0xa4c(%rbp)
movq %rdx, %r12
movq %rdi, %rdx
movq 0x18(%rbp), %rdi
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
leaq -0xb20(%rbp), %rax
movq %rax, -0xa80(%rbp)
movq (%rdx), %r15
movq %rsi, -0xaa0(%rbp)
movq 0x8(%rsi), %r14
movw $0x101, 0x684(%rdx) # imm = 0x101
movl 0x28(%r12), %ecx
movl 0x2c(%r12), %r8d
movl 0x744(%r15), %eax
movq %rcx, -0xab0(%rbp)
addl %ecx, %eax
movl %eax, -0xa2c(%rbp)
movq %rdx, -0xb08(%rbp)
movq %rdx, -0xaa8(%rbp)
movq 0x378(%rdx), %rax
movq %rax, -0xa78(%rbp)
movq %rax, -0xaf8(%rbp)
movq %r14, -0xb00(%rbp)
movq %rdi, -0xa70(%rbp)
movq %r14, -0xa68(%rbp)
cmpb $0x0, 0x20(%rbp)
movq %r15, -0xa28(%rbp)
movq %r12, -0xa18(%rbp)
movl %r8d, -0xa1c(%rbp)
je 0x57a08
movq (%r12), %r13
movq (%r13), %rsi
movl 0x744(%rsi), %edx
movl 0x20(%r12), %eax
subl %edx, %eax
movq 0x10(%r12), %r15
addq %rdx, %r15
movq %r15, -0xa38(%rbp)
testb $0x2e, 0xa2(%r14)
sete %r9b
testb $0x2, %r8b
sete %cl
andb %r9b, %cl
cmpb $0x1, %cl
jne 0x57a26
movzwl 0xaa(%r14), %ecx
xorl %edx, %edx
divl %ecx
addl $-0x2, %eax
imull %ecx, %eax
movl 0x740(%rsi), %edx
movl %ecx, %esi
subl %edx, %esi
movl %esi, -0xa60(%rbp)
movq (%r13), %rdx
movl 0x740(%rdx), %edx
movl %edx, -0xa5c(%rbp)
movl $0x0, -0xa58(%rbp)
addq %rax, %r15
leaq (%r15,%rcx), %rax
movq %rax, -0xa48(%rbp)
movq %r15, %rsi
movq %rcx, %rdx
callq 0x29080
movq %r15, %rbx
jmp 0x57afa
leaq -0xa70(%rbp), %rdi
leaq -0xa48(%rbp), %rdx
movq %r12, %rsi
callq 0x57e2b
movq %rax, %rbx
jmp 0x57b2e
movl %eax, %r12d
movq %rdx, %rbx
leaq -0xa10(%rbp), %rax
leaq -0xad0(%rbp), %rdi
movq %rax, (%rdi)
movq %r14, 0x8(%rdi)
movb $0x0, (%rax)
leaq -0xa38(%rbp), %rcx
movl %r8d, %esi
xorl %edx, %edx
callq *0xe0(%r14)
testl %eax, %eax
je 0x57aeb
movq %r13, -0xa40(%rbp)
movq %r14, %r13
movl -0xa1c(%rbp), %r14d
movl %r12d, %r12d
addq %r15, %r12
subq %rbx, %r12
leaq -0xa38(%rbp), %rcx
movq (%rcx), %rcx
movq %r15, %rbx
movq %rcx, %r15
movq -0xac0(%rbp), %rcx
movq %rcx, -0xa60(%rbp)
movl -0xab8(%rbp), %ecx
movl %ecx, -0xa58(%rbp)
movq -0xa70(%rbp), %rdi
movl %eax, %edx
leaq -0xa10(%rbp), %rsi
callq 0x29080
leaq -0xad0(%rbp), %rdi
movl %r14d, %esi
xorl %edx, %edx
leaq -0xa38(%rbp), %rcx
callq *0xe0(%r13)
testl %eax, %eax
je 0x57b0a
movq -0xa38(%rbp), %rcx
cmpq %r12, %rcx
jb 0x57a83
movq %r15, -0xa48(%rbp)
jmp 0x57b1d
movq %r13, %rdi
movl $0x7e, %esi
callq 0x3fdc4
xorl %ebx, %ebx
movq -0xa18(%rbp), %r12
movq -0xa28(%rbp), %r15
jmp 0x57b2e
movq -0xa40(%rbp), %rdi
movl $0x7e, %esi
callq 0x3fdc4
xorl %ebx, %ebx
movq -0xa18(%rbp), %r12
movq -0xa28(%rbp), %r15
movq %r13, %r14
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testq %rbx, %rbx
je 0x57e05
movq %r14, -0xa40(%rbp)
movl -0xa5c(%rbp), %r14d
addl -0xa60(%rbp), %r14d
movq 0x10(%r12), %rax
subq %rax, %rbx
movl 0x20(%r12), %r13d
movl %ebx, 0x20(%r12)
movl 0x744(%r15), %ecx
movb %bl, -0x1(%rax,%rcx)
movq 0x10(%r12), %rax
movl 0x744(%r15), %ecx
movq %rbx, -0xa90(%rbp)
movb %bh, -0x2(%rax,%rcx)
movq -0xa48(%rbp), %rsi
movq %rsi, -0xad0(%rbp)
movq -0xab0(%rbp), %r12
testq %r12, %r12
je 0x57bb8
subq %r12, %rsi
movl 0x744(%r15), %edi
addq -0xa78(%rbp), %rdi
movq %r12, %rdx
callq 0x29080
leaq -0xa80(%rbp), %rdx
movq -0xaa8(%rbp), %r15
movq %r15, %rdi
movl $0x6, %esi
callq 0x6f6f7
movq %rax, -0xaf0(%rbp)
cmpq $-0x1, %rax
je 0x57d61
movq %rax, %rbx
movq %r13, -0xa88(%rbp)
leaq -0xa70(%rbp), %rsi
movq -0xaa0(%rbp), %r13
movq %r13, %rdi
callq 0x41e84
movl %r14d, %esi
addq (%r13), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x6d38d
leaq -0xad0(%rbp), %rcx
leaq -0xa70(%rbp), %rdi
movl -0xa1c(%rbp), %esi
movl %r12d, %edx
movq -0xa40(%rbp), %r14
callq *0xe0(%r14)
testl %eax, %eax
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
je 0x57e05
leaq -0xa70(%rbp), %rdi
leaq -0xa10(%rbp), %r9
movl %r12d, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq *0xf0(%r14)
movq -0xa88(%rbp), %r13
movq -0xa18(%rbp), %rcx
addq 0x10(%rcx), %r13
movl %eax, %ebx
movq -0xad0(%rbp), %rsi
subq %rsi, %r13
movl -0xa2c(%rbp), %r12d
movq -0xa78(%rbp), %r15
addq %r15, %r12
movl %eax, %edi
addq %r12, %rdi
movl %r13d, %edx
callq 0x29080
movq %r14, %rdi
movq %r12, %rsi
leaq -0xa10(%rbp), %rdx
callq *0xf8(%r14)
addl -0xa2c(%rbp), %ebx
addl %r13d, %ebx
movq -0xa28(%rbp), %r14
movl 0x744(%r14), %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x292a0
movl -0xa1c(%rbp), %ecx
movl %ecx, -0xadc(%rbp)
movl %ebx, -0xae8(%rbp)
movl 0x744(%r14), %eax
addl $-0x3, %eax
movq %r15, %rdx
movb %cl, (%r15,%rax)
movl 0x744(%r14), %eax
movb %bl, -0x1(%r15,%rax)
movl 0x744(%r14), %eax
movl %ebx, %r12d
movb %bh, -0x2(%rdx,%rax)
movq -0xa18(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x744(%r14), %ecx
addl $-0x4, %ecx
movb (%rax,%rcx), %al
movb %al, (%r15,%rcx)
cmpb $0x0, 0x7e7(%r14)
je 0x57d6b
leaq -0xb08(%rbp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x566d4
negb %al
movl $0x0, %r15d
sbbl %r15d, %r15d
orl $0x2, %r15d
movq 0x10(%r14), %rbx
jmp 0x57d74
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x57e05
movq %r15, %rbx
movl $0x2, %r15d
movl %r12d, %edi
addq %rbx, %rdi
movq -0xa28(%rbp), %r14
movl 0x7bc(%r14), %edx
subl %r12d, %edx
xorl %esi, %esi
callq 0x292a0
movq -0xa80(%rbp), %rax
movl 0xc(%rax), %esi
leaq -0xb08(%rbp), %rdi
movl $0x3, %edx
callq 0x6f40d
negb %al
movl $0x0, %eax
sbbl %eax, %eax
orl %r15d, %eax
cmpb $0x0, 0x7e7(%r14)
je 0x57e05
movl 0x10(%rbp), %r9d
xorl %ebx, %ebx
movq -0xa18(%rbp), %rdi
movl -0xa4c(%rbp), %esi
movq -0xa90(%rbp), %rdx
movq %rax, %r14
movq -0xa98(%rbp), %rcx
movl -0xa50(%rbp), %r8d
pushq %rbx
pushq %rbx
pushq $0x0
pushq %rbx
callq 0x57f43
addq $0x20, %rsp
negb %al
sbbl %ebx, %ebx
orl %r14d, %ebx
movl %ebx, %eax
movq %fs:0x28, %rcx
cmpq -0x30(%rbp), %rcx
jne 0x57e26
addq $0xaf8, %rsp # imm = 0xAF8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x29250
|
_ma_split_page:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0AF8h
mov [rbp+var_A50], r9d
mov [rbp+var_A98], r8
mov [rbp+var_A4C], ecx
mov r12, rdx
mov rdx, rdi
mov rdi, [rbp+arg_8]
mov rax, fs:28h
mov [rbp+var_30], rax
lea rax, [rbp+var_B20]
mov [rbp+var_A80], rax
mov r15, [rdx]
mov [rbp+var_AA0], rsi
mov r14, [rsi+8]
mov word ptr [rdx+684h], 101h
mov ecx, [r12+28h]
mov r8d, [r12+2Ch]
mov eax, [r15+744h]
mov [rbp+var_AB0], rcx
add eax, ecx
mov [rbp+var_A2C], eax
mov [rbp+var_B08], rdx
mov [rbp+var_AA8], rdx
mov rax, [rdx+378h]
mov [rbp+var_A78], rax
mov [rbp+var_AF8], rax
mov [rbp+var_B00], r14
mov [rbp+var_A70], rdi
mov [rbp+var_A68], r14
cmp [rbp+arg_10], 0
mov [rbp+var_A28], r15
mov [rbp+var_A18], r12
mov [rbp+var_A1C], r8d
jz loc_57A08
mov r13, [r12]
mov rsi, [r13+0]
mov edx, [rsi+744h]
mov eax, [r12+20h]
sub eax, edx
mov r15, [r12+10h]
add r15, rdx
mov [rbp+var_A38], r15
test byte ptr [r14+0A2h], 2Eh
setz r9b
test r8b, 2
setz cl
and cl, r9b
cmp cl, 1
jnz short loc_57A26
movzx ecx, word ptr [r14+0AAh]
xor edx, edx
div ecx
add eax, 0FFFFFFFEh
imul eax, ecx
mov edx, [rsi+740h]
mov esi, ecx
sub esi, edx
mov dword ptr [rbp+var_A60], esi
mov rdx, [r13+0]
mov edx, [rdx+740h]
mov dword ptr [rbp+var_A60+4], edx
mov [rbp+var_A58], 0
add r15, rax
lea rax, [r15+rcx]
mov [rbp+var_A48], rax
mov rsi, r15
mov rdx, rcx
call _memcpy
mov rbx, r15
jmp loc_57AFA
loc_57A08:
lea rdi, [rbp+var_A70]
lea rdx, [rbp+var_A48]
mov rsi, r12
call _ma_find_half_pos
mov rbx, rax
jmp loc_57B2E
loc_57A26:
mov r12d, eax
mov rbx, rdx
lea rax, [rbp+var_A10]
lea rdi, [rbp+var_AD0]
mov [rdi], rax
mov [rdi+8], r14
mov byte ptr [rax], 0
lea rcx, [rbp+var_A38]
mov esi, r8d
xor edx, edx
call qword ptr [r14+0E0h]
test eax, eax
jz loc_57AEB
mov [rbp+var_A40], r13
mov r13, r14
mov r14d, [rbp+var_A1C]
mov r12d, r12d
add r12, r15
sub r12, rbx
lea rcx, [rbp+var_A38]
mov rcx, [rcx]
loc_57A83:
mov rbx, r15
mov r15, rcx
mov rcx, [rbp+var_AC0]
mov [rbp+var_A60], rcx
mov ecx, [rbp+var_AB8]
mov [rbp+var_A58], ecx
mov rdi, [rbp+var_A70]
mov edx, eax
lea rsi, [rbp+var_A10]
call _memcpy
lea rdi, [rbp+var_AD0]
mov esi, r14d
xor edx, edx
lea rcx, [rbp+var_A38]
call qword ptr [r13+0E0h]
test eax, eax
jz short loc_57B0A
mov rcx, [rbp+var_A38]
cmp rcx, r12
jb short loc_57A83
mov [rbp+var_A48], r15
jmp short loc_57B1D
loc_57AEB:
mov rdi, r13
mov esi, 7Eh ; '~'
call _ma_set_fatal_error
xor ebx, ebx
loc_57AFA:
mov r12, [rbp+var_A18]
mov r15, [rbp+var_A28]
jmp short loc_57B2E
loc_57B0A:
mov rdi, [rbp+var_A40]
mov esi, 7Eh ; '~'
call _ma_set_fatal_error
xor ebx, ebx
loc_57B1D:
mov r12, [rbp+var_A18]
mov r15, [rbp+var_A28]
mov r14, r13
loc_57B2E:
mov eax, 0FFFFFFFFh
test rbx, rbx
jz loc_57E05
mov [rbp+var_A40], r14
mov r14d, dword ptr [rbp+var_A60+4]
add r14d, dword ptr [rbp+var_A60]
mov rax, [r12+10h]
sub rbx, rax
mov r13d, [r12+20h]
mov [r12+20h], ebx
mov ecx, [r15+744h]
mov [rax+rcx-1], bl
mov rax, [r12+10h]
mov ecx, [r15+744h]
mov [rbp+var_A90], rbx
mov [rax+rcx-2], bh
mov rsi, [rbp+var_A48]
mov [rbp+var_AD0], rsi
mov r12, [rbp+var_AB0]
test r12, r12
jz short loc_57BB8
sub rsi, r12
mov edi, [r15+744h]
add rdi, [rbp+var_A78]
mov rdx, r12
call _memcpy
loc_57BB8:
lea rdx, [rbp+var_A80]
mov r15, [rbp+var_AA8]
mov rdi, r15
mov esi, 6
call _ma_new
mov [rbp+var_AF0], rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jz loc_57D61
mov rbx, rax
mov [rbp+var_A88], r13
lea rsi, [rbp+var_A70]
mov r13, [rbp+var_AA0]
mov rdi, r13
call _ma_copy_key
mov esi, r14d
add rsi, [r13+0]
mov rdi, r15
mov rdx, rbx
call _ma_kpointer
lea rcx, [rbp+var_AD0]
lea rdi, [rbp+var_A70]
mov esi, [rbp+var_A1C]
mov edx, r12d
mov r14, [rbp+var_A40]
call qword ptr [r14+0E0h]
test eax, eax
mov eax, 0FFFFFFFFh
jz loc_57E05
lea rdi, [rbp+var_A70]
lea r9, [rbp+var_A10]
mov esi, r12d
xor edx, edx
xor ecx, ecx
xor r8d, r8d
call qword ptr [r14+0F0h]
mov r13, [rbp+var_A88]
mov rcx, [rbp+var_A18]
add r13, [rcx+10h]
mov ebx, eax
mov rsi, [rbp+var_AD0]
sub r13, rsi
mov r12d, [rbp+var_A2C]
mov r15, [rbp+var_A78]
add r12, r15
mov edi, eax
add rdi, r12
mov edx, r13d
call _memcpy
mov rdi, r14
mov rsi, r12
lea rdx, [rbp+var_A10]
call qword ptr [r14+0F8h]
add ebx, [rbp+var_A2C]
add ebx, r13d
mov r14, [rbp+var_A28]
mov edx, [r14+744h]
mov rdi, r15
xor esi, esi
call _memset
mov ecx, [rbp+var_A1C]
mov [rbp+var_ADC], ecx
mov [rbp+var_AE8], ebx
mov eax, [r14+744h]
add eax, 0FFFFFFFDh
mov rdx, r15
mov [r15+rax], cl
mov eax, [r14+744h]
mov [r15+rax-1], bl
mov eax, [r14+744h]
mov r12d, ebx
mov [rdx+rax-2], bh
mov rax, [rbp+var_A18]
mov rax, [rax+10h]
mov ecx, [r14+744h]
add ecx, 0FFFFFFFCh
mov al, [rax+rcx]
mov [r15+rcx], al
cmp byte ptr [r14+7E7h], 0
jz short loc_57D6B
lea r14, [rbp+var_B08]
mov rdi, r14
xor esi, esi
call _ma_log_new
neg al
mov r15d, 0
sbb r15d, r15d
or r15d, 2
mov rbx, [r14+10h]
jmp short loc_57D74
loc_57D61:
mov eax, 0FFFFFFFFh
jmp loc_57E05
loc_57D6B:
mov rbx, r15
mov r15d, 2
loc_57D74:
mov edi, r12d
add rdi, rbx
mov r14, [rbp+var_A28]
mov edx, [r14+7BCh]
sub edx, r12d
xor esi, esi
call _memset
mov rax, [rbp+var_A80]
mov esi, [rax+0Ch]
lea rdi, [rbp+var_B08]
mov edx, 3
call _ma_write_keypage
neg al
mov eax, 0
sbb eax, eax
or eax, r15d
cmp byte ptr [r14+7E7h], 0
jz short loc_57E05
mov r9d, [rbp+arg_0]
xor ebx, ebx
mov rdi, [rbp+var_A18]
mov esi, [rbp+var_A4C]
mov rdx, [rbp+var_A90]
mov r14, rax
mov rcx, [rbp+var_A98]
mov r8d, [rbp+var_A50]
push rbx
push rbx
push 0
push rbx
call _ma_log_split
add rsp, 20h
neg al
sbb ebx, ebx
or ebx, r14d
mov eax, ebx
loc_57E05:
mov rcx, fs:28h
cmp rcx, [rbp+var_30]
jnz short loc_57E26
add rsp, 0AF8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_57E26:
call ___stack_chk_fail
|
long long ma_split_page(
long long a1,
long long a2,
long long **a3,
int a4,
long long a5,
int a6,
int a7,
long long a8,
char a9)
{
long long **v9; // r12
long long v10; // r15
long long v11; // r14
unsigned int v12; // r8d
int v13; // eax
long long *v14; // r13
long long v15; // rsi
long long v16; // rdx
unsigned int v17; // eax
long long v18; // r15
long long v19; // rcx
long long v20; // rax
long long v21; // r15
long long half_pos; // rbx
unsigned int v23; // r12d
long long v24; // rbx
unsigned int v25; // eax
long long v26; // rdx
long long v27; // rcx
long long v28; // r8
int v29; // r9d
long long v30; // r13
unsigned int v31; // r14d
unsigned long long v32; // r12
long long v33; // rcx
long long v34; // rdx
long long v35; // rcx
long long v36; // r8
int v37; // r9d
long long result; // rax
unsigned int v39; // r14d
long long *v40; // rax
long long v41; // rbx
long long v42; // r13
long long *v43; // rax
long long v44; // rcx
unsigned int v45; // r12d
long long v46; // r15
_QWORD *v47; // r13
long long *v48; // r14
bool v49; // zf
long long v50; // rbx
long long v51; // r13
long long v52; // r15
long long v53; // r12
long long v54; // r14
unsigned int v55; // r12d
int v56; // r15d
long long v57; // rbx
long long v58; // r14
char v59; // [rsp+0h] [rbp-B20h] BYREF
long long *v60[2]; // [rsp+18h] [rbp-B08h] BYREF
long long v61; // [rsp+28h] [rbp-AF8h]
long long v62; // [rsp+30h] [rbp-AF0h]
int v63; // [rsp+38h] [rbp-AE8h]
unsigned int v64; // [rsp+44h] [rbp-ADCh]
_QWORD v65[3]; // [rsp+50h] [rbp-AD0h] BYREF
int v66; // [rsp+68h] [rbp-AB8h]
long long v67; // [rsp+70h] [rbp-AB0h]
long long v68; // [rsp+78h] [rbp-AA8h]
_QWORD *v69; // [rsp+80h] [rbp-AA0h]
long long v70; // [rsp+88h] [rbp-A98h]
long long v71; // [rsp+90h] [rbp-A90h]
long long v72; // [rsp+98h] [rbp-A88h]
char *v73; // [rsp+A0h] [rbp-A80h] BYREF
long long v74; // [rsp+A8h] [rbp-A78h]
_QWORD v75[2]; // [rsp+B0h] [rbp-A70h] BYREF
long long v76; // [rsp+C0h] [rbp-A60h]
int v77; // [rsp+C8h] [rbp-A58h]
int v78; // [rsp+D0h] [rbp-A50h]
int v79; // [rsp+D4h] [rbp-A4Ch]
long long v80; // [rsp+D8h] [rbp-A48h] BYREF
long long *v81; // [rsp+E0h] [rbp-A40h]
unsigned long long v82; // [rsp+E8h] [rbp-A38h] BYREF
unsigned int v83; // [rsp+F4h] [rbp-A2Ch]
long long v84; // [rsp+F8h] [rbp-A28h]
unsigned int v85; // [rsp+104h] [rbp-A1Ch]
long long **v86; // [rsp+108h] [rbp-A18h]
_BYTE v87[2528]; // [rsp+110h] [rbp-A10h] BYREF
unsigned long long v88; // [rsp+AF0h] [rbp-30h]
v78 = a6;
v70 = a5;
v79 = a4;
v9 = a3;
v88 = __readfsqword(0x28u);
v73 = &v59;
v10 = *(_QWORD *)a1;
v69 = (_QWORD *)a2;
v11 = *(_QWORD *)(a2 + 8);
*(_WORD *)(a1 + 1668) = 257;
v12 = *((_DWORD *)a3 + 11);
v13 = *(_DWORD *)(v10 + 1860);
v67 = *((unsigned int *)a3 + 10);
v83 = v67 + v13;
v60[0] = (long long *)a1;
v68 = a1;
v74 = *(_QWORD *)(a1 + 888);
v61 = v74;
v60[1] = (long long *)v11;
v75[0] = a8;
v75[1] = v11;
v84 = v10;
v86 = a3;
v85 = v12;
if ( !a9 )
{
half_pos = ma_find_half_pos(v75, a3, &v80);
goto LABEL_14;
}
v14 = *a3;
v15 = **a3;
v16 = *(unsigned int *)(v15 + 1860);
v17 = *((_DWORD *)v9 + 8) - v16;
v18 = (long long)v9[2] + v16;
v82 = v18;
if ( (*(_BYTE *)(v11 + 162) & 0x2E) == 0 && (v12 & 2) == 0 )
{
v19 = *(unsigned __int16 *)(v11 + 170);
v20 = (unsigned int)v19 * (v17 / *(unsigned __int16 *)(v11 + 170) - 2);
LODWORD(v76) = *(unsigned __int16 *)(v11 + 170) - *(_DWORD *)(v15 + 1856);
HIDWORD(v76) = *(_DWORD *)(*v14 + 1856);
v77 = 0;
v21 = v20 + v18;
v80 = v21 + v19;
memcpy(a8, v21, v19);
half_pos = v21;
LABEL_11:
v9 = v86;
v10 = v84;
goto LABEL_14;
}
v23 = v17;
v24 = v16;
v65[0] = v87;
v65[1] = v11;
v87[0] = 0;
v25 = (*(long long ( **)(_QWORD *, _QWORD, _QWORD, unsigned long long *))(v11 + 224))(v65, v12, 0LL, &v82);
if ( !v25 )
{
ma_set_fatal_error(v14, 126, v26, v27, v28, v29);
half_pos = 0LL;
goto LABEL_11;
}
v81 = v14;
v30 = v11;
v31 = v85;
v32 = v18 + v23 - v24;
v33 = v82;
while ( 1 )
{
half_pos = v18;
v18 = v33;
v76 = v65[2];
v77 = v66;
memcpy(v75[0], v87, v25);
v25 = (*(long long ( **)(_QWORD *, _QWORD, _QWORD, unsigned long long *))(v30 + 224))(v65, v31, 0LL, &v82);
if ( !v25 )
break;
v33 = v82;
if ( v82 >= v32 )
{
v80 = v18;
goto LABEL_13;
}
}
ma_set_fatal_error(v81, 126, v34, v35, v36, v37);
half_pos = 0LL;
LABEL_13:
v9 = v86;
v10 = v84;
v11 = v30;
LABEL_14:
result = 0xFFFFFFFFLL;
if ( half_pos )
{
v81 = (long long *)v11;
v39 = v76 + HIDWORD(v76);
v40 = v9[2];
v41 = half_pos - (_QWORD)v40;
v42 = *((unsigned int *)v9 + 8);
*((_DWORD *)v9 + 8) = v41;
*((_BYTE *)v40 + *(unsigned int *)(v10 + 1860) - 1) = v41;
v43 = v9[2];
v44 = *(unsigned int *)(v10 + 1860);
v71 = v41;
*((_BYTE *)v43 + v44 - 2) = BYTE1(v41);
v65[0] = v80;
v45 = v67;
if ( v67 )
memcpy(v74 + *(unsigned int *)(v10 + 1860), v80 - v67, v67);
v46 = v68;
v62 = ma_new(v68, 6LL, &v73);
if ( v62 == -1 )
{
return 0xFFFFFFFFLL;
}
else
{
v72 = v42;
v47 = v69;
ma_copy_key((long long)v69, (long long)v75);
ma_kpointer(v46, *v47 + v39);
v48 = v81;
v49 = ((unsigned int ( *)(_QWORD *, _QWORD, _QWORD, _QWORD *))v81[28])(v75, v85, v45, v65) == 0;
result = 0xFFFFFFFFLL;
if ( !v49 )
{
v50 = ((unsigned int ( *)(_QWORD *, _QWORD, _QWORD, _QWORD, _QWORD, _BYTE *))v48[30])(
v75,
v45,
0LL,
0LL,
0LL,
v87);
v51 = (long long)v86[2] + v72 - v65[0];
v52 = v74;
v53 = v74 + v83;
memcpy(v53 + v50, v65[0], (unsigned int)(*((_DWORD *)v86 + 4) + v72 - LODWORD(v65[0])));
((void ( *)(long long *, long long, _BYTE *))v48[31])(v48, v53, v87);
LODWORD(v50) = v51 + v83 + v50;
v54 = v84;
memset(v52, 0LL, *(unsigned int *)(v84 + 1860));
v64 = v85;
v63 = v50;
*(_BYTE *)(v52 + (unsigned int)(*(_DWORD *)(v54 + 1860) - 3)) = v85;
*(_BYTE *)(v52 + *(unsigned int *)(v54 + 1860) - 1) = v50;
v55 = v50;
*(_BYTE *)(v52 + *(unsigned int *)(v54 + 1860) - 2) = BYTE1(v50);
*(_BYTE *)(v52 + (unsigned int)(*(_DWORD *)(v54 + 1860) - 4)) = *((_BYTE *)v86[2]
+ (unsigned int)(*(_DWORD *)(v54 + 1860) - 4));
if ( *(_BYTE *)(v54 + 2023) )
{
v56 = ma_log_new(v60, 0) ? -1 : 2;
v57 = v61;
}
else
{
v57 = v52;
v56 = 2;
}
v58 = v84;
memset(v57 + v55, 0LL, *(_DWORD *)(v84 + 1980) - v55);
result = v56 | (unsigned int)-((unsigned __int8)ma_write_keypage(v60, *((unsigned int *)v73 + 3), 3LL) != 0);
if ( *(_BYTE *)(v58 + 2023) )
return (unsigned __int8)ma_log_split((_DWORD)v86, v79, v71, v70, v78, a7, 0, 0LL, 0, 0) != 0
? -1
: (unsigned int)result;
}
}
}
return result;
}
|
_ma_split_page:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xaf8
MOV dword ptr [RBP + -0xa50],R9D
MOV qword ptr [RBP + -0xa98],R8
MOV dword ptr [RBP + -0xa4c],ECX
MOV R12,RDX
MOV RDX,RDI
MOV RDI,qword ptr [RBP + 0x18]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
LEA RAX,[RBP + -0xb20]
MOV qword ptr [RBP + -0xa80],RAX
MOV R15,qword ptr [RDX]
MOV qword ptr [RBP + -0xaa0],RSI
MOV R14,qword ptr [RSI + 0x8]
MOV word ptr [RDX + 0x684],0x101
MOV ECX,dword ptr [R12 + 0x28]
MOV R8D,dword ptr [R12 + 0x2c]
MOV EAX,dword ptr [R15 + 0x744]
MOV qword ptr [RBP + -0xab0],RCX
ADD EAX,ECX
MOV dword ptr [RBP + -0xa2c],EAX
MOV qword ptr [RBP + -0xb08],RDX
MOV qword ptr [RBP + -0xaa8],RDX
MOV RAX,qword ptr [RDX + 0x378]
MOV qword ptr [RBP + -0xa78],RAX
MOV qword ptr [RBP + -0xaf8],RAX
MOV qword ptr [RBP + -0xb00],R14
MOV qword ptr [RBP + -0xa70],RDI
MOV qword ptr [RBP + -0xa68],R14
CMP byte ptr [RBP + 0x20],0x0
MOV qword ptr [RBP + -0xa28],R15
MOV qword ptr [RBP + -0xa18],R12
MOV dword ptr [RBP + -0xa1c],R8D
JZ 0x00157a08
MOV R13,qword ptr [R12]
MOV RSI,qword ptr [R13]
MOV EDX,dword ptr [RSI + 0x744]
MOV EAX,dword ptr [R12 + 0x20]
SUB EAX,EDX
MOV R15,qword ptr [R12 + 0x10]
ADD R15,RDX
MOV qword ptr [RBP + -0xa38],R15
TEST byte ptr [R14 + 0xa2],0x2e
SETZ R9B
TEST R8B,0x2
SETZ CL
AND CL,R9B
CMP CL,0x1
JNZ 0x00157a26
MOVZX ECX,word ptr [R14 + 0xaa]
XOR EDX,EDX
DIV ECX
ADD EAX,-0x2
IMUL EAX,ECX
MOV EDX,dword ptr [RSI + 0x740]
MOV ESI,ECX
SUB ESI,EDX
MOV dword ptr [RBP + -0xa60],ESI
MOV RDX,qword ptr [R13]
MOV EDX,dword ptr [RDX + 0x740]
MOV dword ptr [RBP + -0xa5c],EDX
MOV dword ptr [RBP + -0xa58],0x0
ADD R15,RAX
LEA RAX,[R15 + RCX*0x1]
MOV qword ptr [RBP + -0xa48],RAX
MOV RSI,R15
MOV RDX,RCX
CALL 0x00129080
MOV RBX,R15
JMP 0x00157afa
LAB_00157a08:
LEA RDI,[RBP + -0xa70]
LEA RDX,[RBP + -0xa48]
MOV RSI,R12
CALL 0x00157e2b
MOV RBX,RAX
JMP 0x00157b2e
LAB_00157a26:
MOV R12D,EAX
MOV RBX,RDX
LEA RAX,[RBP + -0xa10]
LEA RDI,[RBP + -0xad0]
MOV qword ptr [RDI],RAX
MOV qword ptr [RDI + 0x8],R14
MOV byte ptr [RAX],0x0
LEA RCX,[RBP + -0xa38]
MOV ESI,R8D
XOR EDX,EDX
CALL qword ptr [R14 + 0xe0]
TEST EAX,EAX
JZ 0x00157aeb
MOV qword ptr [RBP + -0xa40],R13
MOV R13,R14
MOV R14D,dword ptr [RBP + -0xa1c]
MOV R12D,R12D
ADD R12,R15
SUB R12,RBX
LEA RCX,[RBP + -0xa38]
MOV RCX,qword ptr [RCX]
LAB_00157a83:
MOV RBX,R15
MOV R15,RCX
MOV RCX,qword ptr [RBP + -0xac0]
MOV qword ptr [RBP + -0xa60],RCX
MOV ECX,dword ptr [RBP + -0xab8]
MOV dword ptr [RBP + -0xa58],ECX
MOV RDI,qword ptr [RBP + -0xa70]
MOV EDX,EAX
LEA RSI,[RBP + -0xa10]
CALL 0x00129080
LEA RDI,[RBP + -0xad0]
MOV ESI,R14D
XOR EDX,EDX
LEA RCX,[RBP + -0xa38]
CALL qword ptr [R13 + 0xe0]
TEST EAX,EAX
JZ 0x00157b0a
MOV RCX,qword ptr [RBP + -0xa38]
CMP RCX,R12
JC 0x00157a83
MOV qword ptr [RBP + -0xa48],R15
JMP 0x00157b1d
LAB_00157aeb:
MOV RDI,R13
MOV ESI,0x7e
CALL 0x0013fdc4
XOR EBX,EBX
LAB_00157afa:
MOV R12,qword ptr [RBP + -0xa18]
MOV R15,qword ptr [RBP + -0xa28]
JMP 0x00157b2e
LAB_00157b0a:
MOV RDI,qword ptr [RBP + -0xa40]
MOV ESI,0x7e
CALL 0x0013fdc4
XOR EBX,EBX
LAB_00157b1d:
MOV R12,qword ptr [RBP + -0xa18]
MOV R15,qword ptr [RBP + -0xa28]
MOV R14,R13
LAB_00157b2e:
MOV EAX,0xffffffff
TEST RBX,RBX
JZ 0x00157e05
MOV qword ptr [RBP + -0xa40],R14
MOV R14D,dword ptr [RBP + -0xa5c]
ADD R14D,dword ptr [RBP + -0xa60]
MOV RAX,qword ptr [R12 + 0x10]
SUB RBX,RAX
MOV R13D,dword ptr [R12 + 0x20]
MOV dword ptr [R12 + 0x20],EBX
MOV ECX,dword ptr [R15 + 0x744]
MOV byte ptr [RAX + RCX*0x1 + -0x1],BL
MOV RAX,qword ptr [R12 + 0x10]
MOV ECX,dword ptr [R15 + 0x744]
MOV qword ptr [RBP + -0xa90],RBX
MOV byte ptr [RAX + RCX*0x1 + -0x2],BH
MOV RSI,qword ptr [RBP + -0xa48]
MOV qword ptr [RBP + -0xad0],RSI
MOV R12,qword ptr [RBP + -0xab0]
TEST R12,R12
JZ 0x00157bb8
SUB RSI,R12
MOV EDI,dword ptr [R15 + 0x744]
ADD RDI,qword ptr [RBP + -0xa78]
MOV RDX,R12
CALL 0x00129080
LAB_00157bb8:
LEA RDX,[RBP + -0xa80]
MOV R15,qword ptr [RBP + -0xaa8]
MOV RDI,R15
MOV ESI,0x6
CALL 0x0016f6f7
MOV qword ptr [RBP + -0xaf0],RAX
CMP RAX,-0x1
JZ 0x00157d61
MOV RBX,RAX
MOV qword ptr [RBP + -0xa88],R13
LEA RSI,[RBP + -0xa70]
MOV R13,qword ptr [RBP + -0xaa0]
MOV RDI,R13
CALL 0x00141e84
MOV ESI,R14D
ADD RSI,qword ptr [R13]
MOV RDI,R15
MOV RDX,RBX
CALL 0x0016d38d
LEA RCX,[RBP + -0xad0]
LEA RDI,[RBP + -0xa70]
MOV ESI,dword ptr [RBP + -0xa1c]
MOV EDX,R12D
MOV R14,qword ptr [RBP + -0xa40]
CALL qword ptr [R14 + 0xe0]
TEST EAX,EAX
MOV EAX,0xffffffff
JZ 0x00157e05
LEA RDI,[RBP + -0xa70]
LEA R9,[RBP + -0xa10]
MOV ESI,R12D
XOR EDX,EDX
XOR ECX,ECX
XOR R8D,R8D
CALL qword ptr [R14 + 0xf0]
MOV R13,qword ptr [RBP + -0xa88]
MOV RCX,qword ptr [RBP + -0xa18]
ADD R13,qword ptr [RCX + 0x10]
MOV EBX,EAX
MOV RSI,qword ptr [RBP + -0xad0]
SUB R13,RSI
MOV R12D,dword ptr [RBP + -0xa2c]
MOV R15,qword ptr [RBP + -0xa78]
ADD R12,R15
MOV EDI,EAX
ADD RDI,R12
MOV EDX,R13D
CALL 0x00129080
MOV RDI,R14
MOV RSI,R12
LEA RDX,[RBP + -0xa10]
CALL qword ptr [R14 + 0xf8]
ADD EBX,dword ptr [RBP + -0xa2c]
ADD EBX,R13D
MOV R14,qword ptr [RBP + -0xa28]
MOV EDX,dword ptr [R14 + 0x744]
MOV RDI,R15
XOR ESI,ESI
CALL 0x001292a0
MOV ECX,dword ptr [RBP + -0xa1c]
MOV dword ptr [RBP + -0xadc],ECX
MOV dword ptr [RBP + -0xae8],EBX
MOV EAX,dword ptr [R14 + 0x744]
ADD EAX,-0x3
MOV RDX,R15
MOV byte ptr [R15 + RAX*0x1],CL
MOV EAX,dword ptr [R14 + 0x744]
MOV byte ptr [R15 + RAX*0x1 + -0x1],BL
MOV EAX,dword ptr [R14 + 0x744]
MOV R12D,EBX
MOV byte ptr [RDX + RAX*0x1 + -0x2],BH
MOV RAX,qword ptr [RBP + -0xa18]
MOV RAX,qword ptr [RAX + 0x10]
MOV ECX,dword ptr [R14 + 0x744]
ADD ECX,-0x4
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [R15 + RCX*0x1],AL
CMP byte ptr [R14 + 0x7e7],0x0
JZ 0x00157d6b
LEA R14,[RBP + -0xb08]
MOV RDI,R14
XOR ESI,ESI
CALL 0x001566d4
NEG AL
MOV R15D,0x0
SBB R15D,R15D
OR R15D,0x2
MOV RBX,qword ptr [R14 + 0x10]
JMP 0x00157d74
LAB_00157d61:
MOV EAX,0xffffffff
JMP 0x00157e05
LAB_00157d6b:
MOV RBX,R15
MOV R15D,0x2
LAB_00157d74:
MOV EDI,R12D
ADD RDI,RBX
MOV R14,qword ptr [RBP + -0xa28]
MOV EDX,dword ptr [R14 + 0x7bc]
SUB EDX,R12D
XOR ESI,ESI
CALL 0x001292a0
MOV RAX,qword ptr [RBP + -0xa80]
MOV ESI,dword ptr [RAX + 0xc]
LEA RDI,[RBP + -0xb08]
MOV EDX,0x3
CALL 0x0016f40d
NEG AL
MOV EAX,0x0
SBB EAX,EAX
OR EAX,R15D
CMP byte ptr [R14 + 0x7e7],0x0
JZ 0x00157e05
MOV R9D,dword ptr [RBP + 0x10]
XOR EBX,EBX
MOV RDI,qword ptr [RBP + -0xa18]
MOV ESI,dword ptr [RBP + -0xa4c]
MOV RDX,qword ptr [RBP + -0xa90]
MOV R14,RAX
MOV RCX,qword ptr [RBP + -0xa98]
MOV R8D,dword ptr [RBP + -0xa50]
PUSH RBX
PUSH RBX
PUSH 0x0
PUSH RBX
CALL 0x00157f43
ADD RSP,0x20
NEG AL
SBB EBX,EBX
OR EBX,R14D
MOV EAX,EBX
LAB_00157e05:
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x30]
JNZ 0x00157e26
ADD RSP,0xaf8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00157e26:
CALL 0x00129250
|
uint _ma_split_page(long *param_1,long *param_2,long *param_3,int4 param_4,int8 param_5,
int4 param_6,int4 param_7,void *param_8,char param_9)
{
ushort uVar1;
long *plVar2;
long *plVar3;
uint uVar4;
int1 *puVar5;
char cVar6;
uint uVar7;
uint uVar8;
int iVar9;
uint uVar10;
long lVar11;
void *__s;
ulong uVar12;
int1 *puVar13;
int1 *__src;
long in_FS_OFFSET;
int1 local_b28 [24];
long *local_b10;
long *local_b08;
void *local_b00;
long local_af8;
uint local_af0;
uint local_ae4;
int1 *local_ad8;
long *local_ad0;
int8 local_ac8;
int4 local_ac0;
ulong local_ab8;
long *local_ab0;
long *local_aa8;
int8 local_aa0;
long local_a98;
ulong local_a90;
int1 *local_a88;
void *local_a80;
void *local_a78;
long *local_a70;
int8 local_a68;
int4 local_a60;
int4 local_a58;
int4 local_a54;
int1 *local_a50;
long *local_a48;
int1 *local_a40;
uint local_a34;
long local_a30;
uint local_a24;
long *local_a20;
int1 local_a18 [2528];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
local_a88 = local_b28;
lVar11 = *param_1;
plVar2 = (long *)param_2[1];
*(int2 *)((long)param_1 + 0x684) = 0x101;
local_ab8 = (ulong)*(uint *)(param_3 + 5);
local_a24 = *(uint *)((long)param_3 + 0x2c);
local_a34 = *(int *)(lVar11 + 0x744) + *(uint *)(param_3 + 5);
local_b00 = (void *)param_1[0x6f];
local_a78 = param_8;
local_b10 = param_1;
local_b08 = plVar2;
local_ab0 = param_1;
local_aa8 = param_2;
local_aa0 = param_5;
local_a80 = local_b00;
local_a70 = plVar2;
local_a58 = param_6;
local_a54 = param_4;
local_a30 = lVar11;
local_a20 = param_3;
if (param_9 == '\0') {
__src = (int1 *)_ma_find_half_pos(&local_a78,param_3,&local_a50);
}
else {
plVar3 = (long *)*param_3;
uVar10 = *(uint *)(*plVar3 + 0x744);
uVar7 = (int)param_3[4] - uVar10;
puVar13 = (int1 *)(param_3[2] + (ulong)uVar10);
local_a40 = puVar13;
if ((local_a24 & 2) == 0 && (*(byte *)((long)plVar2 + 0xa2) & 0x2e) == 0) {
uVar1 = *(ushort *)((long)plVar2 + 0xaa);
local_a68 = CONCAT44(*(int4 *)(*plVar3 + 0x740),(uint)uVar1 - *(int *)(*plVar3 + 0x740))
;
local_a60 = 0;
__src = puVar13 + (uVar7 / uVar1 - 2) * (uint)uVar1;
local_a50 = __src + uVar1;
memcpy(param_8,__src,(ulong)uVar1);
param_3 = local_a20;
lVar11 = local_a30;
}
else {
local_ad8 = local_a18;
local_a18[0] = 0;
local_ad0 = plVar2;
uVar8 = (*(code *)plVar2[0x1c])(&local_ad8,local_a24,0,&local_a40);
uVar4 = local_a24;
if (uVar8 == 0) {
_ma_set_fatal_error(plVar3,0x7e);
__src = (int1 *)0x0;
param_3 = local_a20;
lVar11 = local_a30;
}
else {
puVar5 = puVar13;
local_a48 = plVar3;
do {
__src = puVar5;
puVar5 = local_a40;
local_a68 = local_ac8;
local_a60 = local_ac0;
memcpy(local_a78,local_a18,(ulong)uVar8);
uVar8 = (*(code *)plVar2[0x1c])(&local_ad8,uVar4,0,&local_a40);
if (uVar8 == 0) {
_ma_set_fatal_error(local_a48,0x7e);
__src = (int1 *)0x0;
param_3 = local_a20;
lVar11 = local_a30;
goto LAB_00157b2e;
}
} while (local_a40 < puVar13 + ((ulong)uVar7 - (ulong)uVar10));
local_a50 = puVar5;
param_3 = local_a20;
lVar11 = local_a30;
}
}
}
LAB_00157b2e:
uVar12 = local_ab8;
uVar10 = 0xffffffff;
if (__src != (int1 *)0x0) {
uVar7 = local_a68._4_4_ + (int)local_a68;
local_a98 = (long)__src - param_3[2];
uVar10 = *(uint *)(param_3 + 4);
*(int *)(param_3 + 4) = (int)local_a98;
*(char *)(param_3[2] + -1 + (ulong)*(uint *)(lVar11 + 0x744)) = (char)local_a98;
*(char *)(param_3[2] + -2 + (ulong)*(uint *)(lVar11 + 0x744)) = (char)((ulong)local_a98 >> 8);
local_ad8 = local_a50;
local_a48 = plVar2;
if (local_ab8 != 0) {
memcpy((void *)((ulong)*(uint *)(lVar11 + 0x744) + (long)local_a80),local_a50 + -local_ab8,
local_ab8);
}
plVar2 = local_ab0;
lVar11 = _ma_new(local_ab0,6,&local_a88);
plVar3 = local_aa8;
local_af8 = lVar11;
if (lVar11 == -1) {
uVar10 = 0xffffffff;
}
else {
local_a90 = (ulong)uVar10;
_ma_copy_key(local_aa8,&local_a78);
_ma_kpointer(plVar2,(ulong)uVar7 + *plVar3,lVar11);
plVar2 = local_a48;
iVar9 = (*(code *)local_a48[0x1c])(&local_a78,local_a24,uVar12 & 0xffffffff,&local_ad8);
uVar10 = 0xffffffff;
if (iVar9 != 0) {
uVar10 = (*(code *)plVar2[0x1e])(&local_a78,uVar12 & 0xffffffff,0,0,0,local_a18);
__s = local_a80;
uVar12 = (local_a90 + local_a20[2]) - (long)local_ad8;
lVar11 = (ulong)local_a34 + (long)local_a80;
memcpy((void *)((ulong)uVar10 + lVar11),local_ad8,uVar12 & 0xffffffff);
(*(code *)plVar2[0x1f])(plVar2,lVar11,local_a18);
lVar11 = local_a30;
uVar7 = uVar10 + local_a34 + (int)uVar12;
memset(__s,0,(ulong)*(uint *)(local_a30 + 0x744));
local_ae4 = local_a24;
*(char *)((long)__s + (ulong)(*(int *)(lVar11 + 0x744) - 3)) = (char)local_a24;
*(char *)((long)__s + ((ulong)*(uint *)(lVar11 + 0x744) - 1)) = (char)uVar7;
*(char *)((long)__s + ((ulong)*(uint *)(lVar11 + 0x744) - 2)) = (char)(uVar7 >> 8);
uVar12 = (ulong)(*(int *)(lVar11 + 0x744) - 4);
*(int1 *)((long)__s + uVar12) = *(int1 *)(local_a20[2] + uVar12);
local_af0 = uVar7;
if (*(char *)(lVar11 + 0x7e7) == '\0') {
uVar10 = 2;
}
else {
cVar6 = _ma_log_new(&local_b10);
uVar10 = -(uint)(cVar6 != '\0') | 2;
__s = local_b00;
}
lVar11 = local_a30;
memset((void *)((ulong)uVar7 + (long)__s),0,(ulong)(*(int *)(local_a30 + 0x7bc) - uVar7));
cVar6 = _ma_write_keypage(&local_b10,*(int4 *)(local_a88 + 0xc),3);
uVar10 = -(uint)(cVar6 != '\0') | uVar10;
if (*(char *)(lVar11 + 0x7e7) != '\0') {
cVar6 = _ma_log_split(local_a20,local_a54,local_a98,local_aa0,local_a58,param_7,0,0,0,0);
uVar10 = -(uint)(cVar6 != '\0') | uVar10;
}
}
}
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar10;
}
|
|
66,001 |
BeginDrawing
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rcore.c
|
void BeginDrawing(void)
{
// WARNING: Previously to BeginDrawing() other render textures drawing could happen,
// consequently the measure for update vs draw is not accurate (only the total frame time is accurate)
CORE.Time.current = GetTime(); // Number of elapsed seconds since InitTimer()
CORE.Time.update = CORE.Time.current - CORE.Time.previous;
CORE.Time.previous = CORE.Time.current;
rlLoadIdentity(); // Reset current matrix (modelview)
rlMultMatrixf(MatrixToFloat(CORE.Window.screenScale)); // Apply screen scaling
//rlTranslatef(0.375, 0.375, 0); // HACK to have 2D pixel-perfect drawing on OpenGL 1.1
// NOTE: Not required with OpenGL 3.3+
}
|
O0
|
c
|
BeginDrawing:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
callq 0xca7a0
movsd %xmm0, 0x14e808(%rip) # 0x21b720
movsd 0x14e800(%rip), %xmm0 # 0x21b720
subsd 0x14e800(%rip), %xmm0 # 0x21b728
movsd %xmm0, 0x14e800(%rip) # 0x21b730
movsd 0x14e7e8(%rip), %xmm0 # 0x21b720
movsd %xmm0, 0x14e7e8(%rip) # 0x21b728
callq 0xaf640
leaq -0x80(%rbp), %rdi
leaq 0x14dd30(%rip), %rsi # 0x21ac80
addq $0x64, %rsi
movl $0x40, %edx
callq 0xa400
movups -0x80(%rbp), %xmm0
movups -0x70(%rbp), %xmm1
movups -0x60(%rbp), %xmm2
movups -0x50(%rbp), %xmm3
movq %rsp, %rax
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0x40(%rbp), %rdi
callq 0xc0120
leaq -0x40(%rbp), %rdi
callq 0xb0130
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
BeginDrawing:
push rbp
mov rbp, rsp
sub rsp, 0C0h
call GetTime
movsd cs:qword_21B720, xmm0
movsd xmm0, cs:qword_21B720
subsd xmm0, cs:qword_21B728
movsd cs:qword_21B730, xmm0
movsd xmm0, cs:qword_21B720
movsd cs:qword_21B728, xmm0
call rlLoadIdentity
lea rdi, [rbp+var_80]
lea rsi, CORE
add rsi, 64h ; 'd'
mov edx, 40h ; '@'
call _memcpy
movups xmm0, [rbp+var_80]
movups xmm1, [rbp+var_70]
movups xmm2, [rbp+var_60]
movups xmm3, [rbp+var_50]
mov rax, rsp
movups xmmword ptr [rax+30h], xmm3
movups xmmword ptr [rax+20h], xmm2
movups xmmword ptr [rax+10h], xmm1
movups xmmword ptr [rax], xmm0
lea rdi, [rbp+var_40]
call MatrixToFloatV
lea rdi, [rbp+var_40]
call rlMultMatrixf
add rsp, 0C0h
pop rbp
retn
|
long long BeginDrawing(double a1, double a2, double a3, double a4, double a5, double a6, double a7, double a8)
{
double v8; // xmm0_8
double v9; // xmm1_8
double v10; // xmm2_8
double v11; // xmm3_8
long long v12; // rdx
long long v13; // rcx
long long v14; // r8
long long v15; // r9
double v16; // xmm4_8
double v17; // xmm5_8
long long v19[2]; // [rsp+40h] [rbp-80h] BYREF
double v20; // [rsp+50h] [rbp-70h]
long long v21; // [rsp+58h] [rbp-68h]
double v22; // [rsp+60h] [rbp-60h]
long long v23; // [rsp+68h] [rbp-58h]
double v24; // [rsp+70h] [rbp-50h]
long long v25; // [rsp+78h] [rbp-48h]
_DWORD v26[16]; // [rsp+80h] [rbp-40h] BYREF
GetTime();
qword_21B720 = *(_QWORD *)&a1;
*(double *)&qword_21B730 = a1 - *(double *)&qword_21B728;
qword_21B728 = *(_QWORD *)&a1;
rlLoadIdentity();
memcpy(v19, (char *)&CORE[12] + 4, 64LL);
v8 = *(double *)v19;
v9 = v20;
v10 = v22;
v11 = v24;
MatrixToFloatV(
v26,
(long long)&CORE[12] + 4,
v12,
v13,
v14,
v15,
v19[0],
v19[1],
*(long long *)&v20,
v21,
*(long long *)&v22,
v23,
*(long long *)&v24,
v25);
return rlMultMatrixf(v26, v8, v9, v10, v11, v16, v17, a7, a8);
}
|
BeginDrawing:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xc0
CALL 0x001ca7a0
MOVSD qword ptr [0x0031b720],XMM0
MOVSD XMM0,qword ptr [0x0031b720]
SUBSD XMM0,qword ptr [0x0031b728]
MOVSD qword ptr [0x0031b730],XMM0
MOVSD XMM0,qword ptr [0x0031b720]
MOVSD qword ptr [0x0031b728],XMM0
CALL 0x001af640
LEA RDI,[RBP + -0x80]
LEA RSI,[0x31ac80]
ADD RSI,0x64
MOV EDX,0x40
CALL 0x0010a400
MOVUPS XMM0,xmmword ptr [RBP + -0x80]
MOVUPS XMM1,xmmword ptr [RBP + -0x70]
MOVUPS XMM2,xmmword ptr [RBP + -0x60]
MOVUPS XMM3,xmmword ptr [RBP + -0x50]
MOV RAX,RSP
MOVUPS xmmword ptr [RAX + 0x30],XMM3
MOVUPS xmmword ptr [RAX + 0x20],XMM2
MOVUPS xmmword ptr [RAX + 0x10],XMM1
MOVUPS xmmword ptr [RAX],XMM0
LEA RDI,[RBP + -0x40]
CALL 0x001c0120
LEA RDI,[RBP + -0x40]
CALL 0x001b0130
ADD RSP,0xc0
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void BeginDrawing(void)
{
int1 local_88 [64];
int1 local_48 [64];
DAT_0031b720 = (double)GetTime();
DAT_0031b730 = DAT_0031b720 - _DAT_0031b728;
_DAT_0031b728 = DAT_0031b720;
rlLoadIdentity();
memcpy(local_88,&DAT_0031ace4,0x40);
MatrixToFloatV(local_48);
rlMultMatrixf(local_48);
return;
}
|
|
66,002 |
BeginDrawing
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rcore.c
|
void BeginDrawing(void)
{
// WARNING: Previously to BeginDrawing() other render textures drawing could happen,
// consequently the measure for update vs draw is not accurate (only the total frame time is accurate)
CORE.Time.current = GetTime(); // Number of elapsed seconds since InitTimer()
CORE.Time.update = CORE.Time.current - CORE.Time.previous;
CORE.Time.previous = CORE.Time.current;
rlLoadIdentity(); // Reset current matrix (modelview)
rlMultMatrixf(MatrixToFloat(CORE.Window.screenScale)); // Apply screen scaling
//rlTranslatef(0.375, 0.375, 0); // HACK to have 2D pixel-perfect drawing on OpenGL 1.1
// NOTE: Not required with OpenGL 3.3+
}
|
O2
|
c
|
BeginDrawing:
subq $0x48, %rsp
callq 0xa58ec
movsd %xmm0, 0xc7efd(%rip) # 0x128680
movapd %xmm0, %xmm1
subsd 0xc7ef9(%rip), %xmm1 # 0x128688
movsd %xmm1, 0xc7ef9(%rip) # 0x128690
movsd %xmm0, 0xc7ee9(%rip) # 0x128688
callq 0x50688
movss 0xc7498(%rip), %xmm0 # 0x127c44
movss 0xc7494(%rip), %xmm1 # 0x127c48
movss 0xc7490(%rip), %xmm2 # 0x127c4c
movss 0xc748c(%rip), %xmm3 # 0x127c50
movss 0xc7488(%rip), %xmm4 # 0x127c54
movss 0xc7484(%rip), %xmm5 # 0x127c58
movss 0xc7480(%rip), %xmm6 # 0x127c5c
movss 0xc747c(%rip), %xmm7 # 0x127c60
movss 0xc7477(%rip), %xmm8 # 0x127c64
movss 0xc7472(%rip), %xmm9 # 0x127c68
movss 0xc746d(%rip), %xmm10 # 0x127c6c
movss 0xc7468(%rip), %xmm11 # 0x127c70
movss 0xc7463(%rip), %xmm12 # 0x127c74
movss 0xc745e(%rip), %xmm13 # 0x127c78
movss 0xc7459(%rip), %xmm14 # 0x127c7c
movss 0xc7454(%rip), %xmm15 # 0x127c80
leaq 0x8(%rsp), %rdi
movss %xmm0, (%rdi)
movss %xmm4, 0x4(%rdi)
movss %xmm8, 0x8(%rdi)
movss %xmm12, 0xc(%rdi)
movss %xmm1, 0x10(%rdi)
movss %xmm5, 0x14(%rdi)
movss %xmm9, 0x18(%rdi)
movss %xmm13, 0x1c(%rdi)
movss %xmm2, 0x20(%rdi)
movss %xmm6, 0x24(%rdi)
movss %xmm10, 0x28(%rdi)
movss %xmm14, 0x2c(%rdi)
movss %xmm3, 0x30(%rdi)
movss %xmm7, 0x34(%rdi)
movss %xmm11, 0x38(%rdi)
movss %xmm15, 0x3c(%rdi)
callq 0x50d0c
addq $0x48, %rsp
retq
|
BeginDrawing:
sub rsp, 48h
call glfwGetTime
movsd cs:qword_128680, xmm0
movapd xmm1, xmm0
subsd xmm1, cs:qword_128688
movsd cs:qword_128690, xmm1
movsd cs:qword_128688, xmm0
call rlLoadIdentity
movss xmm0, cs:dword_127C44
movss xmm1, dword ptr cs:xmmword_127C48
movss xmm2, dword ptr cs:xmmword_127C48+4
movss xmm3, dword ptr cs:xmmword_127C48+8
movss xmm4, dword ptr cs:xmmword_127C48+0Ch
movss xmm5, cs:dword_127C58
movss xmm6, dword ptr cs:xmmword_127C5C
movss xmm7, dword ptr cs:xmmword_127C5C+4
movss xmm8, dword ptr cs:xmmword_127C5C+8
movss xmm9, dword ptr cs:xmmword_127C5C+0Ch
movss xmm10, cs:dword_127C6C
movss xmm11, dword ptr cs:xmmword_127C70
movss xmm12, dword ptr cs:xmmword_127C70+4
movss xmm13, dword ptr cs:xmmword_127C70+8
movss xmm14, dword ptr cs:xmmword_127C70+0Ch
movss xmm15, cs:dword_127C80
lea rdi, [rsp+48h+var_40]
movss dword ptr [rdi], xmm0
movss dword ptr [rdi+4], xmm4
movss dword ptr [rdi+8], xmm8
movss dword ptr [rdi+0Ch], xmm12
movss dword ptr [rdi+10h], xmm1
movss dword ptr [rdi+14h], xmm5
movss dword ptr [rdi+18h], xmm9
movss dword ptr [rdi+1Ch], xmm13
movss dword ptr [rdi+20h], xmm2
movss dword ptr [rdi+24h], xmm6
movss dword ptr [rdi+28h], xmm10
movss dword ptr [rdi+2Ch], xmm14
movss dword ptr [rdi+30h], xmm3
movss dword ptr [rdi+34h], xmm7
movss dword ptr [rdi+38h], xmm11
movss dword ptr [rdi+3Ch], xmm15
call rlMultMatrixf
add rsp, 48h
retn
|
__m128 * BeginDrawing(
double a1,
double a2,
double a3,
double a4,
double a5,
double a6,
double a7,
double a8,
long long a9,
long long a10)
{
long long v10; // rdx
long long v11; // rcx
long long v12; // r8
long long v13; // r9
__int32 v15[16]; // [rsp+8h] [rbp-40h] BYREF
qword_128680 = glfwGetTime(a1, a2, a3, a4, a5, a6, a7, a8);
*(double *)&qword_128690 = *(double *)&qword_128680 - *(double *)&qword_128688;
qword_128688 = qword_128680;
rlLoadIdentity();
v15[0] = dword_127C44;
v15[1] = HIDWORD(xmmword_127C48);
v15[2] = DWORD2(xmmword_127C5C);
v15[3] = DWORD1(xmmword_127C70);
v15[4] = xmmword_127C48;
v15[5] = dword_127C58;
v15[6] = HIDWORD(xmmword_127C5C);
v15[7] = DWORD2(xmmword_127C70);
v15[8] = DWORD1(xmmword_127C48);
v15[9] = xmmword_127C5C;
v15[10] = dword_127C6C;
v15[11] = HIDWORD(xmmword_127C70);
v15[12] = DWORD2(xmmword_127C48);
v15[13] = DWORD1(xmmword_127C5C);
v15[14] = xmmword_127C70;
v15[15] = dword_127C80;
return rlMultMatrixf(
v15,
a10,
v10,
v11,
v12,
v13,
COERCE_DOUBLE((unsigned long long)dword_127C44),
COERCE_DOUBLE((unsigned long long)(unsigned int)xmmword_127C48),
COERCE_DOUBLE((unsigned long long)DWORD1(xmmword_127C48)),
COERCE_DOUBLE((unsigned long long)DWORD2(xmmword_127C48)),
(__m128)HIDWORD(xmmword_127C48),
(__m128)(unsigned int)dword_127C58,
(__m128)(unsigned int)xmmword_127C5C,
(__m128)DWORD1(xmmword_127C5C));
}
|
BeginDrawing:
SUB RSP,0x48
CALL 0x001a58ec
MOVSD qword ptr [0x00228680],XMM0
MOVAPD XMM1,XMM0
SUBSD XMM1,qword ptr [0x00228688]
MOVSD qword ptr [0x00228690],XMM1
MOVSD qword ptr [0x00228688],XMM0
CALL 0x00150688
MOVSS XMM0,dword ptr [0x00227c44]
MOVSS XMM1,dword ptr [0x00227c48]
MOVSS XMM2,dword ptr [0x00227c4c]
MOVSS XMM3,dword ptr [0x00227c50]
MOVSS XMM4,dword ptr [0x00227c54]
MOVSS XMM5,dword ptr [0x00227c58]
MOVSS XMM6,dword ptr [0x00227c5c]
MOVSS XMM7,dword ptr [0x00227c60]
MOVSS XMM8,dword ptr [0x00227c64]
MOVSS XMM9,dword ptr [0x00227c68]
MOVSS XMM10,dword ptr [0x00227c6c]
MOVSS XMM11,dword ptr [0x00227c70]
MOVSS XMM12,dword ptr [0x00227c74]
MOVSS XMM13,dword ptr [0x00227c78]
MOVSS XMM14,dword ptr [0x00227c7c]
MOVSS XMM15,dword ptr [0x00227c80]
LEA RDI,[RSP + 0x8]
MOVSS dword ptr [RDI],XMM0
MOVSS dword ptr [RDI + 0x4],XMM4
MOVSS dword ptr [RDI + 0x8],XMM8
MOVSS dword ptr [RDI + 0xc],XMM12
MOVSS dword ptr [RDI + 0x10],XMM1
MOVSS dword ptr [RDI + 0x14],XMM5
MOVSS dword ptr [RDI + 0x18],XMM9
MOVSS dword ptr [RDI + 0x1c],XMM13
MOVSS dword ptr [RDI + 0x20],XMM2
MOVSS dword ptr [RDI + 0x24],XMM6
MOVSS dword ptr [RDI + 0x28],XMM10
MOVSS dword ptr [RDI + 0x2c],XMM14
MOVSS dword ptr [RDI + 0x30],XMM3
MOVSS dword ptr [RDI + 0x34],XMM7
MOVSS dword ptr [RDI + 0x38],XMM11
MOVSS dword ptr [RDI + 0x3c],XMM15
CALL 0x00150d0c
ADD RSP,0x48
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void BeginDrawing(void)
{
_DAT_00228680 = (double)glfwGetTime();
_DAT_00228690 = _DAT_00228680 - _DAT_00228688;
_DAT_00228688 = _DAT_00228680;
rlLoadIdentity();
rlMultMatrixf();
return;
}
|
|
66,003 |
BeginDrawing
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rcore.c
|
void BeginDrawing(void)
{
// WARNING: Previously to BeginDrawing() other render textures drawing could happen,
// consequently the measure for update vs draw is not accurate (only the total frame time is accurate)
CORE.Time.current = GetTime(); // Number of elapsed seconds since InitTimer()
CORE.Time.update = CORE.Time.current - CORE.Time.previous;
CORE.Time.previous = CORE.Time.current;
rlLoadIdentity(); // Reset current matrix (modelview)
rlMultMatrixf(MatrixToFloat(CORE.Window.screenScale)); // Apply screen scaling
//rlTranslatef(0.375, 0.375, 0); // HACK to have 2D pixel-perfect drawing on OpenGL 1.1
// NOTE: Not required with OpenGL 3.3+
}
|
O3
|
c
|
BeginDrawing:
subq $0x48, %rsp
callq 0xbe92e
movsd %xmm0, 0xca77f(%rip) # 0x13c660
movapd %xmm0, %xmm1
subsd 0xca77b(%rip), %xmm1 # 0x13c668
movsd %xmm1, 0xca77b(%rip) # 0x13c670
movsd %xmm0, 0xca76b(%rip) # 0x13c668
movq 0xc925c(%rip), %rax # 0x13b160
movl $0x3f800000, %ecx # imm = 0x3F800000
movl %ecx, (%rax)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x4(%rax)
movl %ecx, 0x14(%rax)
movupd %xmm0, 0x18(%rax)
movl %ecx, 0x28(%rax)
movupd %xmm0, 0x2c(%rax)
movl %ecx, 0x3c(%rax)
movss 0xc9cf5(%rip), %xmm0 # 0x13bc24
movss 0xc9cf1(%rip), %xmm1 # 0x13bc28
movss 0xc9ced(%rip), %xmm2 # 0x13bc2c
movss 0xc9ce9(%rip), %xmm3 # 0x13bc30
movss 0xc9ce5(%rip), %xmm4 # 0x13bc34
movss 0xc9ce1(%rip), %xmm5 # 0x13bc38
movss 0xc9cdd(%rip), %xmm6 # 0x13bc3c
movss 0xc9cd9(%rip), %xmm7 # 0x13bc40
movss 0xc9cd4(%rip), %xmm8 # 0x13bc44
movss 0xc9ccf(%rip), %xmm9 # 0x13bc48
movss 0xc9cca(%rip), %xmm10 # 0x13bc4c
movss 0xc9cc5(%rip), %xmm11 # 0x13bc50
movss 0xc9cc0(%rip), %xmm12 # 0x13bc54
movss 0xc9cbb(%rip), %xmm13 # 0x13bc58
movss 0xc9cb6(%rip), %xmm14 # 0x13bc5c
movss 0xc9cb1(%rip), %xmm15 # 0x13bc60
leaq 0x8(%rsp), %rdi
movss %xmm0, (%rdi)
movss %xmm4, 0x4(%rdi)
movss %xmm8, 0x8(%rdi)
movss %xmm12, 0xc(%rdi)
movss %xmm1, 0x10(%rdi)
movss %xmm5, 0x14(%rdi)
movss %xmm9, 0x18(%rdi)
movss %xmm13, 0x1c(%rdi)
movss %xmm2, 0x20(%rdi)
movss %xmm6, 0x24(%rdi)
movss %xmm10, 0x28(%rdi)
movss %xmm14, 0x2c(%rdi)
movss %xmm3, 0x30(%rdi)
movss %xmm7, 0x34(%rdi)
movss %xmm11, 0x38(%rdi)
movss %xmm15, 0x3c(%rdi)
callq 0x60a3f
addq $0x48, %rsp
retq
|
BeginDrawing:
sub rsp, 48h
call glfwGetTime
movsd cs:qword_13C660, xmm0
movapd xmm1, xmm0
subsd xmm1, cs:qword_13C668
movsd cs:qword_13C670, xmm1
movsd cs:qword_13C668, xmm0
mov rax, cs:qword_13B160
mov ecx, 3F800000h
mov [rax], ecx
xorpd xmm0, xmm0
movupd xmmword ptr [rax+4], xmm0
mov [rax+14h], ecx
movupd xmmword ptr [rax+18h], xmm0
mov [rax+28h], ecx
movupd xmmword ptr [rax+2Ch], xmm0
mov [rax+3Ch], ecx
movss xmm0, cs:dword_13BC24
movss xmm1, dword ptr cs:xmmword_13BC28
movss xmm2, dword ptr cs:xmmword_13BC28+4
movss xmm3, dword ptr cs:xmmword_13BC28+8
movss xmm4, dword ptr cs:xmmword_13BC28+0Ch
movss xmm5, cs:dword_13BC38
movss xmm6, dword ptr cs:xmmword_13BC3C
movss xmm7, dword ptr cs:xmmword_13BC3C+4
movss xmm8, dword ptr cs:xmmword_13BC3C+8
movss xmm9, dword ptr cs:xmmword_13BC3C+0Ch
movss xmm10, cs:dword_13BC4C
movss xmm11, dword ptr cs:xmmword_13BC50
movss xmm12, dword ptr cs:xmmword_13BC50+4
movss xmm13, dword ptr cs:xmmword_13BC50+8
movss xmm14, dword ptr cs:xmmword_13BC50+0Ch
movss xmm15, cs:dword_13BC60
lea rdi, [rsp+48h+var_40]
movss dword ptr [rdi], xmm0
movss dword ptr [rdi+4], xmm4
movss dword ptr [rdi+8], xmm8
movss dword ptr [rdi+0Ch], xmm12
movss dword ptr [rdi+10h], xmm1
movss dword ptr [rdi+14h], xmm5
movss dword ptr [rdi+18h], xmm9
movss dword ptr [rdi+1Ch], xmm13
movss dword ptr [rdi+20h], xmm2
movss dword ptr [rdi+24h], xmm6
movss dword ptr [rdi+28h], xmm10
movss dword ptr [rdi+2Ch], xmm14
movss dword ptr [rdi+30h], xmm3
movss dword ptr [rdi+34h], xmm7
movss dword ptr [rdi+38h], xmm11
movss dword ptr [rdi+3Ch], xmm15
call rlMultMatrixf
add rsp, 48h
retn
|
void BeginDrawing(double a1, double a2, double a3, double a4, double a5, long long a6, long long a7)
{
long long v7; // rax
long long v8; // rdx
long long v9; // r8
long long v10; // r9
__int32 v11[16]; // [rsp+8h] [rbp-40h] BYREF
qword_13C660 = glfwGetTime(a1, a2, a3, a4, a5);
*(double *)&qword_13C670 = *(double *)&qword_13C660 - *(double *)&qword_13C668;
qword_13C668 = qword_13C660;
v7 = qword_13B160;
*(_DWORD *)qword_13B160 = 1065353216;
*(_OWORD *)(v7 + 4) = 0LL;
*(_DWORD *)(v7 + 20) = 1065353216;
*(_OWORD *)(v7 + 24) = 0LL;
*(_DWORD *)(v7 + 40) = 1065353216;
*(_OWORD *)(v7 + 44) = 0LL;
*(_DWORD *)(v7 + 60) = 1065353216;
v11[0] = dword_13BC24;
v11[1] = HIDWORD(xmmword_13BC28);
v11[2] = DWORD2(xmmword_13BC3C);
v11[3] = DWORD1(xmmword_13BC50);
v11[4] = xmmword_13BC28;
v11[5] = dword_13BC38;
v11[6] = HIDWORD(xmmword_13BC3C);
v11[7] = DWORD2(xmmword_13BC50);
v11[8] = DWORD1(xmmword_13BC28);
v11[9] = xmmword_13BC3C;
v11[10] = dword_13BC4C;
v11[11] = HIDWORD(xmmword_13BC50);
v11[12] = DWORD2(xmmword_13BC28);
v11[13] = DWORD1(xmmword_13BC3C);
v11[14] = xmmword_13BC50;
v11[15] = dword_13BC60;
rlMultMatrixf(
v11,
a7,
v8,
1065353216LL,
v9,
v10,
COERCE_DOUBLE((unsigned long long)dword_13BC24),
COERCE_DOUBLE((unsigned long long)(unsigned int)xmmword_13BC28),
COERCE_DOUBLE((unsigned long long)DWORD1(xmmword_13BC28)),
COERCE_DOUBLE((unsigned long long)DWORD2(xmmword_13BC28)),
(__m128)HIDWORD(xmmword_13BC28),
(__m128)(unsigned int)dword_13BC38,
(__m128)(unsigned int)xmmword_13BC3C,
(__m128)DWORD1(xmmword_13BC3C));
}
|
BeginDrawing:
SUB RSP,0x48
CALL 0x001be92e
MOVSD qword ptr [0x0023c660],XMM0
MOVAPD XMM1,XMM0
SUBSD XMM1,qword ptr [0x0023c668]
MOVSD qword ptr [0x0023c670],XMM1
MOVSD qword ptr [0x0023c668],XMM0
MOV RAX,qword ptr [0x0023b160]
MOV ECX,0x3f800000
MOV dword ptr [RAX],ECX
XORPD XMM0,XMM0
MOVUPD xmmword ptr [RAX + 0x4],XMM0
MOV dword ptr [RAX + 0x14],ECX
MOVUPD xmmword ptr [RAX + 0x18],XMM0
MOV dword ptr [RAX + 0x28],ECX
MOVUPD xmmword ptr [RAX + 0x2c],XMM0
MOV dword ptr [RAX + 0x3c],ECX
MOVSS XMM0,dword ptr [0x0023bc24]
MOVSS XMM1,dword ptr [0x0023bc28]
MOVSS XMM2,dword ptr [0x0023bc2c]
MOVSS XMM3,dword ptr [0x0023bc30]
MOVSS XMM4,dword ptr [0x0023bc34]
MOVSS XMM5,dword ptr [0x0023bc38]
MOVSS XMM6,dword ptr [0x0023bc3c]
MOVSS XMM7,dword ptr [0x0023bc40]
MOVSS XMM8,dword ptr [0x0023bc44]
MOVSS XMM9,dword ptr [0x0023bc48]
MOVSS XMM10,dword ptr [0x0023bc4c]
MOVSS XMM11,dword ptr [0x0023bc50]
MOVSS XMM12,dword ptr [0x0023bc54]
MOVSS XMM13,dword ptr [0x0023bc58]
MOVSS XMM14,dword ptr [0x0023bc5c]
MOVSS XMM15,dword ptr [0x0023bc60]
LEA RDI,[RSP + 0x8]
MOVSS dword ptr [RDI],XMM0
MOVSS dword ptr [RDI + 0x4],XMM4
MOVSS dword ptr [RDI + 0x8],XMM8
MOVSS dword ptr [RDI + 0xc],XMM12
MOVSS dword ptr [RDI + 0x10],XMM1
MOVSS dword ptr [RDI + 0x14],XMM5
MOVSS dword ptr [RDI + 0x18],XMM9
MOVSS dword ptr [RDI + 0x1c],XMM13
MOVSS dword ptr [RDI + 0x20],XMM2
MOVSS dword ptr [RDI + 0x24],XMM6
MOVSS dword ptr [RDI + 0x28],XMM10
MOVSS dword ptr [RDI + 0x2c],XMM14
MOVSS dword ptr [RDI + 0x30],XMM3
MOVSS dword ptr [RDI + 0x34],XMM7
MOVSS dword ptr [RDI + 0x38],XMM11
MOVSS dword ptr [RDI + 0x3c],XMM15
CALL 0x00160a3f
ADD RSP,0x48
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void BeginDrawing(void)
{
int4 *puVar1;
_DAT_0023c660 = (double)glfwGetTime();
puVar1 = DAT_0023b160;
_DAT_0023c670 = _DAT_0023c660 - _DAT_0023c668;
_DAT_0023c668 = _DAT_0023c660;
*DAT_0023b160 = 0x3f800000;
*(int8 *)(puVar1 + 1) = 0;
*(int8 *)(puVar1 + 3) = 0;
puVar1[5] = 0x3f800000;
*(int8 *)(puVar1 + 6) = 0;
*(int8 *)(puVar1 + 8) = 0;
puVar1[10] = 0x3f800000;
*(int8 *)(puVar1 + 0xb) = 0;
*(int8 *)(puVar1 + 0xd) = 0;
puVar1[0xf] = 0x3f800000;
rlMultMatrixf();
return;
}
|
|
66,004 |
Item_date_typecast::get_date(THD*, st_mysql_time*, date_mode_t)
|
eloqsql/sql/item_timefunc.cc
|
bool Item_date_typecast::get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
{
date_mode_t tmp= (fuzzydate | sql_mode_for_dates(thd)) & ~TIME_TIME_ONLY;
// Force truncation
Date *d= new(ltime) Date(thd, args[0], Date::Options(date_conv_mode_t(tmp)));
return (null_value= !d->is_valid_date());
}
|
O0
|
cpp
|
Item_date_typecast::get_date(THD*, st_mysql_time*, date_mode_t):
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %ecx, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7c5a70
movl %eax, -0x2c(%rbp)
leaq -0x4(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x9d9850
movl %eax, -0x28(%rbp)
leaq 0xc1ad0b(%rip), %rdi # 0x15f4450
callq 0x7c65a0
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x92d260
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rsi
movq %rsi, -0x70(%rbp)
movl $0x28, %edi
callq 0x6e6980
movq %rax, %rcx
movq %rcx, -0x68(%rbp)
movb $0x0, -0x39(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x60(%rbp)
je 0x9d97f1
movq -0x78(%rbp), %rax
movb $0x1, -0x39(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x90(%rbp)
movq 0x70(%rax), %rax
movq (%rax), %rax
movq %rax, -0x88(%rbp)
leaq -0x24(%rbp), %rdi
callq 0x669050
movl %eax, -0x7c(%rbp)
jmp 0x9d97b1
movl -0x7c(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %esi
leaq -0x44(%rbp), %rdi
callq 0x8cf950
jmp 0x9d97c5
movq -0x88(%rbp), %rdx
movq -0x90(%rbp), %rsi
movq -0x68(%rbp), %rdi
movl -0x44(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %ecx
callq 0x7cfba0
jmp 0x9d97e7
movq -0x68(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x9d97f1
movq -0x60(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x7cfa90
movq -0x78(%rbp), %rcx
xorb $-0x1, %al
movb %al, %dl
andb $0x1, %dl
movb %dl, 0x64(%rcx)
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
testb $0x1, -0x39(%rbp)
jne 0x9d982f
jmp 0x9d983c
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdi
callq 0x6e6a00
jmp 0x9d983e
movq -0x50(%rbp), %rdi
callq 0x433ff0
nopw (%rax,%rax)
|
_ZN18Item_date_typecast8get_dateEP3THDP13st_mysql_time11date_mode_t:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_4], ecx
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
mov [rbp+var_78], rax
mov rdi, [rbp+var_18]; THD *
call _Z18sql_mode_for_datesP3THD; sql_mode_for_dates(THD *)
mov [rbp+var_2C], eax
lea rdi, [rbp+var_4]
lea rsi, [rbp+var_2C]
call _ZorRK11date_mode_tRK16date_conv_mode_t; operator|(date_mode_t const&,date_conv_mode_t const&)
mov [rbp+var_28], eax
lea rdi, _ZL14TIME_TIME_ONLY_143; TIME_TIME_ONLY
call _ZNK16date_conv_mode_tcoEv; date_conv_mode_t::operator~(void)
mov rsi, rax
lea rdi, [rbp+var_28]
call _ZNK11date_mode_tanEy; date_mode_t::operator&(ulong long)
mov [rbp+var_24], eax
mov rsi, [rbp+var_20]
mov [rbp+var_70], rsi
mov edi, 28h ; '('
call _ZN8TemporalnwEmP13st_mysql_time; Temporal::operator new(ulong,st_mysql_time *)
mov rcx, rax
mov [rbp+var_68], rcx
mov [rbp+var_39], 0
xor eax, eax
cmp rcx, 0
mov [rbp+var_60], rax
jz short loc_9D97F1
mov rax, [rbp+var_78]
mov [rbp+var_39], 1
mov rcx, [rbp+var_18]
mov [rbp+var_90], rcx
mov rax, [rax+70h]
mov rax, [rax]
mov [rbp+var_88], rax
lea rdi, [rbp+var_24]
call _ZNK11date_mode_tcv16date_conv_mode_tEv; date_mode_t::operator date_conv_mode_t(void)
mov [rbp+var_7C], eax
jmp short $+2
loc_9D97B1:
mov eax, [rbp+var_7C]
mov [rbp+var_48], eax
mov esi, [rbp+var_48]
lea rdi, [rbp+var_44]
call _ZN4Date7OptionsC2E16date_conv_mode_t; Date::Options::Options(date_conv_mode_t)
jmp short $+2
loc_9D97C5:
mov rdx, [rbp+var_88]
mov rsi, [rbp+var_90]
mov rdi, [rbp+var_68]
mov eax, [rbp+var_44]
mov [rbp+var_40], eax
mov ecx, [rbp+var_40]
call _ZN4DateC2EP3THDP4Item11date_mode_t; Date::Date(THD *,Item *,date_mode_t)
jmp short $+2
loc_9D97E7:
mov rax, [rbp+var_68]
mov [rbp+var_60], rax
jmp short $+2
loc_9D97F1:
mov rax, [rbp+var_60]
mov [rbp+var_38], rax
mov rdi, [rbp+var_38]; this
call _ZNK4Date13is_valid_dateEv; Date::is_valid_date(void)
mov rcx, [rbp+var_78]
xor al, 0FFh
mov dl, al
and dl, 1
mov [rcx+64h], dl
and al, 1
add rsp, 90h
pop rbp
retn
mov rcx, rax
mov eax, edx
mov [rbp+var_50], rcx
mov [rbp+var_54], eax
test [rbp+var_39], 1
jnz short loc_9D982F
jmp short loc_9D983C
loc_9D982F:
mov rsi, [rbp+var_70]
mov rdi, [rbp+var_68]
call _ZN8TemporaldlEPvP13st_mysql_time; Temporal::operator delete(void *,st_mysql_time *)
loc_9D983C:
jmp short $+2
loc_9D983E:
mov rdi, [rbp+var_50]
call __Unwind_Resume
|
bool Item_date_typecast::get_date(long long a1, THD *a2, long long a3, int a4)
{
int v4; // eax
bool is_valid_date; // al
THD *v7; // [rsp+0h] [rbp-90h]
long long v8; // [rsp+8h] [rbp-88h]
long long v9; // [rsp+28h] [rbp-68h]
Date *v10; // [rsp+30h] [rbp-60h]
unsigned int v11; // [rsp+48h] [rbp-48h]
unsigned int v12[2]; // [rsp+4Ch] [rbp-44h] BYREF
char v13; // [rsp+57h] [rbp-39h]
Date *v14; // [rsp+58h] [rbp-38h]
int v15; // [rsp+64h] [rbp-2Ch] BYREF
int v16; // [rsp+68h] [rbp-28h] BYREF
int v17; // [rsp+6Ch] [rbp-24h] BYREF
long long v18; // [rsp+70h] [rbp-20h]
THD *v19; // [rsp+78h] [rbp-18h]
long long v20; // [rsp+80h] [rbp-10h]
int v21; // [rsp+8Ch] [rbp-4h] BYREF
v21 = a4;
v20 = a1;
v19 = a2;
v18 = a3;
v15 = sql_mode_for_dates(a2);
v16 = operator|(&v21, &v15);
v4 = date_conv_mode_t::operator~(&TIME_TIME_ONLY);
v17 = date_mode_t::operator&(&v16, v4);
v9 = Temporal::operator new(40LL, v18);
v13 = 0;
v10 = 0LL;
if ( v9 )
{
v13 = 1;
v7 = v19;
v8 = **(_QWORD **)(a1 + 112);
v11 = date_mode_t::operator date_conv_mode_t(&v17);
Date::Options::Options((long long)v12, v11);
v12[1] = v12[0];
Date::Date(v9, (long long)v7, v8, v12[0]);
v10 = (Date *)v9;
}
v14 = v10;
is_valid_date = Date::is_valid_date(v10);
*(_BYTE *)(a1 + 100) = !is_valid_date;
return !is_valid_date;
}
|
ha_lock_engine:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
CMP qword ptr [RBP + -0x18],0x0
JZ 0x009d9742
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x4]
MOV ECX,EAX
LEA RAX,[0x16f30f0]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x006cf050
MOV qword ptr [RBP + -0x8],RAX
JMP 0x009d974a
LAB_009d9742:
MOV qword ptr [RBP + -0x8],0x0
LAB_009d974a:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x20
POP RBP
RET
|
/* ha_lock_engine(THD*, handlerton const*) */
int8 ha_lock_engine(THD *param_1,handlerton *param_2)
{
int8 local_10;
if (param_2 == (handlerton *)0x0) {
local_10 = 0;
}
else {
local_10 = plugin_lock(param_1,*(st_plugin_int **)
(hton2plugin + (ulong)*(uint *)(param_2 + 4) * 8));
}
return local_10;
}
|
|
66,005 |
my_numcells_cp932
|
eloqsql/strings/ctype-cp932.c
|
static
size_t my_numcells_cp932(CHARSET_INFO *cs __attribute__((unused)),
const char *str, const char *str_end)
{
size_t clen= 0;
const uchar *b= (const uchar *) str;
const uchar *e= (const uchar *) str_end;
for (clen= 0; b < e; )
{
if (*b >= 0xA1 && *b <= 0xDF)
{
clen++;
b++;
}
else if (*b > 0x7F)
{
clen+= 2;
b+= 2;
}
else
{
clen++;
b++;
}
}
return clen;
}
|
O3
|
c
|
my_numcells_cp932:
cmpq %rdx, %rsi
jae 0xadfa3
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movl $0x1, %ecx
movb (%rsi), %dil
leal 0x5f(%rdi), %r8d
shrb $0x7, %dil
movzbl %dil, %edi
incq %rdi
cmpb $0x3f, %r8b
cmovbq %rcx, %rdi
addq %rdi, %rax
addq %rdi, %rsi
cmpq %rdx, %rsi
jb 0xadf7c
popq %rbp
retq
xorl %eax, %eax
retq
|
my_numcells_cp932:
cmp rsi, rdx
jnb short loc_ADFA3
push rbp
mov rbp, rsp
xor eax, eax
mov ecx, 1
loc_ADF7C:
mov dil, [rsi]
lea r8d, [rdi+5Fh]
shr dil, 7
movzx edi, dil
inc rdi
cmp r8b, 3Fh ; '?'
cmovb rdi, rcx
add rax, rdi
add rsi, rdi
cmp rsi, rdx
jb short loc_ADF7C
pop rbp
retn
loc_ADFA3:
xor eax, eax
retn
|
long long my_numcells_cp932(long long a1, _BYTE *a2, unsigned long long a3)
{
long long result; // rax
long long v4; // rdi
if ( (unsigned long long)a2 >= a3 )
return 0LL;
result = 0LL;
do
{
v4 = (*a2 >> 7) + 1LL;
if ( (unsigned __int8)(*a2 + 95) < 0x3Fu )
v4 = 1LL;
result += v4;
a2 += v4;
}
while ( (unsigned long long)a2 < a3 );
return result;
}
|
my_numcells_cp932:
CMP RSI,RDX
JNC 0x001adfa3
PUSH RBP
MOV RBP,RSP
XOR EAX,EAX
MOV ECX,0x1
LAB_001adf7c:
MOV DIL,byte ptr [RSI]
LEA R8D,[RDI + 0x5f]
SHR DIL,0x7
MOVZX EDI,DIL
INC RDI
CMP R8B,0x3f
CMOVC RDI,RCX
ADD RAX,RDI
ADD RSI,RDI
CMP RSI,RDX
JC 0x001adf7c
POP RBP
RET
LAB_001adfa3:
XOR EAX,EAX
RET
|
long my_numcells_cp932(int8 param_1,byte *param_2,byte *param_3)
{
long lVar1;
long lVar2;
if (param_2 < param_3) {
lVar1 = 0;
do {
lVar2 = (ulong)(*param_2 >> 7) + 1;
if ((byte)(*param_2 + 0x5f) < 0x3f) {
lVar2 = 1;
}
lVar1 = lVar1 + lVar2;
param_2 = param_2 + lVar2;
} while (param_2 < param_3);
return lVar1;
}
return 0;
}
|
|
66,006 |
MNN::SpaceBatch::Verify(flatbuffers::Verifier&) const
|
mnn-tts/MNN/schema/current/TensorflowOp_generated.h
|
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, 4) &&
verifier.VerifyTable(blockShape()) &&
VerifyOffset(verifier, 6) &&
verifier.VerifyTable(padding()) &&
verifier.EndTable();
}
|
O0
|
c
|
MNN::SpaceBatch::Verify(flatbuffers::Verifier&) const:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0x28(%rsp), %rsi
callq 0x6d010
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x27(%rsp)
jne 0x792b4
jmp 0x7936b
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl $0x4, %edx
callq 0x6d040
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x27(%rsp)
jne 0x792da
jmp 0x7936b
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x79380
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x6df70
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x27(%rsp)
jne 0x7930a
jmp 0x7936b
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl $0x6, %edx
callq 0x6d040
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x27(%rsp)
jne 0x7932d
jmp 0x7936b
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x793a0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x6df70
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x27(%rsp)
jne 0x7935d
jmp 0x7936b
movq 0x28(%rsp), %rdi
callq 0x6d6f0
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
|
_ZNK3MNN10SpaceBatch6VerifyERN11flatbuffers8VerifierE:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov [rsp+38h+var_10], rsi
mov rdi, [rsp+38h+var_8]; this
mov [rsp+38h+var_20], rdi
mov rsi, [rsp+38h+var_10]; flatbuffers::Verifier *
call _ZNK11flatbuffers5Table16VerifyTableStartERNS_8VerifierE; flatbuffers::Table::VerifyTableStart(flatbuffers::Verifier &)
mov cl, al
xor eax, eax
test cl, 1
mov [rsp+38h+var_11], al
jnz short loc_792B4
jmp loc_7936B
loc_792B4:
mov rdi, [rsp+38h+var_20]; this
mov rsi, [rsp+38h+var_10]; flatbuffers::Verifier *
mov edx, 4; unsigned __int16
call _ZNK11flatbuffers5Table12VerifyOffsetERKNS_8VerifierEt; flatbuffers::Table::VerifyOffset(flatbuffers::Verifier const&,ushort)
mov cl, al
xor eax, eax
test cl, 1
mov [rsp+38h+var_11], al
jnz short loc_792DA
jmp loc_7936B
loc_792DA:
mov rdi, [rsp+38h+var_20]; this
mov rax, [rsp+38h+var_10]
mov [rsp+38h+var_28], rax
call _ZNK3MNN10SpaceBatch10blockShapeEv; MNN::SpaceBatch::blockShape(void)
mov rdi, [rsp+38h+var_28]
mov rsi, rax
call _ZN11flatbuffers8Verifier11VerifyTableIN3MNN4BlobEEEbPKT_; flatbuffers::Verifier::VerifyTable<MNN::Blob>(MNN::Blob const*)
mov cl, al
xor eax, eax
test cl, 1
mov [rsp+38h+var_11], al
jnz short loc_7930A
jmp short loc_7936B
loc_7930A:
mov rdi, [rsp+38h+var_20]; this
mov rsi, [rsp+38h+var_10]; flatbuffers::Verifier *
mov edx, 6; unsigned __int16
call _ZNK11flatbuffers5Table12VerifyOffsetERKNS_8VerifierEt; flatbuffers::Table::VerifyOffset(flatbuffers::Verifier const&,ushort)
mov cl, al
xor eax, eax
test cl, 1
mov [rsp+38h+var_11], al
jnz short loc_7932D
jmp short loc_7936B
loc_7932D:
mov rdi, [rsp+38h+var_20]; this
mov rax, [rsp+38h+var_10]
mov [rsp+38h+var_30], rax
call _ZNK3MNN10SpaceBatch7paddingEv; MNN::SpaceBatch::padding(void)
mov rdi, [rsp+38h+var_30]
mov rsi, rax
call _ZN11flatbuffers8Verifier11VerifyTableIN3MNN4BlobEEEbPKT_; flatbuffers::Verifier::VerifyTable<MNN::Blob>(MNN::Blob const*)
mov cl, al
xor eax, eax
test cl, 1
mov [rsp+38h+var_11], al
jnz short loc_7935D
jmp short loc_7936B
loc_7935D:
mov rdi, [rsp+38h+var_10]; this
call _ZN11flatbuffers8Verifier8EndTableEv; flatbuffers::Verifier::EndTable(void)
mov [rsp+38h+var_11], al
loc_7936B:
mov al, [rsp+38h+var_11]
and al, 1
add rsp, 38h
retn
|
char MNN::SpaceBatch::Verify(MNN::SpaceBatch *this, flatbuffers::Verifier *a2)
{
MNN::Blob *v2; // rax
MNN::Blob *v3; // rax
char v5; // [rsp+27h] [rbp-11h]
v5 = 0;
if ( (flatbuffers::Table::VerifyTableStart(this, a2) & 1) != 0 )
{
v5 = 0;
if ( flatbuffers::Table::VerifyOffset(this, a2, 4u) )
{
v2 = (MNN::Blob *)MNN::SpaceBatch::blockShape(this);
v5 = 0;
if ( (flatbuffers::Verifier::VerifyTable<MNN::Blob>(a2, v2) & 1) != 0 )
{
v5 = 0;
if ( flatbuffers::Table::VerifyOffset(this, a2, 6u) )
{
v3 = (MNN::Blob *)MNN::SpaceBatch::padding(this);
v5 = 0;
if ( (flatbuffers::Verifier::VerifyTable<MNN::Blob>(a2, v3) & 1) != 0 )
v5 = flatbuffers::Verifier::EndTable(a2);
}
}
}
}
return v5 & 1;
}
|
Verify:
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 + 0x18],RDI
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x0016d010
MOV CL,AL
XOR EAX,EAX
TEST CL,0x1
MOV byte ptr [RSP + 0x27],AL
JNZ 0x001792b4
JMP 0x0017936b
LAB_001792b4:
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x28]
MOV EDX,0x4
CALL 0x0016d040
MOV CL,AL
XOR EAX,EAX
TEST CL,0x1
MOV byte ptr [RSP + 0x27],AL
JNZ 0x001792da
JMP 0x0017936b
LAB_001792da:
MOV RDI,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x00179380
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,RAX
CALL 0x0016df70
MOV CL,AL
XOR EAX,EAX
TEST CL,0x1
MOV byte ptr [RSP + 0x27],AL
JNZ 0x0017930a
JMP 0x0017936b
LAB_0017930a:
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x28]
MOV EDX,0x6
CALL 0x0016d040
MOV CL,AL
XOR EAX,EAX
TEST CL,0x1
MOV byte ptr [RSP + 0x27],AL
JNZ 0x0017932d
JMP 0x0017936b
LAB_0017932d:
MOV RDI,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x8],RAX
CALL 0x001793a0
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,RAX
CALL 0x0016df70
MOV CL,AL
XOR EAX,EAX
TEST CL,0x1
MOV byte ptr [RSP + 0x27],AL
JNZ 0x0017935d
JMP 0x0017936b
LAB_0017935d:
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x0016d6f0
MOV byte ptr [RSP + 0x27],AL
LAB_0017936b:
MOV AL,byte ptr [RSP + 0x27]
AND AL,0x1
ADD RSP,0x38
RET
|
/* MNN::SpaceBatch::Verify(flatbuffers::Verifier&) const */
ulong __thiscall MNN::SpaceBatch::Verify(SpaceBatch *this,Verifier *param_1)
{
bool bVar1;
uint uVar2;
Blob *pBVar3;
int8 uVar4;
int1 local_11;
uVar2 = flatbuffers::Table::VerifyTableStart((Table *)this,param_1);
uVar4 = 0;
local_11 = 0;
if ((uVar2 & 1) != 0) {
uVar2 = flatbuffers::Table::VerifyOffset((Table *)this,param_1,4);
uVar4 = 0;
local_11 = 0;
if ((uVar2 & 1) != 0) {
pBVar3 = (Blob *)blockShape(this);
bVar1 = flatbuffers::Verifier::VerifyTable<MNN::Blob>(param_1,pBVar3);
uVar4 = 0;
local_11 = 0;
if (bVar1) {
uVar2 = flatbuffers::Table::VerifyOffset((Table *)this,param_1,6);
uVar4 = 0;
local_11 = 0;
if ((uVar2 & 1) != 0) {
pBVar3 = (Blob *)padding(this);
bVar1 = flatbuffers::Verifier::VerifyTable<MNN::Blob>(param_1,pBVar3);
uVar4 = 0;
local_11 = 0;
if (bVar1) {
uVar4 = flatbuffers::Verifier::EndTable(param_1);
local_11 = (int1)uVar4;
}
}
}
}
}
return CONCAT71((int7)((ulong)uVar4 >> 8),local_11) & 0xffffffffffffff01;
}
|
|
66,007 |
my_load_path
|
eloqsql/mysys/mf_loadpath.c
|
char * my_load_path(char * to, const char *path,
const char *own_path_prefix)
{
char buff[FN_REFLEN+1];
const char *from= buff;
int is_cur;
DBUG_ENTER("my_load_path");
DBUG_PRINT("enter",("path: %s prefix: %s",path,
own_path_prefix ? own_path_prefix : ""));
if ((path[0] == FN_HOMELIB && path[1] == FN_LIBCHAR) ||
test_if_hard_path(path))
from= path;
else if ((is_cur=(path[0] == FN_CURLIB && path[1] == FN_LIBCHAR)) ||
(is_prefix(path,FN_PARENTDIR)) ||
! own_path_prefix)
{
if (is_cur)
is_cur=2; /* Remove current dir */
if (! my_getwd(buff,(uint) (FN_REFLEN-strlen(path)+is_cur),MYF(0)))
{
size_t length= strlen(buff);
(void) strmake(buff + length, path+is_cur, FN_REFLEN - length);
}
else
from= path; /* Return org file name */
}
else
(void) strxnmov(buff, FN_REFLEN, own_path_prefix, path, NullS);
strmake(to, from, FN_REFLEN-1);
DBUG_PRINT("exit",("to: %s",to));
DBUG_RETURN(to);
}
|
O3
|
c
|
my_load_path:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
cmpb $0x7e, (%rsi)
jne 0xab986
cmpb $0x2f, 0x1(%r14)
je 0xab992
movq %r14, %rdi
callq 0xa149a
testl %eax, %eax
je 0xab9cd
movq %r14, %r12
movl $0x1ff, %edx # imm = 0x1FF
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd9de4
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0xaba74
movq %rbx, %rax
addq $0x218, %rsp # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x2e, (%r14)
jne 0xab9e0
movl $0x2, %r13d
cmpb $0x2f, 0x1(%r14)
je 0xaba1f
leaq 0x2f90f(%rip), %rsi # 0xdb2f6
movq %r14, %rdi
callq 0xd84c4
xorl %r13d, %r13d
testq %r15, %r15
je 0xaba1f
testl %eax, %eax
jne 0xaba1f
leaq -0x240(%rbp), %r12
movl $0x200, %esi # imm = 0x200
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xd9f04
jmp 0xab995
movq %r14, %rdi
callq 0x29330
leal 0x200(%r13), %esi
subl %eax, %esi
leaq -0x240(%rbp), %r12
movq %r12, %rdi
xorl %edx, %edx
callq 0xa1304
testl %eax, %eax
jne 0xab992
movq %r12, %rdi
callq 0x29330
leaq (%rax,%rbp), %rdi
addq $-0x240, %rdi # imm = 0xFDC0
addq %r13, %r14
movl $0x200, %edx # imm = 0x200
subq %rax, %rdx
movq %r14, %rsi
callq 0xd9de4
jmp 0xab995
callq 0x29240
nopl (%rax)
|
my_load_path:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 218h
mov r15, rdx
mov r14, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
cmp byte ptr [rsi], 7Eh ; '~'
jnz short loc_AB986
cmp byte ptr [r14+1], 2Fh ; '/'
jz short loc_AB992
loc_AB986:
mov rdi, r14
call test_if_hard_path
test eax, eax
jz short loc_AB9CD
loc_AB992:
mov r12, r14
loc_AB995:
mov edx, 1FFh
mov rdi, rbx
mov rsi, r12
call strmake
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz loc_ABA74
mov rax, rbx
add rsp, 218h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_AB9CD:
cmp byte ptr [r14], 2Eh ; '.'
jnz short loc_AB9E0
mov r13d, 2
cmp byte ptr [r14+1], 2Fh ; '/'
jz short loc_ABA1F
loc_AB9E0:
lea rsi, aTesting+8; ".."
mov rdi, r14
call is_prefix
xor r13d, r13d
test r15, r15
jz short loc_ABA1F
test eax, eax
jnz short loc_ABA1F
lea r12, [rbp+var_240]
mov esi, 200h
mov rdi, r12
mov rdx, r15
mov rcx, r14
xor r8d, r8d
xor eax, eax
call strxnmov
jmp loc_AB995
loc_ABA1F:
mov rdi, r14
call _strlen
lea esi, [r13+200h]
sub esi, eax
lea r12, [rbp+var_240]
mov rdi, r12
xor edx, edx
call my_getwd
test eax, eax
jnz loc_AB992
mov rdi, r12
call _strlen
lea rdi, [rax+rbp]
add rdi, 0FFFFFFFFFFFFFDC0h
add r14, r13
mov edx, 200h
sub rdx, rax
mov rsi, r14
call strmake
jmp loc_AB995
loc_ABA74:
call ___stack_chk_fail
|
long long my_load_path(long long a1, char *a2, long long a3)
{
char *v4; // r12
long long v6; // r13
int v7; // eax
int v8; // r9d
int v9; // eax
long long v10; // rax
char v11[528]; // [rsp+0h] [rbp-240h] BYREF
unsigned long long v12; // [rsp+210h] [rbp-30h]
v12 = __readfsqword(0x28u);
if ( (*a2 != 126 || a2[1] != 47) && !test_if_hard_path(a2) )
{
if ( *a2 != 46 || (v6 = 2LL, a2[1] != 47) )
{
v7 = is_prefix(a2, "..");
v6 = 0LL;
if ( a3 )
{
if ( !v7 )
{
v4 = v11;
strxnmov((unsigned int)v11, 512, a3, (_DWORD)a2, 0, v8, v11[0]);
goto LABEL_5;
}
}
}
v9 = strlen(a2);
v4 = v11;
if ( !(unsigned int)my_getwd(v11, (unsigned int)(v6 + 512 - v9), 0) )
{
v10 = strlen(v11);
strmake(&v11[v10], &a2[v6], 512 - v10);
goto LABEL_5;
}
}
v4 = a2;
LABEL_5:
strmake(a1, v4, 511LL);
return a1;
}
|
my_load_path:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x218
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
CMP byte ptr [RSI],0x7e
JNZ 0x001ab986
CMP byte ptr [R14 + 0x1],0x2f
JZ 0x001ab992
LAB_001ab986:
MOV RDI,R14
CALL 0x001a149a
TEST EAX,EAX
JZ 0x001ab9cd
LAB_001ab992:
MOV R12,R14
LAB_001ab995:
MOV EDX,0x1ff
MOV RDI,RBX
MOV RSI,R12
CALL 0x001d9de4
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001aba74
MOV RAX,RBX
ADD RSP,0x218
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001ab9cd:
CMP byte ptr [R14],0x2e
JNZ 0x001ab9e0
MOV R13D,0x2
CMP byte ptr [R14 + 0x1],0x2f
JZ 0x001aba1f
LAB_001ab9e0:
LEA RSI,[0x1db2f6]
MOV RDI,R14
CALL 0x001d84c4
XOR R13D,R13D
TEST R15,R15
JZ 0x001aba1f
TEST EAX,EAX
JNZ 0x001aba1f
LEA R12,[RBP + -0x240]
MOV ESI,0x200
MOV RDI,R12
MOV RDX,R15
MOV RCX,R14
XOR R8D,R8D
XOR EAX,EAX
CALL 0x001d9f04
JMP 0x001ab995
LAB_001aba1f:
MOV RDI,R14
CALL 0x00129330
LEA ESI,[R13 + 0x200]
SUB ESI,EAX
LEA R12,[RBP + -0x240]
MOV RDI,R12
XOR EDX,EDX
CALL 0x001a1304
TEST EAX,EAX
JNZ 0x001ab992
MOV RDI,R12
CALL 0x00129330
LEA RDI,[RAX + RBP*0x1]
ADD RDI,-0x240
ADD R14,R13
MOV EDX,0x200
SUB RDX,RAX
MOV RSI,R14
CALL 0x001d9de4
JMP 0x001ab995
LAB_001aba74:
CALL 0x00129240
|
int8 my_load_path(int8 param_1,char *param_2,long param_3)
{
int iVar1;
size_t sVar2;
long lVar3;
long in_FS_OFFSET;
char local_248 [528];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
if (((*param_2 != '~') || (param_2[1] != '/')) && (iVar1 = test_if_hard_path(param_2), iVar1 == 0)
) {
if ((*param_2 != '.') || (lVar3 = 2, param_2[1] != '/')) {
iVar1 = is_prefix(param_2,"..");
lVar3 = 0;
if ((param_3 != 0) && (iVar1 == 0)) {
strxnmov(local_248,0x200,param_3,param_2,0);
param_2 = local_248;
goto LAB_001ab995;
}
}
sVar2 = strlen(param_2);
iVar1 = my_getwd(local_248,((int)lVar3 + 0x200) - (int)sVar2,0);
if (iVar1 == 0) {
sVar2 = strlen(local_248);
strmake(local_248 + sVar2,param_2 + lVar3,0x200 - sVar2);
param_2 = local_248;
}
}
LAB_001ab995:
strmake(param_1,param_2,0x1ff);
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
}
|
|
66,008 |
ma_net_write_command
|
eloqsql/libmariadb/libmariadb/ma_net.c
|
int ma_net_write_command(NET *net, uchar command,
const char *packet, size_t len,
my_bool disable_flush)
{
uchar buff[NET_HEADER_SIZE+1];
size_t buff_size= NET_HEADER_SIZE + 1;
size_t length= 1 + len; /* 1 extra byte for command */
int rc;
buff[NET_HEADER_SIZE]= 0;
buff[4]=command;
if (length >= MAX_PACKET_LENGTH)
{
len= MAX_PACKET_LENGTH - 1;
do
{
int3store(buff, MAX_PACKET_LENGTH);
buff[3]= (net->compress) ? 0 : (uchar) (net->pkt_nr++);
if (ma_net_write_buff(net, (char *)buff, buff_size) ||
ma_net_write_buff(net, packet, len))
return(1);
packet+= len;
length-= MAX_PACKET_LENGTH;
len= MAX_PACKET_LENGTH;
buff_size= NET_HEADER_SIZE; /* don't send command for further packets */
} while (length >= MAX_PACKET_LENGTH);
len= length;
}
int3store(buff,length);
buff[3]= (net->compress) ? 0 :(uchar) (net->pkt_nr++);
rc= test (ma_net_write_buff(net,(char *)buff, buff_size) ||
ma_net_write_buff(net,packet,len));
if (!rc && !disable_flush)
return test(ma_net_flush(net));
return rc;
}
|
O3
|
c
|
ma_net_write_command:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, -0x3c(%rbp)
movq %rdx, %r15
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
leaq 0x1(%rcx), %rax
movb %sil, -0x31(%rbp)
movl $0x5, %edx
cmpq $0xffffff, %rax # imm = 0xFFFFFF
jb 0x35fde
movl $0xfffffe, %r14d # imm = 0xFFFFFE
movq %rax, %r12
movb $0x1, %r13b
movw $0xffff, -0x35(%rbp) # imm = 0xFFFF
movb $-0x1, -0x33(%rbp)
cmpb $0x0, 0x84(%rbx)
je 0x35f85
xorl %eax, %eax
jmp 0x35f8e
movl 0x60(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x60(%rbx)
movb %al, -0x32(%rbp)
movq %rbx, %rdi
leaq -0x35(%rbp), %rsi
callq 0x35e09
testl %eax, %eax
jne 0x36045
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x35e09
testl %eax, %eax
jne 0x36045
addq %r14, %r15
addq $-0xffffff, %r12 # imm = 0xFF000001
movl $0x4, %edx
movl $0xffffff, %r14d # imm = 0xFFFFFF
movq %r12, %rax
cmpq $0xfffffe, %r12 # imm = 0xFFFFFE
ja 0x35f6e
jmp 0x35fe1
movq %rcx, %r12
movb %al, -0x35(%rbp)
movb %ah, -0x34(%rbp)
shrl $0x10, %eax
movb %al, -0x33(%rbp)
cmpb $0x0, 0x84(%rbx)
je 0x35ffa
xorl %eax, %eax
jmp 0x36003
movl 0x60(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x60(%rbx)
leaq -0x35(%rbp), %rsi
movb %al, 0x3(%rsi)
movq %rbx, %rdi
callq 0x35e09
movb $0x1, %r13b
testl %eax, %eax
jne 0x36045
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x35e09
testl %eax, %eax
setne %r13b
cmpb $0x0, -0x3c(%rbp)
jne 0x36045
testl %eax, %eax
jne 0x36045
movq %rbx, %rdi
callq 0x35ac6
testl %eax, %eax
setne %r13b
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x36067
movzbl %r13b, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13510
|
ma_net_write_command:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov [rbp+var_3C], r8d
mov r15, rdx
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
lea rax, [rcx+1]
mov [rbp+var_31], sil
mov edx, 5
cmp rax, 0FFFFFFh
jb short loc_35FDE
mov r14d, 0FFFFFEh
mov r12, rax
mov r13b, 1
loc_35F6E:
mov [rbp+var_35], 0FFFFh
mov [rbp+var_33], 0FFh
cmp byte ptr [rbx+84h], 0
jz short loc_35F85
xor eax, eax
jmp short loc_35F8E
loc_35F85:
mov eax, [rbx+60h]
lea ecx, [rax+1]
mov [rbx+60h], ecx
loc_35F8E:
mov [rbp+var_32], al
mov rdi, rbx
lea rsi, [rbp+var_35]
call ma_net_write_buff
test eax, eax
jnz loc_36045
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call ma_net_write_buff
test eax, eax
jnz loc_36045
add r15, r14
add r12, 0FFFFFFFFFF000001h
mov edx, 4
mov r14d, 0FFFFFFh
mov rax, r12
cmp r12, 0FFFFFEh
ja short loc_35F6E
jmp short loc_35FE1
loc_35FDE:
mov r12, rcx
loc_35FE1:
mov byte ptr [rbp+var_35], al
mov byte ptr [rbp+var_35+1], ah
shr eax, 10h
mov [rbp+var_33], al
cmp byte ptr [rbx+84h], 0
jz short loc_35FFA
xor eax, eax
jmp short loc_36003
loc_35FFA:
mov eax, [rbx+60h]
lea ecx, [rax+1]
mov [rbx+60h], ecx
loc_36003:
lea rsi, [rbp+var_35]
mov [rsi+3], al
mov rdi, rbx
call ma_net_write_buff
mov r13b, 1
test eax, eax
jnz short loc_36045
mov rdi, rbx
mov rsi, r15
mov rdx, r12
call ma_net_write_buff
test eax, eax
setnz r13b
cmp byte ptr [rbp+var_3C], 0
jnz short loc_36045
test eax, eax
jnz short loc_36045
mov rdi, rbx
call ma_net_flush
test eax, eax
setnz r13b
loc_36045:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_36067
movzx eax, r13b
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_36067:
call ___stack_chk_fail
|
_BOOL8 ma_net_write_command(long long a1, char a2, long long a3, unsigned long long a4, char a5)
{
int v6; // eax
unsigned long long v7; // rdx
unsigned long long v8; // r14
unsigned long long v9; // r12
bool v10; // r13
int v11; // eax
int v12; // eax
BOOL v13; // eax
__int16 v16; // [rsp+Bh] [rbp-35h] BYREF
char v17; // [rsp+Dh] [rbp-33h]
char v18; // [rsp+Eh] [rbp-32h]
char v19; // [rsp+Fh] [rbp-31h]
unsigned long long v20; // [rsp+10h] [rbp-30h]
v20 = __readfsqword(0x28u);
v6 = a4 + 1;
v19 = a2;
v7 = 5LL;
if ( a4 + 1 < 0xFFFFFF )
{
v9 = a4;
LABEL_11:
v16 = v6;
v17 = BYTE2(v6);
if ( *(_BYTE *)(a1 + 132) )
{
LOBYTE(v12) = 0;
}
else
{
v12 = *(_DWORD *)(a1 + 96);
*(_DWORD *)(a1 + 96) = v12 + 1;
}
v18 = v12;
v10 = 1;
if ( !ma_net_write_buff(a1, (long long)&v16, v7) )
{
v13 = ma_net_write_buff(a1, a3, v9);
v10 = v13;
if ( !a5 && !v13 )
return (unsigned int)ma_net_flush(a1) != 0;
}
}
else
{
v8 = 16777214LL;
v9 = a4 + 1;
v10 = 1;
while ( 1 )
{
v16 = -1;
v17 = -1;
if ( *(_BYTE *)(a1 + 132) )
{
LOBYTE(v11) = 0;
}
else
{
v11 = *(_DWORD *)(a1 + 96);
*(_DWORD *)(a1 + 96) = v11 + 1;
}
v18 = v11;
if ( ma_net_write_buff(a1, (long long)&v16, v7) || ma_net_write_buff(a1, a3, v8) )
break;
a3 += v8;
v9 -= 0xFFFFFFLL;
v7 = 4LL;
v8 = 0xFFFFFFLL;
v6 = v9;
if ( v9 <= 0xFFFFFE )
goto LABEL_11;
}
}
return v10;
}
|
ma_net_write_command:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV dword ptr [RBP + -0x3c],R8D
MOV R15,RDX
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
LEA RAX,[RCX + 0x1]
MOV byte ptr [RBP + -0x31],SIL
MOV EDX,0x5
CMP RAX,0xffffff
JC 0x00135fde
MOV R14D,0xfffffe
MOV R12,RAX
MOV R13B,0x1
LAB_00135f6e:
MOV word ptr [RBP + -0x35],0xffff
MOV byte ptr [RBP + -0x33],0xff
CMP byte ptr [RBX + 0x84],0x0
JZ 0x00135f85
XOR EAX,EAX
JMP 0x00135f8e
LAB_00135f85:
MOV EAX,dword ptr [RBX + 0x60]
LEA ECX,[RAX + 0x1]
MOV dword ptr [RBX + 0x60],ECX
LAB_00135f8e:
MOV byte ptr [RBP + -0x32],AL
MOV RDI,RBX
LEA RSI,[RBP + -0x35]
CALL 0x00135e09
TEST EAX,EAX
JNZ 0x00136045
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x00135e09
TEST EAX,EAX
JNZ 0x00136045
ADD R15,R14
ADD R12,-0xffffff
MOV EDX,0x4
MOV R14D,0xffffff
MOV RAX,R12
CMP R12,0xfffffe
JA 0x00135f6e
JMP 0x00135fe1
LAB_00135fde:
MOV R12,RCX
LAB_00135fe1:
MOV byte ptr [RBP + -0x35],AL
MOV byte ptr [RBP + -0x34],AH
SHR EAX,0x10
MOV byte ptr [RBP + -0x33],AL
CMP byte ptr [RBX + 0x84],0x0
JZ 0x00135ffa
XOR EAX,EAX
JMP 0x00136003
LAB_00135ffa:
MOV EAX,dword ptr [RBX + 0x60]
LEA ECX,[RAX + 0x1]
MOV dword ptr [RBX + 0x60],ECX
LAB_00136003:
LEA RSI,[RBP + -0x35]
MOV byte ptr [RSI + 0x3],AL
MOV RDI,RBX
CALL 0x00135e09
MOV R13B,0x1
TEST EAX,EAX
JNZ 0x00136045
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R12
CALL 0x00135e09
TEST EAX,EAX
SETNZ R13B
CMP byte ptr [RBP + -0x3c],0x0
JNZ 0x00136045
TEST EAX,EAX
JNZ 0x00136045
MOV RDI,RBX
CALL 0x00135ac6
TEST EAX,EAX
SETNZ R13B
LAB_00136045:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00136067
MOVZX EAX,R13B
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00136067:
CALL 0x00113510
|
bool ma_net_write_command(long param_1,int1 param_2,long param_3,ulong param_4,char param_5)
{
int iVar1;
int8 uVar2;
ulong uVar3;
long lVar4;
long in_FS_OFFSET;
bool bVar5;
int2 local_3d;
int1 local_3b;
int1 local_3a;
int1 local_39;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
uVar3 = param_4 + 1;
uVar2 = 5;
local_39 = param_2;
if (0xfffffe < uVar3) {
lVar4 = 0xfffffe;
bVar5 = true;
do {
local_3d = 0xffff;
local_3b = 0xff;
if (*(char *)(param_1 + 0x84) == '\0') {
iVar1 = *(int *)(param_1 + 0x60);
*(int *)(param_1 + 0x60) = iVar1 + 1;
}
else {
iVar1 = 0;
}
local_3a = (int1)iVar1;
iVar1 = ma_net_write_buff(param_1,&local_3d,uVar2);
if ((iVar1 != 0) || (iVar1 = ma_net_write_buff(param_1,param_3,lVar4), iVar1 != 0))
goto LAB_00136045;
param_3 = param_3 + lVar4;
uVar3 = uVar3 - 0xffffff;
uVar2 = 4;
lVar4 = 0xffffff;
param_4 = uVar3;
} while (0xfffffe < uVar3);
}
local_3d = (int2)uVar3;
local_3b = (int1)(uVar3 >> 0x10);
if (*(char *)(param_1 + 0x84) == '\0') {
iVar1 = *(int *)(param_1 + 0x60);
*(int *)(param_1 + 0x60) = iVar1 + 1;
}
else {
iVar1 = 0;
}
local_3a = (int1)iVar1;
iVar1 = ma_net_write_buff(param_1,&local_3d,uVar2);
bVar5 = true;
if (iVar1 == 0) {
iVar1 = ma_net_write_buff(param_1,param_3,param_4);
bVar5 = iVar1 != 0;
if ((param_5 == '\0') && (iVar1 == 0)) {
iVar1 = ma_net_flush(param_1);
bVar5 = iVar1 != 0;
}
}
LAB_00136045:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return bVar5;
}
|
|
66,009 |
ma_write_undo_key_insert
|
eloqsql/storage/maria/ma_write.c
|
int _ma_write_undo_key_insert(MARIA_HA *info, const MARIA_KEY *key,
my_off_t *root, my_off_t new_root, LSN *res_lsn)
{
MARIA_SHARE *share= info->s;
MARIA_KEYDEF *keyinfo= key->keyinfo;
uchar log_data[LSN_STORE_SIZE + FILEID_STORE_SIZE +
KEY_NR_STORE_SIZE];
const uchar *key_value;
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 2];
struct st_msg_to_write_hook_for_undo_key msg;
uint key_length;
/* Save if we need to write a clr record */
lsn_store(log_data, info->trn->undo_lsn);
key_nr_store(log_data + LSN_STORE_SIZE + FILEID_STORE_SIZE,
keyinfo->key_nr);
key_length= key->data_length + key->ref_length;
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= sizeof(log_data);
log_array[TRANSLOG_INTERNAL_PARTS + 1].str= key->data;
log_array[TRANSLOG_INTERNAL_PARTS + 1].length= key_length;
msg.root= root;
msg.value= new_root;
msg.auto_increment= 0;
key_value= key->data;
if (share->base.auto_key == ((uint) keyinfo->key_nr + 1))
{
const HA_KEYSEG *keyseg= keyinfo->seg;
uchar reversed[MARIA_MAX_KEY_BUFF];
if (keyseg->flag & HA_SWAP_KEY)
{
/* We put key from log record to "data record" packing format... */
const uchar *key_ptr= key->data, *key_end= key->data + keyseg->length;
uchar *to= reversed + keyseg->length;
do
{
*--to= *key_ptr++;
} while (key_ptr != key_end);
key_value= to;
}
/* ... so that we can read it with: */
msg.auto_increment=
ma_retrieve_auto_increment(key_value, keyseg->type);
/* and write_hook_for_undo_key_insert() will pick this. */
}
return translog_write_record(res_lsn, LOGREC_UNDO_KEY_INSERT,
info->trn, info,
(translog_size_t)
log_array[TRANSLOG_INTERNAL_PARTS + 0].length +
key_length,
TRANSLOG_INTERNAL_PARTS + 2, log_array,
log_data + LSN_STORE_SIZE, &msg) ? -1 : 0;
}
|
O3
|
c
|
ma_write_undo_key_insert:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa50, %rsp # imm = 0xA50
movq %r8, %rbx
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
movq (%rdi), %r9
movq 0x8(%rsi), %r8
movq 0x8(%rdi), %rax
movq 0x98(%rax), %rdi
movq %rdi, %r10
shrq $0x20, %r10
leaq -0x32(%rbp), %r11
movb %r10b, (%r11)
movq %rdi, %r10
shrq $0x28, %r10
movb %r10b, 0x1(%r11)
movq %rdi, %r10
shrq $0x30, %r10
movb %r10b, 0x2(%r11)
movl %edi, 0x3(%r11)
movzbl 0xa5(%r8), %r10d
movb %r10b, 0x9(%r11)
movl 0x14(%rsi), %r15d
addl 0x10(%rsi), %r15d
movq %r11, -0xa50(%rbp)
movq $0xa, -0xa48(%rbp)
movq (%rsi), %rdi
movq %rdi, -0xa40(%rbp)
movq %r15, -0xa38(%rbp)
movq %rdx, -0xa30(%rbp)
movq %rcx, -0xa28(%rbp)
movq $0x0, -0xa18(%rbp)
incl %r10d
cmpl %r10d, 0x3ec(%r9)
jne 0x66c2e
movq 0xc0(%r8), %rax
testb $0x40, 0x12(%rax)
je 0x66c1a
movzwl 0x14(%rax), %ecx
leaq -0xa10(%rbp), %rdx
movb (%rdi), %sil
incq %rdi
movb %sil, -0xa11(%rbp,%rcx)
decq %rcx
jne 0x66c04
movq %rdx, %rdi
movzbl 0x18(%rax), %esi
callq 0x374a7
movq %rax, -0xa18(%rbp)
movq 0x8(%r14), %rax
leaq -0x2b(%rbp), %r10
addl $0xa, %r15d
subq $0x8, %rsp
leaq -0xa30(%rbp), %r11
leaq -0xa70(%rbp), %r12
movq %rbx, %rdi
movl $0x15, %esi
movq %rax, %rdx
movq %r14, %rcx
movl %r15d, %r8d
movl $0x4, %r9d
pushq %r11
pushq %r10
pushq %r12
callq 0x2a8ac
addq $0x20, %rsp
movl %eax, %ecx
xorl %eax, %eax
negb %cl
sbbl %eax, %eax
movq %fs:0x28, %rcx
cmpq -0x28(%rbp), %rcx
jne 0x66c95
addq $0xa50, %rsp # imm = 0xA50
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x29270
|
_ma_write_undo_key_insert:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 0A50h
mov rbx, r8
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_28], rax
mov r9, [rdi]
mov r8, [rsi+8]
mov rax, [rdi+8]
mov rdi, [rax+98h]
mov r10, rdi
shr r10, 20h
lea r11, [rbp+var_32]
mov [r11], r10b
mov r10, rdi
shr r10, 28h
mov [r11+1], r10b
mov r10, rdi
shr r10, 30h
mov [r11+2], r10b
mov [r11+3], edi
movzx r10d, byte ptr [r8+0A5h]
mov [r11+9], r10b
mov r15d, [rsi+14h]
add r15d, [rsi+10h]
mov [rbp+var_A50], r11
mov [rbp+var_A48], 0Ah
mov rdi, [rsi]
mov [rbp+var_A40], rdi
mov [rbp+var_A38], r15
mov [rbp+var_A30], rdx
mov [rbp+var_A28], rcx
mov [rbp+var_A18], 0
inc r10d
cmp [r9+3ECh], r10d
jnz short loc_66C2E
mov rax, [r8+0C0h]
test byte ptr [rax+12h], 40h
jz short loc_66C1A
movzx ecx, word ptr [rax+14h]
lea rdx, [rbp+var_A10]
loc_66C04:
mov sil, [rdi]
inc rdi
mov byte ptr [rbp+rcx+var_A18+7], sil
dec rcx
jnz short loc_66C04
mov rdi, rdx
loc_66C1A:
movzx esi, byte ptr [rax+18h]
call ma_retrieve_auto_increment
mov [rbp+var_A18], rax
mov rax, [r14+8]
loc_66C2E:
lea r10, [rbp+var_2B]
add r15d, 0Ah
sub rsp, 8
lea r11, [rbp+var_A30]
lea r12, [rbp+var_A70]
mov rdi, rbx
mov esi, 15h
mov rdx, rax
mov rcx, r14
mov r8d, r15d
mov r9d, 4
push r11
push r10
push r12
call translog_write_record
add rsp, 20h
mov ecx, eax
xor eax, eax
neg cl
sbb eax, eax
mov rcx, fs:28h
cmp rcx, [rbp+var_28]
jnz short loc_66C95
add rsp, 0A50h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_66C95:
call ___stack_chk_fail
|
long long ma_write_undo_key_insert(long long *a1, long long a2, long long a3, long long a4, unsigned long long a5)
{
long long v7; // r9
long long v8; // r8
long long v9; // rax
long long v10; // rdi
long long v11; // r15
unsigned __int8 *v12; // rdi
long long v13; // rax
long long v14; // rcx
char v15; // si
__int128 v17; // [rsp+0h] [rbp-A70h] BYREF
_BYTE *v18; // [rsp+20h] [rbp-A50h]
long long v19; // [rsp+28h] [rbp-A48h]
unsigned __int8 *v20; // [rsp+30h] [rbp-A40h]
long long v21; // [rsp+38h] [rbp-A38h]
_QWORD v22[3]; // [rsp+40h] [rbp-A30h] BYREF
long long auto_increment; // [rsp+58h] [rbp-A18h]
char v24; // [rsp+60h] [rbp-A10h] BYREF
_BYTE v25[3]; // [rsp+A3Eh] [rbp-32h] BYREF
int v26; // [rsp+A41h] [rbp-2Fh]
__int16 v27; // [rsp+A45h] [rbp-2Bh] BYREF
unsigned __int8 v28; // [rsp+A47h] [rbp-29h]
unsigned long long v29; // [rsp+A48h] [rbp-28h]
v29 = __readfsqword(0x28u);
v7 = *a1;
v8 = *(_QWORD *)(a2 + 8);
v9 = a1[1];
v10 = *(_QWORD *)(v9 + 152);
v25[0] = BYTE4(v10);
v25[1] = BYTE5(v10);
v25[2] = BYTE6(v10);
v26 = v10;
v28 = *(_BYTE *)(v8 + 165);
v11 = (unsigned int)(*(_DWORD *)(a2 + 16) + *(_DWORD *)(a2 + 20));
v18 = v25;
v19 = 10LL;
v12 = *(unsigned __int8 **)a2;
v20 = *(unsigned __int8 **)a2;
v21 = v11;
v22[0] = a3;
v22[1] = a4;
auto_increment = 0LL;
if ( *(_DWORD *)(v7 + 1004) == v28 + 1 )
{
v13 = *(_QWORD *)(v8 + 192);
if ( (*(_BYTE *)(v13 + 18) & 0x40) != 0 )
{
v14 = *(unsigned __int16 *)(v13 + 20);
do
{
v15 = *v12++;
*((_BYTE *)&auto_increment + v14-- + 7) = v15;
}
while ( v14 );
v12 = (unsigned __int8 *)&v24;
}
auto_increment = ma_retrieve_auto_increment(v12, *(unsigned __int8 *)(v13 + 24));
v9 = a1[1];
}
return (unsigned int)-((unsigned __int8)translog_write_record(
a5,
(int *)((char *)&dword_14 + 1),
v9,
a1,
(int)v11 + 10,
4,
&v17,
&v27,
(long long)v22) != 0);
}
|
_ma_write_undo_key_insert:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0xa50
MOV RBX,R8
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV R9,qword ptr [RDI]
MOV R8,qword ptr [RSI + 0x8]
MOV RAX,qword ptr [RDI + 0x8]
MOV RDI,qword ptr [RAX + 0x98]
MOV R10,RDI
SHR R10,0x20
LEA R11,[RBP + -0x32]
MOV byte ptr [R11],R10B
MOV R10,RDI
SHR R10,0x28
MOV byte ptr [R11 + 0x1],R10B
MOV R10,RDI
SHR R10,0x30
MOV byte ptr [R11 + 0x2],R10B
MOV dword ptr [R11 + 0x3],EDI
MOVZX R10D,byte ptr [R8 + 0xa5]
MOV byte ptr [R11 + 0x9],R10B
MOV R15D,dword ptr [RSI + 0x14]
ADD R15D,dword ptr [RSI + 0x10]
MOV qword ptr [RBP + -0xa50],R11
MOV qword ptr [RBP + -0xa48],0xa
MOV RDI,qword ptr [RSI]
MOV qword ptr [RBP + -0xa40],RDI
MOV qword ptr [RBP + -0xa38],R15
MOV qword ptr [RBP + -0xa30],RDX
MOV qword ptr [RBP + -0xa28],RCX
MOV qword ptr [RBP + -0xa18],0x0
INC R10D
CMP dword ptr [R9 + 0x3ec],R10D
JNZ 0x00166c2e
MOV RAX,qword ptr [R8 + 0xc0]
TEST byte ptr [RAX + 0x12],0x40
JZ 0x00166c1a
MOVZX ECX,word ptr [RAX + 0x14]
LEA RDX,[RBP + -0xa10]
LAB_00166c04:
MOV SIL,byte ptr [RDI]
INC RDI
MOV byte ptr [RBP + RCX*0x1 + -0xa11],SIL
DEC RCX
JNZ 0x00166c04
MOV RDI,RDX
LAB_00166c1a:
MOVZX ESI,byte ptr [RAX + 0x18]
CALL 0x001374a7
MOV qword ptr [RBP + -0xa18],RAX
MOV RAX,qword ptr [R14 + 0x8]
LAB_00166c2e:
LEA R10,[RBP + -0x2b]
ADD R15D,0xa
SUB RSP,0x8
LEA R11,[RBP + -0xa30]
LEA R12,[RBP + -0xa70]
MOV RDI,RBX
MOV ESI,0x15
MOV RDX,RAX
MOV RCX,R14
MOV R8D,R15D
MOV R9D,0x4
PUSH R11
PUSH R10
PUSH R12
CALL 0x0012a8ac
ADD RSP,0x20
MOV ECX,EAX
XOR EAX,EAX
NEG CL
SBB EAX,EAX
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x28]
JNZ 0x00166c95
ADD RSP,0xa50
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00166c95:
CALL 0x00129270
|
int _ma_write_undo_key_insert
(long *param_1,long *param_2,int8 param_3,int8 param_4,int8 param_5)
{
int1 uVar1;
int8 uVar2;
char cVar3;
long lVar4;
ulong uVar5;
int1 *puVar6;
int1 *puVar7;
uint uVar8;
long in_FS_OFFSET;
int1 local_a78 [32];
int1 *local_a58;
int8 local_a50;
int1 *local_a48;
ulong local_a40;
int8 local_a38;
int8 local_a30;
int8 local_a20;
int1 local_a18 [2526];
int1 local_3a;
int1 local_39;
int1 local_38;
int4 local_37;
int1 local_33 [2];
byte local_31;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
lVar4 = param_1[1];
uVar2 = *(int8 *)(lVar4 + 0x98);
local_a58 = &local_3a;
local_3a = (int1)((ulong)uVar2 >> 0x20);
local_39 = (int1)((ulong)uVar2 >> 0x28);
local_38 = (int1)((ulong)uVar2 >> 0x30);
local_37 = (int4)uVar2;
local_31 = *(byte *)(param_2[1] + 0xa5);
uVar8 = *(int *)((long)param_2 + 0x14) + (int)param_2[2];
local_a40 = (ulong)uVar8;
local_a50 = 10;
local_a48 = (int1 *)*param_2;
local_a20 = 0;
local_a38 = param_3;
local_a30 = param_4;
if (*(int *)(*param_1 + 0x3ec) == local_31 + 1) {
lVar4 = *(long *)(param_2[1] + 0xc0);
puVar7 = local_a48;
if ((*(byte *)(lVar4 + 0x12) & 0x40) != 0) {
uVar5 = (ulong)*(ushort *)(lVar4 + 0x14);
puVar7 = local_a18;
puVar6 = local_a48;
do {
uVar1 = *puVar6;
puVar6 = puVar6 + 1;
local_a18[uVar5 - 1] = uVar1;
uVar5 = uVar5 - 1;
} while (uVar5 != 0);
}
local_a20 = ma_retrieve_auto_increment(puVar7,*(int1 *)(lVar4 + 0x18));
lVar4 = param_1[1];
}
cVar3 = translog_write_record
(param_5,0x15,lVar4,param_1,uVar8 + 10,4,local_a78,local_33,&local_a38);
if (*(long *)(in_FS_OFFSET + 0x28) != local_30) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return -(uint)(cVar3 != '\0');
}
|
|
66,010 |
translog_destroy
|
eloqsql/storage/maria/ma_loghandler.c
|
void translog_destroy()
{
TRANSLOG_FILE **file;
uint i;
uint8 current_buffer;
DBUG_ENTER("translog_destroy");
DBUG_ASSERT(translog_status == TRANSLOG_OK ||
translog_status == TRANSLOG_READONLY);
translog_lock();
current_buffer= log_descriptor.bc.buffer_no;
translog_status= (translog_status == TRANSLOG_READONLY ?
TRANSLOG_UNINITED :
TRANSLOG_SHUTDOWN);
if (log_descriptor.bc.buffer->file != NULL)
translog_finish_page(&log_descriptor.horizon, &log_descriptor.bc);
translog_unlock();
for (i= 0; i < TRANSLOG_BUFFERS_NO; i++)
{
struct st_translog_buffer *buffer= (log_descriptor.buffers +
((i + current_buffer + 1) %
TRANSLOG_BUFFERS_NO));
translog_buffer_destroy(buffer);
}
translog_status= TRANSLOG_UNINITED;
/* close files */
while ((file= (TRANSLOG_FILE **)pop_dynamic(&log_descriptor.open_files)))
translog_close_log_file(*file);
mysql_mutex_destroy(&log_descriptor.sent_to_disk_lock);
mysql_mutex_destroy(&log_descriptor.file_header_lock);
mysql_mutex_destroy(&log_descriptor.unfinished_files_lock);
mysql_mutex_destroy(&log_descriptor.purger_lock);
mysql_mutex_destroy(&log_descriptor.log_flush_lock);
mysql_mutex_destroy(&log_descriptor.dirty_buffer_mask_lock);
mysql_cond_destroy(&log_descriptor.log_flush_cond);
mysql_cond_destroy(&log_descriptor.new_goal_cond);
mysql_rwlock_destroy(&log_descriptor.open_files_lock);
delete_dynamic(&log_descriptor.open_files);
delete_dynamic(&log_descriptor.unfinished_files);
if (log_descriptor.directory_fd >= 0)
mysql_file_close(log_descriptor.directory_fd, MYF(MY_WME));
if (id_to_share != NULL)
my_free(id_to_share + 1);
DBUG_VOID_RETURN;
}
|
O3
|
c
|
translog_destroy:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
callq 0x49f07
movzbl 0xbb4f52(%rip), %r15d # 0xc016f6
xorl %eax, %eax
cmpl $0x2, 0x3b30b3(%rip) # 0x3ff860
setne %al
leal (%rax,%rax,2), %eax
movl %eax, 0x3b30a7(%rip) # 0x3ff860
movq 0xbb4f28(%rip), %rbx # 0xc016e8
cmpq $0x0, 0x100038(%rbx)
je 0x4c7e4
leaq 0xbb4ee7(%rip), %rdi # 0xc016b8
leaq 0xbb4ee8(%rip), %rsi # 0xc016c0
callq 0x4cafe
movq 0xbb4f04(%rip), %rbx # 0xc016e8
movq 0x1000d0(%rbx), %rdi
testq %rdi, %rdi
jne 0x4cabf
addq $0x100090, %rbx # imm = 0x100090
movq %rbx, %rdi
callq 0x291e0
incl %r15d
xorl %r12d, %r12d
leaq 0x3b4260(%rip), %r13 # 0x400a70
leaq 0x33b8a9(%rip), %r14 # 0x3880c0
leal (%r15,%r12), %eax
andl $0x7, %eax
imulq $0x100120, %rax, %rax # imm = 0x100120
leaq (%rax,%r13), %rbx
addq $0x2f8, %rbx # imm = 0x2F8
cmpq $0x0, 0x100038(%rbx)
je 0x4c862
movq %rbx, %rdi
callq 0x49fa7
movq %rbx, %rdi
callq 0x4dc75
movq 0x1000d0(%rbx), %rdi
testq %rdi, %rdi
jne 0x4c8c8
leaq 0x100090(%rbx), %rdi
callq 0x291e0
movq 0x1000d0(%rbx), %rdi
testq %rdi, %rdi
je 0x4c87f
movq (%r14), %rax
callq *0x48(%rax)
movq $0x0, 0x1000d0(%rbx)
leaq 0x100090(%rbx), %rdi
callq 0x290c0
movq 0x100070(%rbx), %rdi
testq %rdi, %rdi
jne 0x4c8b5
addq $0x100040, %rbx # imm = 0x100040
movq %rbx, %rdi
callq 0x29280
incl %r12d
cmpl $0x8, %r12d
jne 0x4c817
jmp 0x4c8d3
movq (%r14), %rax
callq *0x68(%rax)
movq $0x0, 0x100070(%rbx)
jmp 0x4c897
movq (%r14), %rax
callq *0x160(%rax)
jmp 0x4c856
movl $0x0, 0x3b2f83(%rip) # 0x3ff860
leaq 0x3b43b4(%rip), %rdi # 0x400c98
callq 0x92b97
testq %rax, %rax
je 0x4c90a
leaq 0x3b43a3(%rip), %rbx # 0x400c98
movq (%rax), %rdi
callq 0x4cbe4
movq %rbx, %rdi
callq 0x92b97
testq %rax, %rax
jne 0x4c8f5
movq 0xbb4e5f(%rip), %rdi # 0xc01770
testq %rdi, %rdi
je 0x4c927
movq (%r14), %rax
callq *0x48(%rax)
movq $0x0, 0xbb4e49(%rip) # 0xc01770
leaq 0xbb4e02(%rip), %rdi # 0xc01730
callq 0x290c0
movq 0xbb4f36(%rip), %rdi # 0xc01870
testq %rdi, %rdi
je 0x4c950
movq (%r14), %rax
callq *0x48(%rax)
movq $0x0, 0xbb4f20(%rip) # 0xc01870
leaq 0xbb4ed9(%rip), %rdi # 0xc01830
callq 0x290c0
movq 0xbb4f55(%rip), %rdi # 0xc018b8
testq %rdi, %rdi
je 0x4c979
movq (%r14), %rax
callq *0x48(%rax)
movq $0x0, 0xbb4f3f(%rip) # 0xc018b8
leaq 0xbb4ef8(%rip), %rdi # 0xc01878
callq 0x290c0
movq 0xbb4fa4(%rip), %rdi # 0xc01930
testq %rdi, %rdi
je 0x4c9a2
movq (%r14), %rax
callq *0x48(%rax)
movq $0x0, 0xbb4f8e(%rip) # 0xc01930
leaq 0xbb4f47(%rip), %rdi # 0xc018f0
callq 0x290c0
movq 0xbb4e03(%rip), %rdi # 0xc017b8
testq %rdi, %rdi
je 0x4c9cb
movq (%r14), %rax
callq *0x48(%rax)
movq $0x0, 0xbb4ded(%rip) # 0xc017b8
leaq 0xbb4da6(%rip), %rdi # 0xc01778
callq 0x290c0
movq 0xbb4cd2(%rip), %rdi # 0xc016b0
testq %rdi, %rdi
je 0x4c9f4
movq (%r14), %rax
callq *0x48(%rax)
movq $0x0, 0xbb4cbc(%rip) # 0xc016b0
leaq 0xbb4c75(%rip), %rdi # 0xc01670
callq 0x290c0
movq 0xbb4de9(%rip), %rdi # 0xc017f0
testq %rdi, %rdi
jne 0x4cad4
leaq 0xbb4da9(%rip), %rdi # 0xc017c0
callq 0x29280
movq 0xbb4e05(%rip), %rdi # 0xc01828
testq %rdi, %rdi
jne 0x4cade
leaq 0xbb4dc5(%rip), %rdi # 0xc017f8
callq 0x29280
movq 0x3b4319(%rip), %rdi # 0x400d58
testq %rdi, %rdi
jne 0x4cae8
leaq 0x3b4279(%rip), %rdi # 0x400cc8
callq 0xa5268
leaq 0x3b423d(%rip), %rdi # 0x400c98
callq 0x92cfc
leaq 0xbb4e59(%rip), %rdi # 0xc018c0
callq 0x92cfc
movl 0x3b42ee(%rip), %ebx # 0x400d60
testl %ebx, %ebx
js 0x4ca9b
movq (%r14), %rax
leaq -0x70(%rbp), %rdi
movl %ebx, %esi
movl $0x4, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x4caf2
movl $0x10, %esi
movl %ebx, %edi
callq 0xa1461
movq 0xbb4ee6(%rip), %rdi # 0xc01988
testq %rdi, %rdi
je 0x4cab0
addq $0x8, %rdi
callq 0xa0eba
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x33b5fa(%rip), %rax # 0x3880c0
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x4c7f4
callq 0x2c8cd
jmp 0x4ca10
callq 0x2c8e8
jmp 0x4ca2c
callq 0x2c903
jmp 0x4ca48
movq %rax, %rdi
movl %ebx, %esi
callq 0x2c91e
jmp 0x4ca9b
|
translog_destroy:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
call translog_lock
movzx r15d, byte ptr cs:xmmword_C016F0+6
xor eax, eax
cmp cs:translog_status, 2
setnz al
lea eax, [rax+rax*2]
mov cs:translog_status, eax
mov rbx, qword ptr cs:xmmword_C016E0+8
cmp ds:qword_100038[rbx], 0
jz short loc_4C7E4
lea rdi, qword_C016B8
lea rsi, xmmword_C016C0
call translog_finish_page
mov rbx, qword ptr cs:xmmword_C016E0+8
loc_4C7E4:
mov rdi, ds:qword_1000D0[rbx]
test rdi, rdi
jnz loc_4CABF
loc_4C7F4:
add rbx, 100090h
mov rdi, rbx
call _pthread_mutex_unlock
inc r15d
xor r12d, r12d
lea r13, log_descriptor
lea r14, PSI_server
loc_4C817:
lea eax, [r15+r12]
and eax, 7
imul rax, 100120h
lea rbx, [rax+r13]
add rbx, 2F8h
cmp ds:qword_100038[rbx], 0
jz short loc_4C862
mov rdi, rbx
call translog_buffer_lock
mov rdi, rbx
call translog_buffer_flush
mov rdi, ds:qword_1000D0[rbx]
test rdi, rdi
jnz short loc_4C8C8
loc_4C856:
lea rdi, unk_100090[rbx]
call _pthread_mutex_unlock
loc_4C862:
mov rdi, ds:qword_1000D0[rbx]
test rdi, rdi
jz short loc_4C87F
mov rax, [r14]
call qword ptr [rax+48h]
mov ds:qword_1000D0[rbx], 0
loc_4C87F:
lea rdi, unk_100090[rbx]
call _pthread_mutex_destroy
mov rdi, ds:qword_100070[rbx]
test rdi, rdi
jnz short loc_4C8B5
loc_4C897:
add rbx, 100040h
mov rdi, rbx
call _pthread_cond_destroy
inc r12d
cmp r12d, 8
jnz loc_4C817
jmp short loc_4C8D3
loc_4C8B5:
mov rax, [r14]
call qword ptr [rax+68h]
mov ds:qword_100070[rbx], 0
jmp short loc_4C897
loc_4C8C8:
mov rax, [r14]
call qword ptr [rax+160h]
jmp short loc_4C856
loc_4C8D3:
mov cs:translog_status, 0
lea rdi, qword_400C98
call pop_dynamic
test rax, rax
jz short loc_4C90A
lea rbx, qword_400C98
loc_4C8F5:
mov rdi, [rax]
call translog_close_log_file
mov rdi, rbx
call pop_dynamic
test rax, rax
jnz short loc_4C8F5
loc_4C90A:
mov rdi, cs:qword_C01770
test rdi, rdi
jz short loc_4C927
mov rax, [r14]
call qword ptr [rax+48h]
mov cs:qword_C01770, 0
loc_4C927:
lea rdi, unk_C01730
call _pthread_mutex_destroy
mov rdi, cs:qword_C01870
test rdi, rdi
jz short loc_4C950
mov rax, [r14]
call qword ptr [rax+48h]
mov cs:qword_C01870, 0
loc_4C950:
lea rdi, unk_C01830
call _pthread_mutex_destroy
mov rdi, cs:qword_C018B8
test rdi, rdi
jz short loc_4C979
mov rax, [r14]
call qword ptr [rax+48h]
mov cs:qword_C018B8, 0
loc_4C979:
lea rdi, unk_C01878
call _pthread_mutex_destroy
mov rdi, cs:qword_C01930
test rdi, rdi
jz short loc_4C9A2
mov rax, [r14]
call qword ptr [rax+48h]
mov cs:qword_C01930, 0
loc_4C9A2:
lea rdi, unk_C018F0
call _pthread_mutex_destroy
mov rdi, cs:qword_C017B8
test rdi, rdi
jz short loc_4C9CB
mov rax, [r14]
call qword ptr [rax+48h]
mov cs:qword_C017B8, 0
loc_4C9CB:
lea rdi, unk_C01778
call _pthread_mutex_destroy
mov rdi, cs:qword_C016B0
test rdi, rdi
jz short loc_4C9F4
mov rax, [r14]
call qword ptr [rax+48h]
mov cs:qword_C016B0, 0
loc_4C9F4:
lea rdi, unk_C01670
call _pthread_mutex_destroy
mov rdi, cs:qword_C017F0
test rdi, rdi
jnz loc_4CAD4
loc_4CA10:
lea rdi, unk_C017C0
call _pthread_cond_destroy
mov rdi, cs:qword_C01828
test rdi, rdi
jnz loc_4CADE
loc_4CA2C:
lea rdi, unk_C017F8
call _pthread_cond_destroy
mov rdi, cs:qword_400D58
test rdi, rdi
jnz loc_4CAE8
loc_4CA48:
lea rdi, unk_400CC8
call my_rw_destroy
lea rdi, qword_400C98
call delete_dynamic
lea rdi, qword_C018C0
call delete_dynamic
mov ebx, cs:dword_400D60
test ebx, ebx
js short loc_4CA9B
mov rax, [r14]
lea rdi, [rbp+var_70]
mov esi, ebx
mov edx, 4
call qword ptr [rax+158h]
test rax, rax
jnz short loc_4CAF2
mov esi, 10h
mov edi, ebx
call my_close
loc_4CA9B:
mov rdi, cs:id_to_share
test rdi, rdi
jz short loc_4CAB0
add rdi, 8
call my_free
loc_4CAB0:
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4CABF:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_4C7F4
loc_4CAD4:
call translog_destroy_cold_1
jmp loc_4CA10
loc_4CADE:
call translog_destroy_cold_2
jmp loc_4CA2C
loc_4CAE8:
call translog_destroy_cold_3
jmp loc_4CA48
loc_4CAF2:
mov rdi, rax
mov esi, ebx
call translog_destroy_cold_4
jmp short loc_4CA9B
|
long long translog_destroy()
{
char v0; // r15
long long v1; // rbx
char v2; // r15
int i; // r12d
long long v4; // rax
long long *v5; // rbx
_QWORD *j; // rax
long long result; // rax
unsigned int v8; // ebx
long long v9; // rax
_BYTE v10[112]; // [rsp+0h] [rbp-70h] BYREF
translog_lock();
v0 = BYTE6(xmmword_C016F0);
translog_status = 3 * (translog_status != 2);
v1 = *((_QWORD *)&xmmword_C016E0 + 1);
if ( *(long long *)((char *)&qword_100038 + *((_QWORD *)&xmmword_C016E0 + 1)) )
{
translog_finish_page(&qword_C016B8, &xmmword_C016C0);
v1 = *((_QWORD *)&xmmword_C016E0 + 1);
}
if ( *(long long *)((char *)&qword_1000D0 + v1) )
PSI_server[44]();
pthread_mutex_unlock(v1 + 1048720);
v2 = v0 + 1;
for ( i = 0; i != 8; ++i )
{
v4 = 131108LL * ((v2 + (_BYTE)i) & 7);
v5 = &log_descriptor[v4 + 95];
if ( *(long long *)((char *)&qword_100038 + (_QWORD)v5) )
{
translog_buffer_lock((long long)&log_descriptor[v4 + 95]);
translog_buffer_flush(v5);
if ( *(long long *)((char *)&qword_1000D0 + (_QWORD)v5) )
PSI_server[44]();
pthread_mutex_unlock((char *)&unk_100090 + (_QWORD)v5);
}
if ( *(long long *)((char *)&qword_1000D0 + (_QWORD)v5) )
{
PSI_server[9]();
*(long long *)((char *)&qword_1000D0 + (_QWORD)v5) = 0LL;
}
pthread_mutex_destroy((char *)&unk_100090 + (_QWORD)v5);
if ( *(long long *)((char *)&qword_100070 + (_QWORD)v5) )
{
PSI_server[13]();
*(long long *)((char *)&qword_100070 + (_QWORD)v5) = 0LL;
}
pthread_cond_destroy(v5 + 131080);
}
translog_status = 0;
for ( j = (_QWORD *)pop_dynamic(&qword_400C98); j; j = (_QWORD *)pop_dynamic(&qword_400C98) )
translog_close_log_file(*j);
if ( qword_C01770 )
{
PSI_server[9]();
qword_C01770 = 0LL;
}
pthread_mutex_destroy(&unk_C01730);
if ( qword_C01870 )
{
PSI_server[9]();
qword_C01870 = 0LL;
}
pthread_mutex_destroy(&unk_C01830);
if ( qword_C018B8 )
{
PSI_server[9]();
qword_C018B8 = 0LL;
}
pthread_mutex_destroy(&unk_C01878);
if ( qword_C01930 )
{
PSI_server[9]();
qword_C01930 = 0LL;
}
pthread_mutex_destroy(&unk_C018F0);
if ( qword_C017B8 )
{
PSI_server[9]();
qword_C017B8 = 0LL;
}
pthread_mutex_destroy(&unk_C01778);
if ( qword_C016B0 )
{
PSI_server[9]();
qword_C016B0 = 0LL;
}
pthread_mutex_destroy(&unk_C01670);
if ( qword_C017F0 )
translog_destroy_cold_1();
pthread_cond_destroy(&unk_C017C0);
if ( qword_C01828 )
translog_destroy_cold_2();
pthread_cond_destroy(&unk_C017F8);
if ( qword_400D58 )
translog_destroy_cold_3();
my_rw_destroy(&unk_400CC8);
delete_dynamic(&qword_400C98);
result = delete_dynamic(&qword_C018C0);
v8 = dword_400D60;
if ( dword_400D60 >= 0 )
{
v9 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v10, (unsigned int)dword_400D60, 4LL);
if ( v9 )
result = translog_destroy_cold_4(v9, v8);
else
result = my_close(v8, 16LL);
}
if ( id_to_share )
return my_free(id_to_share + 8);
return result;
}
|
translog_destroy:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
CALL 0x00149f07
MOVZX R15D,byte ptr [0x00d016f6]
XOR EAX,EAX
CMP dword ptr [0x004ff860],0x2
SETNZ AL
LEA EAX,[RAX + RAX*0x2]
MOV dword ptr [0x004ff860],EAX
MOV RBX,qword ptr [0x00d016e8]
CMP qword ptr [RBX + 0x100038],0x0
JZ 0x0014c7e4
LEA RDI,[0xd016b8]
LEA RSI,[0xd016c0]
CALL 0x0014cafe
MOV RBX,qword ptr [0x00d016e8]
LAB_0014c7e4:
MOV RDI,qword ptr [RBX + 0x1000d0]
TEST RDI,RDI
JNZ 0x0014cabf
LAB_0014c7f4:
ADD RBX,0x100090
MOV RDI,RBX
CALL 0x001291e0
INC R15D
XOR R12D,R12D
LEA R13,[0x500a70]
LEA R14,[0x4880c0]
LAB_0014c817:
LEA EAX,[R15 + R12*0x1]
AND EAX,0x7
IMUL RAX,RAX,0x100120
LEA RBX,[RAX + R13*0x1]
ADD RBX,0x2f8
CMP qword ptr [RBX + 0x100038],0x0
JZ 0x0014c862
MOV RDI,RBX
CALL 0x00149fa7
MOV RDI,RBX
CALL 0x0014dc75
MOV RDI,qword ptr [RBX + 0x1000d0]
TEST RDI,RDI
JNZ 0x0014c8c8
LAB_0014c856:
LEA RDI,[RBX + 0x100090]
CALL 0x001291e0
LAB_0014c862:
MOV RDI,qword ptr [RBX + 0x1000d0]
TEST RDI,RDI
JZ 0x0014c87f
MOV RAX,qword ptr [R14]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [RBX + 0x1000d0],0x0
LAB_0014c87f:
LEA RDI,[RBX + 0x100090]
CALL 0x001290c0
MOV RDI,qword ptr [RBX + 0x100070]
TEST RDI,RDI
JNZ 0x0014c8b5
LAB_0014c897:
ADD RBX,0x100040
MOV RDI,RBX
CALL 0x00129280
INC R12D
CMP R12D,0x8
JNZ 0x0014c817
JMP 0x0014c8d3
LAB_0014c8b5:
MOV RAX,qword ptr [R14]
CALL qword ptr [RAX + 0x68]
MOV qword ptr [RBX + 0x100070],0x0
JMP 0x0014c897
LAB_0014c8c8:
MOV RAX,qword ptr [R14]
CALL qword ptr [RAX + 0x160]
JMP 0x0014c856
LAB_0014c8d3:
MOV dword ptr [0x004ff860],0x0
LEA RDI,[0x500c98]
CALL 0x00192b97
TEST RAX,RAX
JZ 0x0014c90a
LEA RBX,[0x500c98]
LAB_0014c8f5:
MOV RDI,qword ptr [RAX]
CALL 0x0014cbe4
MOV RDI,RBX
CALL 0x00192b97
TEST RAX,RAX
JNZ 0x0014c8f5
LAB_0014c90a:
MOV RDI,qword ptr [0x00d01770]
TEST RDI,RDI
JZ 0x0014c927
MOV RAX,qword ptr [R14]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [0x00d01770],0x0
LAB_0014c927:
LEA RDI,[0xd01730]
CALL 0x001290c0
MOV RDI,qword ptr [0x00d01870]
TEST RDI,RDI
JZ 0x0014c950
MOV RAX,qword ptr [R14]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [0x00d01870],0x0
LAB_0014c950:
LEA RDI,[0xd01830]
CALL 0x001290c0
MOV RDI,qword ptr [0x00d018b8]
TEST RDI,RDI
JZ 0x0014c979
MOV RAX,qword ptr [R14]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [0x00d018b8],0x0
LAB_0014c979:
LEA RDI,[0xd01878]
CALL 0x001290c0
MOV RDI,qword ptr [0x00d01930]
TEST RDI,RDI
JZ 0x0014c9a2
MOV RAX,qword ptr [R14]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [0x00d01930],0x0
LAB_0014c9a2:
LEA RDI,[0xd018f0]
CALL 0x001290c0
MOV RDI,qword ptr [0x00d017b8]
TEST RDI,RDI
JZ 0x0014c9cb
MOV RAX,qword ptr [R14]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [0x00d017b8],0x0
LAB_0014c9cb:
LEA RDI,[0xd01778]
CALL 0x001290c0
MOV RDI,qword ptr [0x00d016b0]
TEST RDI,RDI
JZ 0x0014c9f4
MOV RAX,qword ptr [R14]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [0x00d016b0],0x0
LAB_0014c9f4:
LEA RDI,[0xd01670]
CALL 0x001290c0
MOV RDI,qword ptr [0x00d017f0]
TEST RDI,RDI
JNZ 0x0014cad4
LAB_0014ca10:
LEA RDI,[0xd017c0]
CALL 0x00129280
MOV RDI,qword ptr [0x00d01828]
TEST RDI,RDI
JNZ 0x0014cade
LAB_0014ca2c:
LEA RDI,[0xd017f8]
CALL 0x00129280
MOV RDI,qword ptr [0x00500d58]
TEST RDI,RDI
JNZ 0x0014cae8
LAB_0014ca48:
LEA RDI,[0x500cc8]
CALL 0x001a5268
LEA RDI,[0x500c98]
CALL 0x00192cfc
LEA RDI,[0xd018c0]
CALL 0x00192cfc
MOV EBX,dword ptr [0x00500d60]
TEST EBX,EBX
JS 0x0014ca9b
MOV RAX,qword ptr [R14]
LEA RDI,[RBP + -0x70]
MOV ESI,EBX
MOV EDX,0x4
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x0014caf2
MOV ESI,0x10
MOV EDI,EBX
CALL 0x001a1461
LAB_0014ca9b:
MOV RDI,qword ptr [0x00d01988]
TEST RDI,RDI
JZ 0x0014cab0
ADD RDI,0x8
CALL 0x001a0eba
LAB_0014cab0:
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0014cabf:
LEA RAX,[0x4880c0]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0014c7f4
LAB_0014cad4:
CALL 0x0012c8cd
JMP 0x0014ca10
LAB_0014cade:
CALL 0x0012c8e8
JMP 0x0014ca2c
LAB_0014cae8:
CALL 0x0012c903
JMP 0x0014ca48
LAB_0014caf2:
MOV RDI,RAX
MOV ESI,EBX
CALL 0x0012c91e
JMP 0x0014ca9b
|
void translog_destroy(void)
{
long lVar1;
int8 *puVar2;
int iVar3;
uint uVar4;
int1 local_78 [72];
translog_lock();
uVar4 = (uint)DAT_00d016f6;
translog_status = (uint)(translog_status != 2) * 3;
if (*(long *)(Elf64_Ehdr_00100000.e_ident_pad + DAT_00d016e8 + 0x2f) != 0) {
translog_finish_page(&DAT_00d016b8,&DAT_00d016c0);
}
lVar1 = DAT_00d016e8;
if (*(long *)((long)&Elf64_Phdr_ARRAY_00100040[2].p_filesz + DAT_00d016e8) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)((long)&Elf64_Phdr_ARRAY_00100040[1].p_paddr + lVar1));
iVar3 = 0;
do {
lVar1 = (ulong)(uVar4 + 1 + iVar3 & 7) * 0x100120;
if (*(long *)(&DAT_00600da0 + lVar1) != 0) {
translog_buffer_lock(&DAT_00500d68 + lVar1);
translog_buffer_flush(&DAT_00500d68 + lVar1);
if (*(long *)(&DAT_00600e38 + lVar1) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)(lVar1 + 0x600df8));
}
if (*(long *)(&DAT_00600e38 + lVar1) != 0) {
(**(code **)(PSI_server + 0x48))();
*(int8 *)(&DAT_00600e38 + lVar1) = 0;
}
pthread_mutex_destroy((pthread_mutex_t *)(lVar1 + 0x600df8));
if (*(long *)(&DAT_00600dd8 + lVar1) != 0) {
(**(code **)(PSI_server + 0x68))();
*(int8 *)(&DAT_00600dd8 + lVar1) = 0;
}
pthread_cond_destroy((pthread_cond_t *)(lVar1 + 0x600da8));
iVar3 = iVar3 + 1;
} while (iVar3 != 8);
translog_status = 0;
puVar2 = (int8 *)pop_dynamic(&DAT_00500c98);
while (puVar2 != (int8 *)0x0) {
translog_close_log_file(*puVar2);
puVar2 = (int8 *)pop_dynamic(&DAT_00500c98);
}
if (DAT_00d01770 != 0) {
(**(code **)(PSI_server + 0x48))();
DAT_00d01770 = 0;
}
pthread_mutex_destroy((pthread_mutex_t *)&DAT_00d01730);
if (DAT_00d01870 != 0) {
(**(code **)(PSI_server + 0x48))();
DAT_00d01870 = 0;
}
pthread_mutex_destroy((pthread_mutex_t *)&DAT_00d01830);
if (DAT_00d018b8 != 0) {
(**(code **)(PSI_server + 0x48))();
DAT_00d018b8 = 0;
}
pthread_mutex_destroy((pthread_mutex_t *)&DAT_00d01878);
if (DAT_00d01930 != 0) {
(**(code **)(PSI_server + 0x48))();
DAT_00d01930 = 0;
}
pthread_mutex_destroy((pthread_mutex_t *)&DAT_00d018f0);
if (DAT_00d017b8 != 0) {
(**(code **)(PSI_server + 0x48))();
DAT_00d017b8 = 0;
}
pthread_mutex_destroy((pthread_mutex_t *)&DAT_00d01778);
if (DAT_00d016b0 != 0) {
(**(code **)(PSI_server + 0x48))();
DAT_00d016b0 = 0;
}
pthread_mutex_destroy((pthread_mutex_t *)&DAT_00d01670);
if (DAT_00d017f0 != 0) {
translog_destroy_cold_1();
}
pthread_cond_destroy((pthread_cond_t *)&DAT_00d017c0);
if (DAT_00d01828 != 0) {
translog_destroy_cold_2();
}
pthread_cond_destroy((pthread_cond_t *)&DAT_00d017f8);
if (DAT_00500d58 != 0) {
translog_destroy_cold_3();
}
my_rw_destroy(&DAT_00500cc8);
delete_dynamic(&DAT_00500c98);
delete_dynamic(&DAT_00d018c0);
iVar3 = DAT_00500d60;
if (-1 < DAT_00500d60) {
lVar1 = (**(code **)(PSI_server + 0x158))(local_78,DAT_00500d60,4);
if (lVar1 == 0) {
my_close(iVar3,0x10);
}
else {
translog_destroy_cold_4(lVar1,iVar3);
}
}
if (id_to_share != 0) {
my_free(id_to_share + 8);
}
return;
}
|
|
66,011 |
my_once_free
|
eloqsql/mysys/my_once.c
|
void my_once_free(void)
{
reg1 USED_MEM *next,*old;
DBUG_ENTER("my_once_free");
for (next=my_once_root_block ; next ; )
{
old=next; next= next->next ;
free((uchar*) old);
}
my_once_root_block=0;
DBUG_VOID_RETURN;
}
|
O3
|
c
|
my_once_free:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0xb681d2(%rip), %rbx # 0xc0b3e0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xa3226
movq (%rdi), %r14
callq 0x29140
movq %r14, %rdi
testq %r14, %r14
jne 0xa3216
movq $0x0, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
|
my_once_free:
push rbp
mov rbp, rsp
push r14
push rbx
lea rbx, my_once_root_block
mov rdi, [rbx]
test rdi, rdi
jz short loc_A3226
loc_A3216:
mov r14, [rdi]
call _free
mov rdi, r14
test r14, r14
jnz short loc_A3216
loc_A3226:
mov qword ptr [rbx], 0
pop rbx
pop r14
pop rbp
retn
|
long long my_once_free()
{
_QWORD *v0; // rdi
_QWORD *v1; // r14
long long result; // rax
v0 = (_QWORD *)my_once_root_block;
if ( my_once_root_block )
{
do
{
v1 = (_QWORD *)*v0;
result = free(v0);
v0 = v1;
}
while ( v1 );
}
my_once_root_block = 0LL;
return result;
}
|
my_once_free:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
LEA RBX,[0xd0b3e0]
MOV RDI,qword ptr [RBX]
TEST RDI,RDI
JZ 0x001a3226
LAB_001a3216:
MOV R14,qword ptr [RDI]
CALL 0x00129140
MOV RDI,R14
TEST R14,R14
JNZ 0x001a3216
LAB_001a3226:
MOV qword ptr [RBX],0x0
POP RBX
POP R14
POP RBP
RET
|
void my_once_free(void)
{
long *plVar1;
long *__ptr;
__ptr = my_once_root_block;
if (my_once_root_block != (long *)0x0) {
do {
plVar1 = (long *)*__ptr;
free(__ptr);
__ptr = plVar1;
} while (plVar1 != (long *)0x0);
}
my_once_root_block = (long *)0x0;
return;
}
|
|
66,012 |
my_free
|
eloqsql/mysys/my_malloc.c
|
void my_free(void *ptr)
{
my_memory_header *mh;
size_t old_size;
my_bool old_flags;
DBUG_ENTER("my_free");
DBUG_PRINT("my",("ptr: %p", ptr));
if (ptr == NULL)
DBUG_VOID_RETURN;
mh= USER_TO_HEADER(ptr);
old_size= mh->m_size & ~1;
old_flags= mh->m_size & 1;
PSI_CALL_memory_free(mh->m_key, old_size, mh->m_owner);
update_malloc_size(- (longlong) old_size - HEADER_SIZE, old_flags);
#ifndef SAFEMALLOC
/*
Trash memory if not safemalloc. We don't have to do this if safemalloc
is used as safemalloc will also do trashing
*/
TRASH_FREE(ptr, old_size);
#endif
sf_free(mh);
DBUG_VOID_RETURN;
}
|
O0
|
c
|
my_free:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x2e3ee
cmpq $0x0, -0x8(%rbp)
jne 0x2e3f9
jmp 0x2e3f7
jmp 0x2e473
movq -0x8(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
andq $-0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
andq $0x1, %rax
movb %al, -0x19(%rbp)
leaq 0x1abacd(%rip), %rax # 0x1d9ef8
movq (%rax), %rax
movq 0x3f8(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %edi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
callq *%rax
movq 0x1ab570(%rip), %rax # 0x1d99c0
xorl %ecx, %ecx
movl %ecx, %edi
subq -0x18(%rbp), %rdi
subq $0x18, %rdi
movsbl -0x19(%rbp), %esi
callq *%rax
jmp 0x2e464
jmp 0x2e466
jmp 0x2e468
movq -0x10(%rbp), %rdi
callq 0x25400
jmp 0x2e473
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
|
my_free:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
jmp short $+2
loc_2E3EE:
cmp [rbp+var_8], 0
jnz short loc_2E3F9
jmp short $+2
loc_2E3F7:
jmp short loc_2E473
loc_2E3F9:
mov rax, [rbp+var_8]
add rax, 0FFFFFFFFFFFFFFE8h
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rax, [rax+8]
and rax, 0FFFFFFFFFFFFFFFEh
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
mov rax, [rax+8]
and rax, 1
mov [rbp+var_19], al
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+3F8h]
mov rcx, [rbp+var_10]
mov edi, [rcx+10h]
mov rsi, [rbp+var_18]
mov rcx, [rbp+var_10]
mov rdx, [rcx]
call rax
mov rax, cs:update_malloc_size
xor ecx, ecx
mov edi, ecx
sub rdi, [rbp+var_18]
sub rdi, 18h
movsx esi, [rbp+var_19]
call rax ; dummy
jmp short $+2
loc_2E464:
jmp short $+2
loc_2E466:
jmp short $+2
loc_2E468:
mov rdi, [rbp+var_10]
call _free
jmp short $+2
loc_2E473:
add rsp, 20h
pop rbp
retn
|
long long my_free(long long a1)
{
long long result; // rax
char v2; // [rsp+7h] [rbp-19h]
unsigned long long v3; // [rsp+8h] [rbp-18h]
if ( a1 )
{
v3 = *(_QWORD *)(a1 - 24 + 8) & 0xFFFFFFFFFFFFFFFELL;
v2 = *(_BYTE *)(a1 - 24 + 8) & 1;
(*((void ( **)(_QWORD, unsigned long long, _QWORD))PSI_server[0] + 127))(
*(unsigned int *)(a1 - 24 + 16),
v3,
*(_QWORD *)(a1 - 24));
update_malloc_size(-(long long)v3 - 24, v2);
return free(a1 - 24);
}
return result;
}
|
my_free:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
JMP 0x0012e3ee
LAB_0012e3ee:
CMP qword ptr [RBP + -0x8],0x0
JNZ 0x0012e3f9
JMP 0x0012e3f7
LAB_0012e3f7:
JMP 0x0012e473
LAB_0012e3f9:
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,-0x18
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
AND RAX,-0x2
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
AND RAX,0x1
MOV byte ptr [RBP + -0x19],AL
LEA RAX,[0x2d9ef8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x3f8]
MOV RCX,qword ptr [RBP + -0x10]
MOV EDI,dword ptr [RCX + 0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RCX]
CALL RAX
MOV RAX,qword ptr [0x002d99c0]
XOR ECX,ECX
MOV EDI,ECX
SUB RDI,qword ptr [RBP + -0x18]
SUB RDI,0x18
MOVSX ESI,byte ptr [RBP + -0x19]
CALL RAX
JMP 0x0012e464
LAB_0012e464:
JMP 0x0012e466
LAB_0012e466:
JMP 0x0012e468
LAB_0012e468:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00125400
JMP 0x0012e473
LAB_0012e473:
ADD RSP,0x20
POP RBP
RET
|
void my_free(long param_1)
{
int8 uVar1;
ulong uVar2;
if (param_1 != 0) {
uVar2 = *(ulong *)(param_1 + -0x10) & 0xfffffffffffffffe;
uVar1 = *(int8 *)(param_1 + -0x10);
(**(code **)(PSI_server + 0x3f8))
(*(int4 *)(param_1 + -8),uVar2,*(int8 *)(param_1 + -0x18));
(*(code *)update_malloc_size)(-0x18 - uVar2,(byte)uVar1 & 1);
free((int8 *)(param_1 + -0x18));
}
return;
}
|
|
66,013 |
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>::push_back(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
|
void push_back(const basic_json& val)
{
// push_back only works for null objects or arrays
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
{
JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
}
// transform null object into an array
if (is_null())
{
m_data.m_type = value_t::array;
m_data.m_value = value_t::array;
assert_invariant();
}
// add element to array
const auto old_capacity = m_data.m_value.array->capacity();
m_data.m_value.array->push_back(val);
set_parent(m_data.m_value.array->back(), old_capacity);
}
|
O2
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::push_back(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
jne 0x7b317
movb $0x2, (%r14)
callq 0x3db48
movq %rax, 0x8(%r14)
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x3da0e
jmp 0x7b31c
cmpl $0x2, %eax
jne 0x7b330
movq 0x8(%r14), %rdi
movq %rbx, %rsi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x7ea78
pushq $0x20
popq %rdi
callq 0x24460
movq %rax, %rbx
movq %r14, %rdi
callq 0x434f0
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x3ba68(%rip), %rsi # 0xb6dba
leaq 0x10(%rsp), %rdi
callq 0x6355f
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x134, %esi # imm = 0x134
movq %r14, %rcx
callq 0x433a4
xorl %ebp, %ebp
leaq 0x82bbb(%rip), %rsi # 0xfdf38
leaq -0x3b304(%rip), %rdx # 0x40080
movq %rbx, %rdi
callq 0x24ee0
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x251b8
testb %bpl, %bpl
jne 0x7b3a3
jmp 0x7b3ab
movq %rax, %r14
movq %rbx, %rdi
callq 0x24670
movq %r14, %rdi
callq 0x24f60
nop
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9push_backERKSD_:
push rbp; char
push r14; int
push rbx; int
sub rsp, 30h
mov rbx, rsi
mov r14, rdi
movzx eax, byte ptr [rdi]
test eax, eax
jnz short loc_7B317
mov byte ptr [r14], 2
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createIS3_ISD_SaISD_EEJEEEPT_DpOT0_; 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>::create<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>>>()
mov [r14+8], rax
push 1
pop rsi
mov rdi, r14
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)
jmp short loc_7B31C
loc_7B317:
cmp eax, 2
jnz short loc_7B330
loc_7B31C:
mov rdi, [r14+8]
mov rsi, rbx
add rsp, 30h
pop rbx
pop r14
pop rbp
jmp _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE9push_backERKSD_; 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>>::push_back(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&)
loc_7B330:
push 20h ; ' '
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aCannotUsePushB; "cannot use push_back() with "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA29_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(char const(&)[29],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 134h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rdi, [rsp+48h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_7B3A3
jmp short loc_7B3AB
mov r14, rax
loc_7B3A3:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_7B3AB:
mov rdi, r14
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::push_back(
long long a1,
long long a2)
{
nlohmann::json_abi_v3_11_3::detail::type_error *exception; // rbx
const char *v4; // [rsp+8h] [rbp-40h] BYREF
_BYTE v5[56]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 )
{
if ( *(_BYTE *)a1 != 2 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::type_error *)__cxa_allocate_exception(0x20uLL);
v4 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(
(long long)v5,
(long long)"cannot use push_back() with ",
&v4);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
308,
(long long)v5);
__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);
}
}
else
{
*(_BYTE *)a1 = 2;
*(_QWORD *)(a1 + 8) = 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>::create<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>>>();
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a1);
}
return 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>>::push_back(
*(_QWORD *)(a1 + 8),
a2);
}
|
push_back:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RBX,RSI
MOV R14,RDI
MOVZX EAX,byte ptr [RDI]
TEST EAX,EAX
JNZ 0x0017b317
MOV byte ptr [R14],0x2
CALL 0x0013db48
MOV qword ptr [R14 + 0x8],RAX
PUSH 0x1
POP RSI
MOV RDI,R14
CALL 0x0013da0e
JMP 0x0017b31c
LAB_0017b317:
CMP EAX,0x2
JNZ 0x0017b330
LAB_0017b31c:
MOV RDI,qword ptr [R14 + 0x8]
MOV RSI,RBX
ADD RSP,0x30
POP RBX
POP R14
POP RBP
JMP 0x0017ea78
LAB_0017b330:
PUSH 0x20
POP RDI
CALL 0x00124460
MOV RBX,RAX
MOV RDI,R14
CALL 0x001434f0
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_0017b34b:
LEA RSI,[0x1b6dba]
LEA RDI,[RSP + 0x10]
CALL 0x0016355f
MOV BPL,0x1
LAB_0017b35f:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x134
MOV RCX,R14
CALL 0x001433a4
XOR EBP,EBP
LEA RSI,[0x1fdf38]
LEA RDX,[0x140080]
MOV RDI,RBX
CALL 0x00124ee0
|
/* 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(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&) */
void __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::push_back(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)
{
vector *pvVar1;
int8 uVar2;
char *local_40;
detail local_38 [32];
if (*this == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0) {
*this = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2;
pvVar1 = create<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>>>>
();
*(vector **)(this + 8) = pvVar1;
assert_invariant(SUB81(this,0));
}
else if (*this != (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2) {
uVar2 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name(this);
/* try { // try from 0017b34b to 0017b35b has its CatchHandler @ 0017b3a0 */
detail::concat<std::__cxx11::string,char_const(&)[29],char_const*>
(local_38,"cannot use push_back() with ",&local_40);
/* try { // try from 0017b35f to 0017b38b has its CatchHandler @ 0017b38c */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar2,0x134,local_38,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar2,&detail::type_error::typeinfo,detail::exception::~exception);
}
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>>>
::push_back(*(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 + 8),param_1);
return;
}
|
|
66,014 |
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>::push_back(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
|
void push_back(const basic_json& val)
{
// push_back only works for null objects or arrays
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
{
JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
}
// transform null object into an array
if (is_null())
{
m_data.m_type = value_t::array;
m_data.m_value = value_t::array;
assert_invariant();
}
// add element to array
const auto old_capacity = m_data.m_value.array->capacity();
m_data.m_value.array->push_back(val);
set_parent(m_data.m_value.array->back(), old_capacity);
}
|
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>::push_back(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
jne 0xa557a
movb $0x2, (%r14)
movl $0x18, %edi
callq 0x1b890
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x58644
jmp 0xa557f
cmpl $0x2, %eax
jne 0xa5593
movq 0x8(%r14), %rdi
movq %rbx, %rsi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xab79a
movl $0x20, %edi
callq 0x1b440
movq %rax, %rbx
movq %r14, %rdi
callq 0x5eb8c
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x4d813(%rip), %rsi # 0xf2dca
leaq 0x10(%rsp), %rdi
callq 0x86669
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x134, %esi # imm = 0x134
movq %r14, %rcx
callq 0x5e934
xorl %ebp, %ebp
leaq 0x86956(%rip), %rsi # 0x12bf38
leaq -0x4a827(%rip), %rdx # 0x5adc2
movq %rbx, %rdi
callq 0x1bef0
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa560f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1b8b0
testb %bpl, %bpl
jne 0xa5619
jmp 0xa5621
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b650
movq %r14, %rdi
callq 0x1bf70
nop
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9push_backERKSD_:
push rbp; char
push r14; int
push rbx; __int64
sub rsp, 30h
mov rbx, rsi
mov r14, rdi
movzx eax, byte ptr [rdi]
test eax, eax
jnz short loc_A557A
mov byte ptr [r14], 2
mov edi, 18h; unsigned __int64
call __Znwm; operator new(ulong)
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
mov qword ptr [rax+10h], 0
mov [r14+8], rax
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
jmp short loc_A557F
loc_A557A:
cmp eax, 2
jnz short loc_A5593
loc_A557F:
mov rdi, [r14+8]
mov rsi, rbx
add rsp, 30h
pop rbx
pop r14
pop rbp
jmp _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE9push_backERKSD_; 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>>::push_back(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&)
loc_A5593:
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)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aCannotUsePushB; "cannot use push_back() with "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA29_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(char const(&)[29],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 134h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A560F
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A560F:
test bpl, bpl
jnz short loc_A5619
jmp short loc_A5621
mov r14, rax
loc_A5619:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_A5621:
mov rdi, r14
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::push_back(
long long a1,
long long a2)
{
long long v2; // rax
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
const char *v5; // [rsp+8h] [rbp-40h] BYREF
_QWORD v6[2]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 )
{
if ( *(_BYTE *)a1 != 2 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v5 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(
(long long)v6,
(long long)"cannot use push_back() with ",
&v5);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
308,
v6);
__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);
}
}
else
{
*(_BYTE *)a1 = 2;
v2 = operator new(0x18uLL);
*(_OWORD *)v2 = 0LL;
*(_QWORD *)(v2 + 16) = 0LL;
*(_QWORD *)(a1 + 8) = v2;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a1);
}
return 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>>::push_back(
*(_QWORD *)(a1 + 8),
a2);
}
|
push_back:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RBX,RSI
MOV R14,RDI
MOVZX EAX,byte ptr [RDI]
TEST EAX,EAX
JNZ 0x001a557a
MOV byte ptr [R14],0x2
MOV EDI,0x18
CALL 0x0011b890
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],0x0
MOV qword ptr [R14 + 0x8],RAX
MOV RDI,R14
MOV ESI,0x1
CALL 0x00158644
JMP 0x001a557f
LAB_001a557a:
CMP EAX,0x2
JNZ 0x001a5593
LAB_001a557f:
MOV RDI,qword ptr [R14 + 0x8]
MOV RSI,RBX
ADD RSP,0x30
POP RBX
POP R14
POP RBP
JMP 0x001ab79a
LAB_001a5593:
MOV EDI,0x20
CALL 0x0011b440
MOV RBX,RAX
MOV RDI,R14
CALL 0x0015eb8c
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_001a55b0:
LEA RSI,[0x1f2dca]
LEA RDI,[RSP + 0x10]
CALL 0x00186669
MOV BPL,0x1
LAB_001a55c4:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x134
MOV RCX,R14
CALL 0x0015e934
XOR EBP,EBP
LEA RSI,[0x22bf38]
LEA RDX,[0x15adc2]
MOV RDI,RBX
CALL 0x0011bef0
|
/* 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(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&) */
void __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::push_back(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 *puVar1;
int8 uVar2;
char *local_40;
detail local_38 [32];
if (*this == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0) {
*this = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2;
puVar1 = (int8 *)operator_new(0x18);
*puVar1 = 0;
puVar1[1] = 0;
puVar1[2] = 0;
*(int8 **)(this + 8) = puVar1;
assert_invariant(SUB81(this,0));
}
else if (*this != (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2) {
uVar2 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name(this);
/* try { // try from 001a55b0 to 001a55c0 has its CatchHandler @ 001a5616 */
detail::concat<std::__cxx11::string,char_const(&)[29],char_const*>
(local_38,"cannot use push_back() with ",&local_40);
/* try { // try from 001a55c4 to 001a55f0 has its CatchHandler @ 001a55f1 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar2,0x134,local_38,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar2,&detail::type_error::typeinfo,detail::exception::~exception);
}
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>>>
::push_back(*(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 + 8),param_1);
return;
}
|
|
66,015 |
gray_set_cell
|
dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-ft-raster.c
|
static void
gray_set_cell( RAS_ARG_ TCoord ex,
TCoord ey )
{
/* Move the cell pointer to a new position. We set the `invalid' */
/* flag to indicate that the cell isn't part of those we're interested */
/* in during the render phase. This means that: */
/* */
/* . the new vertical position must be within min_ey..max_ey-1. */
/* . the new horizontal position must be strictly less than max_ex */
/* */
/* Note that if a cell is to the left of the clipping region, it is */
/* actually set to the (min_ex-1) horizontal position. */
/* All cells that are on the left of the clipping region go to the */
/* min_ex - 1 horizontal position. */
ey -= ras.min_ey;
if ( ex > ras.max_ex )
ex = ras.max_ex;
ex -= ras.min_ex;
if ( ex < 0 )
ex = -1;
/* are we moving to a different cell ? */
if ( ex != ras.ex || ey != ras.ey )
{
/* record the current one if it is valid */
if ( !ras.invalid )
gray_record_cell( RAS_VAR );
ras.area = 0;
ras.cover = 0;
ras.ex = ex;
ras.ey = ey;
}
ras.invalid = ( (unsigned int)ey >= (unsigned int)ras.count_ey ||
ex >= ras.count_ex );
}
|
O1
|
c
|
gray_set_cell:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
subq 0x20(%rdi), %r14
movq 0x18(%rdi), %rax
cmpq %rsi, %rax
cmovlq %rax, %rsi
subq 0x10(%rdi), %rsi
movq $-0x1, %r15
cmovnsq %rsi, %r15
cmpq (%rdi), %r15
jne 0x3caa5
cmpq 0x8(%rbx), %r14
je 0x3cac9
cmpl $0x0, 0x4c(%rbx)
jne 0x3cab3
movq %rbx, %rdi
callq 0x3c079
movq $0x0, 0x40(%rbx)
movl $0x0, 0x48(%rbx)
movq %r15, (%rbx)
movq %r14, 0x8(%rbx)
movl $0x1, %eax
cmpl 0x38(%rbx), %r14d
jae 0x3cadd
xorl %eax, %eax
cmpq 0x30(%rbx), %r15
setge %al
movl %eax, 0x4c(%rbx)
popq %rbx
popq %r14
popq %r15
retq
|
gray_set_cell:
push r15
push r14
push rbx
mov r14, rdx
mov rbx, rdi
sub r14, [rdi+20h]
mov rax, [rdi+18h]
cmp rax, rsi
cmovl rsi, rax
sub rsi, [rdi+10h]
mov r15, 0FFFFFFFFFFFFFFFFh
cmovns r15, rsi
cmp r15, [rdi]
jnz short loc_3CAA5
cmp r14, [rbx+8]
jz short loc_3CAC9
loc_3CAA5:
cmp dword ptr [rbx+4Ch], 0
jnz short loc_3CAB3
mov rdi, rbx
call gray_record_cell
loc_3CAB3:
mov qword ptr [rbx+40h], 0
mov dword ptr [rbx+48h], 0
mov [rbx], r15
mov [rbx+8], r14
loc_3CAC9:
mov eax, 1
cmp r14d, [rbx+38h]
jnb short loc_3CADD
xor eax, eax
cmp r15, [rbx+30h]
setnl al
loc_3CADD:
mov [rbx+4Ch], eax
pop rbx
pop r14
pop r15
retn
|
_BOOL8 gray_set_cell(long long a1, long long a2, long long a3)
{
long long v3; // r14
long long v4; // rsi
long long v5; // r15
_BOOL8 result; // rax
v3 = a3 - *(_QWORD *)(a1 + 32);
if ( *(_QWORD *)(a1 + 24) < a2 )
a2 = *(_QWORD *)(a1 + 24);
v4 = a2 - *(_QWORD *)(a1 + 16);
v5 = -1LL;
if ( v4 >= 0 )
v5 = v4;
if ( v5 != *(_QWORD *)a1 || v3 != *(_QWORD *)(a1 + 8) )
{
if ( !*(_DWORD *)(a1 + 76) )
gray_record_cell((long long *)a1);
*(_QWORD *)(a1 + 64) = 0LL;
*(_DWORD *)(a1 + 72) = 0;
*(_QWORD *)a1 = v5;
*(_QWORD *)(a1 + 8) = v3;
}
result = 1LL;
if ( (unsigned int)v3 < *(_DWORD *)(a1 + 56) )
result = v5 >= *(_QWORD *)(a1 + 48);
*(_DWORD *)(a1 + 76) = result;
return result;
}
|
gray_set_cell:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RDX
MOV RBX,RDI
SUB R14,qword ptr [RDI + 0x20]
MOV RAX,qword ptr [RDI + 0x18]
CMP RAX,RSI
CMOVL RSI,RAX
SUB RSI,qword ptr [RDI + 0x10]
MOV R15,-0x1
CMOVNS R15,RSI
CMP R15,qword ptr [RDI]
JNZ 0x0013caa5
CMP R14,qword ptr [RBX + 0x8]
JZ 0x0013cac9
LAB_0013caa5:
CMP dword ptr [RBX + 0x4c],0x0
JNZ 0x0013cab3
MOV RDI,RBX
CALL 0x0013c079
LAB_0013cab3:
MOV qword ptr [RBX + 0x40],0x0
MOV dword ptr [RBX + 0x48],0x0
MOV qword ptr [RBX],R15
MOV qword ptr [RBX + 0x8],R14
LAB_0013cac9:
MOV EAX,0x1
CMP R14D,dword ptr [RBX + 0x38]
JNC 0x0013cadd
XOR EAX,EAX
CMP R15,qword ptr [RBX + 0x30]
SETGE AL
LAB_0013cadd:
MOV dword ptr [RBX + 0x4c],EAX
POP RBX
POP R14
POP R15
RET
|
void gray_set_cell(long *param_1,long param_2,long param_3)
{
uint uVar1;
long lVar2;
param_3 = param_3 - param_1[4];
if (param_1[3] < param_2) {
param_2 = param_1[3];
}
lVar2 = -1;
if (-1 < param_2 - param_1[2]) {
lVar2 = param_2 - param_1[2];
}
if ((lVar2 != *param_1) || (param_3 != param_1[1])) {
if (*(int *)((long)param_1 + 0x4c) == 0) {
gray_record_cell(param_1);
}
param_1[8] = 0;
*(int4 *)(param_1 + 9) = 0;
*param_1 = lVar2;
param_1[1] = param_3;
}
uVar1 = 1;
if ((uint)param_3 < *(uint *)(param_1 + 7)) {
uVar1 = (uint)(param_1[6] <= lVar2);
}
*(uint *)((long)param_1 + 0x4c) = uVar1;
return;
}
|
|
66,016 |
gray_set_cell
|
dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-ft-raster.c
|
static void
gray_set_cell( RAS_ARG_ TCoord ex,
TCoord ey )
{
/* Move the cell pointer to a new position. We set the `invalid' */
/* flag to indicate that the cell isn't part of those we're interested */
/* in during the render phase. This means that: */
/* */
/* . the new vertical position must be within min_ey..max_ey-1. */
/* . the new horizontal position must be strictly less than max_ex */
/* */
/* Note that if a cell is to the left of the clipping region, it is */
/* actually set to the (min_ex-1) horizontal position. */
/* All cells that are on the left of the clipping region go to the */
/* min_ex - 1 horizontal position. */
ey -= ras.min_ey;
if ( ex > ras.max_ex )
ex = ras.max_ex;
ex -= ras.min_ex;
if ( ex < 0 )
ex = -1;
/* are we moving to a different cell ? */
if ( ex != ras.ex || ey != ras.ey )
{
/* record the current one if it is valid */
if ( !ras.invalid )
gray_record_cell( RAS_VAR );
ras.area = 0;
ras.cover = 0;
ras.ex = ex;
ras.ey = ey;
}
ras.invalid = ( (unsigned int)ey >= (unsigned int)ras.count_ey ||
ex >= ras.count_ex );
}
|
O2
|
c
|
gray_set_cell:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
subq 0x20(%rdi), %r14
movq 0x18(%rdi), %rax
cmpq %rsi, %rax
cmovlq %rax, %rsi
subq 0x10(%rdi), %rsi
pushq $-0x1
popq %r15
cmovnsq %rsi, %r15
cmpq (%rdi), %r15
jne 0x3503b
cmpq 0x8(%rbx), %r14
je 0x35059
cmpl $0x0, 0x4c(%rbx)
jne 0x35049
movq %rbx, %rdi
callq 0x346cf
andq $0x0, 0x40(%rbx)
andl $0x0, 0x48(%rbx)
movq %r15, (%rbx)
movq %r14, 0x8(%rbx)
cmpl 0x38(%rbx), %r14d
jae 0x3506a
xorl %eax, %eax
cmpq 0x30(%rbx), %r15
setge %al
jmp 0x3506d
pushq $0x1
popq %rax
movl %eax, 0x4c(%rbx)
popq %rbx
popq %r14
popq %r15
retq
|
gray_set_cell:
push r15
push r14
push rbx
mov r14, rdx
mov rbx, rdi
sub r14, [rdi+20h]
mov rax, [rdi+18h]
cmp rax, rsi
cmovl rsi, rax
sub rsi, [rdi+10h]
push 0FFFFFFFFFFFFFFFFh
pop r15
cmovns r15, rsi
cmp r15, [rdi]
jnz short loc_3503B
cmp r14, [rbx+8]
jz short loc_35059
loc_3503B:
cmp dword ptr [rbx+4Ch], 0
jnz short loc_35049
mov rdi, rbx
call gray_record_cell
loc_35049:
and qword ptr [rbx+40h], 0
and dword ptr [rbx+48h], 0
mov [rbx], r15
mov [rbx+8], r14
loc_35059:
cmp r14d, [rbx+38h]
jnb short loc_3506A
xor eax, eax
cmp r15, [rbx+30h]
setnl al
jmp short loc_3506D
loc_3506A:
push 1
pop rax
loc_3506D:
mov [rbx+4Ch], eax
pop rbx
pop r14
pop r15
retn
|
_BOOL8 gray_set_cell(long long a1, long long a2, long long a3)
{
long long v3; // r14
long long v4; // rsi
long long v5; // r15
_BOOL8 result; // rax
v3 = a3 - *(_QWORD *)(a1 + 32);
if ( *(_QWORD *)(a1 + 24) < a2 )
a2 = *(_QWORD *)(a1 + 24);
v4 = a2 - *(_QWORD *)(a1 + 16);
v5 = -1LL;
if ( v4 >= 0 )
v5 = v4;
if ( v5 != *(_QWORD *)a1 || v3 != *(_QWORD *)(a1 + 8) )
{
if ( !*(_DWORD *)(a1 + 76) )
gray_record_cell((long long *)a1);
*(_QWORD *)(a1 + 64) = 0LL;
*(_DWORD *)(a1 + 72) = 0;
*(_QWORD *)a1 = v5;
*(_QWORD *)(a1 + 8) = v3;
}
result = (unsigned int)v3 >= *(_DWORD *)(a1 + 56) || v5 >= *(_QWORD *)(a1 + 48);
*(_DWORD *)(a1 + 76) = result;
return result;
}
|
gray_set_cell:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RDX
MOV RBX,RDI
SUB R14,qword ptr [RDI + 0x20]
MOV RAX,qword ptr [RDI + 0x18]
CMP RAX,RSI
CMOVL RSI,RAX
SUB RSI,qword ptr [RDI + 0x10]
PUSH -0x1
POP R15
CMOVNS R15,RSI
CMP R15,qword ptr [RDI]
JNZ 0x0013503b
CMP R14,qword ptr [RBX + 0x8]
JZ 0x00135059
LAB_0013503b:
CMP dword ptr [RBX + 0x4c],0x0
JNZ 0x00135049
MOV RDI,RBX
CALL 0x001346cf
LAB_00135049:
AND qword ptr [RBX + 0x40],0x0
AND dword ptr [RBX + 0x48],0x0
MOV qword ptr [RBX],R15
MOV qword ptr [RBX + 0x8],R14
LAB_00135059:
CMP R14D,dword ptr [RBX + 0x38]
JNC 0x0013506a
XOR EAX,EAX
CMP R15,qword ptr [RBX + 0x30]
SETGE AL
JMP 0x0013506d
LAB_0013506a:
PUSH 0x1
POP RAX
LAB_0013506d:
MOV dword ptr [RBX + 0x4c],EAX
POP RBX
POP R14
POP R15
RET
|
void gray_set_cell(long *param_1,long param_2,long param_3)
{
uint uVar1;
long lVar2;
param_3 = param_3 - param_1[4];
if (param_1[3] < param_2) {
param_2 = param_1[3];
}
lVar2 = -1;
if (-1 < param_2 - param_1[2]) {
lVar2 = param_2 - param_1[2];
}
if ((lVar2 != *param_1) || (param_3 != param_1[1])) {
if (*(int *)((long)param_1 + 0x4c) == 0) {
gray_record_cell(param_1);
}
param_1[8] = 0;
*(int4 *)(param_1 + 9) = 0;
*param_1 = lVar2;
param_1[1] = param_3;
}
if ((uint)param_3 < *(uint *)(param_1 + 7)) {
uVar1 = (uint)(param_1[6] <= lVar2);
}
else {
uVar1 = 1;
}
*(uint *)((long)param_1 + 0x4c) = uVar1;
return;
}
|
|
66,017 |
ggml_view_4d
|
7CodeWizard[P]stablediffusion/ggml/src/ggml.c
|
struct ggml_tensor * ggml_view_4d(
struct ggml_context * ctx,
struct ggml_tensor * a,
int64_t ne0,
int64_t ne1,
int64_t ne2,
int64_t ne3,
size_t nb1,
size_t nb2,
size_t nb3,
size_t offset) {
const int64_t ne[4] = { ne0, ne1, ne2, ne3 };
struct ggml_tensor * result = ggml_view_impl(ctx, a, 4, ne, offset);
result->nb[1] = nb1;
result->nb[2] = nb2;
result->nb[3] = nb3;
return result;
}
|
O1
|
c
|
ggml_view_4d:
pushq %rbx
subq $0x20, %rsp
movq 0x40(%rsp), %rbx
movq 0x48(%rsp), %rax
movq %rsp, %r10
movq %rdx, (%r10)
movq %rcx, 0x8(%r10)
movq %r8, 0x10(%r10)
movq %r9, 0x18(%r10)
movl $0x4, %edx
movq %r10, %rcx
movq %rax, %r8
callq 0x931a3
vmovaps 0x30(%rsp), %xmm0
vmovups %xmm0, 0x38(%rax)
movq %rbx, 0x48(%rax)
addq $0x20, %rsp
popq %rbx
retq
|
ggml_view_4d:
push rbx
sub rsp, 20h
mov rbx, [rsp+28h+arg_10]
mov rax, [rsp+28h+arg_18]
mov r10, rsp
mov [r10], rdx
mov [r10+8], rcx
mov [r10+10h], r8
mov [r10+18h], r9
mov edx, 4
mov rcx, r10
mov r8, rax
call ggml_view_impl
vmovaps xmm0, [rsp+28h+arg_0]
vmovups xmmword ptr [rax+38h], xmm0
mov [rax+48h], rbx
add rsp, 20h
pop rbx
retn
|
long long ggml_view_4d(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14,
__int128 a15,
long long a16,
long long a17)
{
long long result; // rax
_QWORD v19[5]; // [rsp+0h] [rbp-28h] BYREF
v19[0] = a3;
v19[1] = a4;
v19[2] = a5;
v19[3] = a6;
result = ggml_view_impl(a1, a2, 4, v19, a17, a7, a8, a9, a10, a11, a12, a13, a14);
__asm
{
vmovaps xmm0, [rsp+28h+arg_0]
vmovups xmmword ptr [rax+38h], xmm0
}
*(_QWORD *)(result + 72) = a16;
return result;
}
| |||
66,018 |
ggml_view_4d
|
7CodeWizard[P]stablediffusion/ggml/src/ggml.c
|
struct ggml_tensor * ggml_view_4d(
struct ggml_context * ctx,
struct ggml_tensor * a,
int64_t ne0,
int64_t ne1,
int64_t ne2,
int64_t ne3,
size_t nb1,
size_t nb2,
size_t nb3,
size_t offset) {
const int64_t ne[4] = { ne0, ne1, ne2, ne3 };
struct ggml_tensor * result = ggml_view_impl(ctx, a, 4, ne, offset);
result->nb[1] = nb1;
result->nb[2] = nb2;
result->nb[3] = nb3;
return result;
}
|
O2
|
c
|
ggml_view_4d:
pushq %rbx
subq $0x20, %rsp
movq 0x40(%rsp), %rbx
movq 0x48(%rsp), %rax
movq %rsp, %r10
movq %rdx, (%r10)
movq %rcx, 0x8(%r10)
movq %r8, 0x10(%r10)
movq %r9, 0x18(%r10)
pushq $0x4
popq %rdx
movq %r10, %rcx
movq %rax, %r8
callq 0x6c0ec
vmovaps 0x30(%rsp), %xmm0
vmovups %xmm0, 0x38(%rax)
movq %rbx, 0x48(%rax)
addq $0x20, %rsp
popq %rbx
retq
|
ggml_view_4d:
push rbx
sub rsp, 20h
mov rbx, [rsp+28h+arg_10]
mov rax, [rsp+28h+arg_18]
mov r10, rsp
mov [r10], rdx
mov [r10+8], rcx
mov [r10+10h], r8
mov [r10+18h], r9
push 4
pop rdx
mov rcx, r10
mov r8, rax
call ggml_view_impl
vmovaps xmm0, [rsp+28h+arg_0]
vmovups xmmword ptr [rax+38h], xmm0
mov [rax+48h], rbx
add rsp, 20h
pop rbx
retn
|
long long ggml_view_4d(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14,
__int128 a15,
long long a16,
long long a17)
{
long long result; // rax
_QWORD v19[5]; // [rsp+0h] [rbp-28h] BYREF
v19[0] = a3;
v19[1] = a4;
v19[2] = a5;
v19[3] = a6;
result = ggml_view_impl(a1, a2, 4u, v19, a17, a7, a8, a9, a10, a11, a12, a13, a14);
__asm
{
vmovaps xmm0, [rsp+28h+arg_0]
vmovups xmmword ptr [rax+38h], xmm0
}
*(_QWORD *)(result + 72) = a16;
return result;
}
|
ggml_view_4d:
PUSH RBX
SUB RSP,0x20
MOV RBX,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RSP + 0x48]
MOV R10,RSP
MOV qword ptr [R10],RDX
MOV qword ptr [R10 + 0x8],RCX
MOV qword ptr [R10 + 0x10],R8
MOV qword ptr [R10 + 0x18],R9
PUSH 0x4
POP RDX
MOV RCX,R10
MOV R8,RAX
CALL 0x0016c0ec
VMOVAPS XMM0,xmmword ptr [RSP + 0x30]
VMOVUPS xmmword ptr [RAX + 0x38],XMM0
MOV qword ptr [RAX + 0x48],RBX
ADD RSP,0x20
POP RBX
RET
|
void ggml_view_4d(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int8 param_9,int8 param_10)
{
long lVar1;
int8 local_28;
int8 local_20;
int8 local_18;
int8 local_10;
local_28 = param_3;
local_20 = param_4;
local_18 = param_5;
local_10 = param_6;
lVar1 = ggml_view_impl(param_1,param_2,4,&local_28,param_10);
*(int8 *)(lVar1 + 0x38) = param_7;
*(int8 *)(lVar1 + 0x40) = param_8;
*(int8 *)(lVar1 + 0x48) = param_9;
return;
}
|
|
66,019 |
ggml_view_4d
|
7CodeWizard[P]stablediffusion/ggml/src/ggml.c
|
struct ggml_tensor * ggml_view_4d(
struct ggml_context * ctx,
struct ggml_tensor * a,
int64_t ne0,
int64_t ne1,
int64_t ne2,
int64_t ne3,
size_t nb1,
size_t nb2,
size_t nb3,
size_t offset) {
const int64_t ne[4] = { ne0, ne1, ne2, ne3 };
struct ggml_tensor * result = ggml_view_impl(ctx, a, 4, ne, offset);
result->nb[1] = nb1;
result->nb[2] = nb2;
result->nb[3] = nb3;
return result;
}
|
O3
|
c
|
ggml_view_4d:
pushq %rbx
subq $0x20, %rsp
movq 0x40(%rsp), %rbx
movq 0x48(%rsp), %rax
movq %rsp, %r10
movq %rdx, (%r10)
movq %rcx, 0x8(%r10)
movq %r8, 0x10(%r10)
movq %r9, 0x18(%r10)
movl $0x4, %edx
movq %r10, %rcx
movq %rax, %r8
callq 0x9200f
vmovaps 0x30(%rsp), %xmm0
vmovups %xmm0, 0x38(%rax)
movq %rbx, 0x48(%rax)
addq $0x20, %rsp
popq %rbx
retq
|
ggml_view_4d:
push rbx
sub rsp, 20h
mov rbx, [rsp+28h+arg_10]
mov rax, [rsp+28h+arg_18]
mov r10, rsp
mov [r10], rdx
mov [r10+8], rcx
mov [r10+10h], r8
mov [r10+18h], r9
mov edx, 4
mov rcx, r10
mov r8, rax
call ggml_view_impl
vmovaps xmm0, [rsp+28h+arg_0]
vmovups xmmword ptr [rax+38h], xmm0
mov [rax+48h], rbx
add rsp, 20h
pop rbx
retn
|
long long ggml_view_4d(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14,
__int128 a15,
long long a16,
long long a17)
{
long long result; // rax
_QWORD v19[5]; // [rsp+0h] [rbp-28h] BYREF
v19[0] = a3;
v19[1] = a4;
v19[2] = a5;
v19[3] = a6;
result = ggml_view_impl(a1, a2, 4, v19, a17, a7, a8, a9, a10, a11, a12, a13, a14);
__asm
{
vmovaps xmm0, [rsp+28h+arg_0]
vmovups xmmword ptr [rax+38h], xmm0
}
*(_QWORD *)(result + 72) = a16;
return result;
}
| |||
66,020 |
mysql_real_query_start_internal
|
eloqsql/libmariadb/libmariadb/mariadb_async.c
|
static void
mysql_real_query_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_real_query,
(parms->mysql, parms->stmt_str, parms->length),
parms->mysql,
int,
r_int)
}
|
O3
|
c
|
mysql_real_query_start_internal:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rsi
movq 0x480(%rax), %rcx
movq 0x28(%rcx), %rbx
movq 0x10(%rdi), %rdx
movq %rax, %rdi
callq 0x17190
movl %eax, 0x8(%rbx)
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
mysql_real_query_start_internal:
push rbp
mov rbp, rsp
push rbx
push rax
mov rax, [rdi]
mov rsi, [rdi+8]
mov rcx, [rax+480h]
mov rbx, [rcx+28h]
mov rdx, [rdi+10h]
mov rdi, rax
call _mysql_real_query@libmariadbclient_18
mov [rbx+8], eax
mov dword ptr [rbx], 0
add rsp, 8
pop rbx
pop rbp
retn
|
long long mysql_real_query_start_internal(_QWORD *a1)
{
_DWORD *v1; // rbx
long long result; // rax
v1 = *(_DWORD **)(*(_QWORD *)(*a1 + 1152LL) + 40LL);
result = mysql_real_query_libmariadbclient_18(*a1, a1[1], a1[2]);
v1[2] = result;
*v1 = 0;
return result;
}
|
mysql_real_query_start_internal:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RAX,qword ptr [RDI]
MOV RSI,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RAX + 0x480]
MOV RBX,qword ptr [RCX + 0x28]
MOV RDX,qword ptr [RDI + 0x10]
MOV RDI,RAX
CALL 0x00117190
MOV dword ptr [RBX + 0x8],EAX
MOV dword ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void mysql_real_query_start_internal(long *param_1)
{
int4 *puVar1;
int4 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_real_query(*param_1,param_1[1],param_1[2]);
puVar1[2] = uVar2;
*puVar1 = 0;
return;
}
|
|
66,021 |
minja::Value::Value(char const*)
|
monkey531[P]llama/common/minja.hpp
|
Value(const char * v) : primitive_(std::string(v)) {}
|
O1
|
cpp
|
minja::Value::Value(char const*):
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x53c16
leaq 0x40(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x81658
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9e382
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b900
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9e3ad
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b900
jmp 0x9e3ad
movq %rax, %r14
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x9e3bb
callq 0x6e97a
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x9e3c9
callq 0x6e97a
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x9e3d7
callq 0x6e97a
movq %rbx, %rdi
callq 0x895aa
movq %r14, %rdi
callq 0x1bfc0
nop
|
_ZN5minja5ValueC2EPKc:
push r14
push rbx
sub rsp, 28h
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi+30h], xmm0
movups xmmword ptr [rdi+20h], xmm0
movups xmmword ptr [rdi+10h], xmm0
movups xmmword ptr [rdi], xmm0
lea rdi, [rsp+38h+var_30]
lea rdx, [rsp+38h+var_31]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rdi, [rbx+40h]
lea rsi, [rsp+38h+var_30]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_
lea rax, [rsp+38h+var_20]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_9E382
mov rsi, [rsp+38h+var_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9E382:
add rsp, 28h
pop rbx
pop r14
retn
mov r14, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_9E3AD
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_9E3AD
mov r14, rax
loc_9E3AD:
mov rdi, [rbx+38h]
test rdi, rdi
jz short loc_9E3BB
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9E3BB:
mov rdi, [rbx+28h]
test rdi, rdi
jz short loc_9E3C9
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9E3C9:
mov rdi, [rbx+18h]
test rdi, rdi
jz short loc_9E3D7
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9E3D7:
mov rdi, rbx
call _ZNSt23enable_shared_from_thisIN5minja5ValueEED2Ev; std::enable_shared_from_this<minja::Value>::~enable_shared_from_this()
mov rdi, r14
call __Unwind_Resume
|
void minja::Value::Value(minja::Value *this, char *a2)
{
long long *v2; // [rsp+8h] [rbp-30h] BYREF
long long v3; // [rsp+18h] [rbp-20h] BYREF
*((_OWORD *)this + 3) = 0LL;
*((_OWORD *)this + 2) = 0LL;
*((_OWORD *)this + 1) = 0LL;
*(_OWORD *)this = 0LL;
std::string::basic_string<std::allocator<char>>(&v2, a2);
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_((char *)this + 64);
if ( v2 != &v3 )
operator delete(v2, v3 + 1);
}
|
Value:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOVUPS xmmword ptr [RDI],XMM0
LAB_0019e34a:
LEA RDI,[RSP + 0x8]
LEA RDX,[RSP + 0x7]
CALL 0x00153c16
LEA RDI,[RBX + 0x40]
LAB_0019e35d:
LEA RSI,[RSP + 0x8]
CALL 0x00181658
LAB_0019e367:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0019e382
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011b900
LAB_0019e382:
ADD RSP,0x28
POP RBX
POP R14
RET
|
/* minja::Value::Value(char const*) */
void __thiscall minja::Value::Value(Value *this,char *param_1)
{
allocator local_31;
long *local_30 [2];
long local_20 [2];
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
/* try { // try from 0019e34a to 0019e358 has its CatchHandler @ 0019e3aa */
std::__cxx11::string::string<std::allocator<char>>((string *)local_30,param_1,&local_31);
/* try { // try from 0019e35d to 0019e366 has its CatchHandler @ 0019e38a */
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_
(this + 0x40,local_30);
if (local_30[0] != local_20) {
operator_delete(local_30[0],local_20[0] + 1);
}
return;
}
|
|
66,022 |
minja::Value::at(unsigned long)
|
monkey531[P]llama/common/minja.hpp
|
Value& at(size_t index) {
if (is_null())
throw std::runtime_error("Undefined value or reference");
if (is_array()) return array_->at(index);
if (is_object()) return object_->at(index);
throw std::runtime_error("Value is not an array or object: " + dump());
}
|
O3
|
cpp
|
minja::Value::at(unsigned long):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
movq 0x10(%rdi), %rcx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
jne 0x56736
testq %rcx, %rcx
jne 0x56736
cmpb $0x0, 0x40(%r14)
jne 0x56736
cmpq $0x0, 0x30(%r14)
je 0x56781
testq %rcx, %rcx
je 0x56769
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0x567b3
leaq (%rsi,%rsi,4), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
jmp 0x56778
testq %rdi, %rdi
je 0x567c1
leaq 0x8(%rsp), %rsi
callq 0x56ad2
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x1a390
movq %rax, %rbx
leaq 0x58f98(%rip), %rsi # 0xaf72d
movq %rax, %rdi
callq 0x1a290
movq 0x8c84c(%rip), %rsi # 0xe2ff0
movq 0x8c7c5(%rip), %rdx # 0xe2f70
movq %rbx, %rdi
callq 0x1acd0
leaq 0x5a7f6(%rip), %rdi # 0xb0fb0
xorl %eax, %eax
callq 0x1ab50
movl $0x10, %edi
callq 0x1a390
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x42a18
leaq 0x5a7a5(%rip), %rsi # 0xb0f8e
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x29d9d
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x1ac00
xorl %ebp, %ebp
movq 0x8c7df(%rip), %rsi # 0xe2ff0
movq 0x8c758(%rip), %rdx # 0xe2f70
movq %rbx, %rdi
callq 0x1acd0
movq %rax, %r14
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5683e
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1a740
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x56859
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a740
testb %bpl, %bpl
jne 0x56885
jmp 0x5688d
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x56885
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a740
jmp 0x56885
jmp 0x56882
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a530
movq %r14, %rdi
callq 0x1ad30
nop
|
_ZN5minja5Value2atEm:
push rbp
push r14
push rbx
sub rsp, 50h
mov r14, rdi
mov [rsp+68h+var_60], rsi
mov rcx, [rdi+10h]
mov rdi, [rdi+20h]
test rdi, rdi
jnz short loc_56736
test rcx, rcx
jnz short loc_56736
cmp byte ptr [r14+40h], 0
jnz short loc_56736
cmp qword ptr [r14+30h], 0
jz short loc_56781
loc_56736:
test rcx, rcx
jz short loc_56769
mov rax, [rcx]
mov rcx, [rcx+8]
sub rcx, rax
sar rcx, 4
mov rdx, 0CCCCCCCCCCCCCCCDh
imul rdx, rcx
cmp rdx, rsi
jbe short loc_567B3
lea rcx, [rsi+rsi*4]
shl rcx, 4
add rax, rcx
jmp short loc_56778
loc_56769:
test rdi, rdi
jz short loc_567C1
lea rsi, [rsp+68h+var_60]
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE2atIRmTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OSS_
loc_56778:
add rsp, 50h
pop rbx
pop r14
pop rbp
retn
loc_56781:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aUndefinedValue; "Undefined value or reference"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_567B3:
lea rdi, aVectorMRangeCh; "vector::_M_range_check: __n (which is %"...
xor eax, eax
call __ZSt24__throw_out_of_range_fmtPKcz; std::__throw_out_of_range_fmt(char const*,...)
loc_567C1:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+68h+var_58]
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aValueIsNotAnAr_0; "Value is not an array or object: "
lea rdi, [rsp+68h+var_38]
lea rdx, [rsp+68h+var_58]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+68h+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+68h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_5683E
mov rsi, [rsp+68h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5683E:
lea rax, [rsp+68h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_56859
mov rsi, [rsp+68h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_56859:
test bpl, bpl
jnz short loc_56885
jmp short loc_5688D
mov r14, rax
lea rax, [rsp+68h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_56885
mov rsi, [rsp+68h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_56885
jmp short $+2
loc_56882:
mov r14, rax
loc_56885:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_5688D:
mov rdi, r14
call __Unwind_Resume
|
unsigned long long minja::Value::at(minja::Value *this, unsigned long long a2)
{
_QWORD *v3; // rcx
long long v4; // rdi
unsigned long long v5; // rdx
std::runtime_error *exception; // rbx
void *v8; // rbx
unsigned long long v9; // [rsp+8h] [rbp-60h] BYREF
_BYTE v10[16]; // [rsp+10h] [rbp-58h] BYREF
_BYTE v11[16]; // [rsp+30h] [rbp-38h] BYREF
v9 = a2;
v3 = (_QWORD *)*((_QWORD *)this + 2);
v4 = *((_QWORD *)this + 4);
if ( !v4 && !v3 && !*((_BYTE *)this + 64) && !*((_QWORD *)this + 6) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Undefined value or reference");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( v3 )
{
v5 = 0xCCCCCCCCCCCCCCCDLL * ((long long)(v3[1] - *v3) >> 4);
if ( v5 <= a2 )
std::__throw_out_of_range_fmt("vector::_M_range_check: __n (which is %zu) >= this->size() (which is %zu)", a2, v5);
return 80 * a2 + *v3;
}
else
{
if ( !v4 )
{
v8 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v10, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v11, (long long)"Value is not an array or object: ", (long long)v10);
std::runtime_error::runtime_error(v8, v11);
__cxa_throw(
v8,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE2atIRmTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OSS_(
v4,
&v9);
}
}
|
at:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV R14,RDI
MOV qword ptr [RSP + 0x8],RSI
MOV RCX,qword ptr [RDI + 0x10]
MOV RDI,qword ptr [RDI + 0x20]
TEST RDI,RDI
JNZ 0x00156736
TEST RCX,RCX
JNZ 0x00156736
CMP byte ptr [R14 + 0x40],0x0
JNZ 0x00156736
CMP qword ptr [R14 + 0x30],0x0
JZ 0x00156781
LAB_00156736:
TEST RCX,RCX
JZ 0x00156769
MOV RAX,qword ptr [RCX]
MOV RCX,qword ptr [RCX + 0x8]
SUB RCX,RAX
SAR RCX,0x4
MOV RDX,-0x3333333333333333
IMUL RDX,RCX
CMP RDX,RSI
JBE 0x001567b3
LEA RCX,[RSI + RSI*0x4]
SHL RCX,0x4
ADD RAX,RCX
JMP 0x00156778
LAB_00156769:
TEST RDI,RDI
JZ 0x001567c1
LEA RSI,[RSP + 0x8]
CALL 0x00156ad2
LAB_00156778:
ADD RSP,0x50
POP RBX
POP R14
POP RBP
RET
LAB_00156781:
MOV EDI,0x10
CALL 0x0011a390
MOV RBX,RAX
LAB_0015678e:
LEA RSI,[0x1af72d]
MOV RDI,RAX
CALL 0x0011a290
LAB_0015679d:
MOV RSI,qword ptr [0x001e2ff0]
MOV RDX,qword ptr [0x001e2f70]
MOV RDI,RBX
CALL 0x0011acd0
LAB_001567b3:
LEA RDI,[0x1b0fb0]
XOR EAX,EAX
CALL 0x0011ab50
LAB_001567c1:
MOV EDI,0x10
CALL 0x0011a390
MOV RBX,RAX
LAB_001567ce:
LEA RDI,[RSP + 0x10]
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x00142a18
LAB_001567e2:
LEA RSI,[0x1b0f8e]
LEA RDI,[RSP + 0x30]
LEA RDX,[RSP + 0x10]
CALL 0x00129d9d
MOV BPL,0x1
LAB_001567fb:
LEA RSI,[RSP + 0x30]
MOV RDI,RBX
CALL 0x0011ac00
XOR EBP,EBP
MOV RSI,qword ptr [0x001e2ff0]
MOV RDX,qword ptr [0x001e2f70]
MOV RDI,RBX
CALL 0x0011acd0
|
/* minja::Value::at(unsigned long) */
long __thiscall minja::Value::at(Value *this,ulong param_1)
{
long *plVar1;
long lVar2;
runtime_error *prVar3;
ulong uVar4;
ulong local_60;
int1 local_58 [32];
string local_38 [32];
plVar1 = *(long **)(this + 0x10);
lVar2 = *(long *)(this + 0x20);
local_60 = param_1;
if ((((lVar2 == 0) && (plVar1 == (long *)0x0)) && (this[0x40] == (Value)0x0)) &&
(*(long *)(this + 0x30) == 0)) {
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0015678e to 0015679c has its CatchHandler @ 00156882 */
std::runtime_error::runtime_error(prVar3,"Undefined value or reference");
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_001e2ff0,PTR__runtime_error_001e2f70);
}
if (plVar1 == (long *)0x0) {
if (lVar2 == 0) goto LAB_001567c1;
lVar2 = _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE2atIRmTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OSS_
(lVar2,&local_60);
}
else {
uVar4 = (plVar1[1] - *plVar1 >> 4) * -0x3333333333333333;
if (uVar4 < param_1 || uVar4 - param_1 == 0) {
std::__throw_out_of_range_fmt
("vector::_M_range_check: __n (which is %zu) >= this->size() (which is %zu)");
LAB_001567c1:
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001567ce to 001567e1 has its CatchHandler @ 00156880 */
dump_abi_cxx11_((int)local_58,SUB81(this,0));
/* try { // try from 001567e2 to 001567f7 has its CatchHandler @ 00156860 */
std::operator+((char *)local_38,(string *)"Value is not an array or object: ");
/* try { // try from 001567fb to 0015681f has its CatchHandler @ 00156820 */
std::runtime_error::runtime_error(prVar3,local_38);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_001e2ff0,PTR__runtime_error_001e2f70);
}
lVar2 = *plVar1 + param_1 * 0x50;
}
return lVar2;
}
|
|
66,023 |
binding_system_create
|
eshkol/src/frontend/binding/binding.c
|
BindingSystem* binding_system_create(Arena* arena, DiagnosticContext* diag) {
BindingSystem* system = arena_alloc(arena, sizeof(BindingSystem));
if (!system) {
return NULL;
}
// Initialize the binding system
system->arena = arena;
system->diag = diag;
system->binding_table.names = NULL;
system->binding_table.binding_ids = NULL;
system->binding_table.scope_ids = NULL;
system->binding_table.is_mutable = NULL;
system->binding_table.is_captured = NULL;
system->binding_table.capture_depth = NULL;
system->binding_table.environment_indices = NULL;
system->binding_table.count = 0;
system->binding_table.capacity = 0;
system->scope_stack.ids = NULL;
system->scope_stack.parent_ids = NULL;
system->scope_stack.types = NULL;
system->scope_stack.lambda_ids = NULL;
system->scope_stack.count = 0;
system->scope_stack.capacity = 0;
system->lambda_table.ids = NULL;
system->lambda_table.scope_ids = NULL;
system->lambda_table.environment_ids = NULL;
system->lambda_table.count = 0;
system->lambda_table.capacity = 0;
system->env_table.ids = NULL;
system->env_table.parent_ids = NULL;
system->env_table.scope_ids = NULL;
system->env_table.binding_counts = NULL;
system->env_table.count = 0;
system->env_table.capacity = 0;
system->current_scope_id = 0;
system->next_binding_id = 1; // Start at 1, 0 is reserved for "not found"
system->next_scope_id = 1; // Start at 1, 0 is reserved for global scope
system->next_lambda_id = 1; // Start at 1, 0 is reserved for "not found"
system->next_env_id = 1; // Start at 1, 0 is reserved for "not found"
// Create global scope
uint64_t global_scope_id = binding_system_enter_scope(system);
if (global_scope_id == 0) {
return NULL;
}
// Set the global scope type
if (system->scope_stack.types) {
system->scope_stack.types[0] = SCOPE_GLOBAL;
}
return system;
}
|
O3
|
c
|
binding_system_create:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0x110, %esi # imm = 0x110
callq 0x32ff
testq %rax, %rax
je 0x7d90
movq %rax, %rbx
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rax, %rdi
addq $0x10, %rdi
movl $0xc0, %edx
xorl %esi, %esi
callq 0x10c0
xorps %xmm0, %xmm0
movups %xmm0, 0xd8(%rbx)
movq $0x0, 0xe8(%rbx)
movl $0x1, %eax
movq %rax, 0xf0(%rbx)
movq %rax, 0xf8(%rbx)
movq %rax, 0x100(%rbx)
movq %rax, 0x108(%rbx)
movq %rbx, %rdi
callq 0x7da0
testq %rax, %rax
je 0x7d90
movq 0x68(%rbx), %rax
testq %rax, %rax
je 0x7d92
movl $0x0, (%rax)
jmp 0x7d92
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
binding_system_create:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14, rsi
mov r15, rdi
mov esi, 110h
call arena_alloc
test rax, rax
jz short loc_7D90
mov rbx, rax
mov [rax], r15
mov [rax+8], r14
mov rdi, rax
add rdi, 10h
mov edx, 0C0h
xor esi, esi
call _memset
xorps xmm0, xmm0
movups xmmword ptr [rbx+0D8h], xmm0
mov qword ptr [rbx+0E8h], 0
mov eax, 1
mov [rbx+0F0h], rax
mov [rbx+0F8h], rax
mov [rbx+100h], rax
mov [rbx+108h], rax
mov rdi, rbx
call binding_system_enter_scope
test rax, rax
jz short loc_7D90
mov rax, [rbx+68h]
test rax, rax
jz short loc_7D92
mov dword ptr [rax], 0
jmp short loc_7D92
loc_7D90:
xor ebx, ebx
loc_7D92:
mov rax, rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
_QWORD * binding_system_create(long long a1, long long a2)
{
_QWORD *v2; // rax
_QWORD *v3; // rbx
_DWORD *v4; // rax
v2 = (_QWORD *)arena_alloc(a1, 272LL);
if ( !v2 )
return 0LL;
v3 = v2;
*v2 = a1;
v2[1] = a2;
memset(v2 + 2, 0LL, 192LL);
*(_OWORD *)(v3 + 27) = 0LL;
v3[29] = 0LL;
v3[30] = 1LL;
v3[31] = 1LL;
v3[32] = 1LL;
v3[33] = 1LL;
if ( !binding_system_enter_scope(v3) )
return 0LL;
v4 = (_DWORD *)v3[13];
if ( v4 )
*v4 = 0;
return v3;
}
|
binding_system_create:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV R15,RDI
MOV ESI,0x110
CALL 0x001032ff
TEST RAX,RAX
JZ 0x00107d90
MOV RBX,RAX
MOV qword ptr [RAX],R15
MOV qword ptr [RAX + 0x8],R14
MOV RDI,RAX
ADD RDI,0x10
MOV EDX,0xc0
XOR ESI,ESI
CALL 0x001010c0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0xd8],XMM0
MOV qword ptr [RBX + 0xe8],0x0
MOV EAX,0x1
MOV qword ptr [RBX + 0xf0],RAX
MOV qword ptr [RBX + 0xf8],RAX
MOV qword ptr [RBX + 0x100],RAX
MOV qword ptr [RBX + 0x108],RAX
MOV RDI,RBX
CALL 0x00107da0
TEST RAX,RAX
JZ 0x00107d90
MOV RAX,qword ptr [RBX + 0x68]
TEST RAX,RAX
JZ 0x00107d92
MOV dword ptr [RAX],0x0
JMP 0x00107d92
LAB_00107d90:
XOR EBX,EBX
LAB_00107d92:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int8 * binding_system_create(int8 param_1,int8 param_2)
{
int8 *puVar1;
long lVar2;
puVar1 = (int8 *)arena_alloc();
if (puVar1 != (int8 *)0x0) {
*puVar1 = param_1;
puVar1[1] = param_2;
memset(puVar1 + 2,0,0xc0);
puVar1[0x1b] = 0;
puVar1[0x1c] = 0;
puVar1[0x1d] = 0;
puVar1[0x1e] = 1;
puVar1[0x1f] = 1;
puVar1[0x20] = 1;
puVar1[0x21] = 1;
lVar2 = binding_system_enter_scope(puVar1);
if (lVar2 != 0) {
if ((int4 *)puVar1[0xd] == (int4 *)0x0) {
return puVar1;
}
*(int4 *)puVar1[0xd] = 0;
return puVar1;
}
}
return (int8 *)0x0;
}
|
|
66,024 |
my_mb_wc_utf8mb4_quick
|
eloqsql/strings/ctype-utf8.h
|
static inline int
my_mb_wc_utf8mb4_quick(my_wc_t *pwc, const uchar *s, const uchar *e)
{
uchar c;
if (s >= e)
return MY_CS_TOOSMALL;
c= s[0];
if (c < 0x80)
{
*pwc= c;
return 1;
}
else if (c < 0xc2)
return MY_CS_ILSEQ;
else if (c < 0xe0)
{
if (s + 2 > e) /* We need 2 characters */
return MY_CS_TOOSMALL2;
if (!(IS_CONTINUATION_BYTE(s[1])))
return MY_CS_ILSEQ;
*pwc= UTF8MB2_CODE(c, s[1]);
return 2;
}
else if (c < 0xf0)
{
if (s + 3 > e) /* We need 3 characters */
return MY_CS_TOOSMALL3;
if (!IS_UTF8MB3_STEP2(c, s[1], s[2]))
return MY_CS_ILSEQ;
*pwc= UTF8MB3_CODE(c, s[1], s[2]);
return 3;
}
else if (c < 0xf5)
{
if (s + 4 > e) /* We need 4 characters */
return MY_CS_TOOSMALL4;
if (!IS_UTF8MB4_STEP2(c, s[1], s[2], s[3]))
return MY_CS_ILSEQ;
*pwc= UTF8MB4_CODE(c, s[1], s[2], s[3]);
return 4;
}
return MY_CS_ILSEQ;
}
|
O0
|
c
|
my_mb_wc_utf8mb4_quick:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0x695b6
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x69833
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0x80, %eax
jge 0x695e3
movzbl -0x21(%rbp), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x69833
movzbl -0x21(%rbp), %eax
cmpl $0xc2, %eax
jge 0x695fa
movl $0x0, -0x4(%rbp)
jmp 0x69833
movzbl -0x21(%rbp), %eax
cmpl $0xe0, %eax
jge 0x69670
movq -0x18(%rbp), %rax
addq $0x2, %rax
cmpq -0x20(%rbp), %rax
jbe 0x6961f
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x69833
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jl 0x6963d
movl $0x0, -0x4(%rbp)
jmp 0x69833
movzbl -0x21(%rbp), %eax
andl $0x1f, %eax
movslq %eax, %rcx
shlq $0x6, %rcx
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cltq
orq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0x69833
movzbl -0x21(%rbp), %eax
cmpl $0xf0, %eax
jge 0x6972c
movq -0x18(%rbp), %rax
addq $0x3, %rax
cmpq -0x20(%rbp), %rax
jbe 0x69699
movl $0xffffff99, -0x4(%rbp) # imm = 0xFFFFFF99
jmp 0x69833
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x696d7
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x696d7
movzbl -0x21(%rbp), %eax
cmpl $0xe1, %eax
jge 0x696e3
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xa0, %eax
jge 0x696e3
movl $0x0, -0x4(%rbp)
jmp 0x69833
movzbl -0x21(%rbp), %eax
andl $0xf, %eax
movslq %eax, %rcx
shlq $0xc, %rcx
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cltq
shlq $0x6, %rax
orq %rax, %rcx
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
xorl $0x80, %eax
cltq
orq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x3, -0x4(%rbp)
jmp 0x69833
movzbl -0x21(%rbp), %eax
cmpl $0xf5, %eax
jge 0x69824
movq -0x18(%rbp), %rax
addq $0x4, %rax
cmpq -0x20(%rbp), %rax
jbe 0x69755
movl $0xffffff98, -0x4(%rbp) # imm = 0xFFFFFF98
jmp 0x69833
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x697bf
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x697bf
movq -0x18(%rbp), %rax
movzbl 0x3(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x697bf
movzbl -0x21(%rbp), %eax
cmpl $0xf1, %eax
jge 0x697a5
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x90, %eax
jl 0x697bf
movzbl -0x21(%rbp), %eax
cmpl $0xf3, %eax
jle 0x697c8
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x8f, %eax
jle 0x697c8
movl $0x0, -0x4(%rbp)
jmp 0x69833
movzbl -0x21(%rbp), %eax
andl $0x7, %eax
movslq %eax, %rcx
shlq $0x12, %rcx
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cltq
shlq $0xc, %rax
orq %rax, %rcx
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
xorl $0x80, %eax
cltq
shlq $0x6, %rax
orq %rax, %rcx
movq -0x18(%rbp), %rax
movzbl 0x3(%rax), %eax
xorl $0x80, %eax
cltq
orq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x4, -0x4(%rbp)
jmp 0x69833
jmp 0x69826
jmp 0x69828
jmp 0x6982a
jmp 0x6982c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
|
my_mb_wc_utf8mb4_quick_0:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jb short loc_695B6
mov [rbp+var_4], 0FFFFFF9Bh
jmp loc_69833
loc_695B6:
mov rax, [rbp+var_18]
mov al, [rax]
mov [rbp+var_21], al
movzx eax, [rbp+var_21]
cmp eax, 80h
jge short loc_695E3
movzx eax, [rbp+var_21]
mov ecx, eax
mov rax, [rbp+var_10]
mov [rax], rcx
mov [rbp+var_4], 1
jmp loc_69833
loc_695E3:
movzx eax, [rbp+var_21]
cmp eax, 0C2h
jge short loc_695FA
mov [rbp+var_4], 0
jmp loc_69833
loc_695FA:
movzx eax, [rbp+var_21]
cmp eax, 0E0h
jge short loc_69670
mov rax, [rbp+var_18]
add rax, 2
cmp rax, [rbp+var_20]
jbe short loc_6961F
mov [rbp+var_4], 0FFFFFF9Ah
jmp loc_69833
loc_6961F:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cmp eax, 40h ; '@'
jl short loc_6963D
mov [rbp+var_4], 0
jmp loc_69833
loc_6963D:
movzx eax, [rbp+var_21]
and eax, 1Fh
movsxd rcx, eax
shl rcx, 6
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cdqe
or rcx, rax
mov rax, [rbp+var_10]
mov [rax], rcx
mov [rbp+var_4], 2
jmp loc_69833
loc_69670:
movzx eax, [rbp+var_21]
cmp eax, 0F0h
jge loc_6972C
mov rax, [rbp+var_18]
add rax, 3
cmp rax, [rbp+var_20]
jbe short loc_69699
mov [rbp+var_4], 0FFFFFF99h
jmp loc_69833
loc_69699:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_696D7
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+2]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_696D7
movzx eax, [rbp+var_21]
cmp eax, 0E1h
jge short loc_696E3
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
cmp eax, 0A0h
jge short loc_696E3
loc_696D7:
mov [rbp+var_4], 0
jmp loc_69833
loc_696E3:
movzx eax, [rbp+var_21]
and eax, 0Fh
movsxd rcx, eax
shl rcx, 0Ch
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cdqe
shl rax, 6
or rcx, rax
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+2]
xor eax, 80h
cdqe
or rcx, rax
mov rax, [rbp+var_10]
mov [rax], rcx
mov [rbp+var_4], 3
jmp loc_69833
loc_6972C:
movzx eax, [rbp+var_21]
cmp eax, 0F5h
jge loc_69824
mov rax, [rbp+var_18]
add rax, 4
cmp rax, [rbp+var_20]
jbe short loc_69755
mov [rbp+var_4], 0FFFFFF98h
jmp loc_69833
loc_69755:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_697BF
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+2]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_697BF
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+3]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_697BF
movzx eax, [rbp+var_21]
cmp eax, 0F1h
jge short loc_697A5
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
cmp eax, 90h
jl short loc_697BF
loc_697A5:
movzx eax, [rbp+var_21]
cmp eax, 0F3h
jle short loc_697C8
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
cmp eax, 8Fh
jle short loc_697C8
loc_697BF:
mov [rbp+var_4], 0
jmp short loc_69833
loc_697C8:
movzx eax, [rbp+var_21]
and eax, 7
movsxd rcx, eax
shl rcx, 12h
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cdqe
shl rax, 0Ch
or rcx, rax
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+2]
xor eax, 80h
cdqe
shl rax, 6
or rcx, rax
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+3]
xor eax, 80h
cdqe
or rcx, rax
mov rax, [rbp+var_10]
mov [rax], rcx
mov [rbp+var_4], 4
jmp short loc_69833
loc_69824:
jmp short $+2
loc_69826:
jmp short $+2
loc_69828:
jmp short $+2
loc_6982A:
jmp short $+2
loc_6982C:
mov [rbp+var_4], 0
loc_69833:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long my_mb_wc_utf8mb4_quick_0(unsigned long long *a1, unsigned __int8 *a2, unsigned long long a3)
{
unsigned __int8 v4; // [rsp+1h] [rbp-21h]
if ( (unsigned long long)a2 < a3 )
{
v4 = *a2;
if ( *a2 >= 0x80u )
{
if ( v4 >= 0xC2u )
{
if ( v4 >= 0xE0u )
{
if ( v4 >= 0xF0u )
{
if ( v4 >= 0xF5u )
{
return 0;
}
else if ( (unsigned long long)(a2 + 4) <= a3 )
{
if ( (a2[1] ^ 0x80) < 64
&& (a2[2] ^ 0x80) < 64
&& (a2[3] ^ 0x80) < 64
&& (v4 >= 0xF1u || a2[1] >= 0x90u)
&& (v4 <= 0xF3u || a2[1] <= 0x8Fu) )
{
*a1 = a2[3] ^ 0x80u | ((long long)(a2[2] ^ 0x80u) << 6) | ((long long)(a2[1] ^ 0x80u) << 12) | ((unsigned long long)(v4 & 7) << 18);
return 4;
}
else
{
return 0;
}
}
else
{
return (unsigned int)-104;
}
}
else if ( (unsigned long long)(a2 + 3) <= a3 )
{
if ( (a2[1] ^ 0x80) < 64 && (a2[2] ^ 0x80) < 64 && (v4 >= 0xE1u || a2[1] >= 0xA0u) )
{
*a1 = a2[2] ^ 0x80u | ((long long)(a2[1] ^ 0x80u) << 6) | ((unsigned long long)(v4 & 0xF) << 12);
return 3;
}
else
{
return 0;
}
}
else
{
return (unsigned int)-103;
}
}
else if ( (unsigned long long)(a2 + 2) <= a3 )
{
if ( (a2[1] ^ 0x80) < 64 )
{
*a1 = a2[1] ^ 0x80u | ((unsigned long long)(v4 & 0x1F) << 6);
return 2;
}
else
{
return 0;
}
}
else
{
return (unsigned int)-102;
}
}
else
{
return 0;
}
}
else
{
*a1 = v4;
return 1;
}
}
else
{
return (unsigned int)-101;
}
}
|
my_mb_wc_utf8mb4_quick:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JC 0x001695b6
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x00169833
LAB_001695b6:
MOV RAX,qword ptr [RBP + -0x18]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x21],AL
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0x80
JGE 0x001695e3
MOVZX EAX,byte ptr [RBP + -0x21]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00169833
LAB_001695e3:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xc2
JGE 0x001695fa
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00169833
LAB_001695fa:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xe0
JGE 0x00169670
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x0016961f
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x00169833
LAB_0016961f:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CMP EAX,0x40
JL 0x0016963d
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00169833
LAB_0016963d:
MOVZX EAX,byte ptr [RBP + -0x21]
AND EAX,0x1f
MOVSXD RCX,EAX
SHL RCX,0x6
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CDQE
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x2
JMP 0x00169833
LAB_00169670:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xf0
JGE 0x0016972c
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x3
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x00169699
MOV dword ptr [RBP + -0x4],0xffffff99
JMP 0x00169833
LAB_00169699:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x001696d7
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x2]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x001696d7
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xe1
JGE 0x001696e3
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0xa0
JGE 0x001696e3
LAB_001696d7:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00169833
LAB_001696e3:
MOVZX EAX,byte ptr [RBP + -0x21]
AND EAX,0xf
MOVSXD RCX,EAX
SHL RCX,0xc
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CDQE
SHL RAX,0x6
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x2]
XOR EAX,0x80
CDQE
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x3
JMP 0x00169833
LAB_0016972c:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xf5
JGE 0x00169824
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x4
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x00169755
MOV dword ptr [RBP + -0x4],0xffffff98
JMP 0x00169833
LAB_00169755:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x001697bf
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x2]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x001697bf
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x3]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x001697bf
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xf1
JGE 0x001697a5
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x90
JL 0x001697bf
LAB_001697a5:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xf3
JLE 0x001697c8
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x8f
JLE 0x001697c8
LAB_001697bf:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00169833
LAB_001697c8:
MOVZX EAX,byte ptr [RBP + -0x21]
AND EAX,0x7
MOVSXD RCX,EAX
SHL RCX,0x12
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CDQE
SHL RAX,0xc
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x2]
XOR EAX,0x80
CDQE
SHL RAX,0x6
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x3]
XOR EAX,0x80
CDQE
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x4
JMP 0x00169833
LAB_00169824:
JMP 0x00169826
LAB_00169826:
JMP 0x00169828
LAB_00169828:
JMP 0x0016982a
LAB_0016982a:
JMP 0x0016982c
LAB_0016982c:
MOV dword ptr [RBP + -0x4],0x0
LAB_00169833:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_mb_wc_utf8mb4_quick(ulong *param_1,byte *param_2,byte *param_3)
{
byte bVar1;
int4 local_c;
if (param_2 < param_3) {
bVar1 = *param_2;
if (bVar1 < 0x80) {
*param_1 = (ulong)bVar1;
local_c = 1;
}
else if (bVar1 < 0xc2) {
local_c = 0;
}
else if (bVar1 < 0xe0) {
if (param_3 < param_2 + 2) {
local_c = 0xffffff9a;
}
else if ((param_2[1] ^ 0x80) < 0x40) {
*param_1 = (long)(int)(bVar1 & 0x1f) << 6 | (long)(int)(param_2[1] ^ 0x80);
local_c = 2;
}
else {
local_c = 0;
}
}
else if (bVar1 < 0xf0) {
if (param_3 < param_2 + 3) {
local_c = 0xffffff99;
}
else if ((((param_2[1] ^ 0x80) < 0x40) && ((param_2[2] ^ 0x80) < 0x40)) &&
((0xe0 < bVar1 || (0x9f < param_2[1])))) {
*param_1 = (long)(int)(bVar1 & 0xf) << 0xc | (long)(int)(param_2[1] ^ 0x80) << 6 |
(long)(int)(param_2[2] ^ 0x80);
local_c = 3;
}
else {
local_c = 0;
}
}
else if (bVar1 < 0xf5) {
if (param_3 < param_2 + 4) {
local_c = 0xffffff98;
}
else if ((((((param_2[1] ^ 0x80) < 0x40) && ((param_2[2] ^ 0x80) < 0x40)) &&
((param_2[3] ^ 0x80) < 0x40)) && ((0xf0 < bVar1 || (0x8f < param_2[1])))) &&
((bVar1 < 0xf4 || (param_2[1] < 0x90)))) {
*param_1 = (long)(int)(bVar1 & 7) << 0x12 | (long)(int)(param_2[1] ^ 0x80) << 0xc |
(long)(int)(param_2[2] ^ 0x80) << 6 | (long)(int)(param_2[3] ^ 0x80);
local_c = 4;
}
else {
local_c = 0;
}
}
else {
local_c = 0;
}
}
else {
local_c = 0xffffff9b;
}
return local_c;
}
|
|
66,025 |
nglog::LogDestination::SetLogFilenameExtension(char const*)
|
ng-log[P]ng-log/src/logging.cc
|
inline void LogDestination::SetLogFilenameExtension(const char* ext) {
// Prevent any subtle race conditions by wrapping a mutex lock around
// all this stuff.
std::lock_guard<std::mutex> l{log_mutex};
for (int severity = 0; severity < NUM_SEVERITIES; ++severity) {
log_destination(static_cast<LogSeverity>(severity))
->fileobject_.SetExtension(ext);
}
}
|
O0
|
cpp
|
nglog::LogDestination::SetLogFilenameExtension(char const*):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
leaq 0x678f1(%rip), %rsi # 0x7fe58
callq 0x174a0
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x185ba
movl -0x14(%rbp), %edi
callq 0x17e60
movq %rax, -0x30(%rbp)
jmp 0x18587
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x161f0
jmp 0x18596
jmp 0x18598
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x18573
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x174d0
jmp 0x185c9
leaq -0x10(%rbp), %rdi
callq 0x174d0
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x9d00
nopw %cs:(%rax,%rax)
nopl (%rax)
|
_ZN5nglog14LogDestination23SetLogFilenameExtensionEPKc:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
lea rdi, [rbp+var_10]
lea rsi, _ZN5nglogL9log_mutexE; nglog::log_mutex
call _ZNSt10lock_guardISt5mutexEC2ERS0_; std::lock_guard<std::mutex>::lock_guard(std::mutex&)
mov [rbp+var_14], 0
loc_18573:
cmp [rbp+var_14], 4
jge short loc_185BA
mov edi, [rbp+var_14]
call _ZN5nglog14LogDestination15log_destinationENS_11LogSeverityE; nglog::LogDestination::log_destination(nglog::LogSeverity)
mov [rbp+var_30], rax
jmp short $+2
loc_18587:
mov rdi, [rbp+var_30]; this
mov rsi, [rbp+var_8]; char *
call _ZN5nglog12_GLOBAL__N_113LogFileObject12SetExtensionEPKc; nglog::`anonymous namespace'::LogFileObject::SetExtension(char const*)
jmp short $+2
loc_18596:
jmp short $+2
loc_18598:
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
jmp short loc_18573
mov rcx, rax
mov eax, edx
mov [rbp+var_20], rcx
mov [rbp+var_24], eax
lea rdi, [rbp+var_10]
call _ZNSt10lock_guardISt5mutexED2Ev; std::lock_guard<std::mutex>::~lock_guard()
jmp short loc_185C9
loc_185BA:
lea rdi, [rbp+var_10]
call _ZNSt10lock_guardISt5mutexED2Ev; std::lock_guard<std::mutex>::~lock_guard()
add rsp, 30h
pop rbp
retn
loc_185C9:
mov rdi, [rbp+var_20]
call __Unwind_Resume
|
long long nglog::LogDestination::SetLogFilenameExtension(nglog::LogDestination *this, const char *a2)
{
nglog::_anonymous_namespace_::LogFileObject *v3; // [rsp+0h] [rbp-30h]
signed int i; // [rsp+1Ch] [rbp-14h]
std::mutex *v5; // [rsp+20h] [rbp-10h] BYREF
char *v6; // [rsp+28h] [rbp-8h]
v6 = (char *)this;
std::lock_guard<std::mutex>::lock_guard(&v5, (std::mutex *)&nglog::log_mutex);
for ( i = 0; i < 4; ++i )
{
v3 = (nglog::_anonymous_namespace_::LogFileObject *)nglog::LogDestination::log_destination(i);
nglog::`anonymous namespace'::LogFileObject::SetExtension(v3, v6);
}
return std::lock_guard<std::mutex>::~lock_guard(&v5);
}
|
SetLogFilenameExtension:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
LEA RDI,[RBP + -0x10]
LEA RSI,[0x17fe58]
CALL 0x001174a0
MOV dword ptr [RBP + -0x14],0x0
LAB_00118573:
CMP dword ptr [RBP + -0x14],0x4
JGE 0x001185ba
MOV EDI,dword ptr [RBP + -0x14]
LAB_0011857c:
CALL 0x00117e60
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00118587
LAB_00118587:
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x8]
CALL 0x001161f0
LAB_00118594:
JMP 0x00118596
LAB_00118596:
JMP 0x00118598
LAB_00118598:
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x00118573
LAB_001185ba:
LEA RDI,[RBP + -0x10]
CALL 0x001174d0
ADD RSP,0x30
POP RBP
RET
|
/* nglog::LogDestination::SetLogFilenameExtension(char const*) */
void nglog::LogDestination::SetLogFilenameExtension(char *param_1)
{
LogFileObject *this;
int local_1c;
lock_guard<std::mutex> local_18 [8];
char *local_10;
local_10 = param_1;
std::lock_guard<std::mutex>::lock_guard(local_18,(mutex *)log_mutex);
for (local_1c = 0; local_1c < 4; local_1c = local_1c + 1) {
/* try { // try from 0011857c to 00118593 has its CatchHandler @ 001185a3 */
this = (LogFileObject *)log_destination(local_1c);
(anonymous_namespace)::LogFileObject::SetExtension(this,local_10);
}
std::lock_guard<std::mutex>::~lock_guard(local_18);
return;
}
|
|
66,026 |
my_create
|
eloqsql/mysys/my_create.c
|
File my_create(const char *FileName, int CreateFlags, int access_flags,
myf MyFlags)
{
int fd;
DBUG_ENTER("my_create");
DBUG_PRINT("my",("Name: '%s' CreateFlags: %d AccessFlags: %d MyFlags: %lu",
FileName, CreateFlags, access_flags, MyFlags));
#if defined(_WIN32)
fd= my_win_open(FileName, access_flags | O_CREAT);
#else
fd= open((char *) FileName, access_flags | O_CREAT | O_CLOEXEC,
CreateFlags ? CreateFlags : my_umask);
#endif
if ((MyFlags & MY_SYNC_DIR) && (fd >=0) &&
my_sync_dir_by_file(FileName, MyFlags))
{
my_close(fd, MyFlags);
fd= -1;
}
fd= my_register_filename(fd, FileName, FILE_BY_CREATE,
EE_CANTCREATEFILE, MyFlags);
DBUG_RETURN(fd);
}
|
O3
|
c
|
my_create:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %esi, %eax
movq %rdi, %r14
orl $0x80040, %edx # imm = 0x80040
testl %esi, %esi
jne 0x9dce9
leaq 0x2e7e21(%rip), %rax # 0x385b08
movl (%rax), %eax
movq %r14, %rdi
movl %edx, %esi
movl %eax, %edx
xorl %eax, %eax
callq 0x299a0
movl %eax, %r15d
testw %bx, %bx
setns %al
testl %r15d, %r15d
sets %cl
orb %al, %cl
jne 0x9dd2a
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa15d3
testl %eax, %eax
je 0x9dd2a
movl %r15d, %edi
movq %rbx, %rsi
callq 0xa0515
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
movl %r15d, %edi
movq %r14, %rsi
movl $0x2, %edx
movl $0x1, %ecx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa0436
|
my_create:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rcx
mov eax, esi
mov r14, rdi
or edx, 80040h
test esi, esi
jnz short loc_9DCE9
lea rax, my_umask
mov eax, [rax]
loc_9DCE9:
mov rdi, r14
mov esi, edx
mov edx, eax
xor eax, eax
call _open64
mov r15d, eax
test bx, bx
setns al
test r15d, r15d
sets cl
or cl, al
jnz short loc_9DD2A
mov rdi, r14
mov rsi, rbx
call my_sync_dir_by_file
test eax, eax
jz short loc_9DD2A
mov edi, r15d
mov rsi, rbx
call my_close
mov r15d, 0FFFFFFFFh
loc_9DD2A:
mov edi, r15d
mov rsi, r14
mov edx, 2
mov ecx, 1
mov r8, rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp my_register_filename
|
long long my_create(long long a1, unsigned int a2, int a3, long long a4)
{
unsigned int v5; // eax
unsigned int v6; // edx
int v7; // r15d
v5 = a2;
v6 = a3 | 0x80040;
if ( !a2 )
v5 = my_umask;
v7 = open64(a1, v6, v5);
if ( (a4 & 0x8000u) != 0LL && v7 >= 0 && (unsigned int)my_sync_dir_by_file(a1, a4) )
{
my_close((unsigned int)v7, a4);
v7 = -1;
}
return my_register_filename((unsigned int)v7, a1, 2LL, 1LL, a4);
}
|
my_create:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV EAX,ESI
MOV R14,RDI
OR EDX,0x80040
TEST ESI,ESI
JNZ 0x0019dce9
LEA RAX,[0x485b08]
MOV EAX,dword ptr [RAX]
LAB_0019dce9:
MOV RDI,R14
MOV ESI,EDX
MOV EDX,EAX
XOR EAX,EAX
CALL 0x001299a0
MOV R15D,EAX
TEST BX,BX
SETNS AL
TEST R15D,R15D
SETS CL
OR CL,AL
JNZ 0x0019dd2a
MOV RDI,R14
MOV RSI,RBX
CALL 0x001a15d3
TEST EAX,EAX
JZ 0x0019dd2a
MOV EDI,R15D
MOV RSI,RBX
CALL 0x001a0515
MOV R15D,0xffffffff
LAB_0019dd2a:
MOV EDI,R15D
MOV RSI,R14
MOV EDX,0x2
MOV ECX,0x1
MOV R8,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x001a0436
|
void my_create(char *param_1,uint param_2,uint param_3,int8 param_4)
{
int iVar1;
int iVar2;
if (param_2 == 0) {
param_2 = my_umask;
}
iVar1 = open64(param_1,param_3 | 0x80040,(ulong)param_2);
if (-1 < iVar1 && (short)param_4 < 0) {
iVar2 = my_sync_dir_by_file(param_1,param_4);
if (iVar2 != 0) {
my_close(iVar1,param_4);
iVar1 = -1;
}
}
my_register_filename(iVar1,param_1,2,1,param_4);
return;
}
|
|
66,027 |
my_hash_sort_simple_nopad
|
eloqsql/strings/ctype-simple.c
|
void my_hash_sort_simple_nopad(CHARSET_INFO *cs,
const uchar *key, size_t len,
ulong *nr1, ulong *nr2)
{
register const uchar *sort_order=cs->sort_order;
const uchar *end= key + len;
register ulong m1= *nr1, m2= *nr2;
for (; key < (uchar*) end ; key++)
{
MY_HASH_ADD(m1, m2, (uint) sort_order[(uint) *key]);
}
*nr1= m1;
*nr2= m2;
}
|
O3
|
c
|
my_hash_sort_simple_nopad:
movq (%rcx), %rax
movq (%r8), %r9
testq %rdx, %rdx
jle 0x4af9c
pushq %rbp
movq %rsp, %rbp
movq 0x58(%rdi), %rdi
addq %rsi, %rdx
movl %eax, %r10d
andl $0x3f, %r10d
addq %r9, %r10
movzbl (%rsi), %r11d
movzbl (%rdi,%r11), %r11d
imulq %r10, %r11
movq %rax, %r10
shlq $0x8, %r10
addq %r11, %r10
xorq %r10, %rax
addq $0x3, %r9
incq %rsi
cmpq %rdx, %rsi
jb 0x4af6b
popq %rbp
movq %rax, (%rcx)
movq %r9, (%r8)
retq
|
my_hash_sort_simple_nopad:
mov rax, [rcx]
mov r9, [r8]
test rdx, rdx
jle short loc_4AF9C
push rbp
mov rbp, rsp
mov rdi, [rdi+58h]
add rdx, rsi
loc_4AF6B:
mov r10d, eax
and r10d, 3Fh
add r10, r9
movzx r11d, byte ptr [rsi]
movzx r11d, byte ptr [rdi+r11]
imul r11, r10
mov r10, rax
shl r10, 8
add r10, r11
xor rax, r10
add r9, 3
inc rsi
cmp rsi, rdx
jb short loc_4AF6B
pop rbp
loc_4AF9C:
mov [rcx], rax
mov [r8], r9
retn
|
long long my_hash_sort_simple_nopad(long long a1, unsigned __int8 *a2, long long a3, long long *a4, long long *a5)
{
long long result; // rax
long long v6; // r9
long long v7; // rdi
unsigned __int8 *v8; // rdx
result = *a4;
v6 = *a5;
if ( a3 > 0 )
{
v7 = *(_QWORD *)(a1 + 88);
v8 = &a2[a3];
do
{
result ^= (v6 + (result & 0x3F)) * *(unsigned __int8 *)(v7 + *a2) + (result << 8);
v6 += 3LL;
++a2;
}
while ( a2 < v8 );
}
*a4 = result;
*a5 = v6;
return result;
}
|
my_hash_sort_simple_nopad:
MOV RAX,qword ptr [RCX]
MOV R9,qword ptr [R8]
TEST RDX,RDX
JLE 0x0014af9c
PUSH RBP
MOV RBP,RSP
MOV RDI,qword ptr [RDI + 0x58]
ADD RDX,RSI
LAB_0014af6b:
MOV R10D,EAX
AND R10D,0x3f
ADD R10,R9
MOVZX R11D,byte ptr [RSI]
MOVZX R11D,byte ptr [RDI + R11*0x1]
IMUL R11,R10
MOV R10,RAX
SHL R10,0x8
ADD R10,R11
XOR RAX,R10
ADD R9,0x3
INC RSI
CMP RSI,RDX
JC 0x0014af6b
POP RBP
LAB_0014af9c:
MOV qword ptr [RCX],RAX
MOV qword ptr [R8],R9
RET
|
void my_hash_sort_simple_nopad(long param_1,byte *param_2,long param_3,ulong *param_4,long *param_5)
{
ulong uVar1;
byte *pbVar2;
long lVar3;
uVar1 = *param_4;
lVar3 = *param_5;
if (0 < param_3) {
pbVar2 = param_2 + param_3;
do {
uVar1 = uVar1 ^ uVar1 * 0x100 +
(ulong)*(byte *)(*(long *)(param_1 + 0x58) + (ulong)*param_2) *
((ulong)((uint)uVar1 & 0x3f) + lVar3);
lVar3 = lVar3 + 3;
param_2 = param_2 + 1;
} while (param_2 < pbVar2);
}
*param_4 = uVar1;
*param_5 = lVar3;
return;
}
|
|
66,028 |
my_charset_file_tailoring_realloc
|
eloqsql/strings/ctype.c
|
static int
my_charset_file_tailoring_realloc(MY_CHARSET_FILE *i, size_t newlen)
{
if (i->tailoring_alloced_length > newlen ||
(i->tailoring= i->loader->realloc(i->tailoring,
(i->tailoring_alloced_length=
(newlen + 32*1024)))))
{
return MY_XML_OK;
}
return MY_XML_ERROR;
}
|
O0
|
c
|
my_charset_file_tailoring_realloc:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x698(%rax), %rax
cmpq -0x18(%rbp), %rax
ja 0x7fcb7
movq -0x10(%rbp), %rax
movq 0x7a8(%rax), %rax
movq 0x90(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x688(%rcx), %rdi
movq -0x18(%rbp), %rsi
addq $0x8000, %rsi # imm = 0x8000
movq -0x10(%rbp), %rcx
movq %rsi, 0x698(%rcx)
callq *%rax
movq -0x10(%rbp), %rcx
movq %rax, 0x688(%rcx)
cmpq $0x0, %rax
je 0x7fcc0
movl $0x0, -0x4(%rbp)
jmp 0x7fcc7
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
|
my_charset_file_tailoring_realloc:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov rax, [rax+698h]
cmp rax, [rbp+var_18]
ja short loc_7FCB7
mov rax, [rbp+var_10]
mov rax, [rax+7A8h]
mov rax, [rax+90h]
mov rcx, [rbp+var_10]
mov rdi, [rcx+688h]
mov rsi, [rbp+var_18]
add rsi, 8000h
mov rcx, [rbp+var_10]
mov [rcx+698h], rsi
call rax
mov rcx, [rbp+var_10]
mov [rcx+688h], rax
cmp rax, 0
jz short loc_7FCC0
loc_7FCB7:
mov [rbp+var_4], 0
jmp short loc_7FCC7
loc_7FCC0:
mov [rbp+var_4], 1
loc_7FCC7:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
|
long long my_charset_file_tailoring_realloc(_QWORD *a1, unsigned long long a2)
{
long long ( *v2)(long long); // rax
long long v3; // rdi
long long v4; // rax
unsigned int v7; // [rsp+1Ch] [rbp-4h]
v7 = 0;
if ( a1[211] <= a2 )
{
v2 = *(long long ( **)(long long))(a1[245] + 144LL);
v3 = a1[209];
a1[211] = a2 + 0x8000;
v4 = v2(v3);
a1[209] = v4;
if ( !v4 )
return 1;
}
return v7;
}
|
my_charset_file_tailoring_realloc:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x698]
CMP RAX,qword ptr [RBP + -0x18]
JA 0x0017fcb7
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x7a8]
MOV RAX,qword ptr [RAX + 0x90]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RCX + 0x688]
MOV RSI,qword ptr [RBP + -0x18]
ADD RSI,0x8000
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x698],RSI
CALL RAX
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x688],RAX
CMP RAX,0x0
JZ 0x0017fcc0
LAB_0017fcb7:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0017fcc7
LAB_0017fcc0:
MOV dword ptr [RBP + -0x4],0x1
LAB_0017fcc7:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 my_charset_file_tailoring_realloc(long param_1,ulong param_2)
{
code *pcVar1;
long lVar2;
if (*(ulong *)(param_1 + 0x698) <= param_2) {
pcVar1 = *(code **)(*(long *)(param_1 + 0x7a8) + 0x90);
*(ulong *)(param_1 + 0x698) = param_2 + 0x8000;
lVar2 = (*pcVar1)(*(int8 *)(param_1 + 0x688));
*(long *)(param_1 + 0x688) = lVar2;
if (lVar2 == 0) {
return 1;
}
}
return 0;
}
|
|
66,029 |
mbr_join_square
|
eloqsql/storage/myisam/rt_split.c
|
static double mbr_join_square(const double *a, const double *b, int n_dim)
{
const double *end = a + n_dim * 2;
double square = 1.0;
do
{
square *=
((a[1] < b[1]) ? b[1] : a[1]) - ((a[0] > b[0]) ? b[0] : a[0]);
a += 2;
b += 2;
}while (a != end);
/* Check if not finite (i.e. infinity or NaN) */
if (!isfinite(square))
square = DBL_MAX;
return square;
}
|
O0
|
c
|
mbr_join_square:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movsd 0x8a292(%rip), %xmm0 # 0x165150
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm1
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xdaeeb
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0xdaef9
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
ucomisd (%rax), %xmm0
jbe 0xdaf24
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0xdaf31
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x38(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
subsd %xmm1, %xmm0
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0xdaec3
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
andq %rcx, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
subq %rcx, %rax
setl %al
testb $0x1, %al
jne 0xdafa7
movsd 0x8a1c6(%rip), %xmm0 # 0x165168
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
popq %rbp
retq
nop
|
mbr_join_square_0:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov rax, [rbp+var_8]
mov ecx, [rbp+var_14]
shl ecx, 1
movsxd rcx, ecx
shl rcx, 3
add rax, rcx
mov [rbp+var_20], rax
movsd xmm0, cs:qword_165150
movsd [rbp+var_28], xmm0
loc_DAEC3:
mov rax, [rbp+var_8]
movsd xmm1, qword ptr [rax+8]
mov rax, [rbp+var_10]
movsd xmm0, qword ptr [rax+8]
ucomisd xmm0, xmm1
jbe short loc_DAEEB
mov rax, [rbp+var_10]
movsd xmm0, qword ptr [rax+8]
movsd [rbp+var_30], xmm0
jmp short loc_DAEF9
loc_DAEEB:
mov rax, [rbp+var_8]
movsd xmm0, qword ptr [rax+8]
movsd [rbp+var_30], xmm0
loc_DAEF9:
movsd xmm0, [rbp+var_30]
movsd [rbp+var_38], xmm0
mov rax, [rbp+var_8]
movsd xmm0, qword ptr [rax]
mov rax, [rbp+var_10]
ucomisd xmm0, qword ptr [rax]
jbe short loc_DAF24
mov rax, [rbp+var_10]
movsd xmm0, qword ptr [rax]
movsd [rbp+var_40], xmm0
jmp short loc_DAF31
loc_DAF24:
mov rax, [rbp+var_8]
movsd xmm0, qword ptr [rax]
movsd [rbp+var_40], xmm0
loc_DAF31:
movsd xmm0, [rbp+var_38]
movsd xmm1, [rbp+var_40]
subsd xmm0, xmm1
mulsd xmm0, [rbp+var_28]
movsd [rbp+var_28], xmm0
mov rax, [rbp+var_8]
add rax, 10h
mov [rbp+var_8], rax
mov rax, [rbp+var_10]
add rax, 10h
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
cmp rax, [rbp+var_20]
jnz loc_DAEC3
movsd xmm0, [rbp+var_28]
movq rax, xmm0
mov rcx, 7FFFFFFFFFFFFFFFh
and rax, rcx
mov rcx, 7FF0000000000000h
sub rax, rcx
setl al
test al, 1
jnz short loc_DAFA7
movsd xmm0, cs:qword_165168
movsd [rbp+var_28], xmm0
loc_DAFA7:
movsd xmm0, [rbp+var_28]
pop rbp
retn
|
double mbr_join_square_0(double *a1, double *a2, int a3)
{
double v4; // [rsp+0h] [rbp-40h]
double v5; // [rsp+10h] [rbp-30h]
double v6; // [rsp+18h] [rbp-28h]
double *v8; // [rsp+38h] [rbp-8h]
v8 = a1;
v6 = 1.0;
do
{
if ( a2[1] <= v8[1] )
v5 = v8[1];
else
v5 = a2[1];
if ( *v8 <= *a2 )
v4 = *v8;
else
v4 = *a2;
v6 = (v5 - v4) * v6;
v8 += 2;
a2 += 2;
}
while ( v8 != &a1[2 * a3] );
if ( (*(_QWORD *)&v6 & 0x7FFFFFFFFFFFFFFFuLL) >= 0x7FF0000000000000LL )
return 1.797693134862316e308;
return v6;
}
|
mbr_join_square:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0x14]
SHL ECX,0x1
MOVSXD RCX,ECX
SHL RCX,0x3
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOVSD XMM0,qword ptr [0x00265150]
MOVSD qword ptr [RBP + -0x28],XMM0
LAB_001daec3:
MOV RAX,qword ptr [RBP + -0x8]
MOVSD XMM1,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOVSD XMM0,qword ptr [RAX + 0x8]
UCOMISD XMM0,XMM1
JBE 0x001daeeb
MOV RAX,qword ptr [RBP + -0x10]
MOVSD XMM0,qword ptr [RAX + 0x8]
MOVSD qword ptr [RBP + -0x30],XMM0
JMP 0x001daef9
LAB_001daeeb:
MOV RAX,qword ptr [RBP + -0x8]
MOVSD XMM0,qword ptr [RAX + 0x8]
MOVSD qword ptr [RBP + -0x30],XMM0
LAB_001daef9:
MOVSD XMM0,qword ptr [RBP + -0x30]
MOVSD qword ptr [RBP + -0x38],XMM0
MOV RAX,qword ptr [RBP + -0x8]
MOVSD XMM0,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
UCOMISD XMM0,qword ptr [RAX]
JBE 0x001daf24
MOV RAX,qword ptr [RBP + -0x10]
MOVSD XMM0,qword ptr [RAX]
MOVSD qword ptr [RBP + -0x40],XMM0
JMP 0x001daf31
LAB_001daf24:
MOV RAX,qword ptr [RBP + -0x8]
MOVSD XMM0,qword ptr [RAX]
MOVSD qword ptr [RBP + -0x40],XMM0
LAB_001daf31:
MOVSD XMM0,qword ptr [RBP + -0x38]
MOVSD XMM1,qword ptr [RBP + -0x40]
SUBSD XMM0,XMM1
MULSD XMM0,qword ptr [RBP + -0x28]
MOVSD qword ptr [RBP + -0x28],XMM0
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x10
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x10
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x001daec3
MOVSD XMM0,qword ptr [RBP + -0x28]
MOVQ RAX,XMM0
MOV RCX,0x7fffffffffffffff
AND RAX,RCX
MOV RCX,0x7ff0000000000000
SUB RAX,RCX
SETL AL
TEST AL,0x1
JNZ 0x001dafa7
MOVSD XMM0,qword ptr [0x00265168]
MOVSD qword ptr [RBP + -0x28],XMM0
LAB_001dafa7:
MOVSD XMM0,qword ptr [RBP + -0x28]
POP RBP
RET
|
double mbr_join_square(double *param_1,double *param_2,int param_3)
{
double local_48;
double local_38;
double local_30;
double *local_18;
double *local_10;
local_30 = DAT_00265150;
local_18 = param_2;
local_10 = param_1;
do {
if (local_18[1] <= local_10[1]) {
local_38 = local_10[1];
}
else {
local_38 = local_18[1];
}
if (*local_10 < *local_18 || *local_10 == *local_18) {
local_48 = *local_10;
}
else {
local_48 = *local_18;
}
local_30 = (local_38 - local_48) * local_30;
local_10 = local_10 + 2;
local_18 = local_18 + 2;
} while (local_10 != param_1 + (param_3 << 1));
if (0x7fefffffffffffff < (ulong)ABS(local_30)) {
local_30 = DAT_00265168;
}
return local_30;
}
|
|
66,030 |
get_all_kv_cache_types[abi:cxx11]()
|
monkey531[P]llama/common/arg.cpp
|
static std::string get_all_kv_cache_types() {
std::ostringstream msg;
for (const auto & type : kv_cache_types) {
msg << ggml_type_name(type) << (&type == &kv_cache_types.back() ? "" : ", ");
}
return msg.str();
}
|
O0
|
cpp
|
get_all_kv_cache_types[abi:cxx11]():
subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x1d0(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x5b0c0
leaq 0x22298b(%rip), %rax # 0x2a3f58
movq %rax, 0x50(%rsp)
leaq 0x22297f(%rip), %rdi # 0x2a3f58
callq 0xbe2e0
movq %rax, 0x48(%rsp)
leaq 0x22296e(%rip), %rdi # 0x2a3f58
callq 0xbe310
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xbe340
testb $0x1, %al
jne 0x8160c
jmp 0x816ac
leaq 0x48(%rsp), %rdi
callq 0xbe380
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movl (%rax), %edi
callq 0x5b3a0
movq %rax, 0x10(%rsp)
jmp 0x8162e
movq 0x10(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x5aa50
movq %rax, 0x8(%rsp)
jmp 0x81644
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
leaq 0x222904(%rip), %rdi # 0x2a3f58
callq 0xbe390
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movq (%rsp), %rax
subq %rcx, %rax
leaq 0x18bbd2(%rip), %rax # 0x20d241
leaq 0x18f9b4(%rip), %rsi # 0x21102a
cmoveq %rax, %rsi
callq 0x5aa50
jmp 0x81681
jmp 0x81683
leaq 0x48(%rsp), %rdi
callq 0xbe3d0
jmp 0x815f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x5afe0
jmp 0x816d4
movq 0x18(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x5b450
jmp 0x816bd
leaq 0x58(%rsp), %rdi
callq 0x5afe0
movq 0x20(%rsp), %rax
addq $0x1d8, %rsp # imm = 0x1D8
retq
movq 0x30(%rsp), %rdi
callq 0x5abf0
nop
|
_ZL22get_all_kv_cache_typesB5cxx11v:
sub rsp, 1D8h
mov [rsp+1D8h+var_1C0], rdi
mov rax, rdi
mov [rsp+1D8h+var_1B8], rax
mov [rsp+1D8h+var_8], rdi
lea rdi, [rsp+1D8h+var_180]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
lea rax, _ZL14kv_cache_types; kv_cache_types
mov [rsp+1D8h+var_188], rax
lea rdi, _ZL14kv_cache_types; kv_cache_types
call _ZNKSt6vectorI9ggml_typeSaIS0_EE5beginEv; std::vector<ggml_type>::begin(void)
mov [rsp+1D8h+var_190], rax
lea rdi, _ZL14kv_cache_types; kv_cache_types
call _ZNKSt6vectorI9ggml_typeSaIS0_EE3endEv; std::vector<ggml_type>::end(void)
mov [rsp+1D8h+var_198], rax
loc_815F4:
lea rdi, [rsp+1D8h+var_190]
lea rsi, [rsp+1D8h+var_198]
call _ZN9__gnu_cxxneIPK9ggml_typeSt6vectorIS1_SaIS1_EEEEbRKNS_17__normal_iteratorIT_T0_EESC_; __gnu_cxx::operator!=<ggml_type const*,std::vector<ggml_type>>(__gnu_cxx::__normal_iterator<ggml_type const*,std::vector<ggml_type>> const&,__gnu_cxx::__normal_iterator<ggml_type const*,std::vector<ggml_type>> const&)
test al, 1
jnz short loc_8160C
jmp loc_816AC
loc_8160C:
lea rdi, [rsp+1D8h+var_190]
call _ZNK9__gnu_cxx17__normal_iteratorIPK9ggml_typeSt6vectorIS1_SaIS1_EEEdeEv; __gnu_cxx::__normal_iterator<ggml_type const*,std::vector<ggml_type>>::operator*(void)
mov [rsp+1D8h+var_1A0], rax
mov rax, [rsp+1D8h+var_1A0]
mov edi, [rax]
call _ggml_type_name
mov [rsp+1D8h+var_1C8], rax
jmp short $+2
loc_8162E:
mov rsi, [rsp+1D8h+var_1C8]
lea rdi, [rsp+1D8h+var_180]
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rsp+1D8h+var_1D0], rax
jmp short $+2
loc_81644:
mov rax, [rsp+1D8h+var_1A0]
mov [rsp+1D8h+var_1D8], rax
lea rdi, _ZL14kv_cache_types; kv_cache_types
call _ZNKSt6vectorI9ggml_typeSaIS0_EE4backEv; std::vector<ggml_type>::back(void)
mov rdi, [rsp+1D8h+var_1D0]
mov rcx, rax
mov rax, [rsp+1D8h+var_1D8]
sub rax, rcx
lea rax, aExampleSpecifi+27h; ""
lea rsi, aZuD+6; ", "
cmovz rsi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short $+2
loc_81681:
jmp short $+2
loc_81683:
lea rdi, [rsp+1D8h+var_190]
call _ZN9__gnu_cxx17__normal_iteratorIPK9ggml_typeSt6vectorIS1_SaIS1_EEEppEv; __gnu_cxx::__normal_iterator<ggml_type const*,std::vector<ggml_type>>::operator++(void)
jmp loc_815F4
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
lea rdi, [rsp+arg_50]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
jmp short loc_816D4
loc_816AC:
mov rdi, [rsp+1D8h+var_1C0]
lea rsi, [rsp+1D8h+var_180]
call __ZNKSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEE3strEv; std::ostringstream::str(void)
jmp short $+2
loc_816BD:
lea rdi, [rsp+1D8h+var_180]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
mov rax, [rsp+1D8h+var_1B8]
add rsp, 1D8h
retn
loc_816D4:
mov rdi, [rsp+arg_28]
call __Unwind_Resume
|
long long get_all_kv_cache_types[abi:cxx11](long long a1)
{
long long v1; // rdi
char *v2; // rsi
long long v4; // [rsp+10h] [rbp-1C8h]
unsigned int *v7; // [rsp+38h] [rbp-1A0h]
long long v8; // [rsp+40h] [rbp-198h] BYREF
_QWORD v9[2]; // [rsp+48h] [rbp-190h] BYREF
_BYTE v10[376]; // [rsp+58h] [rbp-180h] BYREF
long long v11; // [rsp+1D0h] [rbp-8h]
v11 = a1;
std::ostringstream::basic_ostringstream(v10);
v9[1] = &kv_cache_types;
v9[0] = std::vector<ggml_type>::begin(&kv_cache_types);
v8 = std::vector<ggml_type>::end(&kv_cache_types);
while ( (__gnu_cxx::operator!=<ggml_type const*,std::vector<ggml_type>>(v9, &v8) & 1) != 0 )
{
v7 = (unsigned int *)__gnu_cxx::__normal_iterator<ggml_type const*,std::vector<ggml_type>>::operator*(v9);
v4 = ggml_type_name(*v7);
v1 = std::operator<<<std::char_traits<char>>(v10, v4);
v2 = ", ";
if ( v7 == (unsigned int *)std::vector<ggml_type>::back(&kv_cache_types) )
v2 = "";
std::operator<<<std::char_traits<char>>(v1, v2);
__gnu_cxx::__normal_iterator<ggml_type const*,std::vector<ggml_type>>::operator++(v9);
}
std::ostringstream::str(a1, v10);
std::ostringstream::~ostringstream(v10);
return a1;
}
|
get_all_kv_cache_types[abi:cxx11]:
SUB RSP,0x1d8
MOV qword ptr [RSP + 0x18],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x1d0],RDI
LEA RDI,[RSP + 0x58]
CALL 0x0015b0c0
LEA RAX,[0x3a3f58]
MOV qword ptr [RSP + 0x50],RAX
LEA RDI,[0x3a3f58]
CALL 0x001be2e0
MOV qword ptr [RSP + 0x48],RAX
LEA RDI,[0x3a3f58]
CALL 0x001be310
MOV qword ptr [RSP + 0x40],RAX
LAB_001815f4:
LEA RDI,[RSP + 0x48]
LEA RSI,[RSP + 0x40]
CALL 0x001be340
TEST AL,0x1
JNZ 0x0018160c
JMP 0x001816ac
LAB_0018160c:
LEA RDI,[RSP + 0x48]
CALL 0x001be380
MOV qword ptr [RSP + 0x38],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV EDI,dword ptr [RAX]
LAB_00181622:
CALL 0x0015b3a0
MOV qword ptr [RSP + 0x10],RAX
JMP 0x0018162e
LAB_0018162e:
MOV RSI,qword ptr [RSP + 0x10]
LEA RDI,[RSP + 0x58]
CALL 0x0015aa50
MOV qword ptr [RSP + 0x8],RAX
JMP 0x00181644
LAB_00181644:
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP],RAX
LEA RDI,[0x3a3f58]
CALL 0x001be390
MOV RDI,qword ptr [RSP + 0x8]
MOV RCX,RAX
MOV RAX,qword ptr [RSP]
SUB RAX,RCX
LEA RAX,[0x30d241]
LEA RSI,[0x31102a]
CMOVZ RSI,RAX
CALL 0x0015aa50
JMP 0x00181681
LAB_00181681:
JMP 0x00181683
LAB_00181683:
LEA RDI,[RSP + 0x48]
CALL 0x001be3d0
JMP 0x001815f4
LAB_001816ac:
MOV RDI,qword ptr [RSP + 0x18]
LEA RSI,[RSP + 0x58]
CALL 0x0015b450
LAB_001816bb:
JMP 0x001816bd
LAB_001816bd:
LEA RDI,[RSP + 0x58]
CALL 0x0015afe0
MOV RAX,qword ptr [RSP + 0x20]
ADD RSP,0x1d8
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* get_all_kv_cache_types[abi:cxx11]() */
int8 get_all_kv_cache_types_abi_cxx11_(void)
{
bool bVar1;
int4 *puVar2;
char *pcVar3;
ostream *poVar4;
int4 *puVar5;
int8 in_RDI;
int8 local_198;
int8 local_190;
int1 *local_188;
ostringstream local_180 [384];
std::__cxx11::ostringstream::ostringstream(local_180);
local_188 = kv_cache_types;
local_190 = std::vector<ggml_type,std::allocator<ggml_type>>::begin
((vector<ggml_type,std::allocator<ggml_type>> *)kv_cache_types);
local_198 = std::vector<ggml_type,std::allocator<ggml_type>>::end
((vector<ggml_type,std::allocator<ggml_type>> *)kv_cache_types);
while( true ) {
bVar1 = __gnu_cxx::operator!=((__normal_iterator *)&local_190,(__normal_iterator *)&local_198);
if (!bVar1) break;
puVar2 = (int4 *)
__gnu_cxx::
__normal_iterator<ggml_type_const*,std::vector<ggml_type,std::allocator<ggml_type>>>::
operator*((__normal_iterator<ggml_type_const*,std::vector<ggml_type,std::allocator<ggml_type>>>
*)&local_190);
/* try { // try from 00181622 to 001816ba has its CatchHandler @ 00181692 */
pcVar3 = (char *)ggml_type_name(*puVar2);
poVar4 = std::operator<<((ostream *)local_180,pcVar3);
puVar5 = (int4 *)
std::vector<ggml_type,std::allocator<ggml_type>>::back
((vector<ggml_type,std::allocator<ggml_type>> *)kv_cache_types);
pcVar3 = ", ";
if (puVar2 == puVar5) {
pcVar3 = "";
}
std::operator<<(poVar4,pcVar3);
__gnu_cxx::__normal_iterator<ggml_type_const*,std::vector<ggml_type,std::allocator<ggml_type>>>
::operator++((__normal_iterator<ggml_type_const*,std::vector<ggml_type,std::allocator<ggml_type>>>
*)&local_190);
}
std::__cxx11::ostringstream::str();
std::__cxx11::ostringstream::~ostringstream(local_180);
return in_RDI;
}
|
|
66,031 |
language::resolve(char const*)
|
untodesu[P]voxelius/game/client/language.cc
|
const char *language::resolve(const char *key)
{
const auto it = language_map.find(key);
if(it != language_map.cend())
return it->second.c_str();
return key;
}
|
O0
|
cpp
|
language::resolve(char const*):
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x2d1c0
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x329f0
jmp 0xd80e4
leaq 0x436305(%rip), %rdi # 0x50e3f0
leaq -0x38(%rbp), %rsi
callq 0xd89b0
movq %rax, -0x70(%rbp)
jmp 0xd80fa
movq -0x70(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2d648
leaq -0x39(%rbp), %rdi
callq 0x2d620
leaq 0x4362d5(%rip), %rdi # 0x50e3f0
callq 0xd8a10
movq %rax, -0x58(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xd89e0
testb $0x1, %al
jne 0xd8137
jmp 0xd8180
leaq -0x18(%rbp), %rdi
callq 0xd8a40
movq %rax, %rdi
addq $0x20, %rdi
callq 0x2c1c0
movq %rax, -0x8(%rbp)
jmp 0xd8188
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xd8175
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2d648
leaq -0x39(%rbp), %rdi
callq 0x2d620
jmp 0xd8192
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x2cbe0
nopl (%rax,%rax)
|
_ZN8language7resolveEPKc:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov [rbp+var_68], rax
lea rdi, [rbp+var_39]
mov [rbp+var_60], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rsi, [rbp+var_68]
mov rdx, [rbp+var_60]
lea rdi, [rbp+var_38]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_D80E4:
lea rdi, _ZL12language_mapB5cxx11; language_map
lea rsi, [rbp+var_38]
call _ZNSt13unordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_St4hashIS5_ESt8equal_toIS5_ESaISt4pairIKS5_S5_EEE4findERSB_; std::unordered_map<std::string,std::string>::find(std::string const&)
mov [rbp+var_70], rax
jmp short $+2
loc_D80FA:
mov rax, [rbp+var_70]
mov [rbp+var_18], rax
lea rdi, [rbp+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rbp+var_39]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
lea rdi, _ZL12language_mapB5cxx11; language_map
call _ZNKSt13unordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_St4hashIS5_ESt8equal_toIS5_ESaISt4pairIKS5_S5_EEE4cendEv; std::unordered_map<std::string,std::string>::cend(void)
mov [rbp+var_58], rax
lea rdi, [rbp+var_18]
lea rsi, [rbp+var_58]
call _ZNSt8__detailneERKNS_19_Node_iterator_baseISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES7_ELb1EEESC_; std::__detail::operator!=(std::__detail::_Node_iterator_base<std::pair<std::string const,std::string>,true> const&,std::__detail::_Node_iterator_base<std::pair<std::string const,std::string>,true> const&)
test al, 1
jnz short loc_D8137
jmp short loc_D8180
loc_D8137:
lea rdi, [rbp+var_18]
call _ZNKSt8__detail14_Node_iteratorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES7_ELb0ELb1EEptEv; std::__detail::_Node_iterator<std::pair<std::string const,std::string>,false,true>::operator->(void)
mov rdi, rax
add rdi, 20h ; ' '
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov [rbp+var_8], rax
jmp short loc_D8188
mov rcx, rax
mov eax, edx
mov [rbp+var_48], rcx
mov [rbp+var_4C], eax
jmp short loc_D8175
mov rcx, rax
mov eax, edx
mov [rbp+var_48], rcx
mov [rbp+var_4C], eax
lea rdi, [rbp+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_D8175:
lea rdi, [rbp+var_39]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_D8192
loc_D8180:
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
loc_D8188:
mov rax, [rbp+var_8]
add rsp, 70h
pop rbp
retn
loc_D8192:
mov rdi, [rbp+var_48]
call __Unwind_Resume
|
language * language::resolve(language *this, const char *a2)
{
long long v2; // rax
long long v4; // [rsp+18h] [rbp-58h] BYREF
char v5; // [rsp+37h] [rbp-39h] BYREF
_BYTE v6[32]; // [rsp+38h] [rbp-38h] BYREF
long long v7; // [rsp+58h] [rbp-18h] BYREF
language *v8; // [rsp+60h] [rbp-10h]
v8 = this;
std::allocator<char>::allocator(&v5, a2);
std::string::basic_string<std::allocator<char>>((long long)v6, (long long)this, (long long)&v5);
v7 = std::unordered_map<std::string,std::string>::find(&language_map[abi:cxx11], v6);
std::string::~string(v6);
std::allocator<char>::~allocator(&v5);
v4 = std::unordered_map<std::string,std::string>::cend(&language_map[abi:cxx11]);
if ( (std::__detail::operator!=(&v7, &v4) & 1) == 0 )
return v8;
v2 = std::__detail::_Node_iterator<std::pair<std::string const,std::string>,false,true>::operator->(&v7);
return (language *)std::string::c_str(v2 + 32);
}
|
resolve:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x68],RAX
LEA RDI,[RBP + -0x39]
MOV qword ptr [RBP + -0x60],RDI
CALL 0x0012d1c0
MOV RSI,qword ptr [RBP + -0x68]
MOV RDX,qword ptr [RBP + -0x60]
LAB_001d80d9:
LEA RDI,[RBP + -0x38]
CALL 0x001329f0
JMP 0x001d80e4
LAB_001d80e4:
LEA RDI,[0x60e3f0]
LEA RSI,[RBP + -0x38]
CALL 0x001d89b0
LAB_001d80f4:
MOV qword ptr [RBP + -0x70],RAX
JMP 0x001d80fa
LAB_001d80fa:
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x18],RAX
LEA RDI,[RBP + -0x38]
CALL 0x0012d648
LEA RDI,[RBP + -0x39]
CALL 0x0012d620
LEA RDI,[0x60e3f0]
CALL 0x001d8a10
MOV qword ptr [RBP + -0x58],RAX
LEA RDI,[RBP + -0x18]
LEA RSI,[RBP + -0x58]
CALL 0x001d89e0
TEST AL,0x1
JNZ 0x001d8137
JMP 0x001d8180
LAB_001d8137:
LEA RDI,[RBP + -0x18]
CALL 0x001d8a40
MOV RDI,RAX
ADD RDI,0x20
CALL 0x0012c1c0
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001d8188
LAB_001d8180:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
LAB_001d8188:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x70
POP RBP
RET
|
/* language::resolve(char const*) */
char * language::resolve(char *param_1)
{
ulong uVar1;
int8 local_60 [3];
allocator local_41;
string local_40 [32];
int8 local_20;
char *local_18;
char *local_10;
local_18 = param_1;
std::allocator<char>::allocator();
/* try { // try from 001d80d9 to 001d80e1 has its CatchHandler @ 001d8152 */
std::__cxx11::string::string<std::allocator<char>>(local_40,param_1,&local_41);
/* try { // try from 001d80e4 to 001d80f3 has its CatchHandler @ 001d8160 */
local_20 = std::
unordered_map<std::__cxx11::string,std::__cxx11::string,std::hash<std::__cxx11::string>,std::equal_to<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
::find((unordered_map<std::__cxx11::string,std::__cxx11::string,std::hash<std::__cxx11::string>,std::equal_to<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
*)language_map_abi_cxx11_,local_40);
std::__cxx11::string::~string(local_40);
std::allocator<char>::~allocator((allocator<char> *)&local_41);
local_60[0] = std::
unordered_map<std::__cxx11::string,std::__cxx11::string,std::hash<std::__cxx11::string>,std::equal_to<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
::cend();
uVar1 = std::__detail::operator!=
((_Node_iterator_base *)&local_20,(_Node_iterator_base *)local_60);
if ((uVar1 & 1) == 0) {
local_10 = local_18;
}
else {
std::__detail::
_Node_iterator<std::pair<std::__cxx11::string_const,std::__cxx11::string>,false,true>::
operator->((_Node_iterator<std::pair<std::__cxx11::string_const,std::__cxx11::string>,false,true>
*)&local_20);
local_10 = (char *)std::__cxx11::string::c_str();
}
return local_10;
}
|
|
66,032 |
language::resolve(char const*)
|
untodesu[P]voxelius/game/client/language.cc
|
const char *language::resolve(const char *key)
{
const auto it = language_map.find(key);
if(it != language_map.cend())
return it->second.c_str();
return key;
}
|
O3
|
cpp
|
language::resolve(char const*):
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2f9b0
leaq 0x205d80(%rip), %rdi # 0x25a1c8
movq %r14, %rsi
callq 0x55df4
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5446e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x268e0
testq %r14, %r14
je 0x54477
movq 0x28(%r14), %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x544a0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x268e0
movq %rbx, %rdi
callq 0x26ff0
|
_ZN8language7resolveEPKc:
push r14
push rbx
sub rsp, 28h
mov rbx, rdi
lea r14, [rsp+38h+var_30]
lea rdx, [rsp+38h+var_31]
mov rdi, r14
mov rsi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rdi, _ZL12language_mapB5cxx11; language_map
mov rsi, r14
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_S5_ESaIS8_ENSt8__detail10_Select1stESt8equal_toIS5_ESt4hashIS5_ENSA_18_Mod_range_hashingENSA_20_Default_ranged_hashENSA_20_Prime_rehash_policyENSA_17_Hashtable_traitsILb1ELb0ELb1EEEE4findERS7_; std::_Hashtable<std::string,std::pair<std::string const,std::string>,std::allocator<std::pair<std::string const,std::string>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(std::string const&)
mov r14, rax
lea rax, [rsp+38h+var_20]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_5446E
mov rsi, [rsp+38h+var_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5446E:
test r14, r14
jz short loc_54477
mov rbx, [r14+28h]
loc_54477:
mov rax, rbx
add rsp, 28h
pop rbx
pop r14
retn
mov rbx, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_544A0
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_544A0:
mov rdi, rbx
call __Unwind_Resume
|
language * language::resolve(language *this, const char *a2)
{
language *v2; // rbx
long long v3; // r14
void *v5[2]; // [rsp+8h] [rbp-30h] BYREF
long long v6; // [rsp+18h] [rbp-20h] BYREF
v2 = this;
std::string::basic_string<std::allocator<char>>(v5, (long long)this);
v3 = std::_Hashtable<std::string,std::pair<std::string const,std::string>,std::allocator<std::pair<std::string const,std::string>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(
&language_map[abi:cxx11],
v5);
if ( v5[0] != &v6 )
operator delete(v5[0], v6 + 1);
if ( v3 )
return *(language **)(v3 + 40);
return v2;
}
|
resolve:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
LEA R14,[RSP + 0x8]
LEA RDX,[RSP + 0x7]
MOV RDI,R14
MOV RSI,RBX
CALL 0x0012f9b0
LAB_00154441:
LEA RDI,[0x35a1c8]
MOV RSI,R14
CALL 0x00155df4
LAB_00154450:
MOV R14,RAX
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0015446e
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001268e0
LAB_0015446e:
TEST R14,R14
JZ 0x00154477
MOV RBX,qword ptr [R14 + 0x28]
LAB_00154477:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R14
RET
|
/* language::resolve(char const*) */
char * language::resolve(char *param_1)
{
long lVar1;
allocator local_31;
long *local_30 [2];
long local_20 [2];
std::__cxx11::string::string<std::allocator<char>>((string *)local_30,param_1,&local_31);
/* try { // try from 00154441 to 0015444f has its CatchHandler @ 00154482 */
lVar1 = std::
_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
::find((_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
*)language_map_abi_cxx11_,(string *)local_30);
if (local_30[0] != local_20) {
operator_delete(local_30[0],local_20[0] + 1);
}
if (lVar1 != 0) {
param_1 = *(char **)(lVar1 + 0x28);
}
return param_1;
}
|
|
66,033 |
google::protobuf::Symbol::full_name() const
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc
|
StringPiece full_name() const {
switch (type()) {
case MESSAGE:
return descriptor()->full_name();
case FIELD:
return field_descriptor()->full_name();
case ONEOF:
return oneof_descriptor()->full_name();
case ENUM:
return enum_descriptor()->full_name();
case ENUM_VALUE:
return enum_value_descriptor()->full_name();
case SERVICE:
return service_descriptor()->full_name();
case METHOD:
return method_descriptor()->full_name();
case FULL_PACKAGE:
return file_descriptor()->package();
case SUB_PACKAGE:
return StringPiece(sub_package_file_descriptor()->file->package())
.substr(0, sub_package_file_descriptor()->name_size);
case QUERY_KEY:
return query_key()->full_name();
default:
GOOGLE_CHECK(false);
}
return "";
}
|
O0
|
cpp
|
google::protobuf::Symbol::full_name() const:
subq $0x98, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x799a0
decl %eax
movl %eax, %ecx
movq %rcx, 0x20(%rsp)
subl $0xa, %eax
ja 0x73828
movq 0x20(%rsp), %rax
leaq 0x179b9d(%rip), %rcx # 0x1ed20c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rdi
callq 0x74670
movq %rax, %rdi
callq 0x163d0
movq %rax, %rsi
leaq 0x88(%rsp), %rdi
callq 0x30550
jmp 0x738ab
movq 0x18(%rsp), %rdi
callq 0x73450
movq %rax, %rdi
callq 0x78700
movq %rax, %rsi
leaq 0x88(%rsp), %rdi
callq 0x30550
jmp 0x738ab
movq 0x18(%rsp), %rdi
callq 0x746b0
movq %rax, %rdi
callq 0x78f50
movq %rax, %rsi
leaq 0x88(%rsp), %rdi
callq 0x30550
jmp 0x738ab
movq 0x18(%rsp), %rdi
callq 0x746f0
movq %rax, %rdi
callq 0x763c0
movq %rax, %rsi
leaq 0x88(%rsp), %rdi
callq 0x30550
jmp 0x738ab
movq 0x18(%rsp), %rdi
callq 0x74730
movq %rax, %rdi
callq 0x792a0
movq %rax, %rsi
leaq 0x88(%rsp), %rdi
callq 0x30550
jmp 0x738ab
movq 0x18(%rsp), %rdi
callq 0x747c0
movq %rax, %rdi
callq 0x795e0
movq %rax, %rsi
leaq 0x88(%rsp), %rdi
callq 0x30550
jmp 0x738ab
movq 0x18(%rsp), %rdi
callq 0x74800
movq %rax, %rdi
callq 0x79780
movq %rax, %rsi
leaq 0x88(%rsp), %rdi
callq 0x30550
jmp 0x738ab
movq 0x18(%rsp), %rdi
callq 0x7e090
movq %rax, %rdi
callq 0x159c0
movq %rax, %rsi
leaq 0x88(%rsp), %rdi
callq 0x30550
jmp 0x738ab
movq 0x18(%rsp), %rdi
callq 0x7e0d0
movq 0x8(%rax), %rdi
callq 0x159c0
movq %rax, %rsi
leaq 0x70(%rsp), %rdi
callq 0x30550
movq 0x18(%rsp), %rdi
callq 0x7e0d0
movslq 0x4(%rax), %rdx
leaq 0x70(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1d4a80
movq %rax, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
jmp 0x738ab
movq 0x18(%rsp), %rdi
callq 0x7e110
movq %rax, %rdi
callq 0x7e150
movq %rax, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
jmp 0x738ab
leaq 0x179ca5(%rip), %rdx # 0x1ed4d4
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x3, %esi
movl $0x2de, %ecx # imm = 0x2DE
callq 0x237e0
movq 0x8(%rsp), %rdi
leaq 0x17c554(%rip), %rsi # 0x1efda8
callq 0x230a0
movq %rax, 0x10(%rsp)
jmp 0x73860
movq 0x10(%rsp), %rsi
leaq 0x2b(%rsp), %rdi
callq 0x23250
jmp 0x73871
leaq 0x38(%rsp), %rdi
callq 0x23820
leaq 0x88(%rsp), %rdi
leaq 0x17a09f(%rip), %rsi # 0x1ed929
callq 0x30720
jmp 0x738ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x23820
jmp 0x738c3
movq 0x88(%rsp), %rax
movq 0x90(%rsp), %rdx
addq $0x98, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x13750
nopl (%rax)
|
_ZNK6google8protobuf6Symbol9full_nameEv:
sub rsp, 98h
mov [rsp+98h+var_18], rdi
mov rdi, [rsp+98h+var_18]; this
mov [rsp+98h+var_80], rdi
call _ZNK6google8protobuf6Symbol4typeEv; google::protobuf::Symbol::type(void)
dec eax; switch 11 cases
mov ecx, eax
mov [rsp+98h+var_78], rcx
sub eax, 0Ah
ja def_73676; jumptable 0000000000073676 default case, case 6
mov rax, [rsp+98h+var_78]
lea rcx, jpt_73676
movsxd rax, ds:(jpt_73676 - 1ED20Ch)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_73678:
mov rdi, [rsp+98h+var_80]; jumptable 0000000000073676 case 1
call _ZNK6google8protobuf6Symbol10descriptorEv; google::protobuf::Symbol::descriptor(void)
mov rdi, rax
call _ZNK6google8protobuf10Descriptor9full_nameB5cxx11Ev; google::protobuf::Descriptor::full_name(void)
mov rsi, rax
lea rdi, [rsp+98h+var_10]
call _ZN6google8protobuf20stringpiece_internal11StringPieceC2ISaIcEEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcET_EE; google::protobuf::stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>(std::string const&)
jmp loc_738AB
loc_7369F:
mov rdi, [rsp+98h+var_80]; jumptable 0000000000073676 case 2
call _ZNK6google8protobuf6Symbol16field_descriptorEv; google::protobuf::Symbol::field_descriptor(void)
mov rdi, rax
call _ZNK6google8protobuf15FieldDescriptor9full_nameB5cxx11Ev; google::protobuf::FieldDescriptor::full_name(void)
mov rsi, rax
lea rdi, [rsp+98h+var_10]
call _ZN6google8protobuf20stringpiece_internal11StringPieceC2ISaIcEEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcET_EE; google::protobuf::stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>(std::string const&)
jmp loc_738AB
loc_736C6:
mov rdi, [rsp+98h+var_80]; jumptable 0000000000073676 case 3
call _ZNK6google8protobuf6Symbol16oneof_descriptorEv; google::protobuf::Symbol::oneof_descriptor(void)
mov rdi, rax
call _ZNK6google8protobuf15OneofDescriptor9full_nameB5cxx11Ev; google::protobuf::OneofDescriptor::full_name(void)
mov rsi, rax
lea rdi, [rsp+98h+var_10]
call _ZN6google8protobuf20stringpiece_internal11StringPieceC2ISaIcEEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcET_EE; google::protobuf::stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>(std::string const&)
jmp loc_738AB
loc_736ED:
mov rdi, [rsp+98h+var_80]; jumptable 0000000000073676 case 4
call _ZNK6google8protobuf6Symbol15enum_descriptorEv; google::protobuf::Symbol::enum_descriptor(void)
mov rdi, rax
call _ZNK6google8protobuf14EnumDescriptor9full_nameB5cxx11Ev; google::protobuf::EnumDescriptor::full_name(void)
mov rsi, rax
lea rdi, [rsp+98h+var_10]
call _ZN6google8protobuf20stringpiece_internal11StringPieceC2ISaIcEEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcET_EE; google::protobuf::stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>(std::string const&)
jmp loc_738AB
loc_73714:
mov rdi, [rsp+98h+var_80]; jumptable 0000000000073676 case 5
call _ZNK6google8protobuf6Symbol21enum_value_descriptorEv; google::protobuf::Symbol::enum_value_descriptor(void)
mov rdi, rax
call _ZNK6google8protobuf19EnumValueDescriptor9full_nameB5cxx11Ev; google::protobuf::EnumValueDescriptor::full_name(void)
mov rsi, rax
lea rdi, [rsp+98h+var_10]
call _ZN6google8protobuf20stringpiece_internal11StringPieceC2ISaIcEEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcET_EE; google::protobuf::stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>(std::string const&)
jmp loc_738AB
loc_7373B:
mov rdi, [rsp+98h+var_80]; jumptable 0000000000073676 case 7
call _ZNK6google8protobuf6Symbol18service_descriptorEv; google::protobuf::Symbol::service_descriptor(void)
mov rdi, rax
call _ZNK6google8protobuf17ServiceDescriptor9full_nameB5cxx11Ev; google::protobuf::ServiceDescriptor::full_name(void)
mov rsi, rax
lea rdi, [rsp+98h+var_10]
call _ZN6google8protobuf20stringpiece_internal11StringPieceC2ISaIcEEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcET_EE; google::protobuf::stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>(std::string const&)
jmp loc_738AB
loc_73762:
mov rdi, [rsp+98h+var_80]; jumptable 0000000000073676 case 8
call _ZNK6google8protobuf6Symbol17method_descriptorEv; google::protobuf::Symbol::method_descriptor(void)
mov rdi, rax
call _ZNK6google8protobuf16MethodDescriptor9full_nameB5cxx11Ev; google::protobuf::MethodDescriptor::full_name(void)
mov rsi, rax
lea rdi, [rsp+98h+var_10]
call _ZN6google8protobuf20stringpiece_internal11StringPieceC2ISaIcEEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcET_EE; google::protobuf::stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>(std::string const&)
jmp loc_738AB
loc_73789:
mov rdi, [rsp+98h+var_80]; jumptable 0000000000073676 case 9
call _ZNK6google8protobuf6Symbol15file_descriptorEv; google::protobuf::Symbol::file_descriptor(void)
mov rdi, rax
call _ZNK6google8protobuf14FileDescriptor7packageB5cxx11Ev; google::protobuf::FileDescriptor::package(void)
mov rsi, rax
lea rdi, [rsp+98h+var_10]
call _ZN6google8protobuf20stringpiece_internal11StringPieceC2ISaIcEEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcET_EE; google::protobuf::stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>(std::string const&)
jmp loc_738AB
loc_737B0:
mov rdi, [rsp+98h+var_80]; jumptable 0000000000073676 case 10
call _ZNK6google8protobuf6Symbol27sub_package_file_descriptorEv; google::protobuf::Symbol::sub_package_file_descriptor(void)
mov rdi, [rax+8]
call _ZNK6google8protobuf14FileDescriptor7packageB5cxx11Ev; google::protobuf::FileDescriptor::package(void)
mov rsi, rax
lea rdi, [rsp+98h+var_28]
call _ZN6google8protobuf20stringpiece_internal11StringPieceC2ISaIcEEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcET_EE; google::protobuf::stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>(std::string const&)
mov rdi, [rsp+98h+var_80]; this
call _ZNK6google8protobuf6Symbol27sub_package_file_descriptorEv; google::protobuf::Symbol::sub_package_file_descriptor(void)
movsxd rdx, dword ptr [rax+4]; unsigned __int64
lea rdi, [rsp+98h+var_28]; this
xor eax, eax
mov esi, eax; unsigned __int64
call _ZNK6google8protobuf20stringpiece_internal11StringPiece6substrEmm; google::protobuf::stringpiece_internal::StringPiece::substr(ulong,ulong)
mov [rsp+98h+var_10], rax
mov [rsp+98h+var_8], rdx
jmp loc_738AB
loc_73801:
mov rdi, [rsp+98h+var_80]; jumptable 0000000000073676 case 11
call _ZNK6google8protobuf6Symbol9query_keyEv; google::protobuf::Symbol::query_key(void)
mov rdi, rax; this
call _ZNK6google8protobuf6Symbol8QueryKey9full_nameEv; google::protobuf::Symbol::QueryKey::full_name(void)
mov [rsp+98h+var_10], rax
mov [rsp+98h+var_8], rdx
jmp loc_738AB
def_73676:
lea rdx, aWorkspaceLlm4b_4; jumptable 0000000000073676 default case, case 6
lea rdi, [rsp+98h+var_60]
mov [rsp+98h+var_90], rdi
mov esi, 3
mov ecx, 2DEh
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+98h+var_90]
lea rsi, aCheckFailedFal_0; "CHECK failed: false: "
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+98h+var_88], rax
jmp short $+2
loc_73860:
mov rsi, [rsp+98h+var_88]
lea rdi, [rsp+98h+var_6D]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_73871:
lea rdi, [rsp+98h+var_60]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
lea rdi, [rsp+98h+var_10]; this
lea rsi, aSyntax0+10h; char *
call _ZN6google8protobuf20stringpiece_internal11StringPieceC2EPKc; google::protobuf::stringpiece_internal::StringPiece::StringPiece(char const*)
jmp short loc_738AB
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
lea rdi, [rsp+arg_30]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
jmp short loc_738C3
loc_738AB:
mov rax, [rsp+98h+var_10]
mov rdx, [rsp+98h+var_8]
add rsp, 98h
retn
loc_738C3:
mov rdi, [rsp+arg_28]
call __Unwind_Resume
|
long long google::protobuf::Symbol::full_name(google::protobuf::Symbol *this)
{
long long v1; // rax
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
long long v11; // rax
long long v12; // rax
long long v13; // rax
long long v14; // rax
long long v15; // rax
long long v16; // rax
long long v17; // rax
long long v18; // rax
long long v19; // rax
long long v20; // rdx
google::protobuf::Symbol::QueryKey *key; // rax
long long v22; // rdx
google::protobuf::internal::LogMessage *v24; // [rsp+10h] [rbp-88h]
_BYTE v25[13]; // [rsp+2Bh] [rbp-6Dh] BYREF
_BYTE v26[56]; // [rsp+38h] [rbp-60h] BYREF
long long v27[3]; // [rsp+70h] [rbp-28h] BYREF
long long v28; // [rsp+88h] [rbp-10h] BYREF
long long v29; // [rsp+90h] [rbp-8h]
v27[2] = (long long)this;
switch ( (unsigned int)google::protobuf::Symbol::type(this) )
{
case 1u:
v1 = google::protobuf::Symbol::descriptor(this);
v2 = google::protobuf::Descriptor::full_name[abi:cxx11](v1);
google::protobuf::stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>(&v28, v2);
break;
case 2u:
v3 = google::protobuf::Symbol::field_descriptor(this);
v4 = google::protobuf::FieldDescriptor::full_name[abi:cxx11](v3);
google::protobuf::stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>(&v28, v4);
break;
case 3u:
v5 = google::protobuf::Symbol::oneof_descriptor(this);
v6 = google::protobuf::OneofDescriptor::full_name[abi:cxx11](v5);
google::protobuf::stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>(&v28, v6);
break;
case 4u:
v7 = google::protobuf::Symbol::enum_descriptor(this);
v8 = google::protobuf::EnumDescriptor::full_name[abi:cxx11](v7);
google::protobuf::stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>(&v28, v8);
break;
case 5u:
v9 = google::protobuf::Symbol::enum_value_descriptor(this);
v10 = google::protobuf::EnumValueDescriptor::full_name[abi:cxx11](v9);
google::protobuf::stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>(&v28, v10);
break;
case 7u:
v11 = google::protobuf::Symbol::service_descriptor(this);
v12 = google::protobuf::ServiceDescriptor::full_name[abi:cxx11](v11);
google::protobuf::stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>(&v28, v12);
break;
case 8u:
v13 = google::protobuf::Symbol::method_descriptor(this);
v14 = google::protobuf::MethodDescriptor::full_name[abi:cxx11](v13);
google::protobuf::stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>(&v28, v14);
break;
case 9u:
v15 = google::protobuf::Symbol::file_descriptor(this);
v16 = google::protobuf::FileDescriptor::package[abi:cxx11](v15);
google::protobuf::stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>(&v28, v16);
break;
case 0xAu:
v17 = google::protobuf::Symbol::sub_package_file_descriptor(this);
v18 = google::protobuf::FileDescriptor::package[abi:cxx11](*(_QWORD *)(v17 + 8));
google::protobuf::stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>(v27, v18);
v19 = google::protobuf::Symbol::sub_package_file_descriptor(this);
v28 = google::protobuf::stringpiece_internal::StringPiece::substr(
(google::protobuf::stringpiece_internal::StringPiece *)v27,
0LL,
*(int *)(v19 + 4));
v29 = v20;
break;
case 0xBu:
key = (google::protobuf::Symbol::QueryKey *)google::protobuf::Symbol::query_key(this);
v28 = google::protobuf::Symbol::QueryKey::full_name(key);
v29 = v22;
break;
default:
google::protobuf::internal::LogMessage::LogMessage(
(long long)v26,
3,
(long long)"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc",
734);
v24 = (google::protobuf::internal::LogMessage *)google::protobuf::internal::LogMessage::operator<<(
(long long)v26,
(long long)"CHECK failed: false: ");
google::protobuf::internal::LogFinisher::operator=((long long)v25, v24);
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v26);
google::protobuf::stringpiece_internal::StringPiece::StringPiece(
(google::protobuf::stringpiece_internal::StringPiece *)&v28,
"");
break;
}
return v28;
}
|
full_name:
SUB RSP,0x98
MOV qword ptr [RSP + 0x80],RDI
MOV RDI,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0x18],RDI
CALL 0x001799a0
DEC EAX
MOV ECX,EAX
MOV qword ptr [RSP + 0x20],RCX
SUB EAX,0xa
JA 0x00173828
MOV RAX,qword ptr [RSP + 0x20]
LEA RCX,[0x2ed20c]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x00174670
MOV RDI,RAX
CALL 0x001163d0
MOV RSI,RAX
LEA RDI,[RSP + 0x88]
CALL 0x00130550
JMP 0x001738ab
caseD_2:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x00173450
MOV RDI,RAX
CALL 0x00178700
MOV RSI,RAX
LEA RDI,[RSP + 0x88]
CALL 0x00130550
JMP 0x001738ab
caseD_3:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001746b0
MOV RDI,RAX
CALL 0x00178f50
MOV RSI,RAX
LEA RDI,[RSP + 0x88]
CALL 0x00130550
JMP 0x001738ab
caseD_4:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001746f0
MOV RDI,RAX
CALL 0x001763c0
MOV RSI,RAX
LEA RDI,[RSP + 0x88]
CALL 0x00130550
JMP 0x001738ab
caseD_5:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x00174730
MOV RDI,RAX
CALL 0x001792a0
MOV RSI,RAX
LEA RDI,[RSP + 0x88]
CALL 0x00130550
JMP 0x001738ab
caseD_7:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001747c0
MOV RDI,RAX
CALL 0x001795e0
MOV RSI,RAX
LEA RDI,[RSP + 0x88]
CALL 0x00130550
JMP 0x001738ab
caseD_8:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x00174800
MOV RDI,RAX
CALL 0x00179780
MOV RSI,RAX
LEA RDI,[RSP + 0x88]
CALL 0x00130550
JMP 0x001738ab
caseD_9:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x0017e090
MOV RDI,RAX
CALL 0x001159c0
MOV RSI,RAX
LEA RDI,[RSP + 0x88]
CALL 0x00130550
JMP 0x001738ab
caseD_a:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x0017e0d0
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x001159c0
MOV RSI,RAX
LEA RDI,[RSP + 0x70]
CALL 0x00130550
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x0017e0d0
MOVSXD RDX,dword ptr [RAX + 0x4]
LEA RDI,[RSP + 0x70]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x002d4a80
MOV qword ptr [RSP + 0x88],RAX
MOV qword ptr [RSP + 0x90],RDX
JMP 0x001738ab
caseD_b:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x0017e110
MOV RDI,RAX
CALL 0x0017e150
MOV qword ptr [RSP + 0x88],RAX
MOV qword ptr [RSP + 0x90],RDX
JMP 0x001738ab
caseD_6:
LEA RDX,[0x2ed4d4]
LEA RDI,[RSP + 0x38]
MOV qword ptr [RSP + 0x8],RDI
MOV ESI,0x3
MOV ECX,0x2de
CALL 0x001237e0
MOV RDI,qword ptr [RSP + 0x8]
LAB_0017384d:
LEA RSI,[0x2efda8]
CALL 0x001230a0
MOV qword ptr [RSP + 0x10],RAX
JMP 0x00173860
LAB_00173860:
MOV RSI,qword ptr [RSP + 0x10]
LEA RDI,[RSP + 0x2b]
CALL 0x00123250
LAB_0017386f:
JMP 0x00173871
LAB_00173871:
LEA RDI,[RSP + 0x38]
CALL 0x00123820
LEA RDI,[RSP + 0x88]
LEA RSI,[0x2ed929]
CALL 0x00130720
JMP 0x001738ab
LAB_001738ab:
MOV RAX,qword ptr [RSP + 0x88]
MOV RDX,qword ptr [RSP + 0x90]
ADD RSP,0x98
RET
|
/* google::protobuf::Symbol::full_name() const */
int1 [16] __thiscall google::protobuf::Symbol::full_name(Symbol *this)
{
int4 uVar1;
Descriptor *this_00;
FieldDescriptor *this_01;
OneofDescriptor *this_02;
EnumDescriptor *this_03;
EnumValueDescriptor *this_04;
ServiceDescriptor *this_05;
MethodDescriptor *this_06;
FileDescriptor *this_07;
long lVar2;
string *psVar3;
QueryKey *this_08;
LogMessage *pLVar4;
int1 auVar5 [16];
LogFinisher local_6d [13];
LogMessage local_60 [56];
StringPiece local_28 [16];
Symbol *local_18;
int8 local_10;
int8 local_8;
local_18 = this;
uVar1 = type(this);
switch(uVar1) {
case 1:
this_00 = (Descriptor *)descriptor(this);
psVar3 = (string *)Descriptor::full_name_abi_cxx11_(this_00);
stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>
((StringPiece *)&local_10,psVar3);
auVar5._8_8_ = local_8;
auVar5._0_8_ = local_10;
break;
case 2:
this_01 = (FieldDescriptor *)field_descriptor(this);
psVar3 = (string *)FieldDescriptor::full_name_abi_cxx11_(this_01);
stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>
((StringPiece *)&local_10,psVar3);
auVar5._8_8_ = local_8;
auVar5._0_8_ = local_10;
break;
case 3:
this_02 = (OneofDescriptor *)oneof_descriptor(this);
psVar3 = (string *)OneofDescriptor::full_name_abi_cxx11_(this_02);
stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>
((StringPiece *)&local_10,psVar3);
auVar5._8_8_ = local_8;
auVar5._0_8_ = local_10;
break;
case 4:
this_03 = (EnumDescriptor *)enum_descriptor(this);
psVar3 = (string *)EnumDescriptor::full_name_abi_cxx11_(this_03);
stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>
((StringPiece *)&local_10,psVar3);
auVar5._8_8_ = local_8;
auVar5._0_8_ = local_10;
break;
case 5:
this_04 = (EnumValueDescriptor *)enum_value_descriptor(this);
psVar3 = (string *)EnumValueDescriptor::full_name_abi_cxx11_(this_04);
stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>
((StringPiece *)&local_10,psVar3);
auVar5._8_8_ = local_8;
auVar5._0_8_ = local_10;
break;
default:
internal::LogMessage::LogMessage
(local_60,3,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc"
,0x2de);
/* try { // try from 0017384d to 0017386e has its CatchHandler @ 00173891 */
pLVar4 = (LogMessage *)internal::LogMessage::operator<<(local_60,"CHECK failed: false: ");
internal::LogFinisher::operator=(local_6d,pLVar4);
internal::LogMessage::~LogMessage(local_60);
stringpiece_internal::StringPiece::StringPiece((StringPiece *)&local_10,"");
auVar5._8_8_ = local_8;
auVar5._0_8_ = local_10;
break;
case 7:
this_05 = (ServiceDescriptor *)service_descriptor(this);
psVar3 = (string *)ServiceDescriptor::full_name_abi_cxx11_(this_05);
stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>
((StringPiece *)&local_10,psVar3);
auVar5._8_8_ = local_8;
auVar5._0_8_ = local_10;
break;
case 8:
this_06 = (MethodDescriptor *)method_descriptor(this);
psVar3 = (string *)MethodDescriptor::full_name_abi_cxx11_(this_06);
stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>
((StringPiece *)&local_10,psVar3);
auVar5._8_8_ = local_8;
auVar5._0_8_ = local_10;
break;
case 9:
this_07 = (FileDescriptor *)file_descriptor(this);
psVar3 = (string *)FileDescriptor::package_abi_cxx11_(this_07);
stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>
((StringPiece *)&local_10,psVar3);
auVar5._8_8_ = local_8;
auVar5._0_8_ = local_10;
break;
case 10:
lVar2 = sub_package_file_descriptor(this);
psVar3 = (string *)FileDescriptor::package_abi_cxx11_(*(FileDescriptor **)(lVar2 + 8));
stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>(local_28,psVar3);
lVar2 = sub_package_file_descriptor(this);
auVar5 = stringpiece_internal::StringPiece::substr(local_28,0,(long)*(int *)(lVar2 + 4));
break;
case 0xb:
this_08 = (QueryKey *)query_key(this);
auVar5 = QueryKey::full_name(this_08);
}
return auVar5;
}
|
|
66,034 |
minja::ForTemplateToken::ForTemplateToken(minja::Location const&, minja::SpaceHandling, minja::SpaceHandling, 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::shared_ptr<minja::Expression>&&, std::shared_ptr<minja::Expression>&&, bool)
|
monkey531[P]llama/common/minja.hpp
|
ForTemplateToken(const Location & location, SpaceHandling pre, SpaceHandling post, const std::vector<std::string> & vns, std::shared_ptr<Expression> && iter,
std::shared_ptr<Expression> && c, bool r)
: TemplateToken(Type::For, location, pre, post), var_names(vns), iterable(std::move(iter)), condition(std::move(c)), recursive(r) {}
|
O3
|
cpp
|
minja::ForTemplateToken::ForTemplateToken(minja::Location const&, minja::SpaceHandling, minja::SpaceHandling, 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::shared_ptr<minja::Expression>&&, std::shared_ptr<minja::Expression>&&, bool):
pushq %r15
pushq %r14
pushq %rbx
movq %r9, %r14
movq %rdi, %rbx
leaq 0x816be(%rip), %r15 # 0xda1c8
addq $0x10, %r15
movq %r15, (%rdi)
movl $0x6, 0x8(%rdi)
movq (%rsi), %rax
movq %rax, 0x10(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x18(%rdi)
testq %rax, %rax
je 0x58b41
movq 0x83465(%rip), %rdi # 0xdbf98
cmpb $0x0, (%rdi)
je 0x58b3d
incl 0x8(%rax)
jmp 0x58b41
lock
incl 0x8(%rax)
movq 0x10(%rsi), %rax
movq %rax, 0x20(%rbx)
movl %edx, 0x28(%rbx)
movl %ecx, 0x2c(%rbx)
leaq 0x820da(%rip), %rax # 0xdac30
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x30(%rbx), %rdi
movq %r8, %rsi
callq 0x35e84
movb 0x28(%rsp), %al
movq 0x20(%rsp), %rcx
xorl %edx, %edx
movq %rdx, 0x50(%rbx)
movups (%r14), %xmm0
movq %rdx, 0x8(%r14)
movups %xmm0, 0x48(%rbx)
movq %rdx, (%r14)
movq %rdx, 0x60(%rbx)
movups (%rcx), %xmm0
movq %rdx, 0x8(%rcx)
movups %xmm0, 0x58(%rbx)
movq %rdx, (%rcx)
movb %al, 0x68(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, (%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x58bb6
callq 0x2ef66
movq %r14, %rdi
callq 0x18ba0
|
_ZN5minja16ForTemplateTokenC2ERKNS_8LocationENS_13SpaceHandlingES4_RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaISB_EEOSt10shared_ptrINS_10ExpressionEESJ_b:
push r15
push r14
push rbx
mov r14, r9
mov rbx, rdi
lea r15, _ZTVN5minja13TemplateTokenE; `vtable for'minja::TemplateToken
add r15, 10h
mov [rdi], r15
mov dword ptr [rdi+8], 6
mov rax, [rsi]
mov [rdi+10h], rax
mov rax, [rsi+8]
mov [rdi+18h], rax
test rax, rax
jz short loc_58B41
mov rdi, cs:__libc_single_threaded_ptr
cmp byte ptr [rdi], 0
jz short loc_58B3D
inc dword ptr [rax+8]
jmp short loc_58B41
loc_58B3D:
lock inc dword ptr [rax+8]
loc_58B41:
mov rax, [rsi+10h]
mov [rbx+20h], rax
mov [rbx+28h], edx
mov [rbx+2Ch], ecx
lea rax, _ZTVN5minja16ForTemplateTokenE; `vtable for'minja::ForTemplateToken
add rax, 10h
mov [rbx], rax
lea rdi, [rbx+30h]
mov rsi, r8
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2ERKS7_; std::vector<std::string>::vector(std::vector<std::string> const&)
mov al, [rsp+18h+arg_8]
mov rcx, [rsp+18h+arg_0]
xor edx, edx
mov [rbx+50h], rdx
movups xmm0, xmmword ptr [r14]
mov [r14+8], rdx
movups xmmword ptr [rbx+48h], xmm0
mov [r14], rdx
mov [rbx+60h], rdx
movups xmm0, xmmword ptr [rcx]
mov [rcx+8], rdx
movups xmmword ptr [rbx+58h], xmm0
mov [rcx], rdx
mov [rbx+68h], al
pop rbx
pop r14
pop r15
retn
mov r14, rax
mov [rbx], r15
mov rdi, [rbx+18h]
test rdi, rdi
jz short loc_58BB6
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_58BB6:
mov rdi, r14
call __Unwind_Resume
|
char minja::ForTemplateToken::ForTemplateToken(
long long a1,
_QWORD *a2,
int a3,
int a4,
_QWORD *a5,
__int128 *a6,
__int128 *a7,
char a8)
{
long long v9; // rax
char result; // al
__int128 v11; // xmm0
__int128 v12; // xmm0
*(_QWORD *)a1 = &`vtable for'minja::TemplateToken + 2;
*(_DWORD *)(a1 + 8) = 6;
*(_QWORD *)(a1 + 16) = *a2;
v9 = a2[1];
*(_QWORD *)(a1 + 24) = v9;
if ( v9 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v9 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v9 + 8));
}
*(_QWORD *)(a1 + 32) = a2[2];
*(_DWORD *)(a1 + 40) = a3;
*(_DWORD *)(a1 + 44) = a4;
*(_QWORD *)a1 = &`vtable for'minja::ForTemplateToken + 2;
std::vector<std::string>::vector(a1 + 48, a5);
result = a8;
*(_QWORD *)(a1 + 80) = 0LL;
v11 = *a6;
*((_QWORD *)a6 + 1) = 0LL;
*(_OWORD *)(a1 + 72) = v11;
*(_QWORD *)a6 = 0LL;
*(_QWORD *)(a1 + 96) = 0LL;
v12 = *a7;
*((_QWORD *)a7 + 1) = 0LL;
*(_OWORD *)(a1 + 88) = v12;
*(_QWORD *)a7 = 0LL;
*(_BYTE *)(a1 + 104) = a8;
return result;
}
|
ForTemplateToken:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,R9
MOV RBX,RDI
LEA R15,[0x1da1c8]
ADD R15,0x10
MOV qword ptr [RDI],R15
MOV dword ptr [RDI + 0x8],0x6
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 0x00158b41
MOV RDI,qword ptr [0x001dbf98]
CMP byte ptr [RDI],0x0
JZ 0x00158b3d
INC dword ptr [RAX + 0x8]
JMP 0x00158b41
LAB_00158b3d:
INC.LOCK dword ptr [RAX + 0x8]
LAB_00158b41:
MOV RAX,qword ptr [RSI + 0x10]
MOV qword ptr [RBX + 0x20],RAX
MOV dword ptr [RBX + 0x28],EDX
MOV dword ptr [RBX + 0x2c],ECX
LEA RAX,[0x1dac30]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
LEA RDI,[RBX + 0x30]
LAB_00158b61:
MOV RSI,R8
CALL 0x00135e84
LAB_00158b69:
MOV AL,byte ptr [RSP + 0x28]
MOV RCX,qword ptr [RSP + 0x20]
XOR EDX,EDX
MOV qword ptr [RBX + 0x50],RDX
MOVUPS XMM0,xmmword ptr [R14]
MOV qword ptr [R14 + 0x8],RDX
MOVUPS xmmword ptr [RBX + 0x48],XMM0
MOV qword ptr [R14],RDX
MOV qword ptr [RBX + 0x60],RDX
MOVUPS XMM0,xmmword ptr [RCX]
MOV qword ptr [RCX + 0x8],RDX
MOVUPS xmmword ptr [RBX + 0x58],XMM0
MOV qword ptr [RCX],RDX
MOV byte ptr [RBX + 0x68],AL
POP RBX
POP R14
POP R15
RET
|
/* minja::ForTemplateToken::ForTemplateToken(minja::Location const&, minja::SpaceHandling,
minja::SpaceHandling, std::vector<std::__cxx11::string, std::allocator<std::__cxx11::string > >
const&, std::shared_ptr<minja::Expression>&&, std::shared_ptr<minja::Expression>&&, bool) */
void __thiscall
minja::ForTemplateToken::ForTemplateToken
(ForTemplateToken *this,int8 *param_1,int4 param_3,int4 param_4,
vector *param_5,int8 *param_6,int8 *param_7,ForTemplateToken param_8)
{
long lVar1;
int8 uVar2;
*(int ***)this = &PTR__TemplateToken_001da1d8;
*(int4 *)(this + 8) = 6;
*(int8 *)(this + 0x10) = *param_1;
lVar1 = param_1[1];
*(long *)(this + 0x18) = lVar1;
if (lVar1 != 0) {
if (*PTR___libc_single_threaded_001dbf98 == '\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__ForTemplateToken_001dac40;
/* try { // try from 00158b61 to 00158b68 has its CatchHandler @ 00158ba2 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)(this + 0x30),
param_5);
*(int8 *)(this + 0x50) = 0;
uVar2 = param_6[1];
param_6[1] = 0;
*(int8 *)(this + 0x48) = *param_6;
*(int8 *)(this + 0x50) = uVar2;
*param_6 = 0;
*(int8 *)(this + 0x60) = 0;
uVar2 = param_7[1];
param_7[1] = 0;
*(int8 *)(this + 0x58) = *param_7;
*(int8 *)(this + 0x60) = uVar2;
*param_7 = 0;
this[0x68] = param_8;
return;
}
|
|
66,035 |
ma_calc_bin_pack_key_length
|
eloqsql/storage/maria/ma_search.c
|
int _ma_calc_bin_pack_key_length(const MARIA_KEY *int_key,
uint nod_flag,
uchar *next_key,
uchar *org_key, uchar *prev_key,
MARIA_KEY_PARAM *s_temp)
{
uint length,key_length,ref_length;
const uchar *key= int_key->data;
s_temp->totlength= key_length= (int_key->data_length + int_key->ref_length+
nod_flag);
#ifdef HAVE_valgrind
s_temp->n_length= s_temp->n_ref_length=0; /* For valgrind */
#endif
s_temp->key=key;
s_temp->prev_key=org_key;
if (prev_key) /* If not first key in block */
{
/* pack key against previous key */
/*
As keys may be identical when running a sort in maria_chk, we
have to guard against the case where keys may be identical
*/
const uchar *end;
end=key+key_length;
for ( ; *key == *prev_key && key < end; key++,prev_key++) ;
s_temp->ref_length= ref_length=(uint) (key-s_temp->key);
length=key_length - ref_length + get_pack_length(ref_length);
}
else
{
/* No previous key */
s_temp->ref_length=ref_length=0;
length=key_length+1;
}
if ((s_temp->next_key_pos=next_key)) /* If another key after */
{
/* pack key against next key */
uint next_length,next_length_pack;
get_key_pack_length(next_length,next_length_pack,next_key);
/* If first key and next key is packed (only on delete) */
if (!prev_key && org_key && next_length)
{
const uchar *end;
for (key= s_temp->key, end=key+next_length ;
*key == *org_key && key < end;
key++,org_key++) ;
ref_length= (uint) (key - s_temp->key);
}
if (next_length > ref_length)
{
/*
We put a key with different case between two keys with the same prefix
Extend next key to have same prefix as this key
*/
s_temp->n_ref_length= ref_length;
s_temp->prev_length= next_length-ref_length;
s_temp->prev_key+= ref_length;
return s_temp->move_length= ((int) (length+ s_temp->prev_length -
next_length_pack +
get_pack_length(ref_length)));
}
/* Check how many characters are identical to next key */
key= s_temp->key+next_length;
s_temp->prev_length= 0;
while (*key++ == *next_key++) ;
if ((ref_length= (uint) (key - s_temp->key)-1) == next_length)
{
s_temp->next_key_pos=0;
return (s_temp->move_length= length); /* Can't pack next key */
}
s_temp->n_ref_length=ref_length;
return s_temp->move_length= (int) (length-(ref_length - next_length) -
next_length_pack +
get_pack_length(ref_length));
}
return (s_temp->move_length= (int) length);
}
|
O0
|
c
|
ma_calc_bin_pack_key_length:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0x14(%rax), %ecx
addl -0x14(%rbp), %ecx
movl %ecx, -0x40(%rbp)
movq -0x38(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x50(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x30(%rbp)
je 0x6e2d8
movq -0x50(%rbp), %rax
movl -0x40(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
movzbl (%rax), %ecx
movq -0x30(%rbp), %rax
movzbl (%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x69(%rbp)
jne 0x6e276
movq -0x50(%rbp), %rax
cmpq -0x58(%rbp), %rax
setb %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x6e27f
jmp 0x6e29b
jmp 0x6e281
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x6e251
movq -0x50(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movl %eax, %ecx
movl %ecx, -0x44(%rbp)
movq -0x38(%rbp), %rax
movl %ecx, 0x20(%rax)
movl -0x40(%rbp), %eax
subl -0x44(%rbp), %eax
movl -0x44(%rbp), %esi
movl $0x1, %ecx
movl $0x3, %edx
cmpl $0xff, %esi
cmovael %edx, %ecx
addl %ecx, %eax
movl %eax, -0x3c(%rbp)
jmp 0x6e2f3
movl $0x0, -0x44(%rbp)
movq -0x38(%rbp), %rax
movl $0x0, 0x20(%rax)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
je 0x6e512
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xff, %eax
je 0x6e335
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movzbl (%rax), %eax
movl %eax, -0x5c(%rbp)
movl $0x1, -0x60(%rbp)
jmp 0x6e369
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %eax
movzwl %ax, %eax
movq -0x20(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %eax
movl %eax, -0x5c(%rbp)
movq -0x20(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x20(%rbp)
movl $0x3, -0x60(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x6e3f5
cmpq $0x0, -0x28(%rbp)
je 0x6e3f5
cmpl $0x0, -0x5c(%rbp)
je 0x6e3f5
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movl -0x5c(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %rax
movzbl (%rax), %ecx
movq -0x28(%rbp), %rax
movzbl (%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x6a(%rbp)
jne 0x6e3bf
movq -0x50(%rbp), %rax
cmpq -0x68(%rbp), %rax
setb %al
movb %al, -0x6a(%rbp)
movb -0x6a(%rbp), %al
testb $0x1, %al
jne 0x6e3c8
jmp 0x6e3e4
jmp 0x6e3ca
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x6e39a
movq -0x50(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x44(%rbp)
movl -0x5c(%rbp), %eax
cmpl -0x44(%rbp), %eax
jbe 0x6e45c
movl -0x44(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x28(%rax)
movl -0x5c(%rbp), %ecx
subl -0x44(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x38(%rax)
movl -0x44(%rbp), %edx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
movl -0x3c(%rbp), %eax
movq -0x38(%rbp), %rcx
addl 0x38(%rcx), %eax
subl -0x60(%rbp), %eax
movl -0x44(%rbp), %esi
movl $0x1, %ecx
movl $0x3, %edx
cmpl $0xff, %esi
cmovael %edx, %ecx
addl %ecx, %eax
movq -0x38(%rbp), %rcx
movl %eax, 0x44(%rcx)
movl %eax, -0x4(%rbp)
jmp 0x6e51f
movq -0x38(%rbp), %rax
movq (%rax), %rax
movl -0x5c(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x50(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x50(%rbp)
movzbl (%rax), %eax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x6e4a2
jmp 0x6e478
movq -0x50(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
subl $0x1, %eax
movl %eax, -0x44(%rbp)
cmpl -0x5c(%rbp), %eax
jne 0x6e4d6
movq -0x38(%rbp), %rax
movq $0x0, 0x10(%rax)
movl -0x3c(%rbp), %eax
movq -0x38(%rbp), %rcx
movl %eax, 0x44(%rcx)
movl %eax, -0x4(%rbp)
jmp 0x6e51f
movl -0x44(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x28(%rax)
movl -0x3c(%rbp), %eax
movl -0x44(%rbp), %ecx
subl -0x5c(%rbp), %ecx
subl %ecx, %eax
subl -0x60(%rbp), %eax
movl -0x44(%rbp), %esi
movl $0x1, %ecx
movl $0x3, %edx
cmpl $0xff, %esi
cmovael %edx, %ecx
addl %ecx, %eax
movq -0x38(%rbp), %rcx
movl %eax, 0x44(%rcx)
movl %eax, -0x4(%rbp)
jmp 0x6e51f
movl -0x3c(%rbp), %eax
movq -0x38(%rbp), %rcx
movl %eax, 0x44(%rcx)
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_ma_calc_bin_pack_key_length:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_50], rax
mov rax, [rbp+var_10]
mov ecx, [rax+10h]
mov rax, [rbp+var_10]
add ecx, [rax+14h]
add ecx, [rbp+var_14]
mov [rbp+var_40], ecx
mov rax, [rbp+var_38]
mov [rax+30h], ecx
mov rcx, [rbp+var_50]
mov rax, [rbp+var_38]
mov [rax], rcx
mov rcx, [rbp+var_28]
mov rax, [rbp+var_38]
mov [rax+8], rcx
cmp [rbp+var_30], 0
jz loc_6E2D8
mov rax, [rbp+var_50]
mov ecx, [rbp+var_40]
add rax, rcx
mov [rbp+var_58], rax
loc_6E251:
mov rax, [rbp+var_50]
movzx ecx, byte ptr [rax]
mov rax, [rbp+var_30]
movzx edx, byte ptr [rax]
xor eax, eax
cmp ecx, edx
mov [rbp+var_69], al
jnz short loc_6E276
mov rax, [rbp+var_50]
cmp rax, [rbp+var_58]
setb al
mov [rbp+var_69], al
loc_6E276:
mov al, [rbp+var_69]
test al, 1
jnz short loc_6E27F
jmp short loc_6E29B
loc_6E27F:
jmp short $+2
loc_6E281:
mov rax, [rbp+var_50]
add rax, 1
mov [rbp+var_50], rax
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
jmp short loc_6E251
loc_6E29B:
mov rax, [rbp+var_50]
mov rcx, [rbp+var_38]
mov rcx, [rcx]
sub rax, rcx
mov ecx, eax
mov [rbp+var_44], ecx
mov rax, [rbp+var_38]
mov [rax+20h], ecx
mov eax, [rbp+var_40]
sub eax, [rbp+var_44]
mov esi, [rbp+var_44]
mov ecx, 1
mov edx, 3
cmp esi, 0FFh
cmovnb ecx, edx
add eax, ecx
mov [rbp+var_3C], eax
jmp short loc_6E2F3
loc_6E2D8:
mov [rbp+var_44], 0
mov rax, [rbp+var_38]
mov dword ptr [rax+20h], 0
mov eax, [rbp+var_40]
add eax, 1
mov [rbp+var_3C], eax
loc_6E2F3:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_38]
mov [rcx+10h], rax
cmp rax, 0
jz loc_6E512
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
cmp eax, 0FFh
jz short loc_6E335
mov rax, [rbp+var_20]
mov rcx, rax
add rcx, 1
mov [rbp+var_20], rcx
movzx eax, byte ptr [rax]
mov [rbp+var_5C], eax
mov [rbp+var_60], 1
jmp short loc_6E369
loc_6E335:
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+2]
movzx eax, ax
mov rcx, [rbp+var_20]
movzx ecx, byte ptr [rcx+1]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx eax, ax
mov [rbp+var_5C], eax
mov rax, [rbp+var_20]
add rax, 3
mov [rbp+var_20], rax
mov [rbp+var_60], 3
loc_6E369:
cmp [rbp+var_30], 0
jnz loc_6E3F5
cmp [rbp+var_28], 0
jz short loc_6E3F5
cmp [rbp+var_5C], 0
jz short loc_6E3F5
mov rax, [rbp+var_38]
mov rax, [rax]
mov [rbp+var_50], rax
mov rax, [rbp+var_50]
mov ecx, [rbp+var_5C]
add rax, rcx
mov [rbp+var_68], rax
loc_6E39A:
mov rax, [rbp+var_50]
movzx ecx, byte ptr [rax]
mov rax, [rbp+var_28]
movzx edx, byte ptr [rax]
xor eax, eax
cmp ecx, edx
mov [rbp+var_6A], al
jnz short loc_6E3BF
mov rax, [rbp+var_50]
cmp rax, [rbp+var_68]
setb al
mov [rbp+var_6A], al
loc_6E3BF:
mov al, [rbp+var_6A]
test al, 1
jnz short loc_6E3C8
jmp short loc_6E3E4
loc_6E3C8:
jmp short $+2
loc_6E3CA:
mov rax, [rbp+var_50]
add rax, 1
mov [rbp+var_50], rax
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
jmp short loc_6E39A
loc_6E3E4:
mov rax, [rbp+var_50]
mov rcx, [rbp+var_38]
mov rcx, [rcx]
sub rax, rcx
mov [rbp+var_44], eax
loc_6E3F5:
mov eax, [rbp+var_5C]
cmp eax, [rbp+var_44]
jbe short loc_6E45C
mov ecx, [rbp+var_44]
mov rax, [rbp+var_38]
mov [rax+28h], ecx
mov ecx, [rbp+var_5C]
sub ecx, [rbp+var_44]
mov rax, [rbp+var_38]
mov [rax+38h], ecx
mov edx, [rbp+var_44]
mov rax, [rbp+var_38]
mov rcx, [rax+8]
mov edx, edx
add rcx, rdx
mov [rax+8], rcx
mov eax, [rbp+var_3C]
mov rcx, [rbp+var_38]
add eax, [rcx+38h]
sub eax, [rbp+var_60]
mov esi, [rbp+var_44]
mov ecx, 1
mov edx, 3
cmp esi, 0FFh
cmovnb ecx, edx
add eax, ecx
mov rcx, [rbp+var_38]
mov [rcx+44h], eax
mov [rbp+var_4], eax
jmp loc_6E51F
loc_6E45C:
mov rax, [rbp+var_38]
mov rax, [rax]
mov ecx, [rbp+var_5C]
add rax, rcx
mov [rbp+var_50], rax
mov rax, [rbp+var_38]
mov dword ptr [rax+38h], 0
loc_6E478:
mov rax, [rbp+var_50]
mov rcx, rax
add rcx, 1
mov [rbp+var_50], rcx
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_20]
mov rdx, rcx
add rdx, 1
mov [rbp+var_20], rdx
movzx ecx, byte ptr [rcx]
cmp eax, ecx
jnz short loc_6E4A2
jmp short loc_6E478
loc_6E4A2:
mov rax, [rbp+var_50]
mov rcx, [rbp+var_38]
mov rcx, [rcx]
sub rax, rcx
sub eax, 1
mov [rbp+var_44], eax
cmp eax, [rbp+var_5C]
jnz short loc_6E4D6
mov rax, [rbp+var_38]
mov qword ptr [rax+10h], 0
mov eax, [rbp+var_3C]
mov rcx, [rbp+var_38]
mov [rcx+44h], eax
mov [rbp+var_4], eax
jmp short loc_6E51F
loc_6E4D6:
mov ecx, [rbp+var_44]
mov rax, [rbp+var_38]
mov [rax+28h], ecx
mov eax, [rbp+var_3C]
mov ecx, [rbp+var_44]
sub ecx, [rbp+var_5C]
sub eax, ecx
sub eax, [rbp+var_60]
mov esi, [rbp+var_44]
mov ecx, 1
mov edx, 3
cmp esi, 0FFh
cmovnb ecx, edx
add eax, ecx
mov rcx, [rbp+var_38]
mov [rcx+44h], eax
mov [rbp+var_4], eax
jmp short loc_6E51F
loc_6E512:
mov eax, [rbp+var_3C]
mov rcx, [rbp+var_38]
mov [rcx+44h], eax
mov [rbp+var_4], eax
loc_6E51F:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long ma_calc_bin_pack_key_length(
unsigned __int8 **a1,
int a2,
unsigned __int8 *a3,
unsigned __int8 *a4,
unsigned __int8 *a5,
unsigned __int8 **a6)
{
int v6; // ecx
int v7; // ecx
unsigned int v8; // eax
unsigned __int8 *v9; // rax
unsigned __int8 *v10; // rcx
int v11; // ecx
bool v13; // [rsp+0h] [rbp-6Ah]
bool v14; // [rsp+1h] [rbp-69h]
int v15; // [rsp+Ah] [rbp-60h]
unsigned int v16; // [rsp+Eh] [rbp-5Ch]
unsigned __int8 *v17; // [rsp+12h] [rbp-58h]
unsigned __int8 *v18; // [rsp+1Ah] [rbp-50h]
unsigned __int8 *i; // [rsp+1Ah] [rbp-50h]
unsigned __int8 *v20; // [rsp+1Ah] [rbp-50h]
unsigned int v21; // [rsp+26h] [rbp-44h]
unsigned int v22; // [rsp+26h] [rbp-44h]
int v23; // [rsp+2Ah] [rbp-40h]
unsigned int v24; // [rsp+2Eh] [rbp-3Ch]
unsigned __int8 *v25; // [rsp+3Ah] [rbp-30h]
unsigned __int8 *v26; // [rsp+42h] [rbp-28h]
unsigned __int8 *v27; // [rsp+4Ah] [rbp-20h]
v26 = a4;
v25 = a5;
v18 = *a1;
v23 = a2 + *((_DWORD *)a1 + 5) + *((_DWORD *)a1 + 4);
*((_DWORD *)a6 + 12) = v23;
*a6 = v18;
a6[1] = a4;
if ( a5 )
{
v17 = &v18[v23];
while ( 1 )
{
v14 = 0;
if ( *v18 == *v25 )
v14 = v18 < v17;
if ( !v14 )
break;
++v18;
++v25;
}
v21 = (_DWORD)v18 - (unsigned int)*a6;
*((_DWORD *)a6 + 8) = v21;
v6 = 1;
if ( v21 >= 0xFF )
v6 = 3;
v24 = v6 + v23 - v21;
}
else
{
v21 = 0;
*((_DWORD *)a6 + 8) = 0;
v24 = v23 + 1;
}
a6[2] = a3;
if ( a3 )
{
if ( *a3 == 255 )
{
v16 = _byteswap_ushort(*(_WORD *)(a3 + 1));
v27 = a3 + 3;
v15 = 3;
}
else
{
v27 = a3 + 1;
v16 = *a3;
v15 = 1;
}
if ( !v25 && v26 && v16 )
{
for ( i = *a6; ; ++i )
{
v13 = 0;
if ( *i == *v26 )
v13 = i < &(*a6)[v16];
if ( !v13 )
break;
++v26;
}
v21 = (_DWORD)i - *(_DWORD *)a6;
}
if ( v16 <= v21 )
{
v20 = &(*a6)[v16];
*((_DWORD *)a6 + 14) = 0;
do
{
v9 = v20++;
v10 = v27++;
}
while ( *v9 == *v10 );
v22 = (_DWORD)v20 - (unsigned int)*a6 - 1;
if ( v22 == v16 )
{
a6[2] = 0LL;
*((_DWORD *)a6 + 17) = v24;
return v24;
}
else
{
*((_DWORD *)a6 + 10) = v22;
v11 = 1;
if ( v22 >= 0xFF )
v11 = 3;
*((_DWORD *)a6 + 17) = v11 + v24 - (v22 - v16) - v15;
return v11 + v24 - (v22 - v16) - v15;
}
}
else
{
*((_DWORD *)a6 + 10) = v21;
*((_DWORD *)a6 + 14) = v16 - v21;
a6[1] += v21;
v7 = 1;
if ( v21 >= 0xFF )
v7 = 3;
v8 = v7 + *((_DWORD *)a6 + 14) + v24 - v15;
*((_DWORD *)a6 + 17) = v8;
return v8;
}
}
else
{
*((_DWORD *)a6 + 17) = v24;
return v24;
}
}
|
_ma_calc_bin_pack_key_length:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
ADD ECX,dword ptr [RAX + 0x14]
ADD ECX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x40],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x30],ECX
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x8],RCX
CMP qword ptr [RBP + -0x30],0x0
JZ 0x0016e2d8
MOV RAX,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RBP + -0x40]
ADD RAX,RCX
MOV qword ptr [RBP + -0x58],RAX
LAB_0016e251:
MOV RAX,qword ptr [RBP + -0x50]
MOVZX ECX,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EDX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,EDX
MOV byte ptr [RBP + -0x69],AL
JNZ 0x0016e276
MOV RAX,qword ptr [RBP + -0x50]
CMP RAX,qword ptr [RBP + -0x58]
SETC AL
MOV byte ptr [RBP + -0x69],AL
LAB_0016e276:
MOV AL,byte ptr [RBP + -0x69]
TEST AL,0x1
JNZ 0x0016e27f
JMP 0x0016e29b
LAB_0016e27f:
JMP 0x0016e281
LAB_0016e281:
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x1
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0016e251
LAB_0016e29b:
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RCX]
SUB RAX,RCX
MOV ECX,EAX
MOV dword ptr [RBP + -0x44],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x20],ECX
MOV EAX,dword ptr [RBP + -0x40]
SUB EAX,dword ptr [RBP + -0x44]
MOV ESI,dword ptr [RBP + -0x44]
MOV ECX,0x1
MOV EDX,0x3
CMP ESI,0xff
CMOVNC ECX,EDX
ADD EAX,ECX
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x0016e2f3
LAB_0016e2d8:
MOV dword ptr [RBP + -0x44],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x20],0x0
MOV EAX,dword ptr [RBP + -0x40]
ADD EAX,0x1
MOV dword ptr [RBP + -0x3c],EAX
LAB_0016e2f3:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x38]
MOV qword ptr [RCX + 0x10],RAX
CMP RAX,0x0
JZ 0x0016e512
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0xff
JZ 0x0016e335
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x20],RCX
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x5c],EAX
MOV dword ptr [RBP + -0x60],0x1
JMP 0x0016e369
LAB_0016e335:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x2]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RCX + 0x1]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX EAX,AX
MOV dword ptr [RBP + -0x5c],EAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x3
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x60],0x3
LAB_0016e369:
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x0016e3f5
CMP qword ptr [RBP + -0x28],0x0
JZ 0x0016e3f5
CMP dword ptr [RBP + -0x5c],0x0
JZ 0x0016e3f5
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RBP + -0x5c]
ADD RAX,RCX
MOV qword ptr [RBP + -0x68],RAX
LAB_0016e39a:
MOV RAX,qword ptr [RBP + -0x50]
MOVZX ECX,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EDX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,EDX
MOV byte ptr [RBP + -0x6a],AL
JNZ 0x0016e3bf
MOV RAX,qword ptr [RBP + -0x50]
CMP RAX,qword ptr [RBP + -0x68]
SETC AL
MOV byte ptr [RBP + -0x6a],AL
LAB_0016e3bf:
MOV AL,byte ptr [RBP + -0x6a]
TEST AL,0x1
JNZ 0x0016e3c8
JMP 0x0016e3e4
LAB_0016e3c8:
JMP 0x0016e3ca
LAB_0016e3ca:
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x1
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0016e39a
LAB_0016e3e4:
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RCX]
SUB RAX,RCX
MOV dword ptr [RBP + -0x44],EAX
LAB_0016e3f5:
MOV EAX,dword ptr [RBP + -0x5c]
CMP EAX,dword ptr [RBP + -0x44]
JBE 0x0016e45c
MOV ECX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x28],ECX
MOV ECX,dword ptr [RBP + -0x5c]
SUB ECX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x38],ECX
MOV EDX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RAX + 0x8]
MOV EDX,EDX
ADD RCX,RDX
MOV qword ptr [RAX + 0x8],RCX
MOV EAX,dword ptr [RBP + -0x3c]
MOV RCX,qword ptr [RBP + -0x38]
ADD EAX,dword ptr [RCX + 0x38]
SUB EAX,dword ptr [RBP + -0x60]
MOV ESI,dword ptr [RBP + -0x44]
MOV ECX,0x1
MOV EDX,0x3
CMP ESI,0xff
CMOVNC ECX,EDX
ADD EAX,ECX
MOV RCX,qword ptr [RBP + -0x38]
MOV dword ptr [RCX + 0x44],EAX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0016e51f
LAB_0016e45c:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x5c]
ADD RAX,RCX
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x38],0x0
LAB_0016e478:
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x50],RCX
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x20]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOVZX ECX,byte ptr [RCX]
CMP EAX,ECX
JNZ 0x0016e4a2
JMP 0x0016e478
LAB_0016e4a2:
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RCX]
SUB RAX,RCX
SUB EAX,0x1
MOV dword ptr [RBP + -0x44],EAX
CMP EAX,dword ptr [RBP + -0x5c]
JNZ 0x0016e4d6
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x10],0x0
MOV EAX,dword ptr [RBP + -0x3c]
MOV RCX,qword ptr [RBP + -0x38]
MOV dword ptr [RCX + 0x44],EAX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0016e51f
LAB_0016e4d6:
MOV ECX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x28],ECX
MOV EAX,dword ptr [RBP + -0x3c]
MOV ECX,dword ptr [RBP + -0x44]
SUB ECX,dword ptr [RBP + -0x5c]
SUB EAX,ECX
SUB EAX,dword ptr [RBP + -0x60]
MOV ESI,dword ptr [RBP + -0x44]
MOV ECX,0x1
MOV EDX,0x3
CMP ESI,0xff
CMOVNC ECX,EDX
ADD EAX,ECX
MOV RCX,qword ptr [RBP + -0x38]
MOV dword ptr [RCX + 0x44],EAX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0016e51f
LAB_0016e512:
MOV EAX,dword ptr [RBP + -0x3c]
MOV RCX,qword ptr [RBP + -0x38]
MOV dword ptr [RCX + 0x44],EAX
MOV dword ptr [RBP + -0x4],EAX
LAB_0016e51f:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int _ma_calc_bin_pack_key_length
(int8 *param_1,int param_2,byte *param_3,char *param_4,char *param_5,
long *param_6)
{
byte bVar1;
byte bVar2;
char *pcVar3;
uint uVar4;
byte *pbVar5;
int local_68;
uint local_64;
byte *local_58;
uint local_4c;
int local_44;
char *local_38;
char *local_30;
byte *local_28;
int local_c;
local_58 = (byte *)*param_1;
uVar4 = *(int *)(param_1 + 2) + *(int *)((long)param_1 + 0x14) + param_2;
*(uint *)(param_6 + 6) = uVar4;
*param_6 = (long)local_58;
param_6[1] = (long)param_4;
local_38 = param_5;
if (param_5 == (char *)0x0) {
local_4c = 0;
*(int4 *)(param_6 + 4) = 0;
local_44 = uVar4 + 1;
}
else {
pcVar3 = (char *)local_58 + uVar4;
for (; *local_58 == *local_38 && local_58 < pcVar3; local_58 = local_58 + 1) {
local_38 = local_38 + 1;
}
local_4c = (int)local_58 - (int)*param_6;
*(uint *)(param_6 + 4) = local_4c;
local_44 = 1;
if (0xfe < local_4c) {
local_44 = 3;
}
local_44 = (uVar4 - local_4c) + local_44;
}
param_6[2] = (long)param_3;
if (param_3 == (byte *)0x0) {
*(int *)((long)param_6 + 0x44) = local_44;
local_c = local_44;
}
else {
if (*param_3 == 0xff) {
local_64 = (uint)CONCAT11(param_3[1],param_3[2]);
local_28 = param_3 + 3;
local_68 = 3;
}
else {
local_28 = param_3 + 1;
local_64 = (uint)*param_3;
local_68 = 1;
}
if (((local_38 == (char *)0x0) && (param_4 != (char *)0x0)) && (local_64 != 0)) {
local_58 = (byte *)*param_6;
pcVar3 = (char *)local_58 + local_64;
local_30 = param_4;
for (; *local_58 == *local_30 && local_58 < pcVar3; local_58 = local_58 + 1) {
local_30 = local_30 + 1;
}
local_4c = (int)local_58 - (int)*param_6;
}
if (local_4c < local_64) {
*(uint *)(param_6 + 5) = local_4c;
*(uint *)(param_6 + 7) = local_64 - local_4c;
param_6[1] = param_6[1] + (ulong)local_4c;
local_c = 1;
if (0xfe < local_4c) {
local_c = 3;
}
local_c = ((local_44 + (int)param_6[7]) - local_68) + local_c;
*(int *)((long)param_6 + 0x44) = local_c;
}
else {
*(int4 *)(param_6 + 7) = 0;
local_58 = (byte *)(*param_6 + (ulong)local_64);
do {
pbVar5 = local_58 + 1;
bVar1 = *local_58;
bVar2 = *local_28;
local_58 = pbVar5;
local_28 = local_28 + 1;
} while (bVar1 == bVar2);
uVar4 = ((int)pbVar5 - (int)*param_6) - 1;
if (uVar4 == local_64) {
param_6[2] = 0;
*(int *)((long)param_6 + 0x44) = local_44;
local_c = local_44;
}
else {
*(uint *)(param_6 + 5) = uVar4;
local_c = 1;
if (0xfe < uVar4) {
local_c = 3;
}
local_c = ((local_44 - (uVar4 - local_64)) - local_68) + local_c;
*(int *)((long)param_6 + 0x44) = local_c;
}
}
}
return local_c;
}
|
|
66,036 |
mysql_ssl_set
|
eloqsql/libmariadb/libmariadb/mariadb_lib.c
|
int STDCALL
mysql_ssl_set(MYSQL *mysql __attribute__((unused)),
const char *key __attribute__((unused)),
const char *cert __attribute__((unused)),
const char *ca __attribute__((unused)),
const char *capath __attribute__((unused)),
const char *cipher __attribute__((unused)))
{
#ifdef HAVE_TLS
char enable= 1;
return (mysql_optionsv(mysql, MYSQL_OPT_SSL_ENFORCE, &enable) |
mysql_optionsv(mysql, MYSQL_OPT_SSL_KEY, key) |
mysql_optionsv(mysql, MYSQL_OPT_SSL_CERT, cert) |
mysql_optionsv(mysql, MYSQL_OPT_SSL_CA, ca) |
mysql_optionsv(mysql, MYSQL_OPT_SSL_CAPATH, capath) |
mysql_optionsv(mysql, MYSQL_OPT_SSL_CIPHER, cipher)) ? 1 : 0;
#else
return 0;
#endif
}
|
O3
|
c
|
mysql_ssl_set:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, -0x40(%rbp)
movq %r8, -0x38(%rbp)
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x29(%rbp), %rdx
movb $0x1, (%rdx)
movl $0x26, %esi
xorl %eax, %eax
callq 0x1b6ee
movl %eax, %r15d
movq %r14, %rdi
movl $0x19, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1b6ee
movl %eax, %ebx
orl %r15d, %ebx
movq %r14, %rdi
movl $0x1a, %esi
movq %r13, %rdx
xorl %eax, %eax
callq 0x1b6ee
movl %eax, %r15d
movq %r14, %rdi
movl $0x1b, %esi
movq %r12, %rdx
xorl %eax, %eax
callq 0x1b6ee
movl %eax, %r12d
orl %r15d, %r12d
orl %ebx, %r12d
movq %r14, %rdi
movl $0x1c, %esi
movq -0x38(%rbp), %rdx
xorl %eax, %eax
callq 0x1b6ee
movl %eax, %ebx
orl %r12d, %ebx
movq %r14, %rdi
movl $0x1d, %esi
movq -0x40(%rbp), %rdx
xorl %eax, %eax
callq 0x1b6ee
xorl %ecx, %ecx
orl %ebx, %eax
setne %cl
movl %ecx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
mysql_ssl_set:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov [rbp+var_40], r9
mov [rbp+var_38], r8
mov r12, rcx
mov r13, rdx
mov rbx, rsi
mov r14, rdi
lea rdx, [rbp+var_29]
mov byte ptr [rdx], 1
mov esi, 26h ; '&'
xor eax, eax
call mysql_optionsv
mov r15d, eax
mov rdi, r14
mov esi, 19h
mov rdx, rbx
xor eax, eax
call mysql_optionsv
mov ebx, eax
or ebx, r15d
mov rdi, r14
mov esi, 1Ah
mov rdx, r13
xor eax, eax
call mysql_optionsv
mov r15d, eax
mov rdi, r14
mov esi, 1Bh
mov rdx, r12
xor eax, eax
call mysql_optionsv
mov r12d, eax
or r12d, r15d
or r12d, ebx
mov rdi, r14
mov esi, 1Ch
mov rdx, [rbp+var_38]
xor eax, eax
call mysql_optionsv
mov ebx, eax
or ebx, r12d
mov rdi, r14
mov esi, 1Dh
mov rdx, [rbp+var_40]
xor eax, eax
call mysql_optionsv
xor ecx, ecx
or eax, ebx
setnz cl
mov eax, ecx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
_BOOL8 mysql_ssl_set(
long long a1,
char *a2,
char *a3,
long long a4,
char *a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
char *v14; // r12
int v16; // r15d
long long v17; // rcx
long long v18; // r8
long long v19; // r9
__m128 v20; // xmm4
__m128 v21; // xmm5
int v22; // ebx
long long v23; // rcx
long long v24; // r8
long long v25; // r9
__m128 v26; // xmm4
__m128 v27; // xmm5
int v28; // r15d
long long v29; // rcx
long long v30; // r8
long long v31; // r9
__m128 v32; // xmm4
__m128 v33; // xmm5
long long v34; // rcx
long long v35; // r8
long long v36; // r9
__m128 v37; // xmm4
__m128 v38; // xmm5
int v39; // ebx
long long v40; // rcx
long long v41; // r8
long long v42; // r9
__m128 v43; // xmm4
__m128 v44; // xmm5
char v46; // [rsp+0h] [rbp-40h]
char v47; // [rsp+0h] [rbp-40h]
char v48; // [rsp+0h] [rbp-40h]
char v49; // [rsp+0h] [rbp-40h]
char *v50; // [rsp+0h] [rbp-40h]
char v52[41]; // [rsp+17h] [rbp-29h] BYREF
v14 = (char *)a4;
v52[0] = 1;
v16 = mysql_optionsv(a1, 38, v52, a4, (long long)a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a6);
v22 = v16 | mysql_optionsv(a1, 25, a2, v17, v18, v19, a7, a8, a9, a10, v20, v21, a13, a14, v46);
v28 = mysql_optionsv(a1, 26, a3, v23, v24, v25, a7, a8, a9, a10, v26, v27, a13, a14, v47);
LODWORD(v14) = v22 | v28 | mysql_optionsv(a1, 27, v14, v29, v30, v31, a7, a8, a9, a10, v32, v33, a13, a14, v48);
v39 = (unsigned int)v14 | mysql_optionsv(a1, 28, a5, v34, v35, v36, a7, a8, a9, a10, v37, v38, a13, a14, v49);
return (v39 | (unsigned int)mysql_optionsv(a1, 29, v50, v40, v41, v42, a7, a8, a9, a10, v43, v44, a13, a14, (char)v50)) != 0;
}
|
mysql_ssl_set:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RBP + -0x40],R9
MOV qword ptr [RBP + -0x38],R8
MOV R12,RCX
MOV R13,RDX
MOV RBX,RSI
MOV R14,RDI
LEA RDX,[RBP + -0x29]
MOV byte ptr [RDX],0x1
MOV ESI,0x26
XOR EAX,EAX
CALL 0x0011b6ee
MOV R15D,EAX
MOV RDI,R14
MOV ESI,0x19
MOV RDX,RBX
XOR EAX,EAX
CALL 0x0011b6ee
MOV EBX,EAX
OR EBX,R15D
MOV RDI,R14
MOV ESI,0x1a
MOV RDX,R13
XOR EAX,EAX
CALL 0x0011b6ee
MOV R15D,EAX
MOV RDI,R14
MOV ESI,0x1b
MOV RDX,R12
XOR EAX,EAX
CALL 0x0011b6ee
MOV R12D,EAX
OR R12D,R15D
OR R12D,EBX
MOV RDI,R14
MOV ESI,0x1c
MOV RDX,qword ptr [RBP + -0x38]
XOR EAX,EAX
CALL 0x0011b6ee
MOV EBX,EAX
OR EBX,R12D
MOV RDI,R14
MOV ESI,0x1d
MOV RDX,qword ptr [RBP + -0x40]
XOR EAX,EAX
CALL 0x0011b6ee
XOR ECX,ECX
OR EAX,EBX
SETNZ CL
MOV EAX,ECX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
bool mysql_ssl_set(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
iVar1 = mysql_optionsv(param_1,0x26);
iVar2 = mysql_optionsv(param_1,0x19,param_2);
iVar3 = mysql_optionsv(param_1,0x1a,param_3);
iVar4 = mysql_optionsv(param_1,0x1b,param_4);
iVar5 = mysql_optionsv(param_1,0x1c,param_5);
iVar6 = mysql_optionsv(param_1,0x1d,param_6);
return iVar6 != 0 || (iVar5 != 0 || ((iVar4 != 0 || iVar3 != 0) || (iVar2 != 0 || iVar1 != 0)));
}
|
|
66,037 |
memcpy
|
seiftnesse[P]memoryallocator/src/custom_alloc_util.c
|
void *_memcpy(void *dest, const void *src, size_t bytes) {
if (!dest || !src || bytes == 0) {
HEAP_LOG("Invalid memcpy parameters: dest=%p, src=%p, bytes=%zu\n", dest, src, bytes);
return dest;
}
// Use 64-bit copies for aligned data when possible
size_t i = 0;
if (!(((uintptr_t) dest | (uintptr_t) src | bytes) & 7)) {
size_t qwords = bytes >> 3;
uint64_t *qdest = (uint64_t *) dest;
const uint64_t *qsrc = (const uint64_t *) src;
for (i = 0; i < qwords; ++i) {
*qdest++ = *qsrc++;
}
i = qwords << 3;
HEAP_LOG("Used optimized 64-bit copy for %zu qwords\n", qwords);
}
// Copy remaining bytes
char *cdest = (char *) dest + i;
const char *csrc = (char *) src + i;
for (; i < bytes; ++i) {
*cdest++ = *csrc++;
}
HEAP_LOG("Memory copied: %zu bytes from %p to %p\n", bytes, src, dest);
return dest;
}
|
O1
|
c
|
memcpy:
movq %rdi, %rax
testq %rdi, %rdi
sete %cl
testq %rsi, %rsi
sete %dil
orb %cl, %dil
testq %rdx, %rdx
sete %cl
orb %dil, %cl
jne 0x11ce9
movl %esi, %ecx
orl %eax, %ecx
movl %edx, %edi
orl %ecx, %edi
testb $0x7, %dil
je 0x11cae
xorl %ecx, %ecx
jmp 0x11cd4
cmpq $0x8, %rdx
jb 0x11ccd
movq %rdx, %rcx
shrq $0x3, %rcx
xorl %edi, %edi
movq (%rsi,%rdi,8), %r8
movq %r8, (%rax,%rdi,8)
incq %rdi
cmpq %rdi, %rcx
jne 0x11cbd
movq %rdx, %rcx
andq $-0x8, %rcx
cmpq %rdx, %rcx
jae 0x11ce9
movb (%rsi,%rcx), %dil
movb %dil, (%rax,%rcx)
incq %rcx
cmpq %rcx, %rdx
jne 0x11cd9
retq
|
_memcpy:
mov rax, rdi
test rdi, rdi
setz cl
test rsi, rsi
setz dil
or dil, cl
test rdx, rdx
setz cl
or cl, dil
jnz short locret_11CE9
mov ecx, esi
or ecx, eax
mov edi, edx
or edi, ecx
test dil, 7
jz short loc_11CAE
xor ecx, ecx
jmp short loc_11CD4
loc_11CAE:
cmp rdx, 8
jb short loc_11CCD
mov rcx, rdx
shr rcx, 3
xor edi, edi
loc_11CBD:
mov r8, [rsi+rdi*8]
mov [rax+rdi*8], r8
inc rdi
cmp rcx, rdi
jnz short loc_11CBD
loc_11CCD:
mov rcx, rdx
and rcx, 0FFFFFFFFFFFFFFF8h
loc_11CD4:
cmp rcx, rdx
jnb short locret_11CE9
loc_11CD9:
mov dil, [rsi+rcx]
mov [rax+rcx], dil
inc rcx
cmp rdx, rcx
jnz short loc_11CD9
locret_11CE9:
retn
|
long long memcpy(long long a1, long long a2, unsigned long long a3)
{
long long result; // rax
unsigned long long v4; // rcx
long long v5; // rdi
result = a1;
if ( a1 != 0 && a2 != 0 && a3 != 0 )
{
if ( (((unsigned __int8)(a1 | a2) | (unsigned __int8)a3) & 7) != 0 )
{
v4 = 0LL;
}
else
{
if ( a3 >= 8 )
{
v5 = 0LL;
do
{
*(_QWORD *)(result + 8 * v5) = *(_QWORD *)(a2 + 8 * v5);
++v5;
}
while ( a3 >> 3 != v5 );
}
v4 = a3 & 0xFFFFFFFFFFFFFFF8LL;
}
if ( v4 < a3 )
{
do
{
*(_BYTE *)(result + v4) = *(_BYTE *)(a2 + v4);
++v4;
}
while ( a3 != v4 );
}
}
return result;
}
|
_memcpy:
MOV RAX,RDI
TEST RDI,RDI
SETZ CL
TEST RSI,RSI
SETZ DIL
OR DIL,CL
TEST RDX,RDX
SETZ CL
OR CL,DIL
JNZ 0x00111ce9
MOV ECX,ESI
OR ECX,EAX
MOV EDI,EDX
OR EDI,ECX
TEST DIL,0x7
JZ 0x00111cae
XOR ECX,ECX
JMP 0x00111cd4
LAB_00111cae:
CMP RDX,0x8
JC 0x00111ccd
MOV RCX,RDX
SHR RCX,0x3
XOR EDI,EDI
LAB_00111cbd:
MOV R8,qword ptr [RSI + RDI*0x8]
MOV qword ptr [RAX + RDI*0x8],R8
INC RDI
CMP RCX,RDI
JNZ 0x00111cbd
LAB_00111ccd:
MOV RCX,RDX
AND RCX,-0x8
LAB_00111cd4:
CMP RCX,RDX
JNC 0x00111ce9
LAB_00111cd9:
MOV DIL,byte ptr [RSI + RCX*0x1]
MOV byte ptr [RAX + RCX*0x1],DIL
INC RCX
CMP RDX,RCX
JNZ 0x00111cd9
LAB_00111ce9:
RET
|
void _memcpy(long param_1,long param_2,ulong param_3)
{
ulong uVar1;
if (param_3 != 0 && (param_2 != 0 && param_1 != 0)) {
if ((((uint)param_3 | (uint)param_2 | (uint)param_1) & 7) == 0) {
if (7 < param_3) {
uVar1 = 0;
do {
*(int8 *)(param_1 + uVar1 * 8) = *(int8 *)(param_2 + uVar1 * 8);
uVar1 = uVar1 + 1;
} while (param_3 >> 3 != uVar1);
}
uVar1 = param_3 & 0xfffffffffffffff8;
}
else {
uVar1 = 0;
}
if (uVar1 < param_3) {
do {
*(int1 *)(param_1 + uVar1) = *(int1 *)(param_2 + uVar1);
uVar1 = uVar1 + 1;
} while (param_3 != uVar1);
}
}
return;
}
|
|
66,038 |
nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::parser(nlohmann::json_abi_v3_11_3::detail::input_stream_adapter&&, std::function<bool (int, nlohmann::json_abi_v3_11_3::detail::parse_event_t, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&)>, bool, bool)
|
llama.cpp/common/json.hpp
|
explicit parser(InputAdapterType&& adapter,
const parser_callback_t<BasicJsonType> cb = nullptr,
const bool allow_exceptions_ = true,
const bool skip_comments = false)
: callback(cb)
, m_lexer(std::move(adapter), skip_comments)
, allow_exceptions(allow_exceptions_)
{
// read first token
get_token();
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::parser(nlohmann::json_abi_v3_11_3::detail::input_stream_adapter&&, std::function<bool (int, nlohmann::json_abi_v3_11_3::detail::parse_event_t, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&)>, bool, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %r15d
movl %ecx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x74486
movl $0x0, 0x20(%rbx)
leaq 0x28(%rbx), %r14
movups (%r12), %xmm0
movups %xmm0, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movb %r15b, 0x38(%rbx)
movl $0xffffffff, 0x3c(%rbx) # imm = 0xFFFFFFFF
xorl %eax, %eax
movb %al, 0x40(%rbx)
leaq 0x88(%rbx), %rcx
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
movq %rcx, 0x78(%rbx)
movq %rax, 0x80(%rbx)
movb %al, 0x88(%rbx)
leaq 0xab42b(%rip), %rcx # 0x11f841
movq %rcx, 0x98(%rbx)
movups %xmm0, 0xa0(%rbx)
movq %rax, 0xb0(%rbx)
callq 0x7451e
movsbl %al, %eax
movl %eax, 0xb8(%rbx)
movb %bpl, 0xc0(%rbx)
movq %r14, %rdi
callq 0x74562
movl %eax, 0x20(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x744e4
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x74475
movq %rbx, %rdi
movq %rbx, %rsi
movl $0x3, %edx
callq *%rax
movq %r15, %rdi
callq 0x20ae0
movq %rax, %rdi
callq 0x2868d
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEEC2EOSG_St8functionIFbiNS1_13parse_event_tERSF_EEbb:
push rbp
push r15
push r14
push r12
push rbx
mov r15d, r8d
mov ebp, ecx
mov r12, rsi
mov rbx, rdi
mov rsi, rdx
call _ZNSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEC2ERKSJ_; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)>::function(std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)> const&)
mov dword ptr [rbx+20h], 0
lea r14, [rbx+28h]
movups xmm0, xmmword ptr [r12]
movups xmmword ptr [rbx+28h], xmm0
xorps xmm0, xmm0
movups xmmword ptr [r12], xmm0
mov [rbx+38h], r15b
mov dword ptr [rbx+3Ch], 0FFFFFFFFh
xor eax, eax
mov [rbx+40h], al
lea rcx, [rbx+88h]
movups xmmword ptr [rbx+48h], xmm0
movups xmmword ptr [rbx+58h], xmm0
movups xmmword ptr [rbx+68h], xmm0
mov [rbx+78h], rcx
mov [rbx+80h], rax
mov [rbx+88h], al
lea rcx, aExampleToolCal+1Dh; ""
mov [rbx+98h], rcx
movups xmmword ptr [rbx+0A0h], xmm0
mov [rbx+0B0h], rax
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE17get_decimal_pointEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::get_decimal_point(void)
movsx eax, al
mov [rbx+0B8h], eax
mov [rbx+0C0h], bpl
mov rdi, r14; this
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE4scanEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::scan(void)
mov [rbx+20h], eax
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
mov r15, rax
mov rdi, r14; this
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEED2Ev; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::~lexer()
mov rax, [rbx+10h]
test rax, rax
jz short loc_74475
mov rdi, rbx
mov rsi, rbx
mov edx, 3
call rax
loc_74475:
mov rdi, r15
call __Unwind_Resume
mov rdi, rax
call __clang_call_terminate
|
long long nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::parser(
long long a1,
_OWORD *a2,
long long a3,
char a4,
char a5)
{
long long result; // rax
std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &)>::function(
a1,
a3);
*(_DWORD *)(a1 + 32) = 0;
*(_OWORD *)(a1 + 40) = *a2;
*a2 = 0LL;
*(_BYTE *)(a1 + 56) = a5;
*(_DWORD *)(a1 + 60) = -1;
*(_BYTE *)(a1 + 64) = 0;
*(_OWORD *)(a1 + 72) = 0LL;
*(_OWORD *)(a1 + 88) = 0LL;
*(_OWORD *)(a1 + 104) = 0LL;
*(_QWORD *)(a1 + 120) = a1 + 136;
*(_QWORD *)(a1 + 128) = 0LL;
*(_BYTE *)(a1 + 136) = 0;
*(_QWORD *)(a1 + 152) = "";
*(_OWORD *)(a1 + 160) = 0LL;
*(_QWORD *)(a1 + 176) = 0LL;
*(_DWORD *)(a1 + 184) = (char)nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::get_decimal_point();
*(_BYTE *)(a1 + 192) = a4;
result = nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::scan((nlohmann::json_abi_v3_11_3::detail::input_stream_adapter *)(a1 + 40));
*(_DWORD *)(a1 + 32) = result;
return result;
}
|
parser:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R15D,R8D
MOV EBP,ECX
MOV R12,RSI
MOV RBX,RDI
MOV RSI,RDX
CALL 0x00174486
MOV dword ptr [RBX + 0x20],0x0
LEA R14,[RBX + 0x28]
MOVUPS XMM0,xmmword ptr [R12]
MOVUPS xmmword ptr [RBX + 0x28],XMM0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R12],XMM0
MOV byte ptr [RBX + 0x38],R15B
MOV dword ptr [RBX + 0x3c],0xffffffff
XOR EAX,EAX
MOV byte ptr [RBX + 0x40],AL
LEA RCX,[RBX + 0x88]
MOVUPS xmmword ptr [RBX + 0x48],XMM0
MOVUPS xmmword ptr [RBX + 0x58],XMM0
MOVUPS xmmword ptr [RBX + 0x68],XMM0
MOV qword ptr [RBX + 0x78],RCX
MOV qword ptr [RBX + 0x80],RAX
MOV byte ptr [RBX + 0x88],AL
LEA RCX,[0x21f841]
MOV qword ptr [RBX + 0x98],RCX
MOVUPS xmmword ptr [RBX + 0xa0],XMM0
MOV qword ptr [RBX + 0xb0],RAX
CALL 0x0017451e
MOVSX EAX,AL
MOV dword ptr [RBX + 0xb8],EAX
MOV byte ptr [RBX + 0xc0],BPL
LAB_00174440:
MOV RDI,R14
CALL 0x00174562
MOV dword ptr [RBX + 0x20],EAX
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::parser(nlohmann::json_abi_v3_11_3::detail::input_stream_adapter&&,
std::function<bool (int, nlohmann::json_abi_v3_11_3::detail::parse_event_t,
nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::string, bool, long,
unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer,
std::vector<unsigned char, std::allocator<unsigned char> >, void>&)>, bool, bool) */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
::parser(parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
*this,int8 *param_1,function *param_3,
parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
param_4,parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
param_5)
{
int8 uVar1;
char cVar2;
int4 uVar3;
std::
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
::function((function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
*)this,param_3);
*(int4 *)(this + 0x20) = 0;
uVar1 = param_1[1];
*(int8 *)(this + 0x28) = *param_1;
*(int8 *)(this + 0x30) = uVar1;
*param_1 = 0;
param_1[1] = 0;
this[0x38] = param_5;
*(int4 *)(this + 0x3c) = 0xffffffff;
this[0x40] = (parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
)0x0;
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 0x50) = 0;
*(int8 *)(this + 0x58) = 0;
*(int8 *)(this + 0x60) = 0;
*(int8 *)(this + 0x68) = 0;
*(int8 *)(this + 0x70) = 0;
*(parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
**)(this + 0x78) = this + 0x88;
*(int8 *)(this + 0x80) = 0;
this[0x88] = (parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
)0x0;
*(char **)(this + 0x98) = "";
*(int8 *)(this + 0xa0) = 0;
*(int8 *)(this + 0xa8) = 0;
*(int8 *)(this + 0xb0) = 0;
cVar2 = lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
::get_decimal_point();
*(int *)(this + 0xb8) = (int)cVar2;
this[0xc0] = param_4;
/* try { // try from 00174440 to 00174447 has its CatchHandler @ 00174454 */
uVar3 = lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
::scan((lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
*)(this + 0x28));
*(int4 *)(this + 0x20) = uVar3;
return;
}
|
|
66,039 |
rb_delete_fixup
|
eloqsql/mysys/tree.c
|
static void rb_delete_fixup(TREE *tree, TREE_ELEMENT ***parent)
{
TREE_ELEMENT *x,*w,*par;
x= **parent;
while (x != tree->root && x->colour == BLACK)
{
if (x == (par=parent[-1][0])->left)
{
w=par->right;
if (w->colour == RED)
{
w->colour=BLACK;
par->colour=RED;
left_rotate(parent[-1],par);
parent[0]= &w->left;
*++parent= &par->left;
w=par->right;
}
if (w->left->colour == BLACK && w->right->colour == BLACK)
{
w->colour=RED;
x=par;
parent--;
}
else
{
if (w->right->colour == BLACK)
{
w->left->colour=BLACK;
w->colour=RED;
right_rotate(&par->right,w);
w=par->right;
}
w->colour=par->colour;
par->colour=BLACK;
w->right->colour=BLACK;
left_rotate(parent[-1],par);
x=tree->root;
break;
}
}
else
{
w=par->left;
if (w->colour == RED)
{
w->colour=BLACK;
par->colour=RED;
right_rotate(parent[-1],par);
parent[0]= &w->right;
*++parent= &par->right;
w=par->left;
}
if (w->right->colour == BLACK && w->left->colour == BLACK)
{
w->colour=RED;
x=par;
parent--;
}
else
{
if (w->left->colour == BLACK)
{
w->right->colour=BLACK;
w->colour=RED;
left_rotate(&par->left,w);
w=par->left;
}
w->colour=par->colour;
par->colour=BLACK;
w->left->colour=BLACK;
right_rotate(parent[-1],par);
x=tree->root;
break;
}
}
}
x->colour=BLACK;
}
|
O0
|
c
|
rb_delete_fixup:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rdx
xorl %eax, %eax
cmpq (%rdx), %rcx
movb %al, -0x29(%rbp)
je 0xc5603
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
shrl $0x1f, %eax
cmpl $0x1, %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xc560f
jmp 0xc597a
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq -0x8(%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, -0x28(%rbp)
cmpq (%rcx), %rax
jne 0xc57d3
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
jne 0xc56ae
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x0, %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0xc65b0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x10(%rbp)
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %eax
shrl $0x1f, %eax
cmpl $0x1, %eax
jne 0xc56ff
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %eax
shrl $0x1f, %eax
cmpl $0x1, %eax
jne 0xc56ff
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x0, %ecx
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0xc57ce
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %eax
shrl $0x1f, %eax
cmpl $0x1, %eax
jne 0xc575b
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x0, %ecx
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
callq 0xc65f0
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movl 0x10(%rax), %edx
shrl $0x1f, %edx
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x1, %edx
shll $0x1f, %edx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl %edx, %ecx
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0xc65b0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xc597a
jmp 0xc5975
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
jne 0xc585c
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x0, %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0xc65f0
movq -0x20(%rbp), %rcx
addq $0x8, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
addq $0x8, %rcx
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x10(%rbp)
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %eax
shrl $0x1f, %eax
cmpl $0x1, %eax
jne 0xc58ad
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %eax
shrl $0x1f, %eax
cmpl $0x1, %eax
jne 0xc58ad
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x0, %ecx
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0xc5973
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %eax
shrl $0x1f, %eax
cmpl $0x1, %eax
jne 0xc5904
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x0, %ecx
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xc65b0
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movl 0x10(%rax), %edx
shrl $0x1f, %edx
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x1, %edx
shll $0x1f, %edx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl %edx, %ecx
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0xc65f0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xc597a
jmp 0xc5975
jmp 0xc55de
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
rb_delete_fixup:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax]
mov [rbp+var_18], rax
loc_C55DE:
mov rcx, [rbp+var_18]
mov rdx, [rbp+var_8]
xor eax, eax
cmp rcx, [rdx]
mov [rbp+var_29], al
jz short loc_C5603
mov rax, [rbp+var_18]
mov eax, [rax+10h]
shr eax, 1Fh
cmp eax, 1
setz al
mov [rbp+var_29], al
loc_C5603:
mov al, [rbp+var_29]
test al, 1
jnz short loc_C560F
jmp loc_C597A
loc_C560F:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
mov rcx, [rcx-8]
mov rcx, [rcx]
mov [rbp+var_28], rcx
cmp rax, [rcx]
jnz loc_C57D3
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov eax, [rax+10h]
shr eax, 1Fh
cmp eax, 0
jnz short loc_C56AE
mov rax, [rbp+var_20]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
mov rax, [rbp+var_28]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 0
mov [rax+10h], ecx
mov rax, [rbp+var_10]
mov rdi, [rax-8]
mov rsi, [rbp+var_28]
call left_rotate
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rcx, [rbp+var_28]
mov rax, [rbp+var_10]
mov rdx, rax
add rdx, 8
mov [rbp+var_10], rdx
mov [rax+8], rcx
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov [rbp+var_20], rax
loc_C56AE:
mov rax, [rbp+var_20]
mov rax, [rax]
mov eax, [rax+10h]
shr eax, 1Fh
cmp eax, 1
jnz short loc_C56FF
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov eax, [rax+10h]
shr eax, 1Fh
cmp eax, 1
jnz short loc_C56FF
mov rax, [rbp+var_20]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 0
mov [rax+10h], ecx
mov rax, [rbp+var_28]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
add rax, 0FFFFFFFFFFFFFFF8h
mov [rbp+var_10], rax
jmp loc_C57CE
loc_C56FF:
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov eax, [rax+10h]
shr eax, 1Fh
cmp eax, 1
jnz short loc_C575B
mov rax, [rbp+var_20]
mov rax, [rax]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
mov rax, [rbp+var_20]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 0
mov [rax+10h], ecx
mov rdi, [rbp+var_28]
add rdi, 8
mov rsi, [rbp+var_20]
call right_rotate
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov [rbp+var_20], rax
loc_C575B:
mov rax, [rbp+var_28]
mov edx, [rax+10h]
shr edx, 1Fh
mov rax, [rbp+var_20]
mov ecx, [rax+10h]
and edx, 1
shl edx, 1Fh
and ecx, 7FFFFFFFh
or ecx, edx
mov [rax+10h], ecx
mov rax, [rbp+var_28]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
mov rax, [rbp+var_10]
mov rdi, [rax-8]
mov rsi, [rbp+var_28]
call left_rotate
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_18], rax
jmp loc_C597A
loc_C57CE:
jmp loc_C5975
loc_C57D3:
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov eax, [rax+10h]
shr eax, 1Fh
cmp eax, 0
jnz short loc_C585C
mov rax, [rbp+var_20]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
mov rax, [rbp+var_28]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 0
mov [rax+10h], ecx
mov rax, [rbp+var_10]
mov rdi, [rax-8]
mov rsi, [rbp+var_28]
call right_rotate
mov rcx, [rbp+var_20]
add rcx, 8
mov rax, [rbp+var_10]
mov [rax], rcx
mov rcx, [rbp+var_28]
add rcx, 8
mov rax, [rbp+var_10]
mov rdx, rax
add rdx, 8
mov [rbp+var_10], rdx
mov [rax+8], rcx
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_20], rax
loc_C585C:
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov eax, [rax+10h]
shr eax, 1Fh
cmp eax, 1
jnz short loc_C58AD
mov rax, [rbp+var_20]
mov rax, [rax]
mov eax, [rax+10h]
shr eax, 1Fh
cmp eax, 1
jnz short loc_C58AD
mov rax, [rbp+var_20]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 0
mov [rax+10h], ecx
mov rax, [rbp+var_28]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
add rax, 0FFFFFFFFFFFFFFF8h
mov [rbp+var_10], rax
jmp loc_C5973
loc_C58AD:
mov rax, [rbp+var_20]
mov rax, [rax]
mov eax, [rax+10h]
shr eax, 1Fh
cmp eax, 1
jnz short loc_C5904
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
mov rax, [rbp+var_20]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 0
mov [rax+10h], ecx
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_20]
call left_rotate
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_20], rax
loc_C5904:
mov rax, [rbp+var_28]
mov edx, [rax+10h]
shr edx, 1Fh
mov rax, [rbp+var_20]
mov ecx, [rax+10h]
and edx, 1
shl edx, 1Fh
and ecx, 7FFFFFFFh
or ecx, edx
mov [rax+10h], ecx
mov rax, [rbp+var_28]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
mov rax, [rbp+var_20]
mov rax, [rax]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
mov rax, [rbp+var_10]
mov rdi, [rax-8]
mov rsi, [rbp+var_28]
call right_rotate
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_18], rax
jmp short loc_C597A
loc_C5973:
jmp short $+2
loc_C5975:
jmp loc_C55DE
loc_C597A:
mov rax, [rbp+var_18]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
add rsp, 30h
pop rbp
retn
|
long long * rb_delete_fixup(long long **a1, _QWORD **a2)
{
_QWORD *v2; // rax
_QWORD *v3; // rax
long long *result; // rax
bool v5; // [rsp+7h] [rbp-29h]
long long *v6; // [rsp+8h] [rbp-28h]
long long v7; // [rsp+10h] [rbp-20h]
long long v8; // [rsp+10h] [rbp-20h]
long long *v9; // [rsp+18h] [rbp-18h]
_QWORD *v10; // [rsp+20h] [rbp-10h]
v10 = a2;
v9 = (long long *)**a2;
while ( 1 )
{
v5 = 0;
if ( v9 != *a1 )
v5 = *((_DWORD *)v9 + 4) >> 31 == 1;
if ( !v5 )
break;
v6 = *(long long **)*(v10 - 1);
if ( v9 == (long long *)*v6 )
{
v7 = v6[1];
if ( *(int *)(v7 + 16) >= 0 )
{
*(_DWORD *)(v7 + 16) = *(_DWORD *)(v7 + 16) & 0x7FFFFFFF | 0x80000000;
*((_DWORD *)v6 + 4) &= ~0x80000000;
left_rotate(*(v10 - 1), v6);
*v10 = v7;
v2 = v10++;
v2[1] = v6;
v7 = v6[1];
}
if ( *(_DWORD *)(*(_QWORD *)v7 + 16LL) >> 31 != 1 || *(_DWORD *)(*(_QWORD *)(v7 + 8) + 16LL) >> 31 != 1 )
{
if ( *(_DWORD *)(*(_QWORD *)(v7 + 8) + 16LL) >> 31 == 1 )
{
*(_DWORD *)(*(_QWORD *)v7 + 16LL) = *(_DWORD *)(*(_QWORD *)v7 + 16LL) & 0x7FFFFFFF | 0x80000000;
*(_DWORD *)(v7 + 16) &= ~0x80000000;
right_rotate(v6 + 1, v7);
v7 = v6[1];
}
*(_DWORD *)(v7 + 16) = (*((_DWORD *)v6 + 4) >> 31 << 31) | *(_DWORD *)(v7 + 16) & 0x7FFFFFFF;
*((_DWORD *)v6 + 4) = v6[2] & 0x7FFFFFFF | 0x80000000;
*(_DWORD *)(*(_QWORD *)(v7 + 8) + 16LL) = *(_DWORD *)(*(_QWORD *)(v7 + 8) + 16LL) & 0x7FFFFFFF | 0x80000000;
left_rotate(*(v10 - 1), v6);
v9 = *a1;
break;
}
*(_DWORD *)(v7 + 16) &= ~0x80000000;
v9 = v6;
--v10;
}
else
{
v8 = *v6;
if ( *(int *)(*v6 + 16) >= 0 )
{
*(_DWORD *)(v8 + 16) = *(_DWORD *)(v8 + 16) & 0x7FFFFFFF | 0x80000000;
*((_DWORD *)v6 + 4) &= ~0x80000000;
right_rotate(*(v10 - 1), v6);
*v10 = v8 + 8;
v3 = v10++;
v3[1] = v6 + 1;
v8 = *v6;
}
if ( *(_DWORD *)(*(_QWORD *)(v8 + 8) + 16LL) >> 31 != 1 || *(_DWORD *)(*(_QWORD *)v8 + 16LL) >> 31 != 1 )
{
if ( *(_DWORD *)(*(_QWORD *)v8 + 16LL) >> 31 == 1 )
{
*(_DWORD *)(*(_QWORD *)(v8 + 8) + 16LL) = *(_DWORD *)(*(_QWORD *)(v8 + 8) + 16LL) & 0x7FFFFFFF | 0x80000000;
*(_DWORD *)(v8 + 16) &= ~0x80000000;
left_rotate(v6, v8);
v8 = *v6;
}
*(_DWORD *)(v8 + 16) = (*((_DWORD *)v6 + 4) >> 31 << 31) | *(_DWORD *)(v8 + 16) & 0x7FFFFFFF;
*((_DWORD *)v6 + 4) = v6[2] & 0x7FFFFFFF | 0x80000000;
*(_DWORD *)(*(_QWORD *)v8 + 16LL) = *(_DWORD *)(*(_QWORD *)v8 + 16LL) & 0x7FFFFFFF | 0x80000000;
right_rotate(*(v10 - 1), v6);
v9 = *a1;
break;
}
*(_DWORD *)(v8 + 16) &= ~0x80000000;
v9 = v6;
--v10;
}
}
result = v9;
*((_DWORD *)v9 + 4) = v9[2] & 0x7FFFFFFF | 0x80000000;
return result;
}
|
rb_delete_fixup:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
LAB_001c55de:
MOV RCX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x8]
XOR EAX,EAX
CMP RCX,qword ptr [RDX]
MOV byte ptr [RBP + -0x29],AL
JZ 0x001c5603
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x10]
SHR EAX,0x1f
CMP EAX,0x1
SETZ AL
MOV byte ptr [RBP + -0x29],AL
LAB_001c5603:
MOV AL,byte ptr [RBP + -0x29]
TEST AL,0x1
JNZ 0x001c560f
JMP 0x001c597a
LAB_001c560f:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + -0x8]
MOV RCX,qword ptr [RCX]
MOV qword ptr [RBP + -0x28],RCX
CMP RAX,qword ptr [RCX]
JNZ 0x001c57d3
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x10]
SHR EAX,0x1f
CMP EAX,0x0
JNZ 0x001c56ae
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x0
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + -0x8]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x001c65b0
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RBP + -0x10],RDX
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x20],RAX
LAB_001c56ae:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x10]
SHR EAX,0x1f
CMP EAX,0x1
JNZ 0x001c56ff
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV EAX,dword ptr [RAX + 0x10]
SHR EAX,0x1f
CMP EAX,0x1
JNZ 0x001c56ff
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x0
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,-0x8
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001c57ce
LAB_001c56ff:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV EAX,dword ptr [RAX + 0x10]
SHR EAX,0x1f
CMP EAX,0x1
JNZ 0x001c575b
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x0
MOV dword ptr [RAX + 0x10],ECX
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x8
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x001c65f0
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x20],RAX
LAB_001c575b:
MOV RAX,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RAX + 0x10]
SHR EDX,0x1f
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x10]
AND EDX,0x1
SHL EDX,0x1f
AND ECX,0x7fffffff
OR ECX,EDX
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + -0x8]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x001c65b0
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001c597a
LAB_001c57ce:
JMP 0x001c5975
LAB_001c57d3:
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x10]
SHR EAX,0x1f
CMP EAX,0x0
JNZ 0x001c585c
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x0
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + -0x8]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x001c65f0
MOV RCX,qword ptr [RBP + -0x20]
ADD RCX,0x8
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x28]
ADD RCX,0x8
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RBP + -0x10],RDX
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
LAB_001c585c:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV EAX,dword ptr [RAX + 0x10]
SHR EAX,0x1f
CMP EAX,0x1
JNZ 0x001c58ad
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x10]
SHR EAX,0x1f
CMP EAX,0x1
JNZ 0x001c58ad
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x0
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,-0x8
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001c5973
LAB_001c58ad:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x10]
SHR EAX,0x1f
CMP EAX,0x1
JNZ 0x001c5904
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x0
MOV dword ptr [RAX + 0x10],ECX
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x001c65b0
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
LAB_001c5904:
MOV RAX,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RAX + 0x10]
SHR EDX,0x1f
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x10]
AND EDX,0x1
SHL EDX,0x1f
AND ECX,0x7fffffff
OR ECX,EDX
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + -0x8]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x001c65f0
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001c597a
LAB_001c5973:
JMP 0x001c5975
LAB_001c5975:
JMP 0x001c55de
LAB_001c597a:
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
ADD RSP,0x30
POP RBP
RET
|
void rb_delete_fixup(long *param_1,long *param_2)
{
long *plVar1;
bool bVar2;
long *local_28;
long *local_20;
long *local_18;
local_20 = *(long **)*param_2;
local_18 = param_2;
do {
bVar2 = false;
if (local_20 != (long *)*param_1) {
bVar2 = (int)local_20[2] < 0;
}
if (!bVar2) goto LAB_001c597a;
plVar1 = *(long **)local_18[-1];
if (local_20 == (long *)*plVar1) {
local_28 = (long *)plVar1[1];
if (-1 < (int)local_28[2]) {
*(uint *)(local_28 + 2) = *(uint *)(local_28 + 2) & 0x7fffffff | 0x80000000;
*(uint *)(plVar1 + 2) = *(uint *)(plVar1 + 2) & 0x7fffffff;
left_rotate(local_18[-1],plVar1);
*local_18 = (long)local_28;
local_18[1] = (long)plVar1;
local_28 = (long *)plVar1[1];
local_18 = local_18 + 1;
}
if ((-1 < *(int *)(*local_28 + 0x10)) || (-1 < *(int *)(local_28[1] + 0x10))) {
if (*(int *)(local_28[1] + 0x10) < 0) {
*(uint *)(*local_28 + 0x10) = *(uint *)(*local_28 + 0x10) & 0x7fffffff | 0x80000000;
*(uint *)(local_28 + 2) = *(uint *)(local_28 + 2) & 0x7fffffff;
right_rotate(plVar1 + 1,local_28);
local_28 = (long *)plVar1[1];
}
*(uint *)(local_28 + 2) =
*(uint *)(local_28 + 2) & 0x7fffffff | *(uint *)(plVar1 + 2) & 0x80000000;
*(uint *)(plVar1 + 2) = *(uint *)(plVar1 + 2) & 0x7fffffff | 0x80000000;
*(uint *)(local_28[1] + 0x10) = *(uint *)(local_28[1] + 0x10) & 0x7fffffff | 0x80000000;
left_rotate(local_18[-1],plVar1);
local_20 = (long *)*param_1;
LAB_001c597a:
*(uint *)(local_20 + 2) = *(uint *)(local_20 + 2) & 0x7fffffff | 0x80000000;
return;
}
*(uint *)(local_28 + 2) = *(uint *)(local_28 + 2) & 0x7fffffff;
}
else {
local_28 = (long *)*plVar1;
if (-1 < (int)local_28[2]) {
*(uint *)(local_28 + 2) = *(uint *)(local_28 + 2) & 0x7fffffff | 0x80000000;
*(uint *)(plVar1 + 2) = *(uint *)(plVar1 + 2) & 0x7fffffff;
right_rotate(local_18[-1],plVar1);
*local_18 = (long)(local_28 + 1);
local_18[1] = (long)(plVar1 + 1);
local_28 = (long *)*plVar1;
local_18 = local_18 + 1;
}
if ((-1 < *(int *)(local_28[1] + 0x10)) || (-1 < *(int *)(*local_28 + 0x10))) {
if (*(int *)(*local_28 + 0x10) < 0) {
*(uint *)(local_28[1] + 0x10) = *(uint *)(local_28[1] + 0x10) & 0x7fffffff | 0x80000000;
*(uint *)(local_28 + 2) = *(uint *)(local_28 + 2) & 0x7fffffff;
left_rotate(plVar1,local_28);
local_28 = (long *)*plVar1;
}
*(uint *)(local_28 + 2) =
*(uint *)(local_28 + 2) & 0x7fffffff | *(uint *)(plVar1 + 2) & 0x80000000;
*(uint *)(plVar1 + 2) = *(uint *)(plVar1 + 2) & 0x7fffffff | 0x80000000;
*(uint *)(*local_28 + 0x10) = *(uint *)(*local_28 + 0x10) & 0x7fffffff | 0x80000000;
right_rotate(local_18[-1],plVar1);
local_20 = (long *)*param_1;
goto LAB_001c597a;
}
*(uint *)(local_28 + 2) = *(uint *)(local_28 + 2) & 0x7fffffff;
}
local_18 = local_18 + -1;
local_20 = plVar1;
} while( true );
}
|
|
66,040 |
stbi__parse_huffman_block
|
dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-image.h
|
static int stbi__parse_huffman_block(stbi__zbuf *a)
{
char *zout = a->zout;
for(;;) {
int z = stbi__zhuffman_decode(a, &a->z_length);
if (z < 256) {
if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes
if (zout >= a->zout_end) {
if (!stbi__zexpand(a, zout, 1)) return 0;
zout = a->zout;
}
*zout++ = (char) z;
} else {
stbi_uc *p;
int len,dist;
if (z == 256) {
a->zout = zout;
if (a->hit_zeof_once && a->num_bits < 16) {
// The first time we hit zeof, we inserted 16 extra zero bits into our bit
// buffer so the decoder can just do its speculative decoding. But if we
// actually consumed any of those bits (which is the case when num_bits < 16),
// the stream actually read past the end so it is malformed.
return stbi__err("unexpected end","Corrupt PNG");
}
return 1;
}
if (z >= 286) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, length codes 286 and 287 must not appear in compressed data
z -= 257;
len = stbi__zlength_base[z];
if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]);
z = stbi__zhuffman_decode(a, &a->z_distance);
if (z < 0 || z >= 30) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, distance codes 30 and 31 must not appear in compressed data
dist = stbi__zdist_base[z];
if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]);
if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG");
if (len > a->zout_end - zout) {
if (!stbi__zexpand(a, zout, len)) return 0;
zout = a->zout;
}
p = (stbi_uc *) (zout - dist);
if (dist == 1) { // run of one byte; common in images.
stbi_uc v = *p;
if (len) { do *zout++ = v; while (--len); }
} else {
if (len) { do *zout++ = *p++; while (--len); }
}
}
}
}
|
O0
|
c
|
stbi__parse_huffman_block:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x3c, %rsi
callq 0x1cf00
movl %eax, -0x1c(%rbp)
cmpl $0x100, -0x1c(%rbp) # imm = 0x100
jge 0x1c9c7
cmpl $0x0, -0x1c(%rbp)
jge 0x1c96f
leaq 0x2151f(%rip), %rdi # 0x3de81
callq 0x15290
movl %eax, -0x4(%rbp)
jmp 0x1cbf2
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jb 0x1c9ac
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x1cd00
cmpl $0x0, %eax
jne 0x1c9a0
movl $0x0, -0x4(%rbp)
jmp 0x1cbf2
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
jmp 0x1cbed
cmpl $0x100, -0x1c(%rbp) # imm = 0x100
jne 0x1ca10
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x1ca04
movq -0x10(%rbp), %rax
cmpl $0x10, 0x10(%rax)
jge 0x1ca04
leaq 0x2149b(%rip), %rdi # 0x3de92
callq 0x15290
movl %eax, -0x4(%rbp)
jmp 0x1cbf2
movl $0x1, -0x4(%rbp)
jmp 0x1cbf2
cmpl $0x11e, -0x1c(%rbp) # imm = 0x11E
jl 0x1ca2d
leaq 0x21461(%rip), %rdi # 0x3de81
callq 0x15290
movl %eax, -0x4(%rbp)
jmp 0x1cbf2
movl -0x1c(%rbp), %eax
subl $0x101, %eax # imm = 0x101
movl %eax, -0x1c(%rbp)
movslq -0x1c(%rbp), %rcx
leaq 0x1f92d(%rip), %rax # 0x3c370
movl (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
movslq -0x1c(%rbp), %rcx
leaq 0x1f99c(%rip), %rax # 0x3c3f0
cmpl $0x0, (%rax,%rcx,4)
je 0x1ca77
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rcx
leaq 0x1f987(%rip), %rax # 0x3c3f0
movl (%rax,%rcx,4), %esi
callq 0x1c0a0
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x820, %rsi # imm = 0x820
callq 0x1cf00
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x1ca9a
cmpl $0x1e, -0x1c(%rbp)
jl 0x1caae
leaq 0x213e0(%rip), %rdi # 0x3de81
callq 0x15290
movl %eax, -0x4(%rbp)
jmp 0x1cbf2
movslq -0x1c(%rbp), %rcx
leaq 0x1f9b7(%rip), %rax # 0x3c470
movl (%rax,%rcx,4), %eax
movl %eax, -0x30(%rbp)
movslq -0x1c(%rbp), %rcx
leaq 0x1fa26(%rip), %rax # 0x3c4f0
cmpl $0x0, (%rax,%rcx,4)
je 0x1caed
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rcx
leaq 0x1fa11(%rip), %rax # 0x3c4f0
movl (%rax,%rcx,4), %esi
callq 0x1c0a0
addl -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq %rcx, %rax
movslq -0x30(%rbp), %rcx
cmpq %rcx, %rax
jge 0x1cb19
leaq 0x21395(%rip), %rdi # 0x3dea1
callq 0x15290
movl %eax, -0x4(%rbp)
jmp 0x1cbf2
movslq -0x2c(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq -0x18(%rbp), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jle 0x1cb5e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x1cd00
cmpl $0x0, %eax
jne 0x1cb52
movl $0x0, -0x4(%rbp)
jmp 0x1cbf2
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
cmpl $0x1, -0x30(%rbp)
jne 0x1cbaf
movq -0x28(%rbp), %rax
movb (%rax), %al
movb %al, -0x31(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x1cbad
jmp 0x1cb89
movb -0x31(%rbp), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0x1cb89
jmp 0x1cbad
jmp 0x1cbeb
cmpl $0x0, -0x2c(%rbp)
je 0x1cbe9
jmp 0x1cbb7
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb (%rax), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0x1cbb7
jmp 0x1cbe9
jmp 0x1cbeb
jmp 0x1cbed
jmp 0x1c938
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
stbi__parse_huffman_block:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov rax, [rax+20h]
mov [rbp+var_18], rax
loc_1C938:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_10]
add rsi, 3Ch ; '<'
call stbi__zhuffman_decode
mov [rbp+var_1C], eax
cmp [rbp+var_1C], 100h
jge short loc_1C9C7
cmp [rbp+var_1C], 0
jge short loc_1C96F
lea rdi, aBadHuffmanCode; "bad huffman code"
call stbi__err
mov [rbp+var_4], eax
jmp loc_1CBF2
loc_1C96F:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
cmp rax, [rcx+30h]
jb short loc_1C9AC
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, 1
call stbi__zexpand
cmp eax, 0
jnz short loc_1C9A0
mov [rbp+var_4], 0
jmp loc_1CBF2
loc_1C9A0:
mov rax, [rbp+var_10]
mov rax, [rax+20h]
mov [rbp+var_18], rax
loc_1C9AC:
mov eax, [rbp+var_1C]
mov cl, al
mov rax, [rbp+var_18]
mov rdx, rax
add rdx, 1
mov [rbp+var_18], rdx
mov [rax], cl
jmp loc_1CBED
loc_1C9C7:
cmp [rbp+var_1C], 100h
jnz short loc_1CA10
mov rcx, [rbp+var_18]
mov rax, [rbp+var_10]
mov [rax+20h], rcx
mov rax, [rbp+var_10]
cmp dword ptr [rax+14h], 0
jz short loc_1CA04
mov rax, [rbp+var_10]
cmp dword ptr [rax+10h], 10h
jge short loc_1CA04
lea rdi, aUnexpectedEnd; "unexpected end"
call stbi__err
mov [rbp+var_4], eax
jmp loc_1CBF2
loc_1CA04:
mov [rbp+var_4], 1
jmp loc_1CBF2
loc_1CA10:
cmp [rbp+var_1C], 11Eh
jl short loc_1CA2D
lea rdi, aBadHuffmanCode; "bad huffman code"
call stbi__err
mov [rbp+var_4], eax
jmp loc_1CBF2
loc_1CA2D:
mov eax, [rbp+var_1C]
sub eax, 101h
mov [rbp+var_1C], eax
movsxd rcx, [rbp+var_1C]
lea rax, stbi__zlength_base
mov eax, [rax+rcx*4]
mov [rbp+var_2C], eax
movsxd rcx, [rbp+var_1C]
lea rax, stbi__zlength_extra
cmp dword ptr [rax+rcx*4], 0
jz short loc_1CA77
mov rdi, [rbp+var_10]
movsxd rcx, [rbp+var_1C]
lea rax, stbi__zlength_extra
mov esi, [rax+rcx*4]
call stbi__zreceive
add eax, [rbp+var_2C]
mov [rbp+var_2C], eax
loc_1CA77:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_10]
add rsi, 820h
call stbi__zhuffman_decode
mov [rbp+var_1C], eax
cmp [rbp+var_1C], 0
jl short loc_1CA9A
cmp [rbp+var_1C], 1Eh
jl short loc_1CAAE
loc_1CA9A:
lea rdi, aBadHuffmanCode; "bad huffman code"
call stbi__err
mov [rbp+var_4], eax
jmp loc_1CBF2
loc_1CAAE:
movsxd rcx, [rbp+var_1C]
lea rax, stbi__zdist_base
mov eax, [rax+rcx*4]
mov [rbp+var_30], eax
movsxd rcx, [rbp+var_1C]
lea rax, stbi__zdist_extra
cmp dword ptr [rax+rcx*4], 0
jz short loc_1CAED
mov rdi, [rbp+var_10]
movsxd rcx, [rbp+var_1C]
lea rax, stbi__zdist_extra
mov esi, [rax+rcx*4]
call stbi__zreceive
add eax, [rbp+var_30]
mov [rbp+var_30], eax
loc_1CAED:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
mov rcx, [rcx+28h]
sub rax, rcx
movsxd rcx, [rbp+var_30]
cmp rax, rcx
jge short loc_1CB19
lea rdi, aBadDist; "bad dist"
call stbi__err
mov [rbp+var_4], eax
jmp loc_1CBF2
loc_1CB19:
movsxd rax, [rbp+var_2C]
mov rcx, [rbp+var_10]
mov rcx, [rcx+30h]
mov rdx, [rbp+var_18]
sub rcx, rdx
cmp rax, rcx
jle short loc_1CB5E
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_2C]
call stbi__zexpand
cmp eax, 0
jnz short loc_1CB52
mov [rbp+var_4], 0
jmp loc_1CBF2
loc_1CB52:
mov rax, [rbp+var_10]
mov rax, [rax+20h]
mov [rbp+var_18], rax
loc_1CB5E:
mov rax, [rbp+var_18]
movsxd rdx, [rbp+var_30]
xor ecx, ecx
sub rcx, rdx
add rax, rcx
mov [rbp+var_28], rax
cmp [rbp+var_30], 1
jnz short loc_1CBAF
mov rax, [rbp+var_28]
mov al, [rax]
mov [rbp+var_31], al
cmp [rbp+var_2C], 0
jz short loc_1CBAD
jmp short $+2
loc_1CB89:
mov cl, [rbp+var_31]
mov rax, [rbp+var_18]
mov rdx, rax
add rdx, 1
mov [rbp+var_18], rdx
mov [rax], cl
mov eax, [rbp+var_2C]
add eax, 0FFFFFFFFh
mov [rbp+var_2C], eax
cmp eax, 0
jnz short loc_1CB89
jmp short $+2
loc_1CBAD:
jmp short loc_1CBEB
loc_1CBAF:
cmp [rbp+var_2C], 0
jz short loc_1CBE9
jmp short $+2
loc_1CBB7:
mov rax, [rbp+var_28]
mov rcx, rax
add rcx, 1
mov [rbp+var_28], rcx
mov cl, [rax]
mov rax, [rbp+var_18]
mov rdx, rax
add rdx, 1
mov [rbp+var_18], rdx
mov [rax], cl
mov eax, [rbp+var_2C]
add eax, 0FFFFFFFFh
mov [rbp+var_2C], eax
cmp eax, 0
jnz short loc_1CBB7
jmp short $+2
loc_1CBE9:
jmp short $+2
loc_1CBEB:
jmp short $+2
loc_1CBED:
jmp loc_1C938
loc_1CBF2:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
|
long long stbi__parse_huffman_block(long long a1)
{
_BYTE *v1; // rax
_BYTE *v2; // rax
char *v3; // rax
char v4; // cl
_BYTE *v5; // rax
char i; // [rsp+Fh] [rbp-31h]
int v8; // [rsp+10h] [rbp-30h]
unsigned int v9; // [rsp+14h] [rbp-2Ch]
char *v10; // [rsp+18h] [rbp-28h]
int v11; // [rsp+24h] [rbp-1Ch]
int v12; // [rsp+24h] [rbp-1Ch]
signed int v13; // [rsp+24h] [rbp-1Ch]
_BYTE *v14; // [rsp+28h] [rbp-18h]
v14 = *(_BYTE **)(a1 + 32);
while ( 1 )
{
while ( 1 )
{
v11 = stbi__zhuffman_decode(a1, a1 + 60);
if ( v11 >= 256 )
break;
if ( v11 < 0 )
return (unsigned int)stbi__err((long long)"bad huffman code");
if ( (unsigned long long)v14 >= *(_QWORD *)(a1 + 48) )
{
if ( !(unsigned int)stbi__zexpand(a1, v14, 1LL) )
return 0;
v14 = *(_BYTE **)(a1 + 32);
}
v1 = v14++;
*v1 = v11;
}
if ( v11 == 256 )
break;
if ( v11 >= 286 )
return (unsigned int)stbi__err((long long)"bad huffman code");
v12 = v11 - 257;
v9 = stbi__zlength_base[v12];
if ( stbi__zlength_extra[v12] )
v9 += stbi__zreceive(a1, stbi__zlength_extra[v12]);
v13 = stbi__zhuffman_decode(a1, a1 + 2080);
if ( (unsigned int)v13 >= 0x1E )
return (unsigned int)stbi__err((long long)"bad huffman code");
v8 = stbi__zdist_base[v13];
if ( stbi__zdist_extra[v13] )
v8 += stbi__zreceive(a1, stbi__zdist_extra[v13]);
if ( (long long)&v14[-*(_QWORD *)(a1 + 40)] < v8 )
return (unsigned int)stbi__err((long long)"bad dist");
if ( (int)v9 > *(_QWORD *)(a1 + 48) - (_QWORD)v14 )
{
if ( !(unsigned int)stbi__zexpand(a1, v14, v9) )
return 0;
v14 = *(_BYTE **)(a1 + 32);
}
v10 = &v14[-v8];
if ( v8 == 1 )
{
for ( i = *v10; v9; --v9 )
{
v2 = v14++;
*v2 = i;
}
}
else
{
for ( ; v9; --v9 )
{
v3 = v10++;
v4 = *v3;
v5 = v14++;
*v5 = v4;
}
}
}
*(_QWORD *)(a1 + 32) = v14;
if ( *(_DWORD *)(a1 + 20) && *(int *)(a1 + 16) < 16 )
return (unsigned int)stbi__err((long long)"unexpected end");
else
return 1;
}
|
stbi__parse_huffman_block:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RBP + -0x18],RAX
LAB_0011c938:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x3c
CALL 0x0011cf00
MOV dword ptr [RBP + -0x1c],EAX
CMP dword ptr [RBP + -0x1c],0x100
JGE 0x0011c9c7
CMP dword ptr [RBP + -0x1c],0x0
JGE 0x0011c96f
LEA RDI,[0x13de81]
CALL 0x00115290
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0011cbf2
LAB_0011c96f:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x30]
JC 0x0011c9ac
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,0x1
CALL 0x0011cd00
CMP EAX,0x0
JNZ 0x0011c9a0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0011cbf2
LAB_0011c9a0:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RBP + -0x18],RAX
LAB_0011c9ac:
MOV EAX,dword ptr [RBP + -0x1c]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
MOV byte ptr [RAX],CL
JMP 0x0011cbed
LAB_0011c9c7:
CMP dword ptr [RBP + -0x1c],0x100
JNZ 0x0011ca10
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x20],RCX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x14],0x0
JZ 0x0011ca04
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x10],0x10
JGE 0x0011ca04
LEA RDI,[0x13de92]
CALL 0x00115290
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0011cbf2
LAB_0011ca04:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0011cbf2
LAB_0011ca10:
CMP dword ptr [RBP + -0x1c],0x11e
JL 0x0011ca2d
LEA RDI,[0x13de81]
CALL 0x00115290
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0011cbf2
LAB_0011ca2d:
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x101
MOV dword ptr [RBP + -0x1c],EAX
MOVSXD RCX,dword ptr [RBP + -0x1c]
LEA RAX,[0x13c370]
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV dword ptr [RBP + -0x2c],EAX
MOVSXD RCX,dword ptr [RBP + -0x1c]
LEA RAX,[0x13c3f0]
CMP dword ptr [RAX + RCX*0x4],0x0
JZ 0x0011ca77
MOV RDI,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x1c]
LEA RAX,[0x13c3f0]
MOV ESI,dword ptr [RAX + RCX*0x4]
CALL 0x0011c0a0
ADD EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x2c],EAX
LAB_0011ca77:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x820
CALL 0x0011cf00
MOV dword ptr [RBP + -0x1c],EAX
CMP dword ptr [RBP + -0x1c],0x0
JL 0x0011ca9a
CMP dword ptr [RBP + -0x1c],0x1e
JL 0x0011caae
LAB_0011ca9a:
LEA RDI,[0x13de81]
CALL 0x00115290
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0011cbf2
LAB_0011caae:
MOVSXD RCX,dword ptr [RBP + -0x1c]
LEA RAX,[0x13c470]
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV dword ptr [RBP + -0x30],EAX
MOVSXD RCX,dword ptr [RBP + -0x1c]
LEA RAX,[0x13c4f0]
CMP dword ptr [RAX + RCX*0x4],0x0
JZ 0x0011caed
MOV RDI,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x1c]
LEA RAX,[0x13c4f0]
MOV ESI,dword ptr [RAX + RCX*0x4]
CALL 0x0011c0a0
ADD EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x30],EAX
LAB_0011caed:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x28]
SUB RAX,RCX
MOVSXD RCX,dword ptr [RBP + -0x30]
CMP RAX,RCX
JGE 0x0011cb19
LEA RDI,[0x13dea1]
CALL 0x00115290
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0011cbf2
LAB_0011cb19:
MOVSXD RAX,dword ptr [RBP + -0x2c]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x30]
MOV RDX,qword ptr [RBP + -0x18]
SUB RCX,RDX
CMP RAX,RCX
JLE 0x0011cb5e
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x2c]
CALL 0x0011cd00
CMP EAX,0x0
JNZ 0x0011cb52
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0011cbf2
LAB_0011cb52:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RBP + -0x18],RAX
LAB_0011cb5e:
MOV RAX,qword ptr [RBP + -0x18]
MOVSXD RDX,dword ptr [RBP + -0x30]
XOR ECX,ECX
SUB RCX,RDX
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
CMP dword ptr [RBP + -0x30],0x1
JNZ 0x0011cbaf
MOV RAX,qword ptr [RBP + -0x28]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x31],AL
CMP dword ptr [RBP + -0x2c],0x0
JZ 0x0011cbad
JMP 0x0011cb89
LAB_0011cb89:
MOV CL,byte ptr [RBP + -0x31]
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JNZ 0x0011cb89
JMP 0x0011cbad
LAB_0011cbad:
JMP 0x0011cbeb
LAB_0011cbaf:
CMP dword ptr [RBP + -0x2c],0x0
JZ 0x0011cbe9
JMP 0x0011cbb7
LAB_0011cbb7:
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x28],RCX
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JNZ 0x0011cbb7
JMP 0x0011cbe9
LAB_0011cbe9:
JMP 0x0011cbeb
LAB_0011cbeb:
JMP 0x0011cbed
LAB_0011cbed:
JMP 0x0011c938
LAB_0011cbf2:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
int4 stbi__parse_huffman_block(long param_1)
{
int1 uVar1;
int iVar2;
int4 uVar3;
int iVar4;
int1 *puVar5;
int local_38;
int local_34;
int1 *local_20;
local_20 = *(int1 **)(param_1 + 0x20);
while( true ) {
while (iVar2 = stbi__zhuffman_decode(param_1,param_1 + 0x3c), iVar2 < 0x100) {
if (iVar2 < 0) {
uVar3 = stbi__err("bad huffman code");
return uVar3;
}
if (*(int1 **)(param_1 + 0x30) <= local_20) {
iVar4 = stbi__zexpand(param_1,local_20,1);
if (iVar4 == 0) {
return 0;
}
local_20 = *(int1 **)(param_1 + 0x20);
}
*local_20 = (char)iVar2;
local_20 = local_20 + 1;
}
if (iVar2 == 0x100) break;
if (0x11d < iVar2) {
uVar3 = stbi__err("bad huffman code");
return uVar3;
}
iVar2 = iVar2 + -0x101;
local_34 = *(int *)(stbi__zlength_base + (long)iVar2 * 4);
if (*(int *)(stbi__zlength_extra + (long)iVar2 * 4) != 0) {
iVar2 = stbi__zreceive(param_1,*(int4 *)(stbi__zlength_extra + (long)iVar2 * 4));
local_34 = iVar2 + local_34;
}
iVar2 = stbi__zhuffman_decode(param_1,param_1 + 0x820);
if ((iVar2 < 0) || (0x1d < iVar2)) {
uVar3 = stbi__err("bad huffman code");
return uVar3;
}
local_38 = *(int *)(stbi__zdist_base + (long)iVar2 * 4);
if (*(int *)(stbi__zdist_extra + (long)iVar2 * 4) != 0) {
iVar2 = stbi__zreceive(param_1,*(int4 *)(stbi__zdist_extra + (long)iVar2 * 4));
local_38 = iVar2 + local_38;
}
if ((long)local_20 - *(long *)(param_1 + 0x28) < (long)local_38) {
uVar3 = stbi__err("bad dist");
return uVar3;
}
if (*(long *)(param_1 + 0x30) - (long)local_20 < (long)local_34) {
iVar2 = stbi__zexpand(param_1,local_20,local_34);
if (iVar2 == 0) {
return 0;
}
local_20 = *(int1 **)(param_1 + 0x20);
}
puVar5 = local_20 + -(long)local_38;
if (local_38 == 1) {
uVar1 = *puVar5;
for (; local_34 != 0; local_34 = local_34 + -1) {
*local_20 = uVar1;
local_20 = local_20 + 1;
}
}
else {
for (; local_34 != 0; local_34 = local_34 + -1) {
*local_20 = *puVar5;
puVar5 = puVar5 + 1;
local_20 = local_20 + 1;
}
}
}
*(int1 **)(param_1 + 0x20) = local_20;
if ((*(int *)(param_1 + 0x14) != 0) && (*(int *)(param_1 + 0x10) < 0x10)) {
uVar3 = stbi__err("unexpected end");
return uVar3;
}
return 1;
}
|
|
66,041 |
OpenSubdiv::v3_6_0::Vtr::internal::Refinement::populateVertexTagsFromParentEdges()
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/vtr/refinement.cpp
|
void
Refinement::populateVertexTagsFromParentEdges() {
//
// Tags for vertices originating from edges are initialized according to the tags
// of the parent edge:
//
Level::VTag vTag;
vTag.clear();
for (Index pEdge = 0; pEdge < _parent->getNumEdges(); ++pEdge) {
Index cVert = _edgeChildVertIndex[pEdge];
if (!IndexIsValid(cVert)) continue;
// From the cleared local VTag, we just need to assign properties dependent
// on the parent edge:
Level::ETag const& pEdgeTag = _parent->_edgeTags[pEdge];
vTag._nonManifold = pEdgeTag._nonManifold;
vTag._boundary = pEdgeTag._boundary;
vTag._semiSharpEdges = pEdgeTag._semiSharp;
vTag._infSharpEdges = pEdgeTag._infSharp;
vTag._infSharpCrease = pEdgeTag._infSharp;
vTag._infIrregular = pEdgeTag._infSharp && pEdgeTag._nonManifold;
vTag._rule = (Level::VTag::VTagSize)((pEdgeTag._semiSharp || pEdgeTag._infSharp)
? Sdc::Crease::RULE_CREASE : Sdc::Crease::RULE_SMOOTH);
_child->_vertTags[cVert] = vTag;
}
}
|
O0
|
cpp
|
OpenSubdiv::v3_6_0::Vtr::internal::Refinement::populateVertexTagsFromParentEdges():
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0xa(%rbp), %rdi
callq 0xd62d0
leaq -0xa(%rbp), %rdi
callq 0xd6540
movl $0x0, -0x10(%rbp)
movq -0x28(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, -0x2c(%rbp)
movq 0x8(%rax), %rdi
callq 0xca130
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x101191
movq -0x28(%rbp), %rdi
addq $0xd8, %rdi
movslq -0x10(%rbp), %rsi
callq 0xc7140
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0xd63b0
testb $0x1, %al
jne 0x100fe7
jmp 0x101183
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0xf0, %rdi
movslq -0x10(%rbp), %rsi
callq 0xc57e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
movw %ax, %cx
movw -0xa(%rbp), %ax
andw $0x1, %cx
andw $-0x2, %ax
orw %cx, %ax
movw %ax, -0xa(%rbp)
movq -0x20(%rbp), %rax
movb (%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %eax
movw %ax, %cx
movw -0xa(%rbp), %ax
andw $0x1, %cx
shlw $0x2, %cx
andw $-0x5, %ax
orw %cx, %ax
movw %ax, -0xa(%rbp)
movq -0x20(%rbp), %rax
movb (%rax), %al
shrb $0x3, %al
andb $0x1, %al
movzbl %al, %eax
movw %ax, %cx
movw -0xa(%rbp), %ax
andw $0x1, %cx
shlw $0x6, %cx
andw $-0x41, %ax
orw %cx, %ax
movw %ax, -0xa(%rbp)
movq -0x20(%rbp), %rax
movb (%rax), %al
shrb $0x2, %al
andb $0x1, %al
movzbl %al, %eax
movw %ax, %cx
movw -0xa(%rbp), %ax
andw $0x1, %cx
shlw $0xd, %cx
andw $0xdfff, %ax # imm = 0xDFFF
orw %cx, %ax
movw %ax, -0xa(%rbp)
movq -0x20(%rbp), %rax
movb (%rax), %al
shrb $0x2, %al
andb $0x1, %al
movzbl %al, %eax
movw %ax, %cx
movw -0xa(%rbp), %ax
andw $0x1, %cx
shlw $0xe, %cx
andw $0xbfff, %ax # imm = 0xBFFF
orw %cx, %ax
movw %ax, -0xa(%rbp)
movq -0x20(%rbp), %rax
movb (%rax), %cl
shrb $0x2, %cl
andb $0x1, %cl
xorl %eax, %eax
cmpb $0x0, %cl
movb %al, -0x2d(%rbp)
je 0x1010e9
movq -0x20(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
cmpb $0x0, %al
setne %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movw %ax, %cx
movw -0xa(%rbp), %ax
andw $0x1, %cx
shlw $0xf, %cx
andw $0x7fff, %ax # imm = 0x7FFF
orw %cx, %ax
movw %ax, -0xa(%rbp)
movq -0x20(%rbp), %rax
movb (%rax), %cl
shrb $0x3, %cl
andb $0x1, %cl
movb $0x1, %al
cmpb $0x0, %cl
movb %al, -0x2e(%rbp)
jne 0x101134
movq -0x20(%rbp), %rax
movb (%rax), %al
shrb $0x2, %al
andb $0x1, %al
cmpb $0x0, %al
setne %al
movb %al, -0x2e(%rbp)
movq -0x28(%rbp), %rax
movb -0x2e(%rbp), %sil
movl $0x1, %ecx
movl $0x4, %edx
testb $0x1, %sil
cmovnel %edx, %ecx
movw %cx, %dx
movw -0xa(%rbp), %cx
andw $0xf, %dx
shlw $0x7, %dx
andw $0xf87f, %cx # imm = 0xF87F
orw %dx, %cx
movw %cx, -0xa(%rbp)
movq 0x10(%rax), %rdi
addq $0x1b0, %rdi # imm = 0x1B0
movslq -0x14(%rbp), %rsi
callq 0xc4dc0
movw -0xa(%rbp), %cx
movw %cx, (%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x100f9d
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
_ZN10OpenSubdiv6v3_6_03Vtr8internal10Refinement33populateVertexTagsFromParentEdgesEv:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_28], rax
lea rdi, [rbp+var_A]; this
call __ZN10OpenSubdiv6v3_6_03Vtr8internal5Level4VTagC2Ev; OpenSubdiv::v3_6_0::Vtr::internal::Level::VTag::VTag(void)
lea rdi, [rbp+var_A]; this
call __ZN10OpenSubdiv6v3_6_03Vtr8internal5Level4VTag5clearEv; OpenSubdiv::v3_6_0::Vtr::internal::Level::VTag::clear(void)
mov dword ptr [rbp+var_14+4], 0
loc_100F9D:
mov rax, [rbp+var_28]
mov ecx, dword ptr [rbp+var_14+4]
mov [rbp+var_2C], ecx
mov rdi, [rax+8]; this
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level11getNumEdgesEv; OpenSubdiv::v3_6_0::Vtr::internal::Level::getNumEdges(void)
mov ecx, eax
mov eax, [rbp+var_2C]
cmp eax, ecx
jge loc_101191
mov rdi, [rbp+var_28]
add rdi, 0D8h
movsxd rsi, dword ptr [rbp+var_14+4]; int
call __ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov eax, [rax]
mov dword ptr [rbp+var_14], eax
mov edi, dword ptr [rbp+var_14]; this
call __ZN10OpenSubdiv6v3_6_03Vtr12IndexIsValidEi; OpenSubdiv::v3_6_0::Vtr::IndexIsValid(int)
test al, 1
jnz short loc_100FE7
jmp loc_101183
loc_100FE7:
mov rax, [rbp+var_28]
mov rdi, [rax+8]
add rdi, 0F0h
movsxd rsi, dword ptr [rbp+var_14+4]
call __ZNKSt6vectorIN10OpenSubdiv6v3_6_03Vtr8internal5Level4ETagESaIS5_EEixEm; std::vector<OpenSubdiv::v3_6_0::Vtr::internal::Level::ETag>::operator[](ulong)
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov al, [rax]
and al, 1
movzx eax, al
mov cx, ax
mov ax, [rbp+var_A]
and cx, 1
and ax, 0FFFEh
or ax, cx
mov [rbp+var_A], ax
mov rax, [rbp+var_20]
mov al, [rax]
shr al, 1
and al, 1
movzx eax, al
mov cx, ax
mov ax, [rbp+var_A]
and cx, 1
shl cx, 2
and ax, 0FFFBh
or ax, cx
mov [rbp+var_A], ax
mov rax, [rbp+var_20]
mov al, [rax]
shr al, 3
and al, 1
movzx eax, al
mov cx, ax
mov ax, [rbp+var_A]
and cx, 1
shl cx, 6
and ax, 0FFBFh
or ax, cx
mov [rbp+var_A], ax
mov rax, [rbp+var_20]
mov al, [rax]
shr al, 2
and al, 1
movzx eax, al
mov cx, ax
mov ax, [rbp+var_A]
and cx, 1
shl cx, 0Dh
and ax, 0DFFFh
or ax, cx
mov [rbp+var_A], ax
mov rax, [rbp+var_20]
mov al, [rax]
shr al, 2
and al, 1
movzx eax, al
mov cx, ax
mov ax, [rbp+var_A]
and cx, 1
shl cx, 0Eh
and ax, 0BFFFh
or ax, cx
mov [rbp+var_A], ax
mov rax, [rbp+var_20]
mov cl, [rax]
shr cl, 2
and cl, 1
xor eax, eax
cmp cl, 0
mov [rbp+var_2D], al
jz short loc_1010E9
mov rax, [rbp+var_20]
mov al, [rax]
and al, 1
cmp al, 0
setnz al
mov [rbp+var_2D], al
loc_1010E9:
mov al, [rbp+var_2D]
and al, 1
movzx eax, al
mov cx, ax
mov ax, [rbp+var_A]
and cx, 1
shl cx, 0Fh
and ax, 7FFFh
or ax, cx
mov [rbp+var_A], ax
mov rax, [rbp+var_20]
mov cl, [rax]
shr cl, 3
and cl, 1
mov al, 1
cmp cl, 0
mov [rbp+var_2E], al
jnz short loc_101134
mov rax, [rbp+var_20]
mov al, [rax]
shr al, 2
and al, 1
cmp al, 0
setnz al
mov [rbp+var_2E], al
loc_101134:
mov rax, [rbp+var_28]
mov sil, [rbp+var_2E]
mov ecx, 1
mov edx, 4
test sil, 1
cmovnz ecx, edx
mov dx, cx
mov cx, [rbp+var_A]
and dx, 0Fh
shl dx, 7
and cx, 0F87Fh
or cx, dx
mov [rbp+var_A], cx
mov rdi, [rax+10h]
add rdi, 1B0h
movsxd rsi, dword ptr [rbp+var_14]
call __ZNSt6vectorIN10OpenSubdiv6v3_6_03Vtr8internal5Level4VTagESaIS5_EEixEm; std::vector<OpenSubdiv::v3_6_0::Vtr::internal::Level::VTag>::operator[](ulong)
mov cx, [rbp+var_A]
mov [rax], cx
loc_101183:
mov eax, dword ptr [rbp+var_14+4]
add eax, 1
mov dword ptr [rbp+var_14+4], eax
jmp loc_100F9D
loc_101191:
add rsp, 30h
pop rbp
retn
|
long long OpenSubdiv::v3_6_0::Vtr::internal::Refinement::populateVertexTagsFromParentEdges(
OpenSubdiv::v3_6_0::Vtr::internal::Level **this)
{
int NumEdges; // ecx
long long result; // rax
char v3; // cl
_WORD *v4; // rax
bool v5; // [rsp+2h] [rbp-2Eh]
bool v6; // [rsp+3h] [rbp-2Dh]
_BYTE *v7; // [rsp+10h] [rbp-20h]
unsigned int v8; // [rsp+1Ch] [rbp-14h]
int i; // [rsp+20h] [rbp-10h]
__int16 v10; // [rsp+26h] [rbp-Ah] BYREF
OpenSubdiv::v3_6_0::Vtr::internal::Level **v11; // [rsp+28h] [rbp-8h]
v11 = this;
OpenSubdiv::v3_6_0::Vtr::internal::Level::VTag::VTag((OpenSubdiv::v3_6_0::Vtr::internal::Level::VTag *)&v10);
OpenSubdiv::v3_6_0::Vtr::internal::Level::VTag::clear((OpenSubdiv::v3_6_0::Vtr::internal::Level::VTag *)&v10);
for ( i = 0; ; ++i )
{
NumEdges = OpenSubdiv::v3_6_0::Vtr::internal::Level::getNumEdges(this[1]);
result = (unsigned int)i;
if ( i >= NumEdges )
break;
v8 = *(_DWORD *)std::vector<int>::operator[](this + 27, i);
if ( (OpenSubdiv::v3_6_0::Vtr::IndexIsValid((OpenSubdiv::v3_6_0::Vtr *)v8, i) & 1) != 0 )
{
v7 = (_BYTE *)std::vector<OpenSubdiv::v3_6_0::Vtr::internal::Level::ETag>::operator[]((char *)this[1] + 240, i);
v10 = *v7 & 1 | v10 & 0xFFFE;
v10 = (4 * ((*v7 & 2) != 0)) | v10 & 0xFFFB;
v10 = (((*v7 & 8) != 0) << 6) | v10 & 0xFFBF;
v10 = (((*v7 & 4) != 0) << 13) | v10 & 0xDFFF;
v10 = (((*v7 & 4) != 0) << 14) | v10 & 0xBFFF;
v6 = 0;
if ( (*v7 & 4) != 0 )
v6 = (*v7 & 1) != 0;
v10 = (v6 << 15) | v10 & 0x7FFF;
v5 = 1;
if ( (*v7 & 8) == 0 )
v5 = (*v7 & 4) != 0;
v3 = 1;
if ( v5 )
v3 = 4;
v10 = ((v3 & 0xF) << 7) | v10 & 0xF87F;
v4 = (_WORD *)std::vector<OpenSubdiv::v3_6_0::Vtr::internal::Level::VTag>::operator[](
(char *)this[2] + 432,
(int)v8);
*v4 = v10;
}
}
return result;
}
| |||
66,042 |
OpenSubdiv::v3_6_0::Vtr::internal::Refinement::populateVertexTagsFromParentEdges()
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/vtr/refinement.cpp
|
void
Refinement::populateVertexTagsFromParentEdges() {
//
// Tags for vertices originating from edges are initialized according to the tags
// of the parent edge:
//
Level::VTag vTag;
vTag.clear();
for (Index pEdge = 0; pEdge < _parent->getNumEdges(); ++pEdge) {
Index cVert = _edgeChildVertIndex[pEdge];
if (!IndexIsValid(cVert)) continue;
// From the cleared local VTag, we just need to assign properties dependent
// on the parent edge:
Level::ETag const& pEdgeTag = _parent->_edgeTags[pEdge];
vTag._nonManifold = pEdgeTag._nonManifold;
vTag._boundary = pEdgeTag._boundary;
vTag._semiSharpEdges = pEdgeTag._semiSharp;
vTag._infSharpEdges = pEdgeTag._infSharp;
vTag._infSharpCrease = pEdgeTag._infSharp;
vTag._infIrregular = pEdgeTag._infSharp && pEdgeTag._nonManifold;
vTag._rule = (Level::VTag::VTagSize)((pEdgeTag._semiSharp || pEdgeTag._infSharp)
? Sdc::Crease::RULE_CREASE : Sdc::Crease::RULE_SMOOTH);
_child->_vertTags[cVert] = vTag;
}
}
|
O1
|
cpp
|
OpenSubdiv::v3_6_0::Vtr::internal::Refinement::populateVertexTagsFromParentEdges():
pushq %rbp
pushq %r14
pushq %rbx
movq 0x8(%rdi), %r9
cmpl $0x0, 0x4(%r9)
jle 0x49edb
xorl %eax, %eax
movl $0x80, %ecx
xorl %edx, %edx
xorl %esi, %esi
movq 0xd8(%rdi), %r8
movslq (%r8,%rdx,4), %r8
cmpq $-0x1, %r8
je 0x49ec7
movq 0xf0(%r9), %r9
movzbl (%r9,%rdx), %r10d
movl %r10d, %r9d
andl $0x1, %r9d
andl $0x183a, %esi # imm = 0x183A
movl %r10d, %r11d
andl $0x2, %r11d
leal (%rsi,%r11,2), %esi
movl %r10d, %r11d
andl $0x8, %r11d
leal (%rsi,%r11,8), %r11d
movl %r10d, %ebx
shrl $0x2, %ebx
andl $0x1, %ebx
movl %ebx, %ebp
shll $0xd, %ebp
shll $0xe, %ebx
movl %r10d, %r14d
shll $0xf, %r14d
testb $0x4, %r10b
cmovel %eax, %r14d
testb $0xc, %r10b
movl $0x200, %esi # imm = 0x200
cmovel %ecx, %esi
orl %r11d, %esi
orl %ebp, %esi
orl %ebx, %esi
orl %r14d, %esi
orl %r9d, %esi
movq 0x10(%rdi), %r9
movq 0x1b0(%r9), %r9
movw %si, (%r9,%r8,2)
incq %rdx
movq 0x8(%rdi), %r9
movslq 0x4(%r9), %r8
cmpq %r8, %rdx
jl 0x49e3e
popq %rbx
popq %r14
popq %rbp
retq
|
_ZN10OpenSubdiv6v3_6_03Vtr8internal10Refinement33populateVertexTagsFromParentEdgesEv:
push rbp
push r14
push rbx
mov r9, [rdi+8]
cmp dword ptr [r9+4], 0
jle loc_49EDB
xor eax, eax
mov ecx, 80h
xor edx, edx
xor esi, esi
loc_49E3E:
mov r8, [rdi+0D8h]
movsxd r8, dword ptr [r8+rdx*4]
cmp r8, 0FFFFFFFFFFFFFFFFh
jz short loc_49EC7
mov r9, [r9+0F0h]
movzx r10d, byte ptr [r9+rdx]
mov r9d, r10d
and r9d, 1
and esi, 183Ah
mov r11d, r10d
and r11d, 2
lea esi, [rsi+r11*2]
mov r11d, r10d
and r11d, 8
lea r11d, [rsi+r11*8]
mov ebx, r10d
shr ebx, 2
and ebx, 1
mov ebp, ebx
shl ebp, 0Dh
shl ebx, 0Eh
mov r14d, r10d
shl r14d, 0Fh
test r10b, 4
cmovz r14d, eax
test r10b, 0Ch
mov esi, 200h
cmovz esi, ecx
or esi, r11d
or esi, ebp
or esi, ebx
or esi, r14d
or esi, r9d
mov r9, [rdi+10h]
mov r9, [r9+1B0h]
mov [r9+r8*2], si
loc_49EC7:
inc rdx
mov r9, [rdi+8]
movsxd r8, dword ptr [r9+4]
cmp rdx, r8
jl loc_49E3E
loc_49EDB:
pop rbx
pop r14
pop rbp
retn
|
long long OpenSubdiv::v3_6_0::Vtr::internal::Refinement::populateVertexTagsFromParentEdges(
OpenSubdiv::v3_6_0::Vtr::internal::Refinement *this)
{
long long v1; // r9
long long result; // rax
long long v3; // rdx
__int16 v4; // si
long long v5; // r8
unsigned int v6; // r10d
__int16 v7; // r9
__int16 v8; // r11
__int16 v9; // r14
__int16 v10; // si
v1 = *((_QWORD *)this + 1);
if ( *(int *)(v1 + 4) > 0 )
{
result = 0LL;
v3 = 0LL;
v4 = 0;
do
{
v5 = *(int *)(*((_QWORD *)this + 27) + 4 * v3);
if ( v5 != -1 )
{
v6 = *(unsigned __int8 *)(*(_QWORD *)(v1 + 240) + v3);
v7 = *(_BYTE *)(*(_QWORD *)(v1 + 240) + v3) & 1;
v8 = (v4 & 0x183A) + 2 * (v6 & 2) + 8 * (v6 & 8);
v9 = (_WORD)v6 << 15;
if ( (v6 & 4) == 0 )
v9 = 0;
v10 = 512;
if ( (v6 & 0xC) == 0 )
v10 = 128;
v4 = v7 | v9 | (((v6 >> 2) & 1) << 14) | (((v6 >> 2) & 1) << 13) | v8 | v10;
*(_WORD *)(*(_QWORD *)(*((_QWORD *)this + 2) + 432LL) + 2 * v5) = v4;
}
++v3;
v1 = *((_QWORD *)this + 1);
}
while ( v3 < *(int *)(v1 + 4) );
}
return result;
}
|
populateVertexTagsFromParentEdges:
PUSH RBP
PUSH R14
PUSH RBX
MOV R9,qword ptr [RDI + 0x8]
CMP dword ptr [R9 + 0x4],0x0
JLE 0x00149edb
XOR EAX,EAX
MOV ECX,0x80
XOR EDX,EDX
XOR ESI,ESI
LAB_00149e3e:
MOV R8,qword ptr [RDI + 0xd8]
MOVSXD R8,dword ptr [R8 + RDX*0x4]
CMP R8,-0x1
JZ 0x00149ec7
MOV R9,qword ptr [R9 + 0xf0]
MOVZX R10D,byte ptr [R9 + RDX*0x1]
MOV R9D,R10D
AND R9D,0x1
AND ESI,0x183a
MOV R11D,R10D
AND R11D,0x2
LEA ESI,[RSI + R11*0x2]
MOV R11D,R10D
AND R11D,0x8
LEA R11D,[RSI + R11*0x8]
MOV EBX,R10D
SHR EBX,0x2
AND EBX,0x1
MOV EBP,EBX
SHL EBP,0xd
SHL EBX,0xe
MOV R14D,R10D
SHL R14D,0xf
TEST R10B,0x4
CMOVZ R14D,EAX
TEST R10B,0xc
MOV ESI,0x200
CMOVZ ESI,ECX
OR ESI,R11D
OR ESI,EBP
OR ESI,EBX
OR ESI,R14D
OR ESI,R9D
MOV R9,qword ptr [RDI + 0x10]
MOV R9,qword ptr [R9 + 0x1b0]
MOV word ptr [R9 + R8*0x2],SI
LAB_00149ec7:
INC RDX
MOV R9,qword ptr [RDI + 0x8]
MOVSXD R8,dword ptr [R9 + 0x4]
CMP RDX,R8
JL 0x00149e3e
LAB_00149edb:
POP RBX
POP R14
POP RBP
RET
|
/* OpenSubdiv::v3_6_0::Vtr::internal::Refinement::populateVertexTagsFromParentEdges() */
void __thiscall
OpenSubdiv::v3_6_0::Vtr::internal::Refinement::populateVertexTagsFromParentEdges(Refinement *this)
{
byte bVar1;
long lVar2;
uint uVar3;
uint uVar4;
uint uVar5;
long lVar6;
long lVar7;
uint uVar8;
lVar7 = *(long *)(this + 8);
if (0 < *(int *)(lVar7 + 4)) {
lVar2 = 0;
uVar5 = 0;
do {
lVar6 = (long)*(int *)(*(long *)(this + 0xd8) + lVar2 * 4);
if (lVar6 != -1) {
bVar1 = *(byte *)(*(long *)(lVar7 + 0xf0) + lVar2);
uVar3 = bVar1 >> 2 & 1;
uVar8 = (uint)bVar1 << 0xf;
if ((bVar1 & 4) == 0) {
uVar8 = 0;
}
uVar4 = 0x200;
if ((bVar1 & 0xc) == 0) {
uVar4 = 0x80;
}
uVar5 = uVar4 | (uVar5 & 0x183a) + (bVar1 & 2) * 2 + (bVar1 & 8) * 8 | uVar3 << 0xd |
uVar3 << 0xe | uVar8 | bVar1 & 1;
*(short *)(*(long *)(*(long *)(this + 0x10) + 0x1b0) + lVar6 * 2) = (short)uVar5;
}
lVar2 = lVar2 + 1;
lVar7 = *(long *)(this + 8);
} while (lVar2 < *(int *)(lVar7 + 4));
}
return;
}
|
|
66,043 |
OpenSubdiv::v3_6_0::Vtr::internal::Refinement::populateVertexTagsFromParentEdges()
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/vtr/refinement.cpp
|
void
Refinement::populateVertexTagsFromParentEdges() {
//
// Tags for vertices originating from edges are initialized according to the tags
// of the parent edge:
//
Level::VTag vTag;
vTag.clear();
for (Index pEdge = 0; pEdge < _parent->getNumEdges(); ++pEdge) {
Index cVert = _edgeChildVertIndex[pEdge];
if (!IndexIsValid(cVert)) continue;
// From the cleared local VTag, we just need to assign properties dependent
// on the parent edge:
Level::ETag const& pEdgeTag = _parent->_edgeTags[pEdge];
vTag._nonManifold = pEdgeTag._nonManifold;
vTag._boundary = pEdgeTag._boundary;
vTag._semiSharpEdges = pEdgeTag._semiSharp;
vTag._infSharpEdges = pEdgeTag._infSharp;
vTag._infSharpCrease = pEdgeTag._infSharp;
vTag._infIrregular = pEdgeTag._infSharp && pEdgeTag._nonManifold;
vTag._rule = (Level::VTag::VTagSize)((pEdgeTag._semiSharp || pEdgeTag._infSharp)
? Sdc::Crease::RULE_CREASE : Sdc::Crease::RULE_SMOOTH);
_child->_vertTags[cVert] = vTag;
}
}
|
O2
|
cpp
|
OpenSubdiv::v3_6_0::Vtr::internal::Refinement::populateVertexTagsFromParentEdges():
pushq %rbp
pushq %r14
pushq %rbx
xorl %eax, %eax
movl $0x80, %ecx
xorl %edx, %edx
xorl %esi, %esi
movq 0x8(%rdi), %r9
movslq 0x4(%r9), %r8
cmpq %r8, %rdx
jge 0x61b27
movq 0xd8(%rdi), %r8
movslq (%r8,%rdx,4), %r8
cmpq $-0x1, %r8
je 0x61b1f
movq 0xf0(%r9), %r9
movzbl (%r9,%rdx), %r10d
movl %r10d, %r9d
andl $0x1, %r9d
andl $0x183a, %esi # imm = 0x183A
movl %r10d, %r11d
andl $0x2, %r11d
leal (%rsi,%r11,2), %esi
movl %r10d, %r11d
andl $0x8, %r11d
leal (%rsi,%r11,8), %r11d
movl %r10d, %ebx
shrl $0x2, %ebx
andl $0x1, %ebx
movl %ebx, %ebp
shll $0xd, %ebp
shll $0xe, %ebx
movl %r10d, %r14d
shll $0xf, %r14d
testb $0x4, %r10b
cmovel %eax, %r14d
testb $0xc, %r10b
movl $0x200, %esi # imm = 0x200
cmovel %ecx, %esi
orl %r11d, %esi
orl %ebp, %esi
orl %ebx, %esi
orl %r14d, %esi
orl %r9d, %esi
movq 0x10(%rdi), %r9
movq 0x1b0(%r9), %r9
movw %si, (%r9,%r8,2)
incq %rdx
jmp 0x61a85
popq %rbx
popq %r14
popq %rbp
retq
|
_ZN10OpenSubdiv6v3_6_03Vtr8internal10Refinement33populateVertexTagsFromParentEdgesEv:
push rbp
push r14
push rbx
xor eax, eax
mov ecx, 80h
xor edx, edx
xor esi, esi
loc_61A85:
mov r9, [rdi+8]
movsxd r8, dword ptr [r9+4]
cmp rdx, r8
jge loc_61B27
mov r8, [rdi+0D8h]
movsxd r8, dword ptr [r8+rdx*4]
cmp r8, 0FFFFFFFFFFFFFFFFh
jz short loc_61B1F
mov r9, [r9+0F0h]
movzx r10d, byte ptr [r9+rdx]
mov r9d, r10d
and r9d, 1
and esi, 183Ah
mov r11d, r10d
and r11d, 2
lea esi, [rsi+r11*2]
mov r11d, r10d
and r11d, 8
lea r11d, [rsi+r11*8]
mov ebx, r10d
shr ebx, 2
and ebx, 1
mov ebp, ebx
shl ebp, 0Dh
shl ebx, 0Eh
mov r14d, r10d
shl r14d, 0Fh
test r10b, 4
cmovz r14d, eax
test r10b, 0Ch
mov esi, 200h
cmovz esi, ecx
or esi, r11d
or esi, ebp
or esi, ebx
or esi, r14d
or esi, r9d
mov r9, [rdi+10h]
mov r9, [r9+1B0h]
mov [r9+r8*2], si
loc_61B1F:
inc rdx
jmp loc_61A85
loc_61B27:
pop rbx
pop r14
pop rbp
retn
|
long long OpenSubdiv::v3_6_0::Vtr::internal::Refinement::populateVertexTagsFromParentEdges(
OpenSubdiv::v3_6_0::Vtr::internal::Refinement *this)
{
long long result; // rax
long long v2; // rdx
__int16 v3; // si
long long v4; // r9
long long v5; // r8
unsigned int v6; // r10d
__int16 v7; // r9
__int16 v8; // r11
__int16 v9; // r14
__int16 v10; // si
result = 0LL;
v2 = 0LL;
v3 = 0;
while ( 1 )
{
v4 = *((_QWORD *)this + 1);
if ( v2 >= *(int *)(v4 + 4) )
break;
v5 = *(int *)(*((_QWORD *)this + 27) + 4 * v2);
if ( v5 != -1 )
{
v6 = *(unsigned __int8 *)(*(_QWORD *)(v4 + 240) + v2);
v7 = *(_BYTE *)(*(_QWORD *)(v4 + 240) + v2) & 1;
v8 = (v3 & 0x183A) + 2 * (v6 & 2) + 8 * (v6 & 8);
v9 = (_WORD)v6 << 15;
if ( (v6 & 4) == 0 )
v9 = 0;
v10 = 512;
if ( (v6 & 0xC) == 0 )
v10 = 128;
v3 = v7 | v9 | (((v6 >> 2) & 1) << 14) | (((v6 >> 2) & 1) << 13) | v8 | v10;
*(_WORD *)(*(_QWORD *)(*((_QWORD *)this + 2) + 432LL) + 2 * v5) = v3;
}
++v2;
}
return result;
}
|
populateVertexTagsFromParentEdges:
PUSH RBP
PUSH R14
PUSH RBX
XOR EAX,EAX
MOV ECX,0x80
XOR EDX,EDX
XOR ESI,ESI
LAB_00161a85:
MOV R9,qword ptr [RDI + 0x8]
MOVSXD R8,dword ptr [R9 + 0x4]
CMP RDX,R8
JGE 0x00161b27
MOV R8,qword ptr [RDI + 0xd8]
MOVSXD R8,dword ptr [R8 + RDX*0x4]
CMP R8,-0x1
JZ 0x00161b1f
MOV R9,qword ptr [R9 + 0xf0]
MOVZX R10D,byte ptr [R9 + RDX*0x1]
MOV R9D,R10D
AND R9D,0x1
AND ESI,0x183a
MOV R11D,R10D
AND R11D,0x2
LEA ESI,[RSI + R11*0x2]
MOV R11D,R10D
AND R11D,0x8
LEA R11D,[RSI + R11*0x8]
MOV EBX,R10D
SHR EBX,0x2
AND EBX,0x1
MOV EBP,EBX
SHL EBP,0xd
SHL EBX,0xe
MOV R14D,R10D
SHL R14D,0xf
TEST R10B,0x4
CMOVZ R14D,EAX
TEST R10B,0xc
MOV ESI,0x200
CMOVZ ESI,ECX
OR ESI,R11D
OR ESI,EBP
OR ESI,EBX
OR ESI,R14D
OR ESI,R9D
MOV R9,qword ptr [RDI + 0x10]
MOV R9,qword ptr [R9 + 0x1b0]
MOV word ptr [R9 + R8*0x2],SI
LAB_00161b1f:
INC RDX
JMP 0x00161a85
LAB_00161b27:
POP RBX
POP R14
POP RBP
RET
|
/* OpenSubdiv::v3_6_0::Vtr::internal::Refinement::populateVertexTagsFromParentEdges() */
void __thiscall
OpenSubdiv::v3_6_0::Vtr::internal::Refinement::populateVertexTagsFromParentEdges(Refinement *this)
{
byte bVar1;
long lVar2;
uint uVar3;
uint uVar4;
uint uVar5;
long lVar6;
uint uVar7;
uVar5 = 0;
for (lVar2 = 0; lVar2 < *(int *)(*(long *)(this + 8) + 4); lVar2 = lVar2 + 1) {
lVar6 = (long)*(int *)(*(long *)(this + 0xd8) + lVar2 * 4);
if (lVar6 != -1) {
bVar1 = *(byte *)(*(long *)(*(long *)(this + 8) + 0xf0) + lVar2);
uVar3 = bVar1 >> 2 & 1;
uVar7 = (uint)bVar1 << 0xf;
if ((bVar1 & 4) == 0) {
uVar7 = 0;
}
uVar4 = 0x200;
if ((bVar1 & 0xc) == 0) {
uVar4 = 0x80;
}
uVar5 = uVar4 | (uVar5 & 0x183a) + (bVar1 & 2) * 2 + (bVar1 & 8) * 8 | uVar3 << 0xd |
uVar3 << 0xe | uVar7 | bVar1 & 1;
*(short *)(*(long *)(*(long *)(this + 0x10) + 0x1b0) + lVar6 * 2) = (short)uVar5;
}
}
return;
}
|
|
66,044 |
js_string_charAt
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_string_charAt(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue val, ret;
JSString *p;
int idx, c;
val = JS_ToStringCheckObject(ctx, this_val);
if (JS_IsException(val))
return val;
p = JS_VALUE_GET_STRING(val);
if (JS_ToInt32Sat(ctx, &idx, argv[0])) {
JS_FreeValue(ctx, val);
return JS_EXCEPTION;
}
if (idx < 0 || idx >= p->len) {
ret = JS_AtomToString(ctx, JS_ATOM_empty_string);
} else {
c = string_get(p, idx);
ret = js_new_string_char(ctx, c);
}
JS_FreeValue(ctx, val);
return ret;
}
|
O1
|
c
|
js_string_charAt:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r12
movq %rdi, %r14
callq 0x425ff
movq %rdx, %rbx
movq %rax, 0x10(%rsp)
cmpl $0x6, %ebx
jne 0x7b01d
movq %rax, %r15
jmp 0x7b0c4
movq 0x10(%rsp), %r15
movq (%r12), %rdx
movq 0x8(%r12), %rcx
movq %rdx, 0x8(%rsp)
cmpl $-0x9, %ecx
jb 0x7b03c
movq 0x8(%rsp), %rax
incl (%rax)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x276c3
testl %eax, %eax
je 0x7b058
movl $0x6, %r12d
xorl %r15d, %r15d
jmp 0x7b0b0
movslq 0x8(%rsp), %rax
testq %rax, %rax
js 0x7b07e
movq 0x4(%r15), %rcx
movl %ecx, %edx
andl $0x7fffffff, %edx # imm = 0x7FFFFFFF
cmpl %edx, %eax
jge 0x7b07e
testl %ecx, %ecx
js 0x7b099
movzbl 0x18(%r15,%rax), %eax
jmp 0x7b09f
movq 0x18(%r14), %rax
movq 0x68(%rax), %rax
movq 0x178(%rax), %r15
incl (%r15)
movq $-0x7, %r12
jmp 0x7b0b0
movzwl 0x18(%r15,%rax,2), %eax
movzwl %ax, %esi
movq %r14, %rdi
callq 0x3d58e
movq %rax, %r15
movq %rdx, %r12
movq 0x10(%rsp), %rsi
movq 0x18(%r14), %rdi
movq %rbx, %rdx
callq 0x1d8c6
movq %r12, %rbx
movq %r15, %rax
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
js_string_charAt:
push r15
push r14
push r12
push rbx
sub rsp, 18h
mov r12, r8
mov r14, rdi
call JS_ToStringCheckObject
mov rbx, rdx
mov [rsp+38h+var_28], rax
cmp ebx, 6
jnz short loc_7B01D
mov r15, rax
jmp loc_7B0C4
loc_7B01D:
mov r15, [rsp+38h+var_28]
mov rdx, [r12]
mov rcx, [r12+8]
mov [rsp+38h+var_30], rdx
cmp ecx, 0FFFFFFF7h
jb short loc_7B03C
mov rax, [rsp+38h+var_30]
inc dword ptr [rax]
loc_7B03C:
lea rsi, [rsp+38h+var_30]
mov rdi, r14
call JS_ToInt32SatFree
test eax, eax
jz short loc_7B058
mov r12d, 6
xor r15d, r15d
jmp short loc_7B0B0
loc_7B058:
movsxd rax, dword ptr [rsp+38h+var_30]
test rax, rax
js short loc_7B07E
mov rcx, [r15+4]
mov edx, ecx
and edx, 7FFFFFFFh
cmp eax, edx
jge short loc_7B07E
test ecx, ecx
js short loc_7B099
movzx eax, byte ptr [r15+rax+18h]
jmp short loc_7B09F
loc_7B07E:
mov rax, [r14+18h]
mov rax, [rax+68h]
mov r15, [rax+178h]
inc dword ptr [r15]
mov r12, 0FFFFFFFFFFFFFFF9h
jmp short loc_7B0B0
loc_7B099:
movzx eax, word ptr [r15+rax*2+18h]
loc_7B09F:
movzx esi, ax
mov rdi, r14
call js_new_string_char
mov r15, rax
mov r12, rdx
loc_7B0B0:
mov rsi, [rsp+38h+var_28]
mov rdi, [r14+18h]
mov rdx, rbx
call JS_FreeValueRT
mov rbx, r12
loc_7B0C4:
mov rax, r15
mov rdx, rbx
add rsp, 18h
pop rbx
pop r12
pop r14
pop r15
retn
|
_DWORD * js_string_charAt(
long long a1,
long long a2,
long long a3,
long long a4,
long long *a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
_DWORD *v15; // rax
long long v16; // rdx
long long v17; // rbx
_DWORD *v18; // r15
_DWORD *v19; // r15
long long v20; // rdx
long long v21; // rcx
unsigned __int16 v22; // ax
_DWORD *v24; // [rsp+8h] [rbp-30h] BYREF
_DWORD *v25; // [rsp+10h] [rbp-28h]
v15 = (_DWORD *)JS_ToStringCheckObject(a1, a2, a3, a4, (long long)a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
v17 = v16;
v25 = v15;
if ( (_DWORD)v16 == 6 )
return v15;
v19 = v25;
v20 = *a5;
v21 = a5[1];
v24 = (_DWORD *)*a5;
if ( (unsigned int)v21 >= 0xFFFFFFF7 )
++*v24;
if ( (unsigned int)JS_ToInt32SatFree(a1, (int *)&v24, v20, v21) )
{
v18 = 0LL;
}
else if ( (int)v24 < 0LL || (int)v24 >= (v19[1] & 0x7FFFFFFF) )
{
v18 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 104LL) + 376LL);
++*v18;
}
else
{
if ( (int)*(_QWORD *)(v19 + 1) < 0 )
v22 = *((_WORD *)v19 + (int)v24 + 12);
else
v22 = *((unsigned __int8 *)v19 + (int)v24 + 24);
v18 = (_DWORD *)js_new_string_char(a1, v22);
}
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v25, v17);
return v18;
}
|
js_string_charAt:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R12,R8
MOV R14,RDI
CALL 0x001425ff
MOV RBX,RDX
MOV qword ptr [RSP + 0x10],RAX
CMP EBX,0x6
JNZ 0x0017b01d
MOV R15,RAX
JMP 0x0017b0c4
LAB_0017b01d:
MOV R15,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [R12]
MOV RCX,qword ptr [R12 + 0x8]
MOV qword ptr [RSP + 0x8],RDX
CMP ECX,-0x9
JC 0x0017b03c
MOV RAX,qword ptr [RSP + 0x8]
INC dword ptr [RAX]
LAB_0017b03c:
LEA RSI,[RSP + 0x8]
MOV RDI,R14
CALL 0x001276c3
TEST EAX,EAX
JZ 0x0017b058
MOV R12D,0x6
XOR R15D,R15D
JMP 0x0017b0b0
LAB_0017b058:
MOVSXD RAX,dword ptr [RSP + 0x8]
TEST RAX,RAX
JS 0x0017b07e
MOV RCX,qword ptr [R15 + 0x4]
MOV EDX,ECX
AND EDX,0x7fffffff
CMP EAX,EDX
JGE 0x0017b07e
TEST ECX,ECX
JS 0x0017b099
MOVZX EAX,byte ptr [R15 + RAX*0x1 + 0x18]
JMP 0x0017b09f
LAB_0017b07e:
MOV RAX,qword ptr [R14 + 0x18]
MOV RAX,qword ptr [RAX + 0x68]
MOV R15,qword ptr [RAX + 0x178]
INC dword ptr [R15]
MOV R12,-0x7
JMP 0x0017b0b0
LAB_0017b099:
MOVZX EAX,word ptr [R15 + RAX*0x2 + 0x18]
LAB_0017b09f:
MOVZX ESI,AX
MOV RDI,R14
CALL 0x0013d58e
MOV R15,RAX
MOV R12,RDX
LAB_0017b0b0:
MOV RSI,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [R14 + 0x18]
MOV RDX,RBX
CALL 0x0011d8c6
MOV RBX,R12
LAB_0017b0c4:
MOV RAX,R15
MOV RDX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R14
POP R15
RET
|
int1 [16] js_string_charAt(long param_1)
{
int *piVar1;
ushort uVar2;
int iVar3;
long lVar5;
uint uVar6;
int8 *in_R8;
int1 auVar7 [16];
int *local_30;
long local_28;
long lVar4;
auVar7 = JS_ToStringCheckObject();
auVar7._8_8_ = auVar7._8_8_;
lVar4 = auVar7._0_8_;
if (auVar7._8_4_ != 6) {
local_30 = (int *)*in_R8;
if (0xfffffff6 < (uint)in_R8[1]) {
*local_30 = *local_30 + 1;
}
local_28 = lVar4;
iVar3 = JS_ToInt32SatFree(param_1,&local_30);
if (iVar3 == 0) {
lVar5 = (long)(int)local_30;
if ((lVar5 < 0) ||
(uVar6 = (uint)*(int8 *)(lVar4 + 4), (int)(uVar6 & 0x7fffffff) <= (int)local_30)) {
piVar1 = *(int **)(*(long *)(*(long *)(param_1 + 0x18) + 0x68) + 0x178);
*piVar1 = *piVar1 + 1;
auVar7._8_8_ = 0xfffffffffffffff9;
auVar7._0_8_ = piVar1;
}
else {
if ((int)uVar6 < 0) {
uVar2 = *(ushort *)(lVar4 + lVar5 * 2 + 0x18);
}
else {
uVar2 = (ushort)*(byte *)(lVar4 + lVar5 + 0x18);
}
auVar7 = js_new_string_char(param_1,uVar2);
}
}
else {
auVar7 = ZEXT816(6) << 0x40;
}
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),local_28,auVar7._8_8_);
}
return auVar7;
}
|
|
66,045 |
Master::processShotResult(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, unsigned long)
|
666mxvbee[P]BattleShip/lib/Master/Master.cpp
|
void Master::processShotResult(const std::string& result, uint64_t x, uint64_t y) {
if (result == "hit") {
std::cout << "Master: Hit at (" << x << ", " << y << ")!" << std::endl;
}
else if (result == "hit_and_sunk") {
std::cout << "Master: Hit and sunk a ship at (" << x << ", " << y << ")!" << std::endl;
}
else if (result == "miss") {
std::cout << "Master: Miss at (" << x << ", " << y << ")." << std::endl;
}
}
|
O2
|
cpp
|
Master::processShotResult(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, unsigned long):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
leaq 0x4b82(%rip), %rsi # 0x18354
movq %r12, %rdi
callq 0x6a6d
leaq 0x4b8d(%rip), %r15 # 0x1836e
testb %al, %al
je 0x137ee
leaq 0x4b71(%rip), %rsi # 0x1835d
jmp 0x1382b
leaq 0x4b52(%rip), %rsi # 0x18347
movq %r12, %rdi
callq 0x6a6d
testb %al, %al
je 0x1380a
leaq 0x4b69(%rip), %rsi # 0x18371
jmp 0x1382b
leaq 0x4b47(%rip), %rsi # 0x18358
movq %r12, %rdi
callq 0x6a6d
testb %al, %al
je 0x1387a
leaq 0x4b20(%rip), %r15 # 0x18344
leaq 0x4b67(%rip), %rsi # 0x18392
movq 0x11766(%rip), %rdi # 0x24f98
callq 0x5360
movq %rax, %rdi
movq %r14, %rsi
callq 0x5270
leaq 0x4ae1(%rip), %rsi # 0x1832a
movq %rax, %rdi
callq 0x5360
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5270
movq %rax, %rdi
movq %r15, %rsi
callq 0x5360
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5190
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
_ZN6Master17processShotResultERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEmm:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rcx
mov r14, rdx
mov r12, rsi
lea rsi, aHit; "hit"
mov rdi, r12
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
lea r15, asc_1836E; ")!"
test al, al
jz short loc_137EE
lea rsi, aMasterHitAt; "Master: Hit at ("
jmp short loc_1382B
loc_137EE:
lea rsi, aHitAndSunk; "hit_and_sunk"
mov rdi, r12
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jz short loc_1380A
lea rsi, aMasterHitAndSu; "Master: Hit and sunk a ship at ("
jmp short loc_1382B
loc_1380A:
lea rsi, aMiss; "miss"
mov rdi, r12
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jz short loc_1387A
lea r15, asc_18344; ")."
lea rsi, aMasterMissAt; "Master: Miss at ("
loc_1382B:
mov rdi, cs:_ZSt4cout_ptr
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
mov rsi, r14
call __ZNSo9_M_insertImEERSoT_; std::ostream::_M_insert<ulong>(ulong)
lea rsi, asc_1832A; ", "
mov rdi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
mov rsi, rbx
call __ZNSo9_M_insertImEERSoT_; std::ostream::_M_insert<ulong>(ulong)
mov rdi, rax
mov rsi, r15
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
jmp __ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_; std::endl<char,std::char_traits<char>>(std::ostream &)
loc_1387A:
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
char Master::processShotResult(long long a1, long long a2, long long a3, long long a4)
{
const char *v6; // r15
const char *v7; // rsi
char result; // al
long long v9; // rax
long long v10; // rax
long long v11; // rax
long long v12; // rax
long long v13; // rax
v6 = ")!";
if ( std::operator==<char>(a2) )
{
v7 = "Master: Hit at (";
}
else if ( std::operator==<char>(a2) )
{
v7 = "Master: Hit and sunk a ship at (";
}
else
{
result = std::operator==<char>(a2);
if ( !result )
return result;
v6 = ").";
v7 = "Master: Miss at (";
}
v9 = std::operator<<<std::char_traits<char>>(&std::cout, v7);
v10 = std::ostream::_M_insert<unsigned long>(v9, a3);
v11 = std::operator<<<std::char_traits<char>>(v10, ", ");
v12 = std::ostream::_M_insert<unsigned long>(v11, a4);
v13 = std::operator<<<std::char_traits<char>>(v12, v6);
return std::endl<char,std::char_traits<char>>(v13);
}
|
processShotResult:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R14,RDX
MOV R12,RSI
LEA RSI,[0x118354]
MOV RDI,R12
CALL 0x00106a6d
LEA R15,[0x11836e]
TEST AL,AL
JZ 0x001137ee
LEA RSI,[0x11835d]
JMP 0x0011382b
LAB_001137ee:
LEA RSI,[0x118347]
MOV RDI,R12
CALL 0x00106a6d
TEST AL,AL
JZ 0x0011380a
LEA RSI,[0x118371]
JMP 0x0011382b
LAB_0011380a:
LEA RSI,[0x118358]
MOV RDI,R12
CALL 0x00106a6d
TEST AL,AL
JZ 0x0011387a
LEA R15,[0x118344]
LEA RSI,[0x118392]
LAB_0011382b:
MOV RDI,qword ptr [0x00124f98]
CALL 0x00105360
MOV RDI,RAX
MOV RSI,R14
CALL 0x00105270
LEA RSI,[0x11832a]
MOV RDI,RAX
CALL 0x00105360
MOV RDI,RAX
MOV RSI,RBX
CALL 0x00105270
MOV RDI,RAX
MOV RSI,R15
CALL 0x00105360
MOV RDI,RAX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
JMP 0x00105190
LAB_0011387a:
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* Master::processShotResult(std::__cxx11::string const&, unsigned long, unsigned long) */
void Master::processShotResult(string *param_1,ulong param_2,ulong param_3)
{
bool bVar1;
ostream *poVar2;
char *pcVar3;
char *pcVar4;
bVar1 = std::operator==((string *)param_2,"hit");
pcVar4 = ")!";
if (bVar1) {
pcVar3 = "Master: Hit at (";
}
else {
bVar1 = std::operator==((string *)param_2,"hit_and_sunk");
if (bVar1) {
pcVar3 = "Master: Hit and sunk a ship at (";
}
else {
bVar1 = std::operator==((string *)param_2,"miss");
if (!bVar1) {
return;
}
pcVar4 = ").";
pcVar3 = "Master: Miss at (";
}
}
poVar2 = std::operator<<((ostream *)PTR_cout_00124f98,pcVar3);
poVar2 = std::ostream::_M_insert<unsigned_long>((ulong)poVar2);
poVar2 = std::operator<<(poVar2,", ");
poVar2 = std::ostream::_M_insert<unsigned_long>((ulong)poVar2);
poVar2 = std::operator<<(poVar2,pcVar4);
std::endl<char,std::char_traits<char>>(poVar2);
return;
}
|
|
66,046 |
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>::get_ref_impl<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>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&)
|
monkey531[P]llama/common/json.hpp
|
static ReferenceType get_ref_impl(ThisType& obj)
{
// delegate the call to get_ptr<>()
auto* ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
if (JSON_HEDLEY_LIKELY(ptr != nullptr))
{
return *ptr;
}
JSON_THROW(type_error::create(303, detail::concat("incompatible ReferenceType for get_ref, actual type is ", obj.type_name()), &obj));
}
|
O2
|
cpp
|
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>::get_ref_impl<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>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x3, (%rdi)
jne 0x83aa8
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x83aa8
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x24460
movq %rax, %rbx
movq %r14, %rdi
callq 0x43ea6
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x3353a(%rip), %rsi # 0xb7004
leaq 0x10(%rsp), %rdi
callq 0x83b2b
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x12f, %esi # imm = 0x12F
movq %r14, %rcx
callq 0x63cea
xorl %ebp, %ebp
leaq 0x7b443(%rip), %rsi # 0xfef38
leaq -0x430c6(%rip), %rdx # 0x40a36
movq %rbx, %rdi
callq 0x24ef0
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x251d8
testb %bpl, %bpl
jne 0x83b1b
jmp 0x83b23
movq %rax, %r14
movq %rbx, %rdi
callq 0x24680
movq %r14, %rdi
callq 0x24f80
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE12get_ref_implIRKS9_KSD_EET_RT0_:
push rbp; char
push r14; int
push rbx; int
sub rsp, 30h
mov r14, rdi
cmp byte ptr [rdi], 3
jnz short loc_83AA8
mov rax, [r14+8]
test rax, rax
jz short loc_83AA8
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_83AA8:
push 20h ; ' '
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aIncompatibleRe; "incompatible ReferenceType for get_ref,"...
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA56_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[56],char const*>(char const(&)[56],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 12Fh; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rdi, [rsp+48h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_83B1B
jmp short loc_83B23
mov r14, rax
loc_83B1B:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_83B23:
mov rdi, r14
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::get_ref_impl<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> const>(
long long a1)
{
long long result; // rax
nlohmann::json_abi_v3_11_3::detail::type_error *exception; // rbx
_BYTE v3[56]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 != 3 || (result = *(_QWORD *)(a1 + 8)) == 0 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::type_error *)__cxa_allocate_exception(0x20uLL);
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(&)[56],char const*>(
v3,
"incompatible ReferenceType for get_ref, actual type is ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
303,
(long long)v3);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return result;
}
|
get_ref_impl<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>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
CMP byte ptr [RDI],0x3
JNZ 0x00183aa8
MOV RAX,qword ptr [R14 + 0x8]
TEST RAX,RAX
JZ 0x00183aa8
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_00183aa8:
PUSH 0x20
POP RDI
CALL 0x00124460
MOV RBX,RAX
MOV RDI,R14
CALL 0x00143ea6
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_00183ac3:
LEA RSI,[0x1b7004]
LEA RDI,[RSP + 0x10]
CALL 0x00183b2b
MOV BPL,0x1
LAB_00183ad7:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x12f
MOV RCX,R14
CALL 0x00163cea
XOR EBP,EBP
LEA RSI,[0x1fef38]
LEA RDX,[0x140a36]
MOV RDI,RBX
CALL 0x00124ef0
|
/* 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>::get_ref_impl<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>(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&) */
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>
::
get_ref_impl<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>
(basic_json *param_1)
{
int8 uVar1;
char *local_40;
detail local_38 [32];
if ((*param_1 == '\x03') && (*(string **)(param_1 + 8) != (string *)0x0)) {
return *(string **)(param_1 + 8);
}
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name((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);
/* try { // try from 00183ac3 to 00183ad3 has its CatchHandler @ 00183b18 */
detail::concat<std::__cxx11::string,char_const(&)[56],char_const*>
(local_38,"incompatible ReferenceType for get_ref, actual type is ",&local_40);
/* try { // try from 00183ad7 to 00183b03 has its CatchHandler @ 00183b04 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar1,0x12f,local_38,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::type_error::typeinfo,detail::exception::~exception);
}
|
|
66,047 |
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>::get_ref_impl<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>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&)
|
monkey531[P]llama/common/json.hpp
|
static ReferenceType get_ref_impl(ThisType& obj)
{
// delegate the call to get_ptr<>()
auto* ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
if (JSON_HEDLEY_LIKELY(ptr != nullptr))
{
return *ptr;
}
JSON_THROW(type_error::create(303, detail::concat("incompatible ReferenceType for get_ref, actual type is ", obj.type_name()), &obj));
}
|
O3
|
cpp
|
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>::get_ref_impl<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>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x3, (%rdi)
jne 0xb92fe
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xb92fe
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x1b440
movq %rax, %rbx
movq %r14, %rdi
callq 0x5f5fc
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x39cf2(%rip), %rsi # 0xf3014
leaq 0x10(%rsp), %rdi
callq 0xb2770
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x12f, %esi # imm = 0x12F
movq %r14, %rcx
callq 0x5f3a4
xorl %ebp, %ebp
leaq 0x72beb(%rip), %rsi # 0x12bf38
leaq -0x5db22(%rip), %rdx # 0x5b832
movq %rbx, %rdi
callq 0x1bf00
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb937a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1b8c0
testb %bpl, %bpl
jne 0xb9384
jmp 0xb938c
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b660
movq %r14, %rdi
callq 0x1bf90
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE12get_ref_implIRS9_SD_EET_RT0_:
push rbp; char
push r14; int
push rbx; __int64
sub rsp, 30h
mov r14, rdi
cmp byte ptr [rdi], 3
jnz short loc_B92FE
mov rax, [r14+8]
test rax, rax
jz short loc_B92FE
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_B92FE:
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)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aIncompatibleRe; "incompatible ReferenceType for get_ref,"...
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA56_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[56],char const*>(char const(&)[56],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 12Fh; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_B937A
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_B937A:
test bpl, bpl
jnz short loc_B9384
jmp short loc_B938C
mov r14, rax
loc_B9384:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_B938C:
mov rdi, r14
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::get_ref_impl<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>>(
long long a1)
{
long long result; // rax
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
const char *v3; // [rsp+8h] [rbp-40h] BYREF
_QWORD v4[2]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 != 3 || (result = *(_QWORD *)(a1 + 8)) == 0 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v3 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[56],char const*>(
(long long)v4,
(long long)"incompatible ReferenceType for get_ref, actual type is ",
&v3);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
303,
v4);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return result;
}
|
get_ref_impl<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>>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
CMP byte ptr [RDI],0x3
JNZ 0x001b92fe
MOV RAX,qword ptr [R14 + 0x8]
TEST RAX,RAX
JZ 0x001b92fe
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_001b92fe:
MOV EDI,0x20
CALL 0x0011b440
MOV RBX,RAX
MOV RDI,R14
CALL 0x0015f5fc
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_001b931b:
LEA RSI,[0x1f3014]
LEA RDI,[RSP + 0x10]
CALL 0x001b2770
MOV BPL,0x1
LAB_001b932f:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x12f
MOV RCX,R14
CALL 0x0015f3a4
XOR EBP,EBP
LEA RSI,[0x22bf38]
LEA RDX,[0x15b832]
MOV RDI,RBX
CALL 0x0011bf00
|
/* 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>::get_ref_impl<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> >(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>&) */
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>
::
get_ref_impl<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>>
(basic_json *param_1)
{
int8 uVar1;
char *local_40;
detail local_38 [32];
if ((*param_1 == (basic_json)0x3) && (*(string **)(param_1 + 8) != (string *)0x0)) {
return *(string **)(param_1 + 8);
}
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name((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);
/* try { // try from 001b931b to 001b932b has its CatchHandler @ 001b9381 */
detail::concat<std::__cxx11::string,char_const(&)[56],char_const*>
(local_38,"incompatible ReferenceType for get_ref, actual type is ",&local_40);
/* try { // try from 001b932f to 001b935b has its CatchHandler @ 001b935c */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar1,0x12f,local_38,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::type_error::typeinfo,detail::exception::~exception);
}
|
|
66,048 |
my_coll_parser_scan_shift
|
eloqsql/strings/ctype-uca.c
|
static int
my_coll_parser_scan_shift(MY_COLL_RULE_PARSER *p)
{
if (my_coll_parser_curr(p)->term == MY_COLL_LEXEM_SHIFT)
{
my_coll_rule_shift_at_level(&p->rule, my_coll_parser_curr(p)->diff);
return my_coll_parser_scan(p);
}
return 0;
}
|
O3
|
c
|
my_coll_parser_scan_shift:
xorl %eax, %eax
cmpl $0x1, (%rdi)
jne 0xc3562
movl 0x20(%rdi), %eax
decl %eax
cmpl $0x3, %eax
ja 0xc3535
leaq 0x1ab62c(%rip), %rcx # 0x26eb10
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
incl 0xd0(%rdi)
movl $0x0, 0xdc(%rdi)
movq $0x0, 0xd4(%rdi)
jmp 0xc3535
incl 0xd8(%rdi)
movl $0x0, 0xdc(%rdi)
jmp 0xc3535
incl 0xdc(%rdi)
jmp 0xc3535
incl 0xd4(%rdi)
movq $0x0, 0xd8(%rdi)
pushq %rbp
movq %rsp, %rbp
leaq 0x28(%rdi), %rax
movq 0x48(%rdi), %rcx
movq %rcx, 0x20(%rdi)
movups 0x28(%rdi), %xmm0
movups 0x38(%rdi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rax, %rdi
callq 0xc322f
movl $0x1, %eax
popq %rbp
retq
|
my_coll_parser_scan_shift:
xor eax, eax
cmp dword ptr [rdi], 1
jnz locret_C3562
mov eax, [rdi+20h]
dec eax; switch 4 cases
cmp eax, 3
ja short def_C34EB; jumptable 00000000000C34EB default case
lea rcx, jpt_C34EB
movsxd rax, ds:(jpt_C34EB - 26EB10h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_C34ED:
inc dword ptr [rdi+0D0h]; jumptable 00000000000C34EB case 1
mov dword ptr [rdi+0DCh], 0
mov qword ptr [rdi+0D4h], 0
jmp short def_C34EB; jumptable 00000000000C34EB default case
loc_C350A:
inc dword ptr [rdi+0D8h]; jumptable 00000000000C34EB case 3
mov dword ptr [rdi+0DCh], 0
jmp short def_C34EB; jumptable 00000000000C34EB default case
loc_C351C:
inc dword ptr [rdi+0DCh]; jumptable 00000000000C34EB case 4
jmp short def_C34EB; jumptable 00000000000C34EB default case
loc_C3524:
inc dword ptr [rdi+0D4h]; jumptable 00000000000C34EB case 2
mov qword ptr [rdi+0D8h], 0
def_C34EB:
push rbp; jumptable 00000000000C34EB default case
mov rbp, rsp
lea rax, [rdi+28h]
mov rcx, [rdi+48h]
mov [rdi+20h], rcx
movups xmm0, xmmword ptr [rdi+28h]
movups xmm1, xmmword ptr [rdi+38h]
movups xmmword ptr [rdi+10h], xmm1
movups xmmword ptr [rdi], xmm0
mov rdi, rax
call my_coll_lexem_next
mov eax, 1
pop rbp
locret_C3562:
retn
|
long long my_coll_parser_scan_shift(long long a1)
{
long long result; // rax
__int128 v2; // xmm0
result = 0LL;
if ( *(_DWORD *)a1 == 1 )
{
switch ( *(_DWORD *)(a1 + 32) )
{
case 1:
++*(_DWORD *)(a1 + 208);
*(_DWORD *)(a1 + 220) = 0;
*(_QWORD *)(a1 + 212) = 0LL;
break;
case 2:
++*(_DWORD *)(a1 + 212);
*(_QWORD *)(a1 + 216) = 0LL;
break;
case 3:
++*(_DWORD *)(a1 + 216);
*(_DWORD *)(a1 + 220) = 0;
break;
case 4:
++*(_DWORD *)(a1 + 220);
break;
default:
break;
}
*(_QWORD *)(a1 + 32) = *(_QWORD *)(a1 + 72);
v2 = *(_OWORD *)(a1 + 40);
*(_OWORD *)(a1 + 16) = *(_OWORD *)(a1 + 56);
*(_OWORD *)a1 = v2;
my_coll_lexem_next(a1 + 40);
return 1LL;
}
return result;
}
|
my_coll_parser_scan_shift:
XOR EAX,EAX
CMP dword ptr [RDI],0x1
JNZ 0x001c3562
MOV EAX,dword ptr [RDI + 0x20]
DEC EAX
CMP EAX,0x3
JA 0x001c3535
LEA RCX,[0x36eb10]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
INC dword ptr [RDI + 0xd0]
MOV dword ptr [RDI + 0xdc],0x0
MOV qword ptr [RDI + 0xd4],0x0
JMP 0x001c3535
caseD_3:
INC dword ptr [RDI + 0xd8]
MOV dword ptr [RDI + 0xdc],0x0
JMP 0x001c3535
caseD_4:
INC dword ptr [RDI + 0xdc]
JMP 0x001c3535
caseD_2:
INC dword ptr [RDI + 0xd4]
MOV qword ptr [RDI + 0xd8],0x0
default:
PUSH RBP
MOV RBP,RSP
LEA RAX,[RDI + 0x28]
MOV RCX,qword ptr [RDI + 0x48]
MOV qword ptr [RDI + 0x20],RCX
MOVUPS XMM0,xmmword ptr [RDI + 0x28]
MOVUPS XMM1,xmmword ptr [RDI + 0x38]
MOVUPS xmmword ptr [RDI + 0x10],XMM1
MOVUPS xmmword ptr [RDI],XMM0
MOV RDI,RAX
CALL 0x001c322f
MOV EAX,0x1
POP RBP
LAB_001c3562:
RET
|
int8 my_coll_parser_scan_shift(int *param_1)
{
int8 uVar1;
uVar1 = 0;
if (*param_1 == 1) {
switch(param_1[8]) {
case 1:
param_1[0x34] = param_1[0x34] + 1;
param_1[0x37] = 0;
param_1[0x35] = 0;
param_1[0x36] = 0;
break;
case 2:
param_1[0x35] = param_1[0x35] + 1;
param_1[0x36] = 0;
param_1[0x37] = 0;
break;
case 3:
param_1[0x36] = param_1[0x36] + 1;
param_1[0x37] = 0;
break;
case 4:
param_1[0x37] = param_1[0x37] + 1;
}
*(int8 *)(param_1 + 8) = *(int8 *)(param_1 + 0x12);
param_1[4] = param_1[0xe];
param_1[5] = param_1[0xf];
param_1[6] = param_1[0x10];
param_1[7] = param_1[0x11];
*param_1 = param_1[10];
param_1[1] = param_1[0xb];
param_1[2] = param_1[0xc];
param_1[3] = param_1[0xd];
my_coll_lexem_next(param_1 + 10);
uVar1 = 1;
}
return uVar1;
}
|
|
66,049 |
LefDefParser::defwBlockagesLayerExceptpgnet()
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defwWriter.cpp
|
int
defwBlockagesLayerExceptpgnet()
{
defwFunc = DEFW_BLOCKAGE_LAYER; // Current function of writer
if (!defwFile)
return DEFW_UNINITIALIZED;
if ((defwState != DEFW_BLOCKAGE_LAYER) && (defwState != DEFW_BLOCKAGE_RECT))
return DEFW_BAD_ORDER;
if (defwState == DEFW_BLOCKAGE_RECT)
fprintf(defwFile, " ;\n"); // end the previous rectangle
fprintf(defwFile, " + EXCEPTPGNET\n");
defwLines++;
defwState = DEFW_BLOCKAGE_LAYER;
return DEFW_OK;
}
|
O0
|
cpp
|
LefDefParser::defwBlockagesLayerExceptpgnet():
pushq %rax
leaq 0xc910(%rip), %rax # 0x2b168
movl $0x2c, (%rax)
leaq 0xc8f3(%rip), %rax # 0x2b158
cmpq $0x0, (%rax)
jne 0x1e878
movl $0x1, 0x4(%rsp)
jmp 0x1e900
leaq 0xc8e5(%rip), %rax # 0x2b164
cmpl $0x2c, (%rax)
je 0x1e89a
leaq 0xc8d9(%rip), %rax # 0x2b164
cmpl $0x2e, (%rax)
je 0x1e89a
movl $0x2, 0x4(%rsp)
jmp 0x1e900
leaq 0xc8c3(%rip), %rax # 0x2b164
cmpl $0x2e, (%rax)
jne 0x1e8be
leaq 0xc8ab(%rip), %rax # 0x2b158
movq (%rax), %rdi
leaq 0x559b(%rip), %rsi # 0x23e52
movb $0x0, %al
callq 0x10f0
leaq 0xc893(%rip), %rax # 0x2b158
movq (%rax), %rdi
leaq 0x6790(%rip), %rsi # 0x2505f
movb $0x0, %al
callq 0x10f0
leaq 0xc883(%rip), %rax # 0x2b160
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0xc877(%rip), %rax # 0x2b160
movl %ecx, (%rax)
leaq 0xc872(%rip), %rax # 0x2b164
movl $0x2c, (%rax)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
popq %rcx
retq
nopw %cs:(%rax,%rax)
|
_ZN12LefDefParser29defwBlockagesLayerExceptpgnetEv:
push rax
lea rax, _ZN12LefDefParser8defwFuncE; LefDefParser::defwFunc
mov dword ptr [rax], 2Ch ; ','
lea rax, _ZN12LefDefParser8defwFileE; LefDefParser::defwFile
cmp qword ptr [rax], 0
jnz short loc_1E878
mov [rsp+8+var_4], 1
jmp loc_1E900
loc_1E878:
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
cmp dword ptr [rax], 2Ch ; ','
jz short loc_1E89A
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
cmp dword ptr [rax], 2Eh ; '.'
jz short loc_1E89A
mov [rsp+8+var_4], 2
jmp short loc_1E900
loc_1E89A:
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
cmp dword ptr [rax], 2Eh ; '.'
jnz short loc_1E8BE
lea rax, _ZN12LefDefParser8defwFileE; LefDefParser::defwFile
mov rdi, [rax]
lea rsi, aDividercharS+10h; " ;\n"
mov al, 0
call _fprintf
loc_1E8BE:
lea rax, _ZN12LefDefParser8defwFileE; LefDefParser::defwFile
mov rdi, [rax]
lea rsi, aExceptpgnet; " + EXCEPTPGNET\n"
mov al, 0
call _fprintf
lea rax, _ZN12LefDefParser9defwLinesE; LefDefParser::defwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9defwLinesE; LefDefParser::defwLines
mov [rax], ecx
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
mov dword ptr [rax], 2Ch ; ','
mov [rsp+8+var_4], 0
loc_1E900:
mov eax, [rsp+8+var_4]
pop rcx
retn
|
long long LefDefParser::defwBlockagesLayerExceptpgnet(LefDefParser *this)
{
LefDefParser::defwFunc = 44;
if ( LefDefParser::defwFile )
{
if ( LefDefParser::defwState == 44 || LefDefParser::defwState == 46 )
{
if ( LefDefParser::defwState == 46 )
fprintf(LefDefParser::defwFile, " ;\n");
fprintf(LefDefParser::defwFile, " + EXCEPTPGNET\n");
++LefDefParser::defwLines;
LefDefParser::defwState = 44;
return 0;
}
else
{
return 2;
}
}
else
{
return 1;
}
}
|
defwBlockagesLayerExceptpgnet:
PUSH RAX
LEA RAX,[0x12b168]
MOV dword ptr [RAX],0x2c
LEA RAX,[0x12b158]
CMP qword ptr [RAX],0x0
JNZ 0x0011e878
MOV dword ptr [RSP + 0x4],0x1
JMP 0x0011e900
LAB_0011e878:
LEA RAX,[0x12b164]
CMP dword ptr [RAX],0x2c
JZ 0x0011e89a
LEA RAX,[0x12b164]
CMP dword ptr [RAX],0x2e
JZ 0x0011e89a
MOV dword ptr [RSP + 0x4],0x2
JMP 0x0011e900
LAB_0011e89a:
LEA RAX,[0x12b164]
CMP dword ptr [RAX],0x2e
JNZ 0x0011e8be
LEA RAX,[0x12b158]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x123e52]
MOV AL,0x0
CALL 0x001010f0
LAB_0011e8be:
LEA RAX,[0x12b158]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x12505f]
MOV AL,0x0
CALL 0x001010f0
LEA RAX,[0x12b160]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x12b160]
MOV dword ptr [RAX],ECX
LEA RAX,[0x12b164]
MOV dword ptr [RAX],0x2c
MOV dword ptr [RSP + 0x4],0x0
LAB_0011e900:
MOV EAX,dword ptr [RSP + 0x4]
POP RCX
RET
|
/* LefDefParser::defwBlockagesLayerExceptpgnet() */
int4 LefDefParser::defwBlockagesLayerExceptpgnet(void)
{
int4 local_4;
defwFunc = 0x2c;
if (defwFile == (FILE *)0x0) {
local_4 = 1;
}
else if ((defwState == 0x2c) || (defwState == 0x2e)) {
if (defwState == 0x2e) {
fprintf(defwFile," ;\n");
}
fprintf(defwFile," + EXCEPTPGNET\n");
defwLines = defwLines + 1;
defwState = 0x2c;
local_4 = 0;
}
else {
local_4 = 2;
}
return local_4;
}
|
|
66,050 |
std::shared_ptr<item> entry_point_item::parse<__gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>>(__gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>&, __gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>, unsigned int)
|
msxemulator/build_O3/_deps/picotool-src/bintool/metadata.h
|
static std::shared_ptr<item> parse(I& it, I end, uint32_t header) {
uint32_t size = decode_size(header);
uint32_t ep = *it++;
uint32_t sp = *it++;
if (size == 3) {
return std::make_shared<entry_point_item>(ep, sp);
} else if (size == 4) {
uint32_t splim = *it++;
return std::make_shared<entry_point_item>(ep, sp, splim);
} else {
printf("Bad block size %d for entry point item\n", size);
assert(false);
return nullptr;
}
}
|
O3
|
c
|
std::shared_ptr<item> entry_point_item::parse<__gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>>(__gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>&, __gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>, unsigned int):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movl %ecx, %edx
shrl $0x8, %edx
testb %cl, %cl
movl $0xff, %ecx
movl $0xffff, %esi # imm = 0xFFFF
cmovnsl %ecx, %esi
movq %rdi, %rbx
andl %edx, %esi
movq (%rax), %rcx
movl (%rcx), %ebp
leaq 0x8(%rcx), %rdx
movq %rdx, (%rax)
movl 0x4(%rcx), %r14d
cmpl $0x4, %esi
je 0x774d9
cmpl $0x3, %esi
jne 0x7752d
movl $0x28, %edi
callq 0xf460
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x6a33e(%rip), %rcx # 0xe17f8
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
leaq 0x6a290(%rip), %rdx # 0xe1758
movq %rdx, 0x10(%rax)
movl %ebp, 0x18(%rax)
movl %r14d, 0x1c(%rax)
movb $0x0, 0x24(%rax)
jmp 0x77524
leaq 0xc(%rcx), %rdx
movq %rdx, (%rax)
movl 0x8(%rcx), %r15d
movl $0x28, %edi
callq 0xf460
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x6a2f5(%rip), %rcx # 0xe17f8
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
leaq 0x6a247(%rip), %rdx # 0xe1758
movq %rdx, 0x10(%rax)
movl %ebp, 0x18(%rax)
movl %r14d, 0x1c(%rax)
movl %r15d, 0x20(%rax)
movb $0x1, 0x24(%rax)
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
jmp 0x77541
leaq 0x33a2e(%rip), %rdi # 0xaaf62
xorl %eax, %eax
callq 0xf070
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
_ZN16entry_point_item5parseIN9__gnu_cxx17__normal_iteratorIPjSt6vectorIjSaIjEEEEEESt10shared_ptrI4itemERT_SB_j:
push rbp
push r15
push r14
push rbx
push rax
mov rax, rsi
mov edx, ecx
shr edx, 8
test cl, cl
mov ecx, 0FFh
mov esi, 0FFFFh
cmovns esi, ecx
mov rbx, rdi
and esi, edx
mov rcx, [rax]
mov ebp, [rcx]
lea rdx, [rcx+8]
mov [rax], rdx
mov r14d, [rcx+4]
cmp esi, 4
jz short loc_774D9
cmp esi, 3
jnz loc_7752D
mov edi, 28h ; '('; unsigned __int64
call __Znwm; operator new(ulong)
mov rcx, 100000001h
mov [rax+8], rcx
lea rcx, off_E17F8
mov [rax], rcx
lea rcx, [rax+10h]
lea rdx, off_E1758
mov [rax+10h], rdx
mov [rax+18h], ebp
mov [rax+1Ch], r14d
mov byte ptr [rax+24h], 0
jmp short loc_77524
loc_774D9:
lea rdx, [rcx+0Ch]
mov [rax], rdx
mov r15d, [rcx+8]
mov edi, 28h ; '('; unsigned __int64
call __Znwm; operator new(ulong)
mov rcx, 100000001h
mov [rax+8], rcx
lea rcx, off_E17F8
mov [rax], rcx
lea rcx, [rax+10h]
lea rdx, off_E1758
mov [rax+10h], rdx
mov [rax+18h], ebp
mov [rax+1Ch], r14d
mov [rax+20h], r15d
mov byte ptr [rax+24h], 1
loc_77524:
mov [rbx], rcx
mov [rbx+8], rax
jmp short loc_77541
loc_7752D:
lea rdi, aBadBlockSizeDF_1; "Bad block size %d for entry point item"...
xor eax, eax
call _printf
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
loc_77541:
mov rax, rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long entry_point_item::parse<__gnu_cxx::__normal_iterator<unsigned int *,std::vector<unsigned int>>>(
long long a1,
int **a2,
long long a3,
unsigned int a4)
{
int v5; // esi
int v6; // esi
int *v7; // rcx
int v8; // ebp
int v9; // r14d
long long v10; // rax
long long v11; // rcx
int v12; // r15d
v5 = 0xFFFF;
if ( (a4 & 0x80u) == 0 )
v5 = 255;
v6 = (a4 >> 8) & v5;
v7 = *a2;
v8 = **a2;
*a2 += 2;
v9 = v7[1];
if ( v6 == 4 )
{
*a2 = v7 + 3;
v12 = v7[2];
v10 = operator new(0x28uLL);
*(_QWORD *)(v10 + 8) = 0x100000001LL;
*(_QWORD *)v10 = off_E17F8;
v11 = v10 + 16;
*(_QWORD *)(v10 + 16) = off_E1758;
*(_DWORD *)(v10 + 24) = v8;
*(_DWORD *)(v10 + 28) = v9;
*(_DWORD *)(v10 + 32) = v12;
*(_BYTE *)(v10 + 36) = 1;
}
else
{
if ( v6 != 3 )
{
printf("Bad block size %d for entry point item\n", v6);
*(_OWORD *)a1 = 0LL;
return a1;
}
v10 = operator new(0x28uLL);
*(_QWORD *)(v10 + 8) = 0x100000001LL;
*(_QWORD *)v10 = off_E17F8;
v11 = v10 + 16;
*(_QWORD *)(v10 + 16) = off_E1758;
*(_DWORD *)(v10 + 24) = v8;
*(_DWORD *)(v10 + 28) = v9;
*(_BYTE *)(v10 + 36) = 0;
}
*(_QWORD *)a1 = v11;
*(_QWORD *)(a1 + 8) = v10;
return a1;
}
|
parse<__gnu_cxx::__normal_iterator<unsigned_int*,std::vector<unsigned_int,std::allocator<unsigned_int>>>>:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RAX,RSI
MOV EDX,ECX
SHR EDX,0x8
TEST CL,CL
MOV ECX,0xff
MOV ESI,0xffff
CMOVNS ESI,ECX
MOV RBX,RDI
AND ESI,EDX
MOV RCX,qword ptr [RAX]
MOV EBP,dword ptr [RCX]
LEA RDX,[RCX + 0x8]
MOV qword ptr [RAX],RDX
MOV R14D,dword ptr [RCX + 0x4]
CMP ESI,0x4
JZ 0x001774d9
CMP ESI,0x3
JNZ 0x0017752d
MOV EDI,0x28
CALL 0x0010f460
MOV RCX,0x100000001
MOV qword ptr [RAX + 0x8],RCX
LEA RCX,[0x1e17f8]
MOV qword ptr [RAX],RCX
LEA RCX,[RAX + 0x10]
LEA RDX,[0x1e1758]
MOV qword ptr [RAX + 0x10],RDX
MOV dword ptr [RAX + 0x18],EBP
MOV dword ptr [RAX + 0x1c],R14D
MOV byte ptr [RAX + 0x24],0x0
JMP 0x00177524
LAB_001774d9:
LEA RDX,[RCX + 0xc]
MOV qword ptr [RAX],RDX
MOV R15D,dword ptr [RCX + 0x8]
MOV EDI,0x28
CALL 0x0010f460
MOV RCX,0x100000001
MOV qword ptr [RAX + 0x8],RCX
LEA RCX,[0x1e17f8]
MOV qword ptr [RAX],RCX
LEA RCX,[RAX + 0x10]
LEA RDX,[0x1e1758]
MOV qword ptr [RAX + 0x10],RDX
MOV dword ptr [RAX + 0x18],EBP
MOV dword ptr [RAX + 0x1c],R14D
MOV dword ptr [RAX + 0x20],R15D
MOV byte ptr [RAX + 0x24],0x1
LAB_00177524:
MOV qword ptr [RBX],RCX
MOV qword ptr [RBX + 0x8],RAX
JMP 0x00177541
LAB_0017752d:
LEA RDI,[0x1aaf62]
XOR EAX,EAX
CALL 0x0010f070
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
LAB_00177541:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* std::shared_ptr<item> entry_point_item::parse<__gnu_cxx::__normal_iterator<unsigned int*,
std::vector<unsigned int, std::allocator<unsigned int> > >
>(__gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned
int> > >&, __gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int,
std::allocator<unsigned int> > >, unsigned int) */
entry_point_item * __thiscall
entry_point_item::
parse<__gnu_cxx::__normal_iterator<unsigned_int*,std::vector<unsigned_int,std::allocator<unsigned_int>>>>
(entry_point_item *this,long *param_1,int8 param_3,uint param_4)
{
int4 uVar1;
int4 uVar2;
int4 uVar3;
int4 *puVar4;
int8 *puVar5;
uint uVar6;
uVar6 = 0xffff;
if (-1 < (char)param_4) {
uVar6 = 0xff;
}
uVar6 = uVar6 & param_4 >> 8;
puVar4 = (int4 *)*param_1;
uVar1 = *puVar4;
*param_1 = (long)(puVar4 + 2);
uVar2 = puVar4[1];
if (uVar6 == 4) {
*param_1 = (long)(puVar4 + 3);
uVar3 = puVar4[2];
puVar5 = (int8 *)operator_new(0x28);
puVar5[1] = 0x100000001;
*puVar5 = &PTR___Sp_counted_ptr_inplace_001e17f8;
puVar5[2] = &PTR__item_001e1758;
*(int4 *)(puVar5 + 3) = uVar1;
*(int4 *)((long)puVar5 + 0x1c) = uVar2;
*(int4 *)(puVar5 + 4) = uVar3;
*(int1 *)((long)puVar5 + 0x24) = 1;
}
else {
if (uVar6 != 3) {
printf("Bad block size %d for entry point item\n");
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
return this;
}
puVar5 = (int8 *)operator_new(0x28);
puVar5[1] = 0x100000001;
*puVar5 = &PTR___Sp_counted_ptr_inplace_001e17f8;
puVar5[2] = &PTR__item_001e1758;
*(int4 *)(puVar5 + 3) = uVar1;
*(int4 *)((long)puVar5 + 0x1c) = uVar2;
*(int1 *)((long)puVar5 + 0x24) = 0;
}
*(int8 **)this = puVar5 + 2;
*(int8 **)(this + 8) = puVar5;
return this;
}
|
|
66,051 |
inline_mysql_file_tell
|
eloqsql/include/mysql/psi/mysql_file.h
|
static inline my_off_t
inline_mysql_file_tell(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, myf flags)
{
my_off_t result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file, PSI_FILE_TELL);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, (size_t) 0, src_file, src_line);
result= my_tell(file, flags);
PSI_FILE_CALL(end_file_wait)(locker, (size_t) 0);
return result;
}
#endif
result= my_tell(file, flags);
return result;
}
|
O3
|
c
|
inline_mysql_file_tell:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %edi, %ebx
leaq 0x34051e(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0x60(%rbp), %rdi
movl %ebx, %esi
movl $0x9, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x45b1d
movl %ebx, %edi
xorl %esi, %esi
callq 0xa0c04
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x18(%rbp), %r14
movq %rax, %rdi
movl %ebx, %esi
movq %r14, %rdx
callq 0x2a190
movq (%r14), %rax
jmp 0x45b14
|
inline_mysql_file_tell:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 50h
mov ebx, edi
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_60]
mov esi, ebx
mov edx, 9
call qword ptr [rax+158h]
test rax, rax
jnz short loc_45B1D
mov edi, ebx
xor esi, esi
call my_tell
loc_45B14:
add rsp, 50h
pop rbx
pop r14
pop rbp
retn
loc_45B1D:
lea r14, [rbp+var_18]
mov rdi, rax
mov esi, ebx
mov rdx, r14
call inline_mysql_file_tell_cold_1
mov rax, [r14]
jmp short loc_45B14
|
long long inline_mysql_file_tell(unsigned int a1)
{
long long v1; // rax
_BYTE v3[72]; // [rsp+0h] [rbp-60h] BYREF
_QWORD v4[3]; // [rsp+48h] [rbp-18h] BYREF
v1 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v3, a1, 9LL);
if ( !v1 )
return my_tell(a1, 0LL);
inline_mysql_file_tell_cold_1(v1, a1, v4);
return v4[0];
}
|
inline_mysql_file_tell:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV EBX,EDI
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x60]
MOV ESI,EBX
MOV EDX,0x9
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x00145b1d
MOV EDI,EBX
XOR ESI,ESI
CALL 0x001a0c04
LAB_00145b14:
ADD RSP,0x50
POP RBX
POP R14
POP RBP
RET
LAB_00145b1d:
LEA R14,[RBP + -0x18]
MOV RDI,RAX
MOV ESI,EBX
MOV RDX,R14
CALL 0x0012a190
MOV RAX,qword ptr [R14]
JMP 0x00145b14
|
int8 inline_mysql_file_tell(int4 param_1)
{
long lVar1;
int1 local_68 [72];
int8 local_20;
lVar1 = (**(code **)(PSI_server + 0x158))(local_68,param_1,9);
if (lVar1 == 0) {
local_20 = my_tell(param_1,0);
}
else {
inline_mysql_file_tell_cold_1(lVar1,param_1,&local_20);
}
return local_20;
}
|
|
66,052 |
crypt_data_scheme_locker
|
eloqsql/storage/maria/ma_crypt.c
|
static void crypt_data_scheme_locker(struct st_encryption_scheme *scheme,
int unlock)
{
MARIA_CRYPT_DATA *crypt_data = (MARIA_CRYPT_DATA*)scheme;
if (unlock)
mysql_mutex_unlock(&crypt_data->lock);
else
mysql_mutex_lock(&crypt_data->lock);
}
|
O3
|
c
|
crypt_data_scheme_locker:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x68(%rdi), %rbx
movq 0xa8(%rdi), %rdi
testl %esi, %esi
je 0x67839
testq %rdi, %rdi
jne 0x6784c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x291d0
testq %rdi, %rdi
jne 0x6785e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x29210
leaq 0x31e7bd(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x6782b
leaq 0x73382(%rip), %rsi # 0xdabe7
movq %rbx, %rdi
movl $0x61, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2ebaf
|
crypt_data_scheme_locker:
push rbp
mov rbp, rsp
push rbx
push rax
lea rbx, [rdi+68h]
mov rdi, [rdi+0A8h]
test esi, esi
jz short loc_67839
test rdi, rdi
jnz short loc_6784C
loc_6782B:
mov rdi, rbx
add rsp, 8
pop rbx
pop rbp
jmp _pthread_mutex_unlock
loc_67839:
test rdi, rdi
jnz short loc_6785E
mov rdi, rbx
add rsp, 8
pop rbx
pop rbp
jmp _pthread_mutex_lock
loc_6784C:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_6782B
loc_6785E:
lea rsi, aWorkspaceLlm4b_10; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, rbx
mov edx, 61h ; 'a'
add rsp, 8
pop rbx
pop rbp
jmp psi_mutex_lock
|
long long crypt_data_scheme_locker(long long a1, int a2)
{
long long v2; // rbx
long long v3; // rdi
v2 = a1 + 104;
v3 = *(_QWORD *)(a1 + 168);
if ( a2 )
{
if ( v3 )
((void ( *)(long long))PSI_server[44])(v3);
return pthread_mutex_unlock(v2);
}
else if ( v3 )
{
return psi_mutex_lock(v2, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_crypt.c", 0x61u);
}
else
{
return pthread_mutex_lock(v2);
}
}
|
crypt_data_scheme_locker:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
LEA RBX,[RDI + 0x68]
MOV RDI,qword ptr [RDI + 0xa8]
TEST ESI,ESI
JZ 0x00167839
TEST RDI,RDI
JNZ 0x0016784c
LAB_0016782b:
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x001291d0
LAB_00167839:
TEST RDI,RDI
JNZ 0x0016785e
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x00129210
LAB_0016784c:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0016782b
LAB_0016785e:
LEA RSI,[0x1dabe7]
MOV RDI,RBX
MOV EDX,0x61
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x0012ebaf
|
void crypt_data_scheme_locker(long param_1,int param_2)
{
pthread_mutex_t *__mutex;
__mutex = (pthread_mutex_t *)(param_1 + 0x68);
if (param_2 != 0) {
if (*(long *)(param_1 + 0xa8) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
return;
}
if (*(long *)(param_1 + 0xa8) == 0) {
pthread_mutex_lock(__mutex);
return;
}
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_crypt.c",0x61);
return;
}
|
|
66,053 |
minja::Value::operator/(minja::Value const&) const
|
llama.cpp/common/minja/minja.hpp
|
Value operator/(const Value& rhs) const {
if (is_number_integer() && rhs.is_number_integer())
return get<int64_t>() / rhs.get<int64_t>();
else
return get<double>() / rhs.get<double>();
}
|
O3
|
cpp
|
minja::Value::operator/(minja::Value const&) const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movb 0x40(%rsi), %al
addb $-0x5, %al
cmpb $0x1, %al
ja 0xecfc3
movb 0x40(%r14), %al
addb $-0x5, %al
cmpb $0x1, %al
ja 0xecfc3
movq %rsi, %rdi
callq 0xc145a
movq %rax, %r15
movq %r14, %rdi
callq 0xc145a
movq %rax, %rcx
movq %r15, %rax
cqto
idivq %rcx
leaq 0x40(%rbx), %r14
xorpd %xmm0, %xmm0
movupd %xmm0, (%rbx)
movupd %xmm0, 0x10(%rbx)
movupd %xmm0, 0x20(%rbx)
movupd %xmm0, 0x30(%rbx)
movupd %xmm0, 0x40(%rbx)
movq %r14, %rdi
movq %rax, %rsi
callq 0x8b520
jmp 0xed00f
movq %rsi, %rdi
callq 0xbe614
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
callq 0xbe614
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
leaq 0x40(%rbx), %r14
xorpd %xmm0, %xmm0
movupd %xmm0, (%rbx)
movupd %xmm0, 0x10(%rbx)
movupd %xmm0, 0x20(%rbx)
movupd %xmm0, 0x30(%rbx)
movupd %xmm0, 0x40(%rbx)
movq %r14, %rdi
movapd %xmm1, %xmm0
callq 0x8aae8
movq %r14, %rdi
movl $0x1, %esi
callq 0x84776
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
|
_ZNK5minja5ValuedvERKS0_:
push r15
push r14
push rbx
sub rsp, 10h
mov r14, rdx
mov rbx, rdi
mov al, [rsi+40h]
add al, 0FBh
cmp al, 1
ja short loc_ECFC3
mov al, [r14+40h]
add al, 0FBh
cmp al, 1
ja short loc_ECFC3
mov rdi, rsi
call _ZNK5minja5Value3getIlEET_v; minja::Value::get<long>(void)
mov r15, rax
mov rdi, r14
call _ZNK5minja5Value3getIlEET_v; minja::Value::get<long>(void)
mov rcx, rax
mov rax, r15
cqo
idiv rcx
lea r14, [rbx+40h]
xorpd xmm0, xmm0
movupd xmmword ptr [rbx], xmm0
movupd xmmword ptr [rbx+10h], xmm0
movupd xmmword ptr [rbx+20h], xmm0
movupd xmmword ptr [rbx+30h], xmm0
movupd xmmword ptr [rbx+40h], xmm0
mov rdi, r14
mov rsi, rax
call _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE5EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_16number_integer_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)5>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::number_integer_t)
jmp short loc_ED00F
loc_ECFC3:
mov rdi, rsi
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
movsd [rsp+28h+var_20], xmm0
mov rdi, r14
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
movsd xmm1, [rsp+28h+var_20]
divsd xmm1, xmm0
lea r14, [rbx+40h]
xorpd xmm0, xmm0
movupd xmmword ptr [rbx], xmm0
movupd xmmword ptr [rbx+10h], xmm0
movupd xmmword ptr [rbx+20h], xmm0
movupd xmmword ptr [rbx+30h], xmm0
movupd xmmword ptr [rbx+40h], xmm0
mov rdi, r14
movapd xmm0, xmm1
call _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE7EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_14number_float_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)7>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::number_float_t)
loc_ED00F:
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rax, rbx
add rsp, 10h
pop rbx
pop r14
pop r15
retn
|
long long minja::Value::operator/(long long a1, long long a2, long long a3)
{
long long v4; // r15
long long v5; // rax
char *v6; // r14
double v7; // xmm0_8
double v9; // [rsp+8h] [rbp-20h]
if ( (unsigned __int8)(*(_BYTE *)(a2 + 64) - 5) > 1u || (unsigned __int8)(*(_BYTE *)(a3 + 64) - 5) > 1u )
{
v9 = minja::Value::get<double>((_QWORD *)a2);
v7 = minja::Value::get<double>((_QWORD *)a3);
v6 = (char *)(a1 + 64);
*(_OWORD *)a1 = 0LL;
*(_OWORD *)(a1 + 16) = 0LL;
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 64) = 0LL;
nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)7>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
(unsigned __int8 *)(a1 + 64),
v9 / v7);
}
else
{
v4 = minja::Value::get<long>((_QWORD *)a2);
v5 = minja::Value::get<long>((_QWORD *)a3);
v6 = (char *)(a1 + 64);
*(_OWORD *)a1 = 0LL;
*(_OWORD *)(a1 + 16) = 0LL;
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 64) = 0LL;
nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)5>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
(unsigned __int8 *)(a1 + 64),
v4 / v5);
}
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v6);
return a1;
}
|
operator/:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV R14,RDX
MOV RBX,RDI
MOV AL,byte ptr [RSI + 0x40]
ADD AL,0xfb
CMP AL,0x1
JA 0x001ecfc3
MOV AL,byte ptr [R14 + 0x40]
ADD AL,0xfb
CMP AL,0x1
JA 0x001ecfc3
MOV RDI,RSI
CALL 0x001c145a
MOV R15,RAX
MOV RDI,R14
CALL 0x001c145a
MOV RCX,RAX
MOV RAX,R15
CQO
IDIV RCX
LEA R14,[RBX + 0x40]
XORPD XMM0,XMM0
MOVUPD xmmword ptr [RBX],XMM0
MOVUPD xmmword ptr [RBX + 0x10],XMM0
MOVUPD xmmword ptr [RBX + 0x20],XMM0
MOVUPD xmmword ptr [RBX + 0x30],XMM0
MOVUPD xmmword ptr [RBX + 0x40],XMM0
MOV RDI,R14
MOV RSI,RAX
CALL 0x0018b520
JMP 0x001ed00f
LAB_001ecfc3:
MOV RDI,RSI
CALL 0x001be614
MOVSD qword ptr [RSP + 0x8],XMM0
MOV RDI,R14
CALL 0x001be614
MOVSD XMM1,qword ptr [RSP + 0x8]
DIVSD XMM1,XMM0
LEA R14,[RBX + 0x40]
XORPD XMM0,XMM0
MOVUPD xmmword ptr [RBX],XMM0
MOVUPD xmmword ptr [RBX + 0x10],XMM0
MOVUPD xmmword ptr [RBX + 0x20],XMM0
MOVUPD xmmword ptr [RBX + 0x30],XMM0
MOVUPD xmmword ptr [RBX + 0x40],XMM0
MOV RDI,R14
MOVAPD XMM0,XMM1
CALL 0x0018aae8
LAB_001ed00f:
MOV RDI,R14
MOV ESI,0x1
CALL 0x00184776
MOV RAX,RBX
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
/* minja::Value::TEMPNAMEPLACEHOLDERVALUE(minja::Value const&) const */
Value * __thiscall minja::Value::operator/(Value *this,Value *param_1)
{
long lVar1;
long lVar2;
Value *in_RDX;
double dVar3;
double dVar4;
if (((byte)((char)param_1[0x40] - 5U) < 2) && ((byte)((char)in_RDX[0x40] - 5U) < 2)) {
lVar1 = get<long>(param_1);
lVar2 = get<long>(in_RDX);
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
nlohmann::json_abi_v3_11_3::detail::
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)5>::
construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(this + 0x40,lVar1 / lVar2,lVar1 % lVar2);
}
else {
dVar3 = get<double>(param_1);
dVar4 = get<double>(in_RDX);
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
nlohmann::json_abi_v3_11_3::detail::
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)7>::
construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(dVar3 / dVar4,this + 0x40);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant((bool)((char)this + '@'));
return this;
}
|
|
66,054 |
ps_fetch_double
|
eloqsql/libmariadb/libmariadb/ma_stmt_codec.c
|
static
void ps_fetch_double(MYSQL_BIND *r_param, const MYSQL_FIELD * field , unsigned char **row)
{
switch (r_param->buffer_type)
{
case MYSQL_TYPE_DOUBLE:
{
double *value= (double *)r_param->buffer;
float8get(*value, *row);
r_param->buffer_length= 8;
}
break;
default:
{
double value;
float8get(value, *row);
convert_from_double(r_param, field, value, sizeof(double));
}
break;
}
(*row)+= 8;
}
|
O0
|
c
|
ps_fetch_double:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x60(%rax), %eax
subl $0x5, %eax
jne 0x304ed
jmp 0x304c2
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $0x8, 0x40(%rax)
jmp 0x30512
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movsd -0x28(%rbp), %xmm0
movl $0x8, %edx
callq 0x323d0
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x8, %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
ps_fetch_double:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov eax, [rax+60h]
sub eax, 5
jnz short loc_304ED
jmp short $+2
loc_304C2:
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
mov rcx, [rcx]
mov rcx, [rcx]
mov [rax], rcx
mov rax, [rbp+var_8]
mov qword ptr [rax+40h], 8
jmp short loc_30512
loc_304ED:
mov rax, [rbp+var_18]
mov rax, [rax]
mov rax, [rax]
mov [rbp+var_28], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
movsd xmm0, [rbp+var_28]
mov edx, 8
call convert_from_double
loc_30512:
mov rax, [rbp+var_18]
mov rcx, [rax]
add rcx, 8
mov [rax], rcx
add rsp, 30h
pop rbp
retn
|
double ** ps_fetch_double(long long a1, long long a2, double **a3)
{
double **result; // rax
if ( *(_DWORD *)(a1 + 96) == 5 )
{
**(double **)(a1 + 16) = **a3;
*(_QWORD *)(a1 + 64) = 8LL;
}
else
{
convert_from_double(a1, a2, 8LL, **a3);
}
result = a3;
++*a3;
return result;
}
|
ps_fetch_double:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x60]
SUB EAX,0x5
JNZ 0x001304ed
JMP 0x001304c2
LAB_001304c2:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
MOV RCX,qword ptr [RCX]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x40],0x8
JMP 0x00130512
LAB_001304ed:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOVSD XMM0,qword ptr [RBP + -0x28]
MOV EDX,0x8
CALL 0x001323d0
LAB_00130512:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX]
ADD RCX,0x8
MOV qword ptr [RAX],RCX
ADD RSP,0x30
POP RBP
RET
|
void ps_fetch_double(long param_1,int8 param_2,long *param_3)
{
if (*(int *)(param_1 + 0x60) == 5) {
**(int8 **)(param_1 + 0x10) = *(int8 *)*param_3;
*(int8 *)(param_1 + 0x40) = 8;
}
else {
convert_from_double(*(int8 *)*param_3,param_1,param_2,8);
}
*param_3 = *param_3 + 8;
return;
}
|
|
66,055 |
yoyo::Message::Message()
|
isyoCode[P]yoyologger/test/./../src/logger.hpp
|
Message() = default;
|
O2
|
cpp
|
yoyo::Message::Message():
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
addq $0x28, %rdi
leaq 0x6653(%rip), %rax # 0xac48
movq %rsp, %rsi
movq %rax, (%rsi)
callq 0x4620
andq $0x0, 0x78(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3a22
movq %r14, %rdi
callq 0x33e0
|
_ZN4yoyo7MessageC2Ev:
push r14
push rbx
push rax
mov r14, rdi
lea rbx, [rdi+8]
lea rax, [rdi+18h]
mov [rdi+8], rax
and qword ptr [rdi+10h], 0
mov byte ptr [rdi+18h], 0
add rdi, 28h ; '('
lea rax, off_AC48; "/workspace/llm4binary/github/2025_star3"...
mov rsi, rsp
mov [rsi], rax
call _ZN4yoyo12LocationInfoC2ERKSt15source_location; yoyo::LocationInfo::LocationInfo(std::source_location const&)
and qword ptr [r14+78h], 0
add rsp, 8
pop rbx
pop r14
retn
mov r14, rax
mov rdi, rbx; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r14
call __Unwind_Resume
|
long long yoyo::Message::Message(yoyo::Message *this)
{
long long result; // rax
*((_QWORD *)this + 1) = (char *)this + 24;
*((_QWORD *)this + 2) = 0LL;
*((_BYTE *)this + 24) = 0;
result = yoyo::LocationInfo::LocationInfo((char *)this + 40);
*((_QWORD *)this + 15) = 0LL;
return result;
}
|
Message:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RDI
LEA RBX,[RDI + 0x8]
LEA RAX,[RDI + 0x18]
MOV qword ptr [RDI + 0x8],RAX
AND qword ptr [RDI + 0x10],0x0
MOV byte ptr [RDI + 0x18],0x0
ADD RDI,0x28
LEA RAX,[0x10ac48]
MOV RSI,RSP
MOV qword ptr [RSI],RAX
LAB_001045fb:
CALL 0x00104620
LAB_00104600:
AND qword ptr [R14 + 0x78],0x0
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* yoyo::Message::Message() */
void __thiscall yoyo::Message::Message(Message *this)
{
int **local_18;
*(Message **)(this + 8) = this + 0x18;
*(int8 *)(this + 0x10) = 0;
this[0x18] = (Message)0x0;
local_18 = &PTR_s__workspace_llm4binary_github_202_0010ac48;
/* try { // try from 001045fb to 001045ff has its CatchHandler @ 0010460d */
LocationInfo::LocationInfo((LocationInfo *)(this + 0x28),(source_location *)&local_18);
*(int8 *)(this + 0x78) = 0;
return;
}
|
|
66,056 |
stbi__zhuffman_decode_slowpath(stbi__zbuf*, stbi__zhuffman*)
|
mnn-tts/MNN/3rd_party/imageHelper/stb_image.h
|
static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z)
{
int b,s,k;
// not resolved by fast table, so compute it the slow way
// use jpeg approach, which requires MSbits at top
k = stbi__bit_reverse(a->code_buffer, 16);
for (s=STBI__ZFAST_BITS+1; ; ++s)
if (k < z->maxcode[s])
break;
if (s == 16) return -1; // invalid code!
// code size is s, so:
b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s];
STBI_ASSERT(z->size[b] == s);
a->code_buffer >>= s;
a->num_bits -= s;
return z->value[b];
}
|
O0
|
c
|
stbi__zhuffman_decode_slowpath(stbi__zbuf*, stbi__zhuffman*):
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movl 0x14(%rax), %edi
movl $0x10, %esi
callq 0x1d9a0
movl %eax, 0x4(%rsp)
movl $0xa, 0x8(%rsp)
movl 0x4(%rsp), %eax
movq 0x10(%rsp), %rcx
movslq 0x8(%rsp), %rdx
cmpl 0x420(%rcx,%rdx,4), %eax
jge 0x1db75
jmp 0x1db84
jmp 0x1db77
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x1db5c
cmpl $0x10, 0x8(%rsp)
jne 0x1db98
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x1dc46
movl 0x4(%rsp), %eax
movl $0x10, %ecx
subl 0x8(%rsp), %ecx
sarl %cl, %eax
movq 0x10(%rsp), %rcx
movslq 0x8(%rsp), %rdx
movzwl 0x400(%rcx,%rdx,2), %ecx
subl %ecx, %eax
movq 0x10(%rsp), %rcx
movslq 0x8(%rsp), %rdx
movzwl 0x464(%rcx,%rdx,2), %ecx
addl %ecx, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movzbl 0x484(%rax,%rcx), %eax
cmpl 0x8(%rsp), %eax
jne 0x1dbed
jmp 0x1dc0c
leaq 0x71f8(%rip), %rdi # 0x24dec
leaq 0x66d0(%rip), %rsi # 0x242cb
movl $0xf97, %edx # imm = 0xF97
leaq 0x71f5(%rip), %rcx # 0x24dfc
callq 0x2100
movl 0x8(%rsp), %ecx
movq 0x18(%rsp), %rax
movl 0x14(%rax), %edx
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, 0x14(%rax)
movl 0x8(%rsp), %edx
movq 0x18(%rsp), %rax
movl 0x10(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x10(%rax)
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movzwl 0x5a4(%rax,%rcx,2), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
|
_ZL30stbi__zhuffman_decode_slowpathP10stbi__zbufP14stbi__zhuffman:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_18], rsi
mov rax, [rsp+28h+var_10]
mov edi, [rax+14h]; int
mov esi, 10h; int
call _ZL17stbi__bit_reverseii; stbi__bit_reverse(int,int)
mov [rsp+28h+var_24], eax
mov [rsp+28h+var_20], 0Ah
loc_1DB5C:
mov eax, [rsp+28h+var_24]
mov rcx, [rsp+28h+var_18]
movsxd rdx, [rsp+28h+var_20]
cmp eax, [rcx+rdx*4+420h]
jge short loc_1DB75
jmp short loc_1DB84
loc_1DB75:
jmp short $+2
loc_1DB77:
mov eax, [rsp+28h+var_20]
add eax, 1
mov [rsp+28h+var_20], eax
jmp short loc_1DB5C
loc_1DB84:
cmp [rsp+28h+var_20], 10h
jnz short loc_1DB98
mov [rsp+28h+var_4], 0FFFFFFFFh
jmp loc_1DC46
loc_1DB98:
mov eax, [rsp+28h+var_24]
mov ecx, 10h
sub ecx, [rsp+28h+var_20]
sar eax, cl
mov rcx, [rsp+28h+var_18]
movsxd rdx, [rsp+28h+var_20]
movzx ecx, word ptr [rcx+rdx*2+400h]
sub eax, ecx
mov rcx, [rsp+28h+var_18]
movsxd rdx, [rsp+28h+var_20]
movzx ecx, word ptr [rcx+rdx*2+464h]
add eax, ecx
mov [rsp+28h+var_1C], eax
mov rax, [rsp+28h+var_18]
movsxd rcx, [rsp+28h+var_1C]
movzx eax, byte ptr [rax+rcx+484h]
cmp eax, [rsp+28h+var_20]
jnz short loc_1DBED
jmp short loc_1DC0C
loc_1DBED:
lea rdi, aZSizeBS; "z->size[b] == s"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/mnn-tt"...
mov edx, 0F97h
lea rcx, aIntStbiZhuffma; "int stbi__zhuffman_decode_slowpath(stbi"...
call ___assert_fail
loc_1DC0C:
mov ecx, [rsp+28h+var_20]
mov rax, [rsp+28h+var_10]
mov edx, [rax+14h]
shr edx, cl
mov ecx, edx
mov [rax+14h], ecx
mov edx, [rsp+28h+var_20]
mov rax, [rsp+28h+var_10]
mov ecx, [rax+10h]
sub ecx, edx
mov [rax+10h], ecx
mov rax, [rsp+28h+var_18]
movsxd rcx, [rsp+28h+var_1C]
movzx eax, word ptr [rax+rcx*2+5A4h]
mov [rsp+28h+var_4], eax
loc_1DC46:
mov eax, [rsp+28h+var_4]
add rsp, 28h
retn
|
long long stbi__zhuffman_decode_slowpath(long long a1, long long a2)
{
int v3; // [rsp+4h] [rbp-24h]
int i; // [rsp+8h] [rbp-20h]
int v5; // [rsp+Ch] [rbp-1Ch]
v3 = stbi__bit_reverse(*(_DWORD *)(a1 + 20), 16);
for ( i = 10; v3 >= *(_DWORD *)(a2 + 4LL * i + 1056); ++i )
;
if ( i == 16 )
{
return (unsigned int)-1;
}
else
{
v5 = *(unsigned __int16 *)(a2 + 2LL * i + 1124) + (v3 >> (16 - i)) - *(unsigned __int16 *)(a2 + 2LL * i + 1024);
if ( *(unsigned __int8 *)(a2 + v5 + 1156) != i )
__assert_fail(
"z->size[b] == s",
"/workspace/llm4binary/github2025/mnn-tts/MNN/3rd_party/imageHelper/stb_image.h",
3991LL,
"int stbi__zhuffman_decode_slowpath(stbi__zbuf *, stbi__zhuffman *)");
*(_DWORD *)(a1 + 20) >>= i;
*(_DWORD *)(a1 + 16) -= i;
return *(unsigned __int16 *)(a2 + 2LL * v5 + 1444);
}
}
|
stbi__zhuffman_decode_slowpath:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV qword ptr [RSP + 0x10],RSI
MOV RAX,qword ptr [RSP + 0x18]
MOV EDI,dword ptr [RAX + 0x14]
MOV ESI,0x10
CALL 0x0011d9a0
MOV dword ptr [RSP + 0x4],EAX
MOV dword ptr [RSP + 0x8],0xa
LAB_0011db5c:
MOV EAX,dword ptr [RSP + 0x4]
MOV RCX,qword ptr [RSP + 0x10]
MOVSXD RDX,dword ptr [RSP + 0x8]
CMP EAX,dword ptr [RCX + RDX*0x4 + 0x420]
JGE 0x0011db75
JMP 0x0011db84
LAB_0011db75:
JMP 0x0011db77
LAB_0011db77:
MOV EAX,dword ptr [RSP + 0x8]
ADD EAX,0x1
MOV dword ptr [RSP + 0x8],EAX
JMP 0x0011db5c
LAB_0011db84:
CMP dword ptr [RSP + 0x8],0x10
JNZ 0x0011db98
MOV dword ptr [RSP + 0x24],0xffffffff
JMP 0x0011dc46
LAB_0011db98:
MOV EAX,dword ptr [RSP + 0x4]
MOV ECX,0x10
SUB ECX,dword ptr [RSP + 0x8]
SAR EAX,CL
MOV RCX,qword ptr [RSP + 0x10]
MOVSXD RDX,dword ptr [RSP + 0x8]
MOVZX ECX,word ptr [RCX + RDX*0x2 + 0x400]
SUB EAX,ECX
MOV RCX,qword ptr [RSP + 0x10]
MOVSXD RDX,dword ptr [RSP + 0x8]
MOVZX ECX,word ptr [RCX + RDX*0x2 + 0x464]
ADD EAX,ECX
MOV dword ptr [RSP + 0xc],EAX
MOV RAX,qword ptr [RSP + 0x10]
MOVSXD RCX,dword ptr [RSP + 0xc]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x484]
CMP EAX,dword ptr [RSP + 0x8]
JNZ 0x0011dbed
JMP 0x0011dc0c
LAB_0011dbed:
LEA RDI,[0x124dec]
LEA RSI,[0x1242cb]
MOV EDX,0xf97
LEA RCX,[0x124dfc]
CALL 0x00102100
LAB_0011dc0c:
MOV ECX,dword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x18]
MOV EDX,dword ptr [RAX + 0x14]
SHR EDX,CL
MOV ECX,EDX
MOV dword ptr [RAX + 0x14],ECX
MOV EDX,dword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x18]
MOV ECX,dword ptr [RAX + 0x10]
SUB ECX,EDX
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RSP + 0x10]
MOVSXD RCX,dword ptr [RSP + 0xc]
MOVZX EAX,word ptr [RAX + RCX*0x2 + 0x5a4]
MOV dword ptr [RSP + 0x24],EAX
LAB_0011dc46:
MOV EAX,dword ptr [RSP + 0x24]
ADD RSP,0x28
RET
|
/* stbi__zhuffman_decode_slowpath(stbi__zbuf*, stbi__zhuffman*) */
uint stbi__zhuffman_decode_slowpath(stbi__zbuf *param_1,stbi__zhuffman *param_2)
{
int iVar1;
uint local_20;
uint local_4;
iVar1 = stbi__bit_reverse(*(int *)(param_1 + 0x14),0x10);
local_20 = 10;
while (*(int *)(param_2 + (long)(int)local_20 * 4 + 0x420) <= iVar1) {
local_20 = local_20 + 1;
}
if (local_20 == 0x10) {
local_4 = 0xffffffff;
}
else {
iVar1 = ((iVar1 >> (0x10 - (byte)local_20 & 0x1f)) -
(uint)*(ushort *)(param_2 + (long)(int)local_20 * 2 + 0x400)) +
(uint)*(ushort *)(param_2 + (long)(int)local_20 * 2 + 0x464);
if ((byte)param_2[(long)iVar1 + 0x484] != local_20) {
/* WARNING: Subroutine does not return */
__assert_fail("z->size[b] == s",
"/workspace/llm4binary/github2025/mnn-tts/MNN/3rd_party/imageHelper/stb_image.h"
,0xf97,"int stbi__zhuffman_decode_slowpath(stbi__zbuf *, stbi__zhuffman *)");
}
*(uint *)(param_1 + 0x14) = *(uint *)(param_1 + 0x14) >> ((byte)local_20 & 0x1f);
*(uint *)(param_1 + 0x10) = *(int *)(param_1 + 0x10) - local_20;
local_4 = (uint)*(ushort *)(param_2 + (long)iVar1 * 2 + 0x5a4);
}
return local_4;
}
|
|
66,057 |
rtree_insert_level
|
eloqsql/storage/myisam/rt_index.c
|
static int rtree_insert_level(MI_INFO *info, uint keynr, uchar *key,
uint key_length, int ins_level)
{
my_off_t old_root;
MI_KEYDEF *keyinfo = info->s->keyinfo + keynr;
int res;
my_off_t new_page;
DBUG_ENTER("rtree_insert_level");
if ((old_root = info->s->state.key_root[keynr]) == HA_OFFSET_ERROR)
{
if ((old_root = _mi_new(info, keyinfo, DFLT_INIT_HITS)) == HA_OFFSET_ERROR)
DBUG_RETURN(-1);
info->buff_used = 1;
mi_putint(info->buff, 2, 0);
res = rtree_add_key(info, keyinfo, key, key_length, info->buff, NULL);
if (_mi_write_keypage(info, keyinfo, old_root, DFLT_INIT_HITS, info->buff))
DBUG_RETURN(1);
info->s->state.key_root[keynr] = old_root;
DBUG_RETURN(res);
}
switch ((res = rtree_insert_req(info, keyinfo, key, key_length,
old_root, &new_page, ins_level, 0)))
{
case 0: /* root was not split */
{
break;
}
case 1: /* root was split, grow a new root */
{
uchar *new_root_buf= info->buff + info->s->base.max_key_block_length;
my_off_t new_root;
uchar *new_key;
uint nod_flag = info->s->base.key_reflength;
DBUG_PRINT("rtree", ("root was split, grow a new root"));
mi_putint(new_root_buf, 2, nod_flag);
if ((new_root = _mi_new(info, keyinfo, DFLT_INIT_HITS)) ==
HA_OFFSET_ERROR)
goto err1;
new_key = new_root_buf + keyinfo->block_length + nod_flag;
_mi_kpointer(info, new_key - nod_flag, old_root);
if (rtree_set_key_mbr(info, keyinfo, new_key, key_length, old_root))
goto err1;
if (rtree_add_key(info, keyinfo, new_key, key_length, new_root_buf, NULL)
== -1)
goto err1;
_mi_kpointer(info, new_key - nod_flag, new_page);
if (rtree_set_key_mbr(info, keyinfo, new_key, key_length, new_page))
goto err1;
if (rtree_add_key(info, keyinfo, new_key, key_length, new_root_buf, NULL)
== -1)
goto err1;
if (_mi_write_keypage(info, keyinfo, new_root,
DFLT_INIT_HITS, new_root_buf))
goto err1;
info->s->state.key_root[keynr] = new_root;
DBUG_PRINT("rtree", ("new root page: %lu level: %d nod_flag: %u",
(ulong) new_root, 0, mi_test_if_nod(new_root_buf)));
break;
err1:
DBUG_RETURN(-1); /* purecov: inspected */
}
default:
case -1: /* error */
{
break;
}
}
DBUG_RETURN(res);
}
|
O0
|
c
|
rtree_insert_level:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x218(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x98(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $-0x1, %rax
jne 0xc94e5
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl $0x3, %edx
callq 0xbe240
movq %rax, -0x30(%rbp)
cmpq $-0x1, %rax
jne 0xc9426
jmp 0xc941a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc9703
movq -0x10(%rbp), %rax
movb $0x1, 0x33d(%rax)
movw $0x2, -0x4a(%rbp)
movzwl -0x4a(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
movb %cl, 0x1(%rax)
movl -0x50(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movq 0x100(%rax), %r8
xorl %eax, %eax
movl %eax, %r9d
callq 0xcab70
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x100(%rax), %r8
movl $0x3, %ecx
callq 0xbdf10
cmpl $0x0, %eax
je 0xc94c1
jmp 0xc94b5
movl $0x1, -0x4(%rbp)
jmp 0xc9703
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x98(%rax), %rax
movl -0x14(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc9703
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %r8
movl -0x28(%rbp), %r9d
movq %rsp, %rax
movl %r9d, (%rax)
movl $0x0, 0x8(%rax)
leaq -0x48(%rbp), %r9
callq 0xca590
movl %eax, -0x3c(%rbp)
movl %eax, %ecx
movl %ecx, -0x78(%rbp)
subl $-0x1, %eax
je 0xc96f9
jmp 0xc9525
movl -0x78(%rbp), %eax
testl %eax, %eax
je 0xc953b
jmp 0xc952e
movl -0x78(%rbp), %eax
subl $0x1, %eax
je 0xc9540
jmp 0xc96f7
jmp 0xc96fb
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movl 0x190(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x17c(%rax), %eax
movl %eax, -0x6c(%rbp)
jmp 0xc9571
movl -0x6c(%rbp), %edx
xorl %eax, %eax
movl $0x8000, %ecx # imm = 0x8000
cmpl $0x0, %edx
cmovnel %ecx, %eax
addl $0x2, %eax
movw %ax, -0x6e(%rbp)
movzwl -0x6e(%rbp), %eax
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %eax
movb %al, %cl
movq -0x58(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x74(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x58(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl $0x3, %edx
callq 0xbe240
movq %rax, -0x60(%rbp)
cmpq $-0x1, %rax
jne 0xc95ca
jmp 0xc96ec
movq -0x58(%rbp), %rax
movq -0x38(%rbp), %rcx
movzwl 0xe(%rcx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movl -0x6c(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rsi
movl -0x6c(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rsi
movq -0x30(%rbp), %rdx
callq 0xc0370
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x68(%rbp), %rdx
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %r8
callq 0xcae40
cmpl $0x0, %eax
je 0xc9626
jmp 0xc96ec
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x68(%rbp), %rdx
movl -0x24(%rbp), %ecx
movq -0x58(%rbp), %r8
xorl %eax, %eax
movl %eax, %r9d
callq 0xcab70
cmpl $-0x1, %eax
jne 0xc964d
jmp 0xc96ec
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rsi
movl -0x6c(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rsi
movq -0x48(%rbp), %rdx
callq 0xc0370
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x68(%rbp), %rdx
movl -0x24(%rbp), %ecx
movq -0x48(%rbp), %r8
callq 0xcae40
cmpl $0x0, %eax
je 0xc968a
jmp 0xc96ec
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x68(%rbp), %rdx
movl -0x24(%rbp), %ecx
movq -0x58(%rbp), %r8
xorl %eax, %eax
movl %eax, %r9d
callq 0xcab70
cmpl $-0x1, %eax
jne 0xc96ae
jmp 0xc96ec
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %r8
movl $0x3, %ecx
callq 0xbdf10
cmpl $0x0, %eax
je 0xc96cf
jmp 0xc96ec
movq -0x60(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x98(%rax), %rax
movl -0x14(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
jmp 0xc96ea
jmp 0xc96fb
jmp 0xc96ee
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc9703
jmp 0xc96f9
jmp 0xc96fb
jmp 0xc96fd
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nop
|
rtree_insert_level:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov [rbp+var_28], r8d
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+218h]
mov ecx, [rbp+var_14]
imul rcx, 70h ; 'p'
add rax, rcx
mov [rbp+var_38], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+98h]
mov ecx, [rbp+var_14]
mov rax, [rax+rcx*8]
mov [rbp+var_30], rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz loc_C94E5
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
mov edx, 3
call _mi_new
mov [rbp+var_30], rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_C9426
jmp short $+2
loc_C941A:
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_C9703
loc_C9426:
mov rax, [rbp+var_10]
mov byte ptr [rax+33Dh], 1
mov [rbp+var_4A], 2
movzx eax, [rbp+var_4A]
mov [rbp+var_50], eax
mov eax, [rbp+var_50]
mov cl, al
mov rax, [rbp+var_10]
mov rax, [rax+100h]
mov [rax+1], cl
mov eax, [rbp+var_50]
shr eax, 8
mov cl, al
mov rax, [rbp+var_10]
mov rax, [rax+100h]
mov [rax], cl
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
mov rdx, [rbp+var_20]
mov ecx, [rbp+var_24]
mov rax, [rbp+var_10]
mov r8, [rax+100h]
xor eax, eax
mov r9d, eax
call rtree_add_key
mov [rbp+var_3C], eax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
mov rdx, [rbp+var_30]
mov rax, [rbp+var_10]
mov r8, [rax+100h]
mov ecx, 3
call _mi_write_keypage
cmp eax, 0
jz short loc_C94C1
jmp short $+2
loc_C94B5:
mov [rbp+var_4], 1
jmp loc_C9703
loc_C94C1:
mov rdx, [rbp+var_30]
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+98h]
mov ecx, [rbp+var_14]
mov [rax+rcx*8], rdx
mov eax, [rbp+var_3C]
mov [rbp+var_4], eax
jmp loc_C9703
loc_C94E5:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
mov rdx, [rbp+var_20]
mov ecx, [rbp+var_24]
mov r8, [rbp+var_30]
mov r9d, [rbp+var_28]
mov rax, rsp
mov [rax], r9d
mov dword ptr [rax+8], 0
lea r9, [rbp+var_48]
call rtree_insert_req
mov [rbp+var_3C], eax
mov ecx, eax
mov [rbp+var_78], ecx
sub eax, 0FFFFFFFFh
jz loc_C96F9
jmp short $+2
loc_C9525:
mov eax, [rbp+var_78]
test eax, eax
jz short loc_C953B
jmp short $+2
loc_C952E:
mov eax, [rbp+var_78]
sub eax, 1
jz short loc_C9540
jmp loc_C96F7
loc_C953B:
jmp loc_C96FB
loc_C9540:
mov rax, [rbp+var_10]
mov rax, [rax+100h]
mov rcx, [rbp+var_10]
mov rcx, [rcx]
mov ecx, [rcx+190h]
add rax, rcx
mov [rbp+var_58], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov eax, [rax+17Ch]
mov [rbp+var_6C], eax
jmp short $+2
loc_C9571:
mov edx, [rbp+var_6C]
xor eax, eax
mov ecx, 8000h
cmp edx, 0
cmovnz eax, ecx
add eax, 2
mov [rbp+var_6E], ax
movzx eax, [rbp+var_6E]
mov [rbp+var_74], eax
mov eax, [rbp+var_74]
mov cl, al
mov rax, [rbp+var_58]
mov [rax+1], cl
mov eax, [rbp+var_74]
shr eax, 8
mov cl, al
mov rax, [rbp+var_58]
mov [rax], cl
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
mov edx, 3
call _mi_new
mov [rbp+var_60], rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_C95CA
jmp loc_C96EC
loc_C95CA:
mov rax, [rbp+var_58]
mov rcx, [rbp+var_38]
movzx ecx, word ptr [rcx+0Eh]
movsxd rcx, ecx
add rax, rcx
mov ecx, [rbp+var_6C]
add rax, rcx
mov [rbp+var_68], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_68]
mov eax, [rbp+var_6C]
mov ecx, eax
xor eax, eax
sub rax, rcx
add rsi, rax
mov rdx, [rbp+var_30]
call _mi_kpointer
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
mov rdx, [rbp+var_68]
mov ecx, [rbp+var_24]
mov r8, [rbp+var_30]
call rtree_set_key_mbr
cmp eax, 0
jz short loc_C9626
jmp loc_C96EC
loc_C9626:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
mov rdx, [rbp+var_68]
mov ecx, [rbp+var_24]
mov r8, [rbp+var_58]
xor eax, eax
mov r9d, eax
call rtree_add_key
cmp eax, 0FFFFFFFFh
jnz short loc_C964D
jmp loc_C96EC
loc_C964D:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_68]
mov eax, [rbp+var_6C]
mov ecx, eax
xor eax, eax
sub rax, rcx
add rsi, rax
mov rdx, [rbp+var_48]
call _mi_kpointer
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
mov rdx, [rbp+var_68]
mov ecx, [rbp+var_24]
mov r8, [rbp+var_48]
call rtree_set_key_mbr
cmp eax, 0
jz short loc_C968A
jmp short loc_C96EC
loc_C968A:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
mov rdx, [rbp+var_68]
mov ecx, [rbp+var_24]
mov r8, [rbp+var_58]
xor eax, eax
mov r9d, eax
call rtree_add_key
cmp eax, 0FFFFFFFFh
jnz short loc_C96AE
jmp short loc_C96EC
loc_C96AE:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
mov rdx, [rbp+var_60]
mov r8, [rbp+var_58]
mov ecx, 3
call _mi_write_keypage
cmp eax, 0
jz short loc_C96CF
jmp short loc_C96EC
loc_C96CF:
mov rdx, [rbp+var_60]
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+98h]
mov ecx, [rbp+var_14]
mov [rax+rcx*8], rdx
jmp short $+2
loc_C96EA:
jmp short loc_C96FB
loc_C96EC:
jmp short $+2
loc_C96EE:
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_C9703
loc_C96F7:
jmp short $+2
loc_C96F9:
jmp short $+2
loc_C96FB:
jmp short $+2
loc_C96FD:
mov eax, [rbp+var_3C]
mov [rbp+var_4], eax
loc_C9703:
mov eax, [rbp+var_4]
add rsp, 90h
pop rbp
retn
|
long long rtree_insert_level(_QWORD *a1, unsigned int a2, long long a3, unsigned int a4, int a5)
{
__int16 v5; // ax
unsigned int v7; // [rsp+24h] [rbp-6Ch]
long long v8; // [rsp+28h] [rbp-68h]
unsigned long long v9; // [rsp+30h] [rbp-60h]
long long v10; // [rsp+38h] [rbp-58h]
unsigned long long v11; // [rsp+48h] [rbp-48h] BYREF
unsigned int inserted; // [rsp+54h] [rbp-3Ch]
long long v13; // [rsp+58h] [rbp-38h]
unsigned long long v14; // [rsp+60h] [rbp-30h]
int v15; // [rsp+68h] [rbp-28h]
unsigned int v16; // [rsp+6Ch] [rbp-24h]
long long v17; // [rsp+70h] [rbp-20h]
unsigned int v18; // [rsp+7Ch] [rbp-14h]
_QWORD *v19; // [rsp+80h] [rbp-10h]
v19 = a1;
v18 = a2;
v17 = a3;
v16 = a4;
v15 = a5;
v13 = 112LL * a2 + *(_QWORD *)(*a1 + 536LL);
v14 = *(_QWORD *)(*(_QWORD *)(*a1 + 152LL) + 8LL * a2);
if ( v14 != -1LL )
{
inserted = rtree_insert_req((_DWORD)v19, v13, v17, v16, v14, (unsigned int)&v11, v15, 0);
if ( inserted == 1 )
{
v10 = *(unsigned int *)(*v19 + 400LL) + v19[32];
v7 = *(_DWORD *)(*v19 + 380LL);
v5 = 0;
if ( v7 )
v5 = 0x8000;
*(_BYTE *)(v10 + 1) = v5 + 2;
*(_BYTE *)v10 = (unsigned __int16)(v5 + 2) >> 8;
v9 = mi_new(v19, v13, 3);
if ( v9 == -1LL )
return (unsigned int)-1;
v8 = v7 + *(unsigned __int16 *)(v13 + 14) + v10;
mi_kpointer((long long)v19, (_BYTE *)(*(unsigned __int16 *)(v13 + 14) + v10), v14);
if ( (unsigned int)rtree_set_key_mbr(v19, v13, v8, v16, v14) )
return (unsigned int)-1;
if ( (unsigned int)rtree_add_key(v19, v13, v8, v16, v10, 0LL) == -1 )
return (unsigned int)-1;
mi_kpointer((long long)v19, (_BYTE *)(v8 - v7), v11);
if ( (unsigned int)rtree_set_key_mbr(v19, v13, v8, v16, v11)
|| (unsigned int)rtree_add_key(v19, v13, v8, v16, v10, 0LL) == -1
|| (unsigned int)mi_write_keypage(v19, v13, v9, 3, (unsigned __int16 *)v10) )
{
return (unsigned int)-1;
}
*(_QWORD *)(*(_QWORD *)(*v19 + 152LL) + 8LL * v18) = v9;
}
return inserted;
}
v14 = mi_new(v19, v13, 3);
if ( v14 == -1LL )
{
return (unsigned int)-1;
}
else
{
*((_BYTE *)v19 + 829) = 1;
*(_BYTE *)(v19[32] + 1LL) = 2;
*(_BYTE *)v19[32] = 0;
inserted = rtree_add_key(v19, v13, v17, v16, v19[32], 0LL);
if ( (unsigned int)mi_write_keypage(v19, v13, v14, 3, (unsigned __int16 *)v19[32]) )
{
return 1;
}
else
{
*(_QWORD *)(*(_QWORD *)(*v19 + 152LL) + 8LL * v18) = v14;
return inserted;
}
}
}
|
rtree_insert_level:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV dword ptr [RBP + -0x28],R8D
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV ECX,dword ptr [RBP + -0x14]
IMUL RCX,RCX,0x70
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x98]
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x30],RAX
CMP RAX,-0x1
JNZ 0x001c94e5
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
MOV EDX,0x3
CALL 0x001be240
MOV qword ptr [RBP + -0x30],RAX
CMP RAX,-0x1
JNZ 0x001c9426
JMP 0x001c941a
LAB_001c941a:
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001c9703
LAB_001c9426:
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x33d],0x1
MOV word ptr [RBP + -0x4a],0x2
MOVZX EAX,word ptr [RBP + -0x4a]
MOV dword ptr [RBP + -0x50],EAX
MOV EAX,dword ptr [RBP + -0x50]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x100]
MOV byte ptr [RAX + 0x1],CL
MOV EAX,dword ptr [RBP + -0x50]
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x100]
MOV byte ptr [RAX],CL
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x10]
MOV R8,qword ptr [RAX + 0x100]
XOR EAX,EAX
MOV R9D,EAX
CALL 0x001cab70
MOV dword ptr [RBP + -0x3c],EAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV R8,qword ptr [RAX + 0x100]
MOV ECX,0x3
CALL 0x001bdf10
CMP EAX,0x0
JZ 0x001c94c1
JMP 0x001c94b5
LAB_001c94b5:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001c9703
LAB_001c94c1:
MOV RDX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x98]
MOV ECX,dword ptr [RBP + -0x14]
MOV qword ptr [RAX + RCX*0x8],RDX
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001c9703
LAB_001c94e5:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x24]
MOV R8,qword ptr [RBP + -0x30]
MOV R9D,dword ptr [RBP + -0x28]
MOV RAX,RSP
MOV dword ptr [RAX],R9D
MOV dword ptr [RAX + 0x8],0x0
LEA R9,[RBP + -0x48]
CALL 0x001ca590
MOV dword ptr [RBP + -0x3c],EAX
MOV ECX,EAX
MOV dword ptr [RBP + -0x78],ECX
SUB EAX,-0x1
JZ 0x001c96f9
JMP 0x001c9525
LAB_001c9525:
MOV EAX,dword ptr [RBP + -0x78]
TEST EAX,EAX
JZ 0x001c953b
JMP 0x001c952e
LAB_001c952e:
MOV EAX,dword ptr [RBP + -0x78]
SUB EAX,0x1
JZ 0x001c9540
JMP 0x001c96f7
LAB_001c953b:
JMP 0x001c96fb
LAB_001c9540:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x100]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX]
MOV ECX,dword ptr [RCX + 0x190]
ADD RAX,RCX
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x17c]
MOV dword ptr [RBP + -0x6c],EAX
JMP 0x001c9571
LAB_001c9571:
MOV EDX,dword ptr [RBP + -0x6c]
XOR EAX,EAX
MOV ECX,0x8000
CMP EDX,0x0
CMOVNZ EAX,ECX
ADD EAX,0x2
MOV word ptr [RBP + -0x6e],AX
MOVZX EAX,word ptr [RBP + -0x6e]
MOV dword ptr [RBP + -0x74],EAX
MOV EAX,dword ptr [RBP + -0x74]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x58]
MOV byte ptr [RAX + 0x1],CL
MOV EAX,dword ptr [RBP + -0x74]
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x58]
MOV byte ptr [RAX],CL
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
MOV EDX,0x3
CALL 0x001be240
MOV qword ptr [RBP + -0x60],RAX
CMP RAX,-0x1
JNZ 0x001c95ca
JMP 0x001c96ec
LAB_001c95ca:
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x38]
MOVZX ECX,word ptr [RCX + 0xe]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV ECX,dword ptr [RBP + -0x6c]
ADD RAX,RCX
MOV qword ptr [RBP + -0x68],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x68]
MOV EAX,dword ptr [RBP + -0x6c]
MOV ECX,EAX
XOR EAX,EAX
SUB RAX,RCX
ADD RSI,RAX
MOV RDX,qword ptr [RBP + -0x30]
CALL 0x001c0370
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x68]
MOV ECX,dword ptr [RBP + -0x24]
MOV R8,qword ptr [RBP + -0x30]
CALL 0x001cae40
CMP EAX,0x0
JZ 0x001c9626
JMP 0x001c96ec
LAB_001c9626:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x68]
MOV ECX,dword ptr [RBP + -0x24]
MOV R8,qword ptr [RBP + -0x58]
XOR EAX,EAX
MOV R9D,EAX
CALL 0x001cab70
CMP EAX,-0x1
JNZ 0x001c964d
JMP 0x001c96ec
LAB_001c964d:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x68]
MOV EAX,dword ptr [RBP + -0x6c]
MOV ECX,EAX
XOR EAX,EAX
SUB RAX,RCX
ADD RSI,RAX
MOV RDX,qword ptr [RBP + -0x48]
CALL 0x001c0370
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x68]
MOV ECX,dword ptr [RBP + -0x24]
MOV R8,qword ptr [RBP + -0x48]
CALL 0x001cae40
CMP EAX,0x0
JZ 0x001c968a
JMP 0x001c96ec
LAB_001c968a:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x68]
MOV ECX,dword ptr [RBP + -0x24]
MOV R8,qword ptr [RBP + -0x58]
XOR EAX,EAX
MOV R9D,EAX
CALL 0x001cab70
CMP EAX,-0x1
JNZ 0x001c96ae
JMP 0x001c96ec
LAB_001c96ae:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x60]
MOV R8,qword ptr [RBP + -0x58]
MOV ECX,0x3
CALL 0x001bdf10
CMP EAX,0x0
JZ 0x001c96cf
JMP 0x001c96ec
LAB_001c96cf:
MOV RDX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x98]
MOV ECX,dword ptr [RBP + -0x14]
MOV qword ptr [RAX + RCX*0x8],RDX
JMP 0x001c96ea
LAB_001c96ea:
JMP 0x001c96fb
LAB_001c96ec:
JMP 0x001c96ee
LAB_001c96ee:
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001c9703
LAB_001c96f7:
JMP 0x001c96f9
LAB_001c96f9:
JMP 0x001c96fb
LAB_001c96fb:
JMP 0x001c96fd
LAB_001c96fd:
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x4],EAX
LAB_001c9703:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x90
POP RBP
RET
|
int rtree_insert_level(long *param_1,uint param_2,int8 param_3,int4 param_4,
int4 param_5)
{
uint uVar1;
short sVar2;
int iVar3;
int1 *puVar4;
long lVar5;
int1 *puVar6;
int8 local_50;
int local_44;
long local_40;
long local_38;
int4 local_30;
int4 local_2c;
int8 local_28;
uint local_1c;
long *local_18;
int local_c;
local_40 = *(long *)(*param_1 + 0x218) + (ulong)param_2 * 0x70;
local_38 = *(long *)(*(long *)(*param_1 + 0x98) + (ulong)param_2 * 8);
local_30 = param_5;
local_2c = param_4;
local_28 = param_3;
local_1c = param_2;
local_18 = param_1;
if (local_38 == -1) {
local_38 = _mi_new(param_1,local_40,3);
if (local_38 == -1) {
return -1;
}
*(int1 *)((long)local_18 + 0x33d) = 1;
*(int1 *)(local_18[0x20] + 1) = 2;
*(int1 *)local_18[0x20] = 0;
local_44 = rtree_add_key(local_18,local_40,local_28,local_2c,local_18[0x20],0);
iVar3 = _mi_write_keypage(local_18,local_40,local_38,3,local_18[0x20]);
if (iVar3 != 0) {
return 1;
}
*(long *)(*(long *)(*local_18 + 0x98) + (ulong)local_1c * 8) = local_38;
return local_44;
}
local_44 = rtree_insert_req(param_1,local_40,param_3,param_4,local_38,&local_50,param_5,0);
if (((local_44 == -1) || (local_44 == 0)) || (local_44 != 1)) {
LAB_001c96fb:
local_c = local_44;
}
else {
puVar4 = (int1 *)(local_18[0x20] + (ulong)*(uint *)(*local_18 + 400));
uVar1 = *(uint *)(*local_18 + 0x17c);
sVar2 = 0;
if (uVar1 != 0) {
sVar2 = -0x8000;
}
puVar4[1] = (char)(sVar2 + 2);
*puVar4 = (char)((ushort)(sVar2 + 2) >> 8);
lVar5 = _mi_new(local_18,local_40,3);
if (lVar5 != -1) {
puVar6 = puVar4 + (ulong)uVar1 + (long)(int)(uint)*(ushort *)(local_40 + 0xe);
_mi_kpointer(local_18,(long)puVar6 - (ulong)uVar1,local_38);
iVar3 = rtree_set_key_mbr(local_18,local_40,puVar6,local_2c,local_38);
if ((iVar3 == 0) &&
(iVar3 = rtree_add_key(local_18,local_40,puVar6,local_2c,puVar4,0), iVar3 != -1)) {
_mi_kpointer(local_18,(long)puVar6 - (ulong)uVar1,local_50);
iVar3 = rtree_set_key_mbr(local_18,local_40,puVar6,local_2c,local_50);
if ((iVar3 == 0) &&
((iVar3 = rtree_add_key(local_18,local_40,puVar6,local_2c,puVar4,0), iVar3 != -1 &&
(iVar3 = _mi_write_keypage(local_18,local_40,lVar5,3,puVar4), iVar3 == 0)))) {
*(long *)(*(long *)(*local_18 + 0x98) + (ulong)local_1c * 8) = lVar5;
goto LAB_001c96fb;
}
}
}
local_c = -1;
}
return local_c;
}
|
|
66,058 |
mysql_stmt_data_seek
|
eloqsql/libmariadb/libmariadb/mariadb_stmt.c
|
void STDCALL mysql_stmt_data_seek(MYSQL_STMT *stmt, unsigned long long offset)
{
unsigned long long i= offset;
MYSQL_ROWS *ptr= stmt->result.data;
while(i-- && ptr)
ptr= ptr->next;
stmt->result_cursor= ptr;
stmt->state= MYSQL_STMT_USER_FETCHING;
return;
}
|
O3
|
c
|
mysql_stmt_data_seek:
pushq %rbp
movq %rsp, %rbp
leaq 0x80(%rdi), %rax
movq (%rax), %rax
addq $-0x1, %rsi
jae 0x24024
testq %rax, %rax
jne 0x24016
movq %rax, 0xe0(%rdi)
movl $0x5, 0x50(%rdi)
popq %rbp
retq
|
mysql_stmt_data_seek:
push rbp
mov rbp, rsp
lea rax, [rdi+80h]
loc_24016:
mov rax, [rax]
add rsi, 0FFFFFFFFFFFFFFFFh
jnb short loc_24024
test rax, rax
jnz short loc_24016
loc_24024:
mov [rdi+0E0h], rax
mov dword ptr [rdi+50h], 5
pop rbp
retn
|
_QWORD * mysql_stmt_data_seek(long long a1, long long a2)
{
_QWORD *result; // rax
bool v3; // cf
result = (_QWORD *)(a1 + 128);
do
{
result = (_QWORD *)*result;
v3 = a2-- != 0;
}
while ( v3 && result );
*(_QWORD *)(a1 + 224) = result;
*(_DWORD *)(a1 + 80) = 5;
return result;
}
|
mysql_stmt_data_seek:
PUSH RBP
MOV RBP,RSP
LEA RAX,[RDI + 0x80]
LAB_00124016:
MOV RAX,qword ptr [RAX]
ADD RSI,-0x1
JNC 0x00124024
TEST RAX,RAX
JNZ 0x00124016
LAB_00124024:
MOV qword ptr [RDI + 0xe0],RAX
MOV dword ptr [RDI + 0x50],0x5
POP RBP
RET
|
void mysql_stmt_data_seek(long param_1,long param_2)
{
long *plVar1;
bool bVar2;
plVar1 = (long *)(param_1 + 0x80);
do {
plVar1 = (long *)*plVar1;
bVar2 = param_2 == 0;
param_2 = param_2 + -1;
if (bVar2) break;
} while (plVar1 != (long *)0x0);
*(long **)(param_1 + 0xe0) = plVar1;
*(int4 *)(param_1 + 0x50) = 5;
return;
}
|
|
66,059 |
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 (&) [9], 0>(char const (&) [9]) 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;
}
|
O0
|
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 (&) [9], 0>(char const (&) [9]) const:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xabf30
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x160288
jmp 0x160364
movb $0x1, 0x83(%rsp)
movl $0x20, %edi
callq 0x59660
movq 0x20(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0xb2d00
movq %rax, 0x90(%rsp)
leaq 0xaf461(%rip), %rsi # 0x20f719
leaq 0x98(%rsp), %rdi
leaq 0x90(%rsp), %rdx
callq 0x167de0
jmp 0x1602cf
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rdi
movl $0x130, %esi # imm = 0x130
leaq 0x98(%rsp), %rdx
callq 0x110c00
jmp 0x1602ed
movq 0x18(%rsp), %rdi
movb $0x0, 0x83(%rsp)
leaq 0x13da87(%rip), %rsi # 0x29dd88
leaq -0xad558(%rip), %rdx # 0xb2db0
callq 0x59ac0
jmp 0x1604e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x160349
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x5a4d8
testb $0x1, 0x83(%rsp)
jne 0x160355
jmp 0x16035f
movq 0x18(%rsp), %rdi
callq 0x59f20
jmp 0x1604d4
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0xb8(%rsp), %rsi
callq 0x169d00
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x78(%rsp)
movq 0x8(%rax), %rdi
callq 0xb1730
movq %rax, 0x70(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xb26d0
testb $0x1, %al
jne 0x1603ad
jmp 0x1604be
movb $0x1, 0x2e(%rsp)
movl $0x20, %edi
callq 0x59660
movq %rax, (%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x5a080
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %rdi
callq 0x5ea00
jmp 0x1603f2
leaq 0xaf350(%rip), %rsi # 0x20f749
leaq 0xaf34f(%rip), %rcx # 0x20f74f
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x169000
jmp 0x160411
movq 0x20(%rsp), %rcx
movq (%rsp), %rdi
movl $0x193, %esi # imm = 0x193
leaq 0x50(%rsp), %rdx
callq 0x169ef0
jmp 0x16042b
movq (%rsp), %rdi
movb $0x0, 0x2e(%rsp)
leaq 0x13d8cd(%rip), %rsi # 0x29dd08
leaq -0xb53b2(%rip), %rdx # 0xab090
callq 0x59ac0
jmp 0x1604e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x1604a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x160496
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x5a4d8
leaq 0x30(%rsp), %rdi
callq 0x5a4d8
leaq 0x2f(%rsp), %rdi
callq 0x5a4b0
testb $0x1, 0x2e(%rsp)
jne 0x1604b3
jmp 0x1604bc
movq (%rsp), %rdi
callq 0x59f20
jmp 0x1604d4
leaq 0x78(%rsp), %rdi
callq 0xb28d0
addq $0x20, %rax
addq $0xc8, %rsp
retq
movq 0x88(%rsp), %rdi
callq 0x59b80
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_:
sub rsp, 0C8h
mov [rsp+0C8h+var_8], rdi
mov qword ptr [rsp+0C8h+var_10], rsi
mov rdi, [rsp+0C8h+var_8]
mov [rsp+0C8h+var_A8], rdi; int
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9is_objectEv; 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>::is_object(void)
xor al, 0FFh
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_160288
jmp loc_160364
loc_160288:
mov [rsp+0C8h+var_45], 1
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rdi, [rsp+0C8h+var_A8]
mov [rsp+0C8h+var_B0], rax; char
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 qword ptr [rsp+0C8h+var_38], rax; char
lea rsi, aCannotUseAtWit; "cannot use at() with "
lea rdi, [rsp+0C8h+var_30]; int
lea rdx, [rsp+0C8h+var_38]; int
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* &&)
jmp short $+2
loc_1602CF:
mov rcx, [rsp+0C8h+var_A8]
mov rdi, [rsp+0C8h+var_B0]; int
mov esi, 130h
lea rdx, [rsp+0C8h+var_30]
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
jmp short $+2
loc_1602ED:
mov rdi, [rsp+0C8h+var_B0]; void *
mov [rsp+0C8h+var_45], 0
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail10type_errorD2Ev; void (*)(void *)
call ___cxa_throw
jmp loc_1604E1
mov rcx, rax
mov eax, edx
mov [rsp+arg_80], rcx
mov [rsp+arg_7C], eax
jmp short loc_160349
mov rcx, rax
mov eax, edx
mov [rsp+arg_80], rcx
mov [rsp+arg_7C], eax
lea rdi, [rsp+arg_90]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_160349:
test [rsp+arg_7B], 1
jnz short loc_160355
jmp short loc_16035F
loc_160355:
mov rdi, [rsp+arg_10]; void *
call ___cxa_free_exception
loc_16035F:
jmp loc_1604D4
loc_160364:
mov rax, [rsp+0C8h+var_A8]
mov rdi, [rax+8]
mov rsi, qword ptr [rsp+0C8h+var_10]
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA9_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_
mov rcx, rax
mov rax, [rsp+0C8h+var_A8]
mov qword ptr [rsp+0C8h+var_50], rcx; int
mov rdi, [rax+8]
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE3endEv; 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>>>::end(void)
mov qword ptr [rsp+0C8h+var_58], rax; char
lea rdi, [rsp+0C8h+var_50]
lea rsi, [rsp+0C8h+var_58]
call _ZN9__gnu_cxxeqIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEEbRKNS_17__normal_iteratorIT_T0_EESR_; __gnu_cxx::operator==<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>>>>(__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>>>> const&,__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>>>> const&)
test al, 1
jnz short loc_1603AD
jmp loc_1604BE
loc_1603AD:
mov [rsp+0C8h+var_9A], 1
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov [rsp+0C8h+var_C8], rax; int
mov rax, qword ptr [rsp+0C8h+var_10]
mov qword ptr [rsp+0C8h+var_C0], rax; int
lea rdi, [rsp+0C8h+var_99]
mov qword ptr [rsp+0C8h+var_B8], rdi; int
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rsi, qword ptr [rsp+0C8h+var_C0]
mov rdx, qword ptr [rsp+0C8h+var_B8]
lea rdi, [rsp+0C8h+var_99+1]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_1603F2:
lea rsi, aKey; "key '"
lea rcx, aNotFound; "' not found"
lea rdi, [rsp+0C8h+var_78]; int
lea rdx, [rsp+0C8h+var_99+1]; int
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] &&)
jmp short $+2
loc_160411:
mov rcx, [rsp+0C8h+var_A8]
mov rdi, [rsp+0C8h+var_C8]; int
mov esi, 193h
lea rdx, [rsp+0C8h+var_78]
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_
jmp short $+2
loc_16042B:
mov rdi, [rsp+0C8h+var_C8]; void *
mov [rsp+0C8h+var_9A], 0
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail12out_of_rangeE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail12out_of_rangeD2Ev; void (*)(void *)
call ___cxa_throw
jmp loc_1604E1
mov rcx, rax
mov eax, edx
mov [rsp+arg_80], rcx
mov [rsp+arg_7C], eax
jmp short loc_1604A0
mov rcx, rax
mov eax, edx
mov [rsp+arg_80], rcx
mov [rsp+arg_7C], eax
jmp short loc_160496
mov rcx, rax
mov eax, edx
mov [rsp+arg_80], rcx
mov [rsp+arg_7C], eax
lea rdi, [rsp+arg_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_160496:
lea rdi, [rsp+arg_28]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_1604A0:
lea rdi, [rsp+arg_27]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
test [rsp+arg_26], 1
jnz short loc_1604B3
jmp short loc_1604BC
loc_1604B3:
mov rdi, [rsp+0]; void *
call ___cxa_free_exception
loc_1604BC:
jmp short loc_1604D4
loc_1604BE:
lea rdi, [rsp+0C8h+var_50]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEptEv; __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>>>>::operator->(void)
add rax, 20h ; ' '
add rsp, 0C8h
retn
loc_1604D4:
mov rdi, [rsp+arg_80]
call __Unwind_Resume
loc_1604E1:
nop word ptr [rax+rax+00000000h]
nop dword ptr [rax+rax+00h]
|
long long ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_(
long long a1,
long long a2)
{
int v2; // ecx
int v3; // r8d
int v4; // r9d
long long v5; // rdx
int v6; // r8d
int v7; // r9d
int v9; // [rsp+0h] [rbp-C8h]
void *v10; // [rsp+0h] [rbp-C8h]
int v11; // [rsp+0h] [rbp-C8h]
void *v12; // [rsp+0h] [rbp-C8h]
void *v13; // [rsp+8h] [rbp-C0h]
long long v14; // [rsp+8h] [rbp-C0h]
int v15; // [rsp+8h] [rbp-C0h]
int v16; // [rsp+10h] [rbp-B8h]
int v17; // [rsp+10h] [rbp-B8h]
int v18; // [rsp+18h] [rbp-B0h]
void *exception; // [rsp+18h] [rbp-B0h]
nlohmann::json_abi_v3_11_3::detail::type_error *v20; // [rsp+18h] [rbp-B0h]
char v21; // [rsp+18h] [rbp-B0h]
int v22; // [rsp+20h] [rbp-A8h]
int v23; // [rsp+28h] [rbp-A0h]
char v24; // [rsp+2Fh] [rbp-99h] BYREF
int v25[4]; // [rsp+30h] [rbp-98h] BYREF
long long v26; // [rsp+40h] [rbp-88h]
int v27; // [rsp+48h] [rbp-80h]
int v28[8]; // [rsp+50h] [rbp-78h] BYREF
char v29[8]; // [rsp+70h] [rbp-58h] BYREF
int v30[2]; // [rsp+78h] [rbp-50h] BYREF
int v31; // [rsp+80h] [rbp-48h]
int v32; // [rsp+88h] [rbp-40h]
char v33[8]; // [rsp+90h] [rbp-38h] BYREF
int v34[8]; // [rsp+98h] [rbp-30h] BYREF
int v35[2]; // [rsp+B8h] [rbp-10h]
long long v36; // [rsp+C0h] [rbp-8h]
v36 = a1;
*(_QWORD *)v35 = a2;
if ( !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>::is_object((_BYTE *)a1) )
{
exception = __cxa_allocate_exception(0x20uLL);
*(_QWORD *)v33 = 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((_BYTE *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(
(int)v34,
(int)"cannot use at() with ",
(int)v33,
v2,
v3,
v4,
v9,
v13,
v16,
(long long)exception);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
v20,
304LL,
(long long)v34,
a1);
HIBYTE(v31) = 0;
__cxa_throw(
v20,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::type_error::~type_error);
}
*(_QWORD *)v30 = ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA9_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_(
*(_QWORD *)(a1 + 8),
*(_QWORD *)v35);
*(_QWORD *)v29 = 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>>>::end(*(_QWORD *)(a1 + 8));
if ( __gnu_cxx::operator==<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>>>>(
(long long)v30,
(long long)v29) )
{
v10 = __cxa_allocate_exception(0x20uLL);
v14 = *(_QWORD *)v35;
std::allocator<char>::allocator(&v24, v29, v5);
std::string::basic_string<std::allocator<char>>((long long)v25, v14, (long long)&v24);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(
(int)v28,
(int)"key '",
(int)v25,
(int)"' not found",
v6,
v7,
v10,
v14,
(int)&v24,
v18,
a1);
ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
v11,
v11,
v15,
v17,
v21,
v22,
v23,
v25[0],
v25[2],
v26,
v27,
v28[0],
v28[2],
v28[4],
v28[6],
v29[0],
v30[0],
v31,
v32,
v33[0]);
__cxa_throw(
v12,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::out_of_range,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::out_of_range::~out_of_range);
}
return __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>>>>::operator->((long long)v30)
+ 32;
}
| |||
66,060 |
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 (&) [9], 0>(char const (&) [9]) 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;
}
|
O1
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> 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 (&) [9], 0>(char const (&) [9]) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpb $0x1, (%rdi)
jne 0xa4ca0
movq %rsi, %r15
movq 0x8(%r14), %r12
movq (%r12), %rbx
movq 0x8(%r12), %rax
cmpq %rax, %rbx
je 0xa4c85
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1a210
testl %eax, %eax
je 0xa4c82
addq $0x30, %rbx
jmp 0xa4c63
movq %rbx, %rax
movq 0x8(%r14), %rcx
cmpq 0x8(%rcx), %rax
je 0xa4cfc
addq $0x20, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x1a430
movq %rax, %rbx
movq %r14, %rdi
callq 0x5d76e
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x4d08e(%rip), %rsi # 0xf1d52
movq %rsp, %rdi
callq 0xaa7d7
movb $0x1, %bpl
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x130, %esi # imm = 0x130
movq %r14, %rcx
callq 0x85d12
xorl %ebp, %ebp
leaq 0x8521d(%rip), %rsi # 0x129f08
leaq -0x4b442(%rip), %rdx # 0x598b0
movq %rbx, %rdi
callq 0x1aea0
jmp 0xa4d75
movl $0x20, %edi
callq 0x1a430
movq %rax, %rbx
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r15, %rdi
callq 0x1a3d0
leaq (%rax,%r15), %rdx
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x21530
leaq 0x4d04f(%rip), %rsi # 0xf1d82
leaq 0x4d04e(%rip), %rcx # 0xf1d88
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0xaade0
movb $0x1, %bpl
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x193, %esi # imm = 0x193
movq %r14, %rcx
callq 0xab15a
xorl %ebp, %ebp
leaq 0x85122(%rip), %rsi # 0x129e88
leaq -0x4b4bd(%rip), %rdx # 0x598b0
movq %rbx, %rdi
callq 0x1aea0
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa4d9b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a890
jmp 0xa4d9b
movq %rax, %r14
movb $0x1, %bpl
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0xa4dd4
movq 0x30(%rsp), %rsi
jmp 0xa4dc4
jmp 0xa4dce
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa4dd4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a890
jmp 0xa4dd4
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xa4de1
movq %rbx, %rdi
callq 0x1a640
movq %r14, %rdi
callq 0x1af20
nop
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_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_A4CA0
mov r15, rsi
mov r12, [r14+8]
mov rbx, [r12]
loc_A4C63:
mov rax, [r12+8]
cmp rbx, rax
jz short loc_A4C85
mov rdi, rbx
mov rsi, r15
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_A4C82
add rbx, 30h ; '0'
jmp short loc_A4C63
loc_A4C82:
mov rax, rbx
loc_A4C85:
mov rcx, [r14+8]
cmp rax, [rcx+8]
jz short loc_A4CFC
add rax, 20h ; ' '
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_A4CA0:
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)
lea rdx, [rsp+68h+var_48]
mov [rdx], rax
lea rsi, aCannotUseAtWit; "cannot use at() with "
mov rdi, rsp
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
mov rdx, rsp
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_A4D75
loc_A4CFC:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r12, [rsp+68h+var_38]
mov [r12-10h], r12
mov rdi, r15
call _strlen
lea rdx, [rax+r15]
lea rdi, [rsp+68h+var_48]
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"
mov rdi, rsp
lea rdx, [rsp+68h+var_48]
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
mov rdx, rsp
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_A4D75:
mov r14, rax
lea rax, [rsp+68h+var_58]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A4D9B
mov rsi, [rsp+68h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_A4D9B
mov r14, rax
mov bpl, 1
loc_A4D9B:
mov rdi, [rsp+68h+var_48]
cmp rdi, r12
jz short loc_A4DD4
mov rsi, [rsp+68h+var_38]
jmp short loc_A4DC4
jmp short loc_A4DCE
mov r14, rax
lea rax, [rsp+68h+var_58]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A4DD4
mov rsi, [rsp+68h+var_58]
loc_A4DC4:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_A4DD4
loc_A4DCE:
mov r14, rax
mov bpl, 1
loc_A4DD4:
test bpl, bpl
jz short loc_A4DE1
mov rdi, rbx; void *
call ___cxa_free_exception
loc_A4DE1:
mov rdi, r14
call __Unwind_Resume
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_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 0x001a4ca0
MOV R15,RSI
MOV R12,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [R12]
LAB_001a4c63:
MOV RAX,qword ptr [R12 + 0x8]
CMP RBX,RAX
JZ 0x001a4c85
MOV RDI,RBX
MOV RSI,R15
CALL 0x0011a210
TEST EAX,EAX
JZ 0x001a4c82
ADD RBX,0x30
JMP 0x001a4c63
LAB_001a4c82:
MOV RAX,RBX
LAB_001a4c85:
MOV RCX,qword ptr [R14 + 0x8]
CMP RAX,qword ptr [RCX + 0x8]
JZ 0x001a4cfc
ADD RAX,0x20
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001a4ca0:
MOV EDI,0x20
CALL 0x0011a430
MOV RBX,RAX
MOV RDI,R14
CALL 0x0015d76e
LEA RDX,[RSP + 0x20]
MOV qword ptr [RDX],RAX
LAB_001a4cbd:
LEA RSI,[0x1f1d52]
MOV RDI,RSP
CALL 0x001aa7d7
MOV BPL,0x1
LAB_001a4ccf:
MOV RDX,RSP
MOV RDI,RBX
MOV ESI,0x130
MOV RCX,R14
CALL 0x00185d12
XOR EBP,EBP
LEA RSI,[0x229f08]
LEA RDX,[0x1598b0]
MOV RDI,RBX
CALL 0x0011aea0
LAB_001a4cfc:
MOV EDI,0x20
CALL 0x0011a430
MOV RBX,RAX
LEA R12,[RSP + 0x30]
MOV qword ptr [R12 + -0x10],R12
MOV RDI,R15
CALL 0x0011a3d0
LEA RDX,[RAX + R15*0x1]
LAB_001a4d1f:
LEA RDI,[RSP + 0x20]
MOV RSI,R15
CALL 0x00121530
LAB_001a4d2c:
LEA RSI,[0x1f1d82]
LEA RCX,[0x1f1d88]
MOV RDI,RSP
LEA RDX,[RSP + 0x20]
CALL 0x001aade0
MOV BPL,0x1
LAB_001a4d4a:
MOV RDX,RSP
MOV RDI,RBX
MOV ESI,0x193
MOV RCX,R14
CALL 0x001ab15a
XOR EBP,EBP
LEA RSI,[0x229e88]
LEA RDX,[0x1598b0]
MOV RDI,RBX
CALL 0x0011aea0
|
char * _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_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)
{
int8 *puVar1;
int iVar2;
char *pcVar3;
int8 uVar4;
size_t sVar5;
char *pcVar6;
detail adStack_68 [32];
char *local_48 [2];
char local_38 [16];
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_48[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 001a4cbd to 001a4ccb has its CatchHandler @ 001a4dce */
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[22],char_const*>
(adStack_68,"cannot use at() with ",local_48);
/* try { // try from 001a4ccf to 001a4cf9 has its CatchHandler @ 001a4dae */
_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,adStack_68,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);
}
puVar1 = *(int8 **)(param_1 + 8);
pcVar6 = (char *)*puVar1;
while ((pcVar3 = (char *)puVar1[1], pcVar6 != pcVar3 &&
(iVar2 = std::__cxx11::string::compare(pcVar6), pcVar3 = pcVar6, iVar2 != 0))) {
pcVar6 = pcVar6 + 0x30;
}
if (pcVar3 == *(char **)(*(long *)(param_1 + 8) + 8)) {
uVar4 = __cxa_allocate_exception(0x20);
local_48[0] = local_38;
sVar5 = strlen(param_2);
/* try { // try from 001a4d1f to 001a4d2b has its CatchHandler @ 001a4dac */
std::__cxx11::string::_M_construct<char_const*>(local_48,param_2,param_2 + sVar5);
/* try { // try from 001a4d2c to 001a4d46 has its CatchHandler @ 001a4d95 */
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,char_const(&)[6],std::__cxx11::string,char_const(&)[12]>
(adStack_68,"key \'",(string *)local_48,"\' not found");
/* try { // try from 001a4d4a to 001a4d74 has its CatchHandler @ 001a4d75 */
_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,adStack_68,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;
}
|
||
66,061 |
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 (&) [9], 0>(char const (&) [9]) 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;
}
|
O2
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> 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 (&) [9], 0>(char const (&) [9]) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
cmpb $0x1, (%rdi)
jne 0x7a331
movq %rsi, %r15
movq 0x8(%r14), %rdi
callq 0x7d9b2
movq 0x8(%r14), %rcx
cmpq 0x8(%rcx), %rax
je 0x7a38f
addq $0x20, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x23450
movq %rax, %rbx
movq %r14, %rdi
callq 0x425be
leaq 0x28(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x399df(%rip), %rsi # 0xb3d32
leaq 0x8(%rsp), %rdi
callq 0x7cfa1
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x130, %esi # imm = 0x130
movq %r14, %rcx
callq 0x6263e
xorl %ebp, %ebp
leaq 0x7fbca(%rip), %rsi # 0xf9f48
leaq -0x3b237(%rip), %rdx # 0x3f14e
movq %rbx, %rdi
callq 0x23e90
jmp 0x7a3f9
pushq $0x20
popq %rdi
callq 0x23450
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r15, %rsi
callq 0x25c26
leaq 0x399af(%rip), %rsi # 0xb3d62
leaq 0x399ae(%rip), %rcx # 0xb3d68
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x7d5ab
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x193, %esi # imm = 0x193
movq %r14, %rcx
callq 0x7da16
xorl %ebp, %ebp
leaq 0x7fade(%rip), %rsi # 0xf9ec8
leaq -0x3b2a3(%rip), %rdx # 0x3f14e
movq %rbx, %rdi
callq 0x23e90
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x24158
jmp 0x7a40e
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
jmp 0x7a41f
jmp 0x7a42b
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x24158
testb %bpl, %bpl
jne 0x7a42e
jmp 0x7a436
movq %rax, %r14
movq %rbx, %rdi
callq 0x23660
movq %r14, %rdi
callq 0x23f10
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA10_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_:
push rbp; char
push r15; int
push r14; int
push rbx; int
sub rsp, 48h
mov r14, rdi
cmp byte ptr [rdi], 1
jnz short loc_7A331
mov r15, rsi
mov rdi, [r14+8]
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA10_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_
mov rcx, [r14+8]
cmp rax, [rcx+8]
jz short loc_7A38F
add rax, 20h ; ' '
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_7A331:
push 20h ; ' '
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+68h+var_40]
mov [rdx], rax
lea rsi, aCannotUseAtWit; "cannot use at() with "
lea rdi, [rsp+68h+var_60]
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_60]
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_7A3F9
loc_7A38F:
push 20h ; ' '
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+68h+var_40]
lea rdx, [rsp+68h+var_61]
mov rsi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rsi, aKey; "key '"
lea rcx, aNotFound; "' not found"
lea rdi, [rsp+68h+var_60]
lea rdx, [rsp+68h+var_40]
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_60]
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_7A3F9:
mov r14, rax
lea rdi, [rsp+68h+var_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_7A40E
mov r14, rax
mov bpl, 1
loc_7A40E:
lea rdi, [rsp+68h+var_40]
jmp short loc_7A41F
jmp short loc_7A42B
mov r14, rax
lea rdi, [rsp+68h+var_60]; void *
loc_7A41F:
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_7A42E
jmp short loc_7A436
loc_7A42B:
mov r14, rax
loc_7A42E:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_7A436:
mov rdi, r14
call __Unwind_Resume
|
long long ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA10_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_(
long long a1,
long long a2)
{
long long v2; // rax
nlohmann::json_abi_v3_11_3::detail::type_error *exception; // rbx
nlohmann::json_abi_v3_11_3::detail::out_of_range *v5; // rbx
char v6; // [rsp+0h] [rbp-68h]
int v7[6]; // [rsp+8h] [rbp-60h] BYREF
char v8; // [rsp+20h] [rbp-48h]
const char *v9; // [rsp+28h] [rbp-40h] BYREF
int v10; // [rsp+30h] [rbp-38h]
int v11; // [rsp+38h] [rbp-30h]
char v12; // [rsp+40h] [rbp-28h]
int v13; // [rsp+48h] [rbp-20h]
int v14; // [rsp+50h] [rbp-18h]
int v15; // [rsp+58h] [rbp-10h]
char v16; // [rsp+60h] [rbp-8h]
if ( *(_BYTE *)a1 != 1 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::type_error *)__cxa_allocate_exception(0x20uLL);
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>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(v7, "cannot use at() with ");
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,
(long long)v7);
__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 = ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA10_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_(*(_QWORD *)(a1 + 8));
if ( v2 == *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL) )
{
v5 = (nlohmann::json_abi_v3_11_3::detail::out_of_range *)__cxa_allocate_exception(0x20uLL);
std::string::basic_string<std::allocator<char>>(&v9, a2);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(
v7,
"key '",
&v9,
"' 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_(
v5,
403,
v6,
v7[0],
v7[2],
v7[4],
v8,
(int)v9,
v10,
v11,
v12,
v13,
v14,
v15,
v16);
__cxa_throw(
v5,
(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 v2 + 32;
}
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA10_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV R14,RDI
CMP byte ptr [RDI],0x1
JNZ 0x0017a331
MOV R15,RSI
MOV RDI,qword ptr [R14 + 0x8]
CALL 0x0017d9b2
MOV RCX,qword ptr [R14 + 0x8]
CMP RAX,qword ptr [RCX + 0x8]
JZ 0x0017a38f
ADD RAX,0x20
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0017a331:
PUSH 0x20
POP RDI
CALL 0x00123450
MOV RBX,RAX
MOV RDI,R14
CALL 0x001425be
LEA RDX,[RSP + 0x28]
MOV qword ptr [RDX],RAX
LAB_0017a34c:
LEA RSI,[0x1b3d32]
LEA RDI,[RSP + 0x8]
CALL 0x0017cfa1
MOV BPL,0x1
LAB_0017a360:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0x130
MOV RCX,R14
CALL 0x0016263e
XOR EBP,EBP
LEA RSI,[0x1f9f48]
LEA RDX,[0x13f14e]
MOV RDI,RBX
CALL 0x00123e90
LAB_0017a38f:
PUSH 0x20
POP RDI
CALL 0x00123450
MOV RBX,RAX
LAB_0017a39a:
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x7]
MOV RSI,R15
CALL 0x00125c26
LAB_0017a3ac:
LEA RSI,[0x1b3d62]
LEA RCX,[0x1b3d68]
LEA RDI,[RSP + 0x8]
LEA RDX,[RSP + 0x28]
CALL 0x0017d5ab
MOV BPL,0x1
LAB_0017a3cc:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0x193
MOV RCX,R14
CALL 0x0017da16
XOR EBP,EBP
LEA RSI,[0x1f9ec8]
LEA RDX,[0x13f14e]
MOV RDI,RBX
CALL 0x00123e90
|
long _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA10_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 lVar1;
int8 uVar2;
allocator local_61;
detail local_60 [32];
char *local_40 [4];
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) {
uVar2 = __cxa_allocate_exception(0x20);
local_40[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 0017a34c to 0017a35c has its CatchHandler @ 0017a42b */
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[22],char_const*>
(local_60,"cannot use at() with ",local_40);
/* try { // try from 0017a360 to 0017a38c has its CatchHandler @ 0017a417 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar2,0x130,local_60,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar2,&nlohmann::json_abi_v3_11_3::detail::type_error::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
lVar1 = _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA10_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_
(*(int8 *)(param_1 + 8));
if (lVar1 != *(long *)(*(long *)(param_1 + 8) + 8)) {
return lVar1 + 0x20;
}
uVar2 = __cxa_allocate_exception(0x20);
/* try { // try from 0017a39a to 0017a3ab has its CatchHandler @ 0017a415 */
std::__cxx11::string::string<std::allocator<char>>((string *)local_40,param_2,&local_61);
/* try { // try from 0017a3ac to 0017a3c8 has its CatchHandler @ 0017a408 */
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,char_const(&)[6],std::__cxx11::string,char_const(&)[12]>
(local_60,"key \'",(string *)local_40,"\' not found");
/* try { // try from 0017a3cc to 0017a3f8 has its CatchHandler @ 0017a3f9 */
_ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar2,0x193,local_60,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar2,&nlohmann::json_abi_v3_11_3::detail::out_of_range::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
|
|
66,062 |
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 (&) [9], 0>(char const (&) [9]) 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 (&) [9], 0>(char const (&) [9]) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpb $0x1, (%rdi)
jne 0xa4761
movq %rsi, %r15
movq 0x8(%r14), %r12
movq (%r12), %rbx
movq 0x8(%r12), %rax
cmpq %rax, %rbx
je 0xa474b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1a210
testl %eax, %eax
je 0xa4740
addq $0x30, %rbx
movq 0x8(%r12), %rax
cmpq %rax, %rbx
jne 0xa4721
jmp 0xa4743
movq %rbx, %rax
movq 0x8(%r14), %rcx
movq 0x8(%rcx), %rbx
cmpq %rbx, %rax
je 0xa47bf
addq $0x20, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x1a430
movq %rax, %rbx
movq %r14, %rdi
callq 0x5df1e
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0x4b5bf(%rip), %rsi # 0xefd42
leaq 0x20(%rsp), %rdi
callq 0xa9f93
movb $0x1, %bpl
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movl $0x130, %esi # imm = 0x130
movq %r14, %rcx
callq 0x858f8
xorl %ebp, %ebp
leaq 0x8379a(%rip), %rsi # 0x127f48
leaq -0x4a661(%rip), %rdx # 0x5a154
movq %rbx, %rdi
callq 0x1aea0
jmp 0xa4838
movl $0x20, %edi
callq 0x1a430
movq %rax, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r15, %rdi
callq 0x1a3d0
leaq (%rax,%r15), %rdx
movq %rsp, %rdi
movq %r15, %rsi
callq 0x21540
leaq 0x4b57e(%rip), %rsi # 0xefd72
leaq 0x4b57d(%rip), %rcx # 0xefd78
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xaa570
movb $0x1, %bpl
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movl $0x193, %esi # imm = 0x193
movq %r14, %rcx
callq 0xaa8e8
xorl %ebp, %ebp
leaq 0x8369f(%rip), %rsi # 0x127ec8
leaq -0x4a6dc(%rip), %rdx # 0x5a154
movq %rbx, %rdi
callq 0x1aea0
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa4856
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a890
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xa48a1
movq 0x10(%rsp), %rsi
jmp 0xa4899
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xa48ab
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a890
jmp 0xa48ab
jmp 0xa48a8
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa48a1
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a890
testb %bpl, %bpl
jne 0xa48ab
jmp 0xa48b3
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a640
movq %r14, %rdi
callq 0x1af20
nop
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA10_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_A4761
mov r15, rsi
mov r12, [r14+8]
mov rbx, [r12]
mov rax, [r12+8]
cmp rbx, rax
jz short loc_A474B
loc_A4721:
mov rdi, rbx
mov rsi, r15
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_A4740
add rbx, 30h ; '0'
mov rax, [r12+8]
cmp rbx, rax
jnz short loc_A4721
jmp short loc_A4743
loc_A4740:
mov rax, rbx
loc_A4743:
mov rcx, [r14+8]
mov rbx, [rcx+8]
loc_A474B:
cmp rax, rbx
jz short loc_A47BF
add rax, 20h ; ' '
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_A4761:
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_A4838
loc_A47BF:
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_A4838:
mov r14, rax
lea rax, [rsp+68h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A4856
mov rsi, [rsp+68h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A4856:
mov rdi, [rsp+68h+var_68]
cmp rdi, r12
jz short loc_A48A1
mov rsi, [rsp+68h+var_58]
jmp short loc_A4899
mov r14, rax
mov rdi, [rsp+68h+var_68]; void *
cmp rdi, r12
jz short loc_A48AB
mov rsi, [rsp+68h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_A48AB
jmp short loc_A48A8
mov r14, rax
lea rax, [rsp+68h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A48A1
mov rsi, [rsp+68h+var_38]
loc_A4899:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A48A1:
test bpl, bpl
jnz short loc_A48AB
jmp short loc_A48B3
loc_A48A8:
mov r14, rax
loc_A48AB:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_A48B3:
mov rdi, r14
call __Unwind_Resume
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA10_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 0x001a4761
MOV R15,RSI
MOV R12,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [R12]
MOV RAX,qword ptr [R12 + 0x8]
CMP RBX,RAX
JZ 0x001a474b
LAB_001a4721:
MOV RDI,RBX
MOV RSI,R15
CALL 0x0011a210
TEST EAX,EAX
JZ 0x001a4740
ADD RBX,0x30
MOV RAX,qword ptr [R12 + 0x8]
CMP RBX,RAX
JNZ 0x001a4721
JMP 0x001a4743
LAB_001a4740:
MOV RAX,RBX
LAB_001a4743:
MOV RCX,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [RCX + 0x8]
LAB_001a474b:
CMP RAX,RBX
JZ 0x001a47bf
ADD RAX,0x20
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001a4761:
MOV EDI,0x20
CALL 0x0011a430
MOV RBX,RAX
MOV RDI,R14
CALL 0x0015df1e
MOV RDX,RSP
MOV qword ptr [RDX],RAX
LAB_001a477c:
LEA RSI,[0x1efd42]
LEA RDI,[RSP + 0x20]
CALL 0x001a9f93
MOV BPL,0x1
LAB_001a4790:
LEA RDX,[RSP + 0x20]
MOV RDI,RBX
MOV ESI,0x130
MOV RCX,R14
CALL 0x001858f8
XOR EBP,EBP
LEA RSI,[0x227f48]
LEA RDX,[0x15a154]
MOV RDI,RBX
CALL 0x0011aea0
LAB_001a47bf:
MOV EDI,0x20
CALL 0x0011a430
MOV RBX,RAX
LEA R12,[RSP + 0x10]
MOV qword ptr [R12 + -0x10],R12
MOV RDI,R15
CALL 0x0011a3d0
LEA RDX,[RAX + R15*0x1]
LAB_001a47e2:
MOV RDI,RSP
MOV RSI,R15
CALL 0x00121540
LAB_001a47ed:
LEA RSI,[0x1efd72]
LEA RCX,[0x1efd78]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x001aa570
MOV BPL,0x1
LAB_001a480b:
LEA RDX,[RSP + 0x20]
MOV RDI,RBX
MOV ESI,0x193
MOV RCX,R14
CALL 0x001aa8e8
XOR EBP,EBP
LEA RSI,[0x227ec8]
LEA RDX,[0x15a154]
MOV RDI,RBX
CALL 0x0011aea0
|
char * _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA10_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 001a477c to 001a478c has its CatchHandler @ 001a48a8 */
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 001a4790 to 001a47bc has its CatchHandler @ 001a4883 */
_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 001a47e2 to 001a47ec has its CatchHandler @ 001a4881 */
std::__cxx11::string::_M_construct<char_const*>(local_68,param_2,param_2 + sVar5);
/* try { // try from 001a47ed to 001a4807 has its CatchHandler @ 001a4866 */
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 001a480b to 001a4837 has its CatchHandler @ 001a4838 */
_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;
}
|
||
66,063 |
maria_scan_init
|
eloqsql/storage/maria/ma_scan.c
|
int maria_scan_init(register MARIA_HA *info)
{
DBUG_ENTER("maria_scan_init");
info->cur_row.nextpos= info->s->pack.header_length; /* Read first record */
info->lastinx= -1; /* Can't forward or backward */
if (info->opt_flag & WRITE_CACHE_USED && flush_io_cache(&info->rec_cache))
DBUG_RETURN(my_errno);
if ((*info->s->scan_init)(info))
DBUG_RETURN(my_errno);
DBUG_RETURN(0);
}
|
O3
|
c
|
maria_scan_init:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x590(%rax), %rcx
movq %rcx, 0xa0(%rdi)
movl $0xffffffff, 0x62c(%rdi) # imm = 0xFFFFFFFF
testb $0x10, 0x61c(%rdi)
je 0x5a8ed
leaq 0x4b8(%rbx), %rdi
movl $0x1, %esi
callq 0x94e91
testl %eax, %eax
jne 0x5a8fa
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x650(%rax)
testb %al, %al
je 0x5a903
callq 0xa13e6
movl (%rax), %eax
jmp 0x5a905
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
maria_scan_init:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
mov rax, [rdi]
mov rcx, [rax+590h]
mov [rdi+0A0h], rcx
mov dword ptr [rdi+62Ch], 0FFFFFFFFh
test byte ptr [rdi+61Ch], 10h
jz short loc_5A8ED
lea rdi, [rbx+4B8h]
mov esi, 1
call my_b_flush_io_cache
test eax, eax
jnz short loc_5A8FA
mov rax, [rbx]
loc_5A8ED:
mov rdi, rbx
call qword ptr [rax+650h]
test al, al
jz short loc_5A903
loc_5A8FA:
call _my_thread_var
mov eax, [rax]
jmp short loc_5A905
loc_5A903:
xor eax, eax
loc_5A905:
add rsp, 8
pop rbx
pop rbp
retn
|
long long maria_scan_init(long long *a1)
{
long long v2; // rax
long long *v3; // rdi
v2 = *a1;
a1[20] = *(_QWORD *)(*a1 + 1424);
*((_DWORD *)a1 + 395) = -1;
if ( (*((_BYTE *)a1 + 1564) & 0x10) != 0 )
{
v3 = a1 + 151;
if ( (unsigned int)my_b_flush_io_cache(v3, 1LL) )
return *(unsigned int *)my_thread_var(v3);
v2 = *a1;
}
v3 = a1;
if ( (*(unsigned __int8 ( **)(long long *))(v2 + 1616))(a1) )
return *(unsigned int *)my_thread_var(v3);
return 0LL;
}
|
maria_scan_init:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RAX,qword ptr [RDI]
MOV RCX,qword ptr [RAX + 0x590]
MOV qword ptr [RDI + 0xa0],RCX
MOV dword ptr [RDI + 0x62c],0xffffffff
TEST byte ptr [RDI + 0x61c],0x10
JZ 0x0015a8ed
LEA RDI,[RBX + 0x4b8]
MOV ESI,0x1
CALL 0x00194e91
TEST EAX,EAX
JNZ 0x0015a8fa
MOV RAX,qword ptr [RBX]
LAB_0015a8ed:
MOV RDI,RBX
CALL qword ptr [RAX + 0x650]
TEST AL,AL
JZ 0x0015a903
LAB_0015a8fa:
CALL 0x001a13e6
MOV EAX,dword ptr [RAX]
JMP 0x0015a905
LAB_0015a903:
XOR EAX,EAX
LAB_0015a905:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
int4 maria_scan_init(long *param_1)
{
char cVar1;
int iVar2;
long lVar3;
int4 *puVar4;
lVar3 = *param_1;
param_1[0x14] = *(long *)(lVar3 + 0x590);
*(int4 *)((long)param_1 + 0x62c) = 0xffffffff;
if ((*(byte *)((long)param_1 + 0x61c) & 0x10) != 0) {
iVar2 = my_b_flush_io_cache(param_1 + 0x97,1);
if (iVar2 != 0) goto LAB_0015a8fa;
lVar3 = *param_1;
}
cVar1 = (**(code **)(lVar3 + 0x650))(param_1);
if (cVar1 == '\0') {
return 0;
}
LAB_0015a8fa:
puVar4 = (int4 *)_my_thread_var();
return *puVar4;
}
|
|
66,064 |
list_free
|
eloqsql/mysys/list.c
|
void list_free(LIST *root, uint free_data)
{
LIST *next;
while (root)
{
next=root->next;
if (free_data)
my_free(root->data);
my_free(root);
root=next;
}
}
|
O3
|
c
|
list_free:
testq %rdi, %rdi
je 0x94f6a
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x8(%r14), %r15
testl %ebx, %ebx
je 0x94f50
movq 0x10(%r14), %rdi
callq 0xa08ce
movq %r14, %rdi
callq 0xa08ce
movq %r15, %r14
testq %r15, %r15
jne 0x94f3f
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
list_free:
test rdi, rdi
jz short locret_94F6A
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov ebx, esi
mov r14, rdi
loc_94F3F:
mov r15, [r14+8]
test ebx, ebx
jz short loc_94F50
mov rdi, [r14+10h]
call my_free
loc_94F50:
mov rdi, r14
call my_free
mov r14, r15
test r15, r15
jnz short loc_94F3F
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
locret_94F6A:
retn
|
long long list_free(long long a1, int a2)
{
long long v2; // r14
long long v3; // r15
long long result; // rax
if ( a1 )
{
v2 = a1;
do
{
v3 = *(_QWORD *)(v2 + 8);
if ( a2 )
my_free(*(_QWORD *)(v2 + 16));
result = my_free(v2);
v2 = v3;
}
while ( v3 );
}
return result;
}
|
list_free:
TEST RDI,RDI
JZ 0x00194f6a
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EBX,ESI
MOV R14,RDI
LAB_00194f3f:
MOV R15,qword ptr [R14 + 0x8]
TEST EBX,EBX
JZ 0x00194f50
MOV RDI,qword ptr [R14 + 0x10]
CALL 0x001a08ce
LAB_00194f50:
MOV RDI,R14
CALL 0x001a08ce
MOV R14,R15
TEST R15,R15
JNZ 0x00194f3f
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
LAB_00194f6a:
RET
|
void list_free(long param_1,int param_2)
{
long lVar1;
if (param_1 != 0) {
do {
lVar1 = *(long *)(param_1 + 8);
if (param_2 != 0) {
my_free(*(int8 *)(param_1 + 0x10));
}
my_free(param_1);
param_1 = lVar1;
} while (lVar1 != 0);
}
return;
}
|
|
66,065 |
bool YAML::detail::node_iterator_base<YAML::detail::node>::operator==<YAML::detail::node>(YAML::detail::node_iterator_base<YAML::detail::node> const&) const
|
aimrt_mujoco_sim/_deps/yaml-cpp-src/include/yaml-cpp/node/detail/node_iterator.h
|
bool operator==(const node_iterator_base<W>& rhs) const {
if (m_type != rhs.m_type)
return false;
switch (m_type) {
case iterator_type::NoneType:
return true;
case iterator_type::Sequence:
return m_seqIt == rhs.m_seqIt;
case iterator_type::Map:
return m_mapIt == rhs.m_mapIt;
}
return true;
}
|
O0
|
c
|
bool YAML::detail::node_iterator_base<YAML::detail::node>::operator==<YAML::detail::node>(YAML::detail::node_iterator_base<YAML::detail::node> const&) const:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl (%rax), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
je 0xcd9ea
movb $0x0, 0x27(%rsp)
jmp 0xcda5b
movq 0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0xcda11
jmp 0xcd9fb
movl 0x4(%rsp), %eax
subl $0x1, %eax
je 0xcda18
jmp 0xcda06
movl 0x4(%rsp), %eax
subl $0x2, %eax
je 0xcda37
jmp 0xcda56
movb $0x1, 0x27(%rsp)
jmp 0xcda5b
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movq 0x10(%rsp), %rsi
addq $0x8, %rsi
callq 0xcda70
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xcda5b
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq 0x10(%rsp), %rsi
addq $0x10, %rsi
callq 0xcdab0
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xcda5b
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
|
_ZNK4YAML6detail18node_iterator_baseINS0_4nodeEEeqIS2_EEbRKNS1_IT_EE:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_18], rsi
mov rax, [rsp+28h+var_10]
mov [rsp+28h+var_20], rax
mov eax, [rax]
mov rcx, [rsp+28h+var_18]
cmp eax, [rcx]
jz short loc_CD9EA
mov [rsp+28h+var_1], 0
jmp short loc_CDA5B
loc_CD9EA:
mov rax, [rsp+28h+var_20]
mov eax, [rax]
mov [rsp+28h+var_24], eax
test eax, eax
jz short loc_CDA11
jmp short $+2
loc_CD9FB:
mov eax, [rsp+28h+var_24]
sub eax, 1
jz short loc_CDA18
jmp short $+2
loc_CDA06:
mov eax, [rsp+28h+var_24]
sub eax, 2
jz short loc_CDA37
jmp short loc_CDA56
loc_CDA11:
mov [rsp+28h+var_1], 1
jmp short loc_CDA5B
loc_CDA18:
mov rdi, [rsp+28h+var_20]
add rdi, 8
mov rsi, [rsp+28h+var_18]
add rsi, 8
call _ZN9__gnu_cxxeqIPPN4YAML6detail4nodeESt6vectorIS4_SaIS4_EEEEbRKNS_17__normal_iteratorIT_T0_EESE_QrqXeqcldtfp_4baseEcldtfp0_4baseERSt14convertible_toIbEE
and al, 1
mov [rsp+28h+var_1], al
jmp short loc_CDA5B
loc_CDA37:
mov rdi, [rsp+28h+var_20]
add rdi, 10h
mov rsi, [rsp+28h+var_18]
add rsi, 10h
call _ZN9__gnu_cxxeqIPSt4pairIPN4YAML6detail4nodeES5_ESt6vectorIS6_SaIS6_EEEEbRKNS_17__normal_iteratorIT_T0_EESG_QrqXeqcldtfp_4baseEcldtfp0_4baseERSt14convertible_toIbEE
and al, 1
mov [rsp+28h+var_1], al
jmp short loc_CDA5B
loc_CDA56:
mov [rsp+28h+var_1], 1
loc_CDA5B:
mov al, [rsp+28h+var_1]
and al, 1
add rsp, 28h
retn
|
char YAML::detail::node_iterator_base<YAML::detail::node>::operator==<YAML::detail::node>(
int *a1,
_DWORD *a2)
{
int v3; // [rsp+4h] [rbp-24h]
if ( *a1 != *a2 )
return 0;
v3 = *a1;
if ( !*a1 )
return 1;
if ( v3 == 1 )
return __gnu_cxx::operator==<YAML::detail::node **,std::vector<YAML::detail::node *>>(a1 + 2, a2 + 2) & 1;
if ( v3 == 2 )
return __gnu_cxx::operator==<std::pair<YAML::detail::node *,YAML::detail::node *> *,std::vector<std::pair<YAML::detail::node *,YAML::detail::node *>>>(
a1 + 4,
a2 + 4) & 1;
return 1;
}
|
operator==:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV qword ptr [RSP + 0x10],RSI
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x8],RAX
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RSP + 0x10]
CMP EAX,dword ptr [RCX]
JZ 0x001cd9ea
MOV byte ptr [RSP + 0x27],0x0
JMP 0x001cda5b
LAB_001cd9ea:
MOV RAX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RSP + 0x4],EAX
TEST EAX,EAX
JZ 0x001cda11
JMP 0x001cd9fb
LAB_001cd9fb:
MOV EAX,dword ptr [RSP + 0x4]
SUB EAX,0x1
JZ 0x001cda18
JMP 0x001cda06
LAB_001cda06:
MOV EAX,dword ptr [RSP + 0x4]
SUB EAX,0x2
JZ 0x001cda37
JMP 0x001cda56
LAB_001cda11:
MOV byte ptr [RSP + 0x27],0x1
JMP 0x001cda5b
LAB_001cda18:
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x8
MOV RSI,qword ptr [RSP + 0x10]
ADD RSI,0x8
CALL 0x001cda70
AND AL,0x1
MOV byte ptr [RSP + 0x27],AL
JMP 0x001cda5b
LAB_001cda37:
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x10
MOV RSI,qword ptr [RSP + 0x10]
ADD RSI,0x10
CALL 0x001cdab0
AND AL,0x1
MOV byte ptr [RSP + 0x27],AL
JMP 0x001cda5b
LAB_001cda56:
MOV byte ptr [RSP + 0x27],0x1
LAB_001cda5b:
MOV AL,byte ptr [RSP + 0x27]
AND AL,0x1
ADD RSP,0x28
RET
|
/* bool
YAML::detail::node_iterator_base<YAML::detail::node>::TEMPNAMEPLACEHOLDERVALUE(YAML::detail::node_iterator_base<YAML::detail::node>
const&) const */
bool __thiscall
YAML::detail::node_iterator_base<YAML::detail::node>::operator==
(node_iterator_base<YAML::detail::node> *this,node_iterator_base *param_1)
{
int iVar1;
byte bVar2;
bool local_1;
if (*(int *)this == *(int *)param_1) {
iVar1 = *(int *)this;
if (iVar1 == 0) {
local_1 = true;
}
else if (iVar1 == 1) {
bVar2 = _ZN9__gnu_cxxeqIPPN4YAML6detail4nodeESt6vectorIS4_SaIS4_EEEEbRKNS_17__normal_iteratorIT_T0_EESE_QrqXeqcldtfp_4baseEcldtfp0_4baseERSt14convertible_toIbEE
(this + 8,param_1 + 8);
local_1 = (bool)(bVar2 & 1);
}
else if (iVar1 == 2) {
bVar2 = _ZN9__gnu_cxxeqIPSt4pairIPN4YAML6detail4nodeES5_ESt6vectorIS6_SaIS6_EEEEbRKNS_17__normal_iteratorIT_T0_EESG_QrqXeqcldtfp_4baseEcldtfp0_4baseERSt14convertible_toIbEE
(this + 0x10,param_1 + 0x10);
local_1 = (bool)(bVar2 & 1);
}
else {
local_1 = true;
}
}
else {
local_1 = false;
}
return local_1;
}
|
|
66,066 |
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;
}
|
O3
|
c
|
my_wc_mb_big5:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x31c25
cmpl $0x7f, %esi
jg 0x31ae8
movb %sil, (%rdx)
movl $0x1, %eax
jmp 0x31c25
leal -0xa2(%rsi), %edi
cmpl $0x55, %edi
ja 0x31afe
movl %edi, %esi
leaq 0x3e2a4(%rip), %rdi # 0x6fda0
jmp 0x31b60
leal -0x2c7(%rsi), %edi
cmpl $0x18a, %edi # imm = 0x18A
ja 0x31b17
movl %edi, %esi
leaq 0x3e33b(%rip), %rdi # 0x6fe50
jmp 0x31b60
leal -0x2013(%rsi), %edi
cmpl $0x2ac, %edi # imm = 0x2AC
ja 0x31b30
movl %edi, %esi
leaq 0x3e642(%rip), %rdi # 0x70170
jmp 0x31b60
leal -0x2460(%rsi), %edi
cmpl $0x1e2, %edi # imm = 0x1E2
ja 0x31b49
movl %edi, %esi
leaq 0x3eb89(%rip), %rdi # 0x706d0
jmp 0x31b60
leal -0x3000(%rsi), %edi
cmpl $0x129, %edi # imm = 0x129
ja 0x31b8d
movl %edi, %esi
leaq 0x3ef40(%rip), %rdi # 0x70aa0
leaq (%rdi,%rsi,2), %rsi
movzwl (%rsi), %edi
testl %edi, %edi
je 0x31c23
leaq 0x2(%rdx), %rsi
cmpq %rcx, %rsi
ja 0x31c25
rolw $0x8, %di
movw %di, (%rdx)
movl $0x2, %eax
jmp 0x31c25
movl $0xa1c0, %edi # imm = 0xA1C0
cmpl $0x32a3, %esi # imm = 0x32A3
je 0x31b6f
leal -0x338e(%rsi), %edi
cmpl $0x47, %edi
ja 0x31bb0
movl %edi, %esi
leaq 0x3f152(%rip), %rdi # 0x70d00
jmp 0x31b60
leal -0x4e00(%rsi), %edi
cmpl $0x4683, %edi # imm = 0x4683
ja 0x31bc9
movl %edi, %esi
leaq 0x3f1c9(%rip), %rdi # 0x70d90
jmp 0x31b60
leal -0x9577(%rsi), %edi
cmpl $0xa2d, %edi # imm = 0xA2D
ja 0x31be5
movl %edi, %esi
leaq 0x47ec0(%rip), %rdi # 0x79aa0
jmp 0x31b60
movl %esi, %edi
andl $0x7ffffffe, %edi # imm = 0x7FFFFFFE
cmpl $0xfa0c, %edi # imm = 0xFA0C
jne 0x31c07
addl $0xffff05f4, %esi # imm = 0xFFFF05F4
leaq 0x4969a(%rip), %rdi # 0x7b29c
jmp 0x31b60
addl $0xffff01d0, %esi # imm = 0xFFFF01D0
cmpl $0x1cd, %esi # imm = 0x1CD
ja 0x31c23
movl %esi, %esi
leaq 0x492e2(%rip), %rdi # 0x7af00
jmp 0x31b60
xorl %eax, %eax
popq %rbp
retq
|
my_wc_mb_big5:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb loc_31C25
cmp esi, 7Fh
jg short loc_31AE8
mov [rdx], sil
mov eax, 1
jmp loc_31C25
loc_31AE8:
lea edi, [rsi-0A2h]
cmp edi, 55h ; 'U'
ja short loc_31AFE
mov esi, edi
lea rdi, tab_uni_big50
jmp short loc_31B60
loc_31AFE:
lea edi, [rsi-2C7h]
cmp edi, 18Ah
ja short loc_31B17
mov esi, edi
lea rdi, tab_uni_big51
jmp short loc_31B60
loc_31B17:
lea edi, [rsi-2013h]
cmp edi, 2ACh
ja short loc_31B30
mov esi, edi
lea rdi, tab_uni_big52
jmp short loc_31B60
loc_31B30:
lea edi, [rsi-2460h]
cmp edi, 1E2h
ja short loc_31B49
mov esi, edi
lea rdi, tab_uni_big53
jmp short loc_31B60
loc_31B49:
lea edi, [rsi-3000h]
cmp edi, 129h
ja short loc_31B8D
mov esi, edi
lea rdi, tab_uni_big54
loc_31B60:
lea rsi, [rdi+rsi*2]
movzx edi, word ptr [rsi]
test edi, edi
jz loc_31C23
loc_31B6F:
lea rsi, [rdx+2]
cmp rsi, rcx
ja loc_31C25
rol di, 8
mov [rdx], di
mov eax, 2
jmp loc_31C25
loc_31B8D:
mov edi, 0A1C0h
cmp esi, 32A3h
jz short loc_31B6F
lea edi, [rsi-338Eh]
cmp edi, 47h ; 'G'
ja short loc_31BB0
mov esi, edi
lea rdi, tab_uni_big56
jmp short loc_31B60
loc_31BB0:
lea edi, [rsi-4E00h]
cmp edi, 4683h
ja short loc_31BC9
mov esi, edi
lea rdi, tab_uni_big57
jmp short loc_31B60
loc_31BC9:
lea edi, [rsi-9577h]
cmp edi, 0A2Dh
ja short loc_31BE5
mov esi, edi
lea rdi, tab_uni_big58
jmp loc_31B60
loc_31BE5:
mov edi, esi
and edi, 7FFFFFFEh
cmp edi, 0FA0Ch
jnz short loc_31C07
add esi, 0FFFF05F4h
lea rdi, tab_uni_big59
jmp loc_31B60
loc_31C07:
add esi, 0FFFF01D0h
cmp esi, 1CDh
ja short loc_31C23
mov esi, esi
lea rdi, tab_uni_big510
jmp loc_31B60
loc_31C23:
xor eax, eax
loc_31C25:
pop rbp
retn
|
long long my_wc_mb_big5(long long a1, int a2, _BYTE *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rsi
_WORD *v6; // rdi
__int16 v7; // di
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
if ( a2 <= 127 )
{
*a3 = a2;
return 1LL;
}
if ( (unsigned int)(a2 - 162) > 0x55 )
{
if ( (unsigned int)(a2 - 711) > 0x18A )
{
if ( (unsigned int)(a2 - 8211) > 0x2AC )
{
if ( (unsigned int)(a2 - 9312) > 0x1E2 )
{
if ( (unsigned int)(a2 - 12288) > 0x129 )
{
v7 = -24128;
if ( a2 == 12963 )
{
LABEL_15:
if ( (unsigned long long)(a3 + 2) <= a4 )
{
*(_WORD *)a3 = __ROL2__(v7, 8);
return 2LL;
}
return result;
}
if ( (unsigned int)(a2 - 13198) > 0x47 )
{
if ( (unsigned int)(a2 - 19968) > 0x4683 )
{
if ( (unsigned int)(a2 - 38263) > 0xA2D )
{
if ( (a2 & 0x7FFFFFFE) == 0xFA0C )
{
v5 = (unsigned int)(a2 - 64012);
v6 = &tab_uni_big59;
}
else
{
LODWORD(v5) = a2 - 65072;
if ( (unsigned int)v5 > 0x1CD )
return 0LL;
v5 = (unsigned int)v5;
v6 = &tab_uni_big510;
}
}
else
{
v5 = (unsigned int)(a2 - 38263);
v6 = &tab_uni_big58;
}
}
else
{
v5 = (unsigned int)(a2 - 19968);
v6 = &tab_uni_big57;
}
}
else
{
v5 = (unsigned int)(a2 - 13198);
v6 = &tab_uni_big56;
}
}
else
{
v5 = (unsigned int)(a2 - 12288);
v6 = &tab_uni_big54;
}
}
else
{
v5 = (unsigned int)(a2 - 9312);
v6 = &tab_uni_big53;
}
}
else
{
v5 = (unsigned int)(a2 - 8211);
v6 = &tab_uni_big52;
}
}
else
{
v5 = (unsigned int)(a2 - 711);
v6 = &tab_uni_big51;
}
}
else
{
v5 = (unsigned int)(a2 - 162);
v6 = &tab_uni_big50;
}
v7 = v6[v5];
if ( v7 )
goto LABEL_15;
return 0LL;
}
return result;
}
|
my_wc_mb_big5:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x00131c25
CMP ESI,0x7f
JG 0x00131ae8
MOV byte ptr [RDX],SIL
MOV EAX,0x1
JMP 0x00131c25
LAB_00131ae8:
LEA EDI,[RSI + -0xa2]
CMP EDI,0x55
JA 0x00131afe
MOV ESI,EDI
LEA RDI,[0x16fda0]
JMP 0x00131b60
LAB_00131afe:
LEA EDI,[RSI + -0x2c7]
CMP EDI,0x18a
JA 0x00131b17
MOV ESI,EDI
LEA RDI,[0x16fe50]
JMP 0x00131b60
LAB_00131b17:
LEA EDI,[RSI + -0x2013]
CMP EDI,0x2ac
JA 0x00131b30
MOV ESI,EDI
LEA RDI,[0x170170]
JMP 0x00131b60
LAB_00131b30:
LEA EDI,[RSI + -0x2460]
CMP EDI,0x1e2
JA 0x00131b49
MOV ESI,EDI
LEA RDI,[0x1706d0]
JMP 0x00131b60
LAB_00131b49:
LEA EDI,[RSI + -0x3000]
CMP EDI,0x129
JA 0x00131b8d
MOV ESI,EDI
LEA RDI,[0x170aa0]
LAB_00131b60:
LEA RSI,[RDI + RSI*0x2]
MOVZX EDI,word ptr [RSI]
TEST EDI,EDI
JZ 0x00131c23
LAB_00131b6f:
LEA RSI,[RDX + 0x2]
CMP RSI,RCX
JA 0x00131c25
ROL DI,0x8
MOV word ptr [RDX],DI
MOV EAX,0x2
JMP 0x00131c25
LAB_00131b8d:
MOV EDI,0xa1c0
CMP ESI,0x32a3
JZ 0x00131b6f
LEA EDI,[RSI + -0x338e]
CMP EDI,0x47
JA 0x00131bb0
MOV ESI,EDI
LEA RDI,[0x170d00]
JMP 0x00131b60
LAB_00131bb0:
LEA EDI,[RSI + -0x4e00]
CMP EDI,0x4683
JA 0x00131bc9
MOV ESI,EDI
LEA RDI,[0x170d90]
JMP 0x00131b60
LAB_00131bc9:
LEA EDI,[RSI + -0x9577]
CMP EDI,0xa2d
JA 0x00131be5
MOV ESI,EDI
LEA RDI,[0x179aa0]
JMP 0x00131b60
LAB_00131be5:
MOV EDI,ESI
AND EDI,0x7ffffffe
CMP EDI,0xfa0c
JNZ 0x00131c07
ADD ESI,0xffff05f4
LEA RDI,[0x17b29c]
JMP 0x00131b60
LAB_00131c07:
ADD ESI,0xffff01d0
CMP ESI,0x1cd
JA 0x00131c23
MOV ESI,ESI
LEA RDI,[0x17af00]
JMP 0x00131b60
LAB_00131c23:
XOR EAX,EAX
LAB_00131c25:
POP RBP
RET
|
int8 my_wc_mb_big5(int8 param_1,uint param_2,ushort *param_3,ushort *param_4)
{
int8 uVar1;
ulong uVar2;
ushort uVar3;
int1 *puVar4;
uVar1 = 0xffffff9b;
if (param_4 <= param_3) {
return 0xffffff9b;
}
if ((int)param_2 < 0x80) {
*(char *)param_3 = (char)param_2;
return 1;
}
if (param_2 - 0xa2 < 0x56) {
uVar2 = (ulong)(param_2 - 0xa2);
puVar4 = tab_uni_big50;
}
else if (param_2 - 0x2c7 < 0x18b) {
uVar2 = (ulong)(param_2 - 0x2c7);
puVar4 = tab_uni_big51;
}
else if (param_2 - 0x2013 < 0x2ad) {
uVar2 = (ulong)(param_2 - 0x2013);
puVar4 = tab_uni_big52;
}
else if (param_2 - 0x2460 < 0x1e3) {
uVar2 = (ulong)(param_2 - 0x2460);
puVar4 = tab_uni_big53;
}
else if (param_2 - 0x3000 < 0x12a) {
uVar2 = (ulong)(param_2 - 0x3000);
puVar4 = tab_uni_big54;
}
else {
uVar3 = 0xa1c0;
if (param_2 == 0x32a3) goto LAB_00131b6f;
if (param_2 - 0x338e < 0x48) {
uVar2 = (ulong)(param_2 - 0x338e);
puVar4 = tab_uni_big56;
}
else if (param_2 - 0x4e00 < 0x4684) {
uVar2 = (ulong)(param_2 - 0x4e00);
puVar4 = tab_uni_big57;
}
else if (param_2 - 0x9577 < 0xa2e) {
uVar2 = (ulong)(param_2 - 0x9577);
puVar4 = tab_uni_big58;
}
else if ((param_2 & 0x7ffffffe) == 0xfa0c) {
uVar2 = (ulong)(param_2 - 0xfa0c);
puVar4 = (int1 *)&tab_uni_big59;
}
else {
if (0x1cd < param_2 - 0xfe30) {
return 0;
}
uVar2 = (ulong)(param_2 - 0xfe30);
puVar4 = tab_uni_big510;
}
}
uVar3 = *(ushort *)((long)puVar4 + uVar2 * 2);
if (uVar3 == 0) {
return 0;
}
LAB_00131b6f:
if (param_3 + 1 <= param_4) {
*param_3 = uVar3 << 8 | uVar3 >> 8;
uVar1 = 2;
}
return uVar1;
}
|
|
66,067 |
minja::Parser::consumeToken(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::SpaceHandling)
|
monkey531[P]llama/common/minja.hpp
|
std::string consumeToken(const std::string & token, SpaceHandling space_handling = SpaceHandling::Strip) {
auto start = it;
consumeSpaces(space_handling);
if (std::distance(it, end) >= (int64_t) token.size() && std::string(it, it + token.size()) == token) {
it += token.size();
return token;
}
it = start;
return "";
}
|
O2
|
cpp
|
minja::Parser::consumeToken(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::SpaceHandling):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x20(%rsi), %r13
movq %rsi, %rdi
movl %ecx, %esi
callq 0x3ffac
movq 0x18(%r15), %rax
movq 0x20(%r15), %rsi
subq %rsi, %rax
movq 0x8(%r14), %rdx
cmpq %rdx, %rax
jl 0x361ff
addq %rsi, %rdx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x5b2f2
movq %r12, %rdi
movq %r14, %rsi
callq 0x2725a
movl %eax, %ebp
movq %r12, %rdi
callq 0x22f48
testb %bpl, %bpl
je 0x361ff
movq 0x8(%r14), %rax
addq %rax, 0x20(%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22a60
jmp 0x36217
movq %r13, 0x20(%r15)
leaq 0x5aee4(%rip), %rsi # 0x910ee
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x26838
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ZN5minja6Parser12consumeTokenERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_13SpaceHandlingE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov r13, [rsi+20h]
mov rdi, rsi
mov esi, ecx
call _ZN5minja6Parser13consumeSpacesENS_13SpaceHandlingE; minja::Parser::consumeSpaces(minja::SpaceHandling)
mov rax, [r15+18h]
mov rsi, [r15+20h]
sub rax, rsi
mov rdx, [r14+8]
cmp rax, rdx
jl short loc_361FF
add rdx, rsi
lea rax, [rsp+58h+var_40]
mov [rax-10h], rax
lea r12, [rsp+58h+var_50]
mov rdi, r12
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIN9__gnu_cxx17__normal_iteratorIPKcS4_EEEEvT_SB_St20forward_iterator_tag; std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::forward_iterator_tag)
mov rdi, r12
mov rsi, r14
call _ZSteqIcEN9__gnu_cxx11__enable_ifIXsr9__is_charIT_EE7__valueEbE6__typeERKNSt7__cxx1112basic_stringIS2_St11char_traitsIS2_ESaIS2_EEESC_
mov ebp, eax
mov rdi, r12; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jz short loc_361FF
mov rax, [r14+8]
add [r15+20h], rax
mov rdi, rbx
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
jmp short loc_36217
loc_361FF:
mov [r15+20h], r13
lea rsi, aSUnableToOpenT+2Bh; ""
lea rdx, [rsp+58h+var_50]
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
loc_36217:
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
_QWORD * minja::Parser::consumeToken(_QWORD *a1, long long a2, _QWORD *a3, unsigned int a4)
{
long long v6; // r13
long long v7; // rsi
long long v8; // rdx
bool v9; // bp
_QWORD v11[2]; // [rsp+8h] [rbp-50h] BYREF
char v12; // [rsp+18h] [rbp-40h] BYREF
v6 = *(_QWORD *)(a2 + 32);
minja::Parser::consumeSpaces(a2, a4);
v7 = *(_QWORD *)(a2 + 32);
v8 = a3[1];
if ( *(_QWORD *)(a2 + 24) - v7 >= v8
&& (v11[0] = &v12,
std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(v11, v7, v7 + v8),
v9 = std::operator==<char>(v11, a3),
std::string::~string(v11),
v9) )
{
*(_QWORD *)(a2 + 32) += a3[1];
std::string::basic_string(a1, a3);
}
else
{
*(_QWORD *)(a2 + 32) = v6;
std::string::basic_string<std::allocator<char>>(a1, (long long)"");
}
return a1;
}
|
consumeToken:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV R13,qword ptr [RSI + 0x20]
MOV RDI,RSI
MOV ESI,ECX
CALL 0x0013ffac
MOV RAX,qword ptr [R15 + 0x18]
MOV RSI,qword ptr [R15 + 0x20]
SUB RAX,RSI
MOV RDX,qword ptr [R14 + 0x8]
CMP RAX,RDX
JL 0x001361ff
ADD RDX,RSI
LEA RAX,[RSP + 0x18]
MOV qword ptr [RAX + -0x10],RAX
LEA R12,[RSP + 0x8]
MOV RDI,R12
CALL 0x0015b2f2
MOV RDI,R12
MOV RSI,R14
CALL 0x0012725a
MOV EBP,EAX
MOV RDI,R12
CALL 0x00122f48
TEST BPL,BPL
JZ 0x001361ff
MOV RAX,qword ptr [R14 + 0x8]
ADD qword ptr [R15 + 0x20],RAX
MOV RDI,RBX
MOV RSI,R14
CALL 0x00122a60
JMP 0x00136217
LAB_001361ff:
MOV qword ptr [R15 + 0x20],R13
LEA RSI,[0x1910ee]
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
CALL 0x00126838
LAB_00136217:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* minja::Parser::consumeToken(std::__cxx11::string const&, minja::SpaceHandling) */
string * minja::Parser::consumeToken
(string *param_1,Parser *param_2,string *param_3,int4 param_4)
{
int8 uVar1;
long lVar2;
char cVar3;
int1 *local_50 [2];
int1 local_40 [16];
uVar1 = *(int8 *)(param_2 + 0x20);
consumeSpaces(param_2,param_4);
lVar2 = *(long *)(param_2 + 0x20);
if (*(long *)(param_3 + 8) <= *(long *)(param_2 + 0x18) - lVar2) {
local_50[0] = local_40;
std::__cxx11::string::
_M_construct<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>
((string *)local_50,lVar2,*(long *)(param_3 + 8) + lVar2);
cVar3 = std::operator==((string *)local_50,param_3);
std::__cxx11::string::~string((string *)local_50);
if (cVar3 != '\0') {
*(long *)(param_2 + 0x20) = *(long *)(param_2 + 0x20) + *(long *)(param_3 + 8);
std::__cxx11::string::string(param_1,param_3);
return param_1;
}
}
*(int8 *)(param_2 + 0x20) = uVar1;
std::__cxx11::string::string<std::allocator<char>>(param_1,"",(allocator *)local_50);
return param_1;
}
|
|
66,068 |
minja::Parser::consumeToken(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::SpaceHandling)
|
monkey531[P]llama/common/minja.hpp
|
std::string consumeToken(const std::string & token, SpaceHandling space_handling = SpaceHandling::Strip) {
auto start = it;
consumeSpaces(space_handling);
if (std::distance(it, end) >= (int64_t) token.size() && std::string(it, it + token.size()) == token) {
it += token.size();
return token;
}
it = start;
return "";
}
|
O3
|
cpp
|
minja::Parser::consumeToken(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::SpaceHandling):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x20(%rsi), %r13
movq %rsi, %rdi
movl %ecx, %esi
callq 0x40c26
movq 0x18(%r15), %rax
movq 0x20(%r15), %rsi
subq %rsi, %rax
movq 0x8(%r14), %rdx
cmpq %rdx, %rax
jl 0x353c8
addq %rsi, %rdx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x61208
movq 0x8(%r12), %rdx
cmpq 0x8(%r14), %rdx
jne 0x3537e
movq 0x8(%rsp), %r12
testq %rdx, %rdx
je 0x35387
movq (%r14), %rsi
movq %r12, %rdi
callq 0x1a790
testl %eax, %eax
sete %bpl
jmp 0x3538a
movq 0x8(%rsp), %r12
xorl %ebp, %ebp
jmp 0x3538a
movb $0x1, %bpl
leaq 0x18(%rsp), %rax
cmpq %rax, %r12
je 0x353a4
movq 0x18(%rsp), %rsi
incq %rsi
movq %r12, %rdi
callq 0x1a740
testb %bpl, %bpl
je 0x353c8
movq 0x8(%r14), %rdx
addq %rdx, 0x20(%r15)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x216d4
jmp 0x353e5
movq %r13, 0x20(%r15)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x76cf4(%rip), %rdx # 0xac0ce
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x20d82
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ZN5minja6Parser12consumeTokenERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_13SpaceHandlingE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov r13, [rsi+20h]
mov rdi, rsi
mov esi, ecx
call _ZN5minja6Parser13consumeSpacesENS_13SpaceHandlingE; minja::Parser::consumeSpaces(minja::SpaceHandling)
mov rax, [r15+18h]
mov rsi, [r15+20h]
sub rax, rsi
mov rdx, [r14+8]
cmp rax, rdx
jl loc_353C8
add rdx, rsi
lea rax, [rsp+58h+var_40]
mov [rax-10h], rax
lea r12, [rsp+58h+var_50]
mov rdi, r12
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIN9__gnu_cxx17__normal_iteratorIPKcS4_EEEEvT_SB_St20forward_iterator_tag; std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::forward_iterator_tag)
mov rdx, [r12+8]
cmp rdx, [r14+8]
jnz short loc_3537E
mov r12, [rsp+58h+var_50]
test rdx, rdx
jz short loc_35387
mov rsi, [r14]
mov rdi, r12
call _bcmp
test eax, eax
setz bpl
jmp short loc_3538A
loc_3537E:
mov r12, [rsp+58h+var_50]
xor ebp, ebp
jmp short loc_3538A
loc_35387:
mov bpl, 1
loc_3538A:
lea rax, [rsp+58h+var_40]
cmp r12, rax
jz short loc_353A4
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
mov rdi, r12; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_353A4:
test bpl, bpl
jz short loc_353C8
mov rdx, [r14+8]
add [r15+20h], rdx
lea rax, [rbx+10h]
mov [rbx], rax
mov rsi, [r14]
add rdx, rsi
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
jmp short loc_353E5
loc_353C8:
mov [r15+20h], r13
lea rax, [rbx+10h]
mov [rbx], rax
lea rdx, aSUnableToOpenT+2Bh; ""
mov rdi, rbx
mov rsi, rdx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
loc_353E5:
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
_QWORD * minja::Parser::consumeToken(_QWORD *a1, long long a2, _BYTE **a3, unsigned int a4)
{
long long v6; // r13
long long v7; // rsi
_BYTE *v8; // rdx
_QWORD *v9; // r12
bool v10; // bp
_BYTE *v11; // rdx
void *v13; // [rsp+8h] [rbp-50h] BYREF
_BYTE *v14; // [rsp+10h] [rbp-48h]
_QWORD v15[8]; // [rsp+18h] [rbp-40h] BYREF
v6 = *(_QWORD *)(a2 + 32);
minja::Parser::consumeSpaces(a2, a4);
v7 = *(_QWORD *)(a2 + 32);
v8 = a3[1];
if ( *(_QWORD *)(a2 + 24) - v7 < (long long)v8 )
goto LABEL_11;
v13 = v15;
std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(&v13, v7, &v8[v7]);
if ( v14 == a3[1] )
{
v9 = v13;
v10 = !v14 || (unsigned int)bcmp(v13, *a3) == 0;
}
else
{
v9 = v13;
v10 = 0;
}
if ( v9 != v15 )
operator delete(v9, v15[0] + 1LL);
if ( v10 )
{
v11 = a3[1];
*(_QWORD *)(a2 + 32) += v11;
*a1 = a1 + 2;
std::string::_M_construct<char *>((long long)a1, *a3, (long long)&v11[(_QWORD)*a3]);
}
else
{
LABEL_11:
*(_QWORD *)(a2 + 32) = v6;
*a1 = a1 + 2;
std::string::_M_construct<char const*>((long long)a1, "", (long long)"");
}
return a1;
}
|
consumeToken:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV R13,qword ptr [RSI + 0x20]
MOV RDI,RSI
MOV ESI,ECX
CALL 0x00140c26
MOV RAX,qword ptr [R15 + 0x18]
MOV RSI,qword ptr [R15 + 0x20]
SUB RAX,RSI
MOV RDX,qword ptr [R14 + 0x8]
CMP RAX,RDX
JL 0x001353c8
ADD RDX,RSI
LEA RAX,[RSP + 0x18]
MOV qword ptr [RAX + -0x10],RAX
LEA R12,[RSP + 0x8]
MOV RDI,R12
CALL 0x00161208
MOV RDX,qword ptr [R12 + 0x8]
CMP RDX,qword ptr [R14 + 0x8]
JNZ 0x0013537e
MOV R12,qword ptr [RSP + 0x8]
TEST RDX,RDX
JZ 0x00135387
MOV RSI,qword ptr [R14]
MOV RDI,R12
CALL 0x0011a790
TEST EAX,EAX
SETZ BPL
JMP 0x0013538a
LAB_0013537e:
MOV R12,qword ptr [RSP + 0x8]
XOR EBP,EBP
JMP 0x0013538a
LAB_00135387:
MOV BPL,0x1
LAB_0013538a:
LEA RAX,[RSP + 0x18]
CMP R12,RAX
JZ 0x001353a4
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
MOV RDI,R12
CALL 0x0011a740
LAB_001353a4:
TEST BPL,BPL
JZ 0x001353c8
MOV RDX,qword ptr [R14 + 0x8]
ADD qword ptr [R15 + 0x20],RDX
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
MOV RSI,qword ptr [R14]
ADD RDX,RSI
MOV RDI,RBX
CALL 0x001216d4
JMP 0x001353e5
LAB_001353c8:
MOV qword ptr [R15 + 0x20],R13
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LEA RDX,[0x1ac0ce]
MOV RDI,RBX
MOV RSI,RDX
CALL 0x00120d82
LAB_001353e5:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* minja::Parser::consumeToken(std::__cxx11::string const&, minja::SpaceHandling) */
long * minja::Parser::consumeToken(long *param_1,Parser *param_2,long *param_3,int4 param_4)
{
int8 uVar1;
long lVar2;
long *plVar3;
int iVar4;
bool bVar5;
long *local_50;
size_t local_48;
long local_40 [2];
uVar1 = *(int8 *)(param_2 + 0x20);
consumeSpaces(param_2,param_4);
lVar2 = *(long *)(param_2 + 0x20);
if (param_3[1] <= *(long *)(param_2 + 0x18) - lVar2) {
local_50 = local_40;
std::__cxx11::string::
_M_construct<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>
(&local_50,lVar2,param_3[1] + lVar2);
plVar3 = local_50;
if (local_48 == param_3[1]) {
if (local_48 == 0) {
bVar5 = true;
}
else {
iVar4 = bcmp(local_50,(void *)*param_3,local_48);
bVar5 = iVar4 == 0;
}
}
else {
bVar5 = false;
}
if (plVar3 != local_40) {
operator_delete(plVar3,local_40[0] + 1);
}
if (bVar5) {
lVar2 = param_3[1];
*(long *)(param_2 + 0x20) = *(long *)(param_2 + 0x20) + lVar2;
*param_1 = (long)(param_1 + 2);
std::__cxx11::string::_M_construct<char*>(param_1,*param_3,lVar2 + *param_3);
return param_1;
}
}
*(int8 *)(param_2 + 0x20) = uVar1;
*param_1 = (long)(param_1 + 2);
std::__cxx11::string::_M_construct<char_const*>(param_1,"");
return param_1;
}
|
|
66,069 |
ha_partition::rnd_init(bool)
|
eloqsql/sql/ha_partition.cc
|
int ha_partition::rnd_init(bool scan)
{
int error;
uint i= 0;
uint32 part_id;
DBUG_ENTER("ha_partition::rnd_init");
/*
For operations that may need to change data, we may need to extend
read_set.
*/
if (get_lock_type() == F_WRLCK)
{
/*
If write_set contains any of the fields used in partition and
subpartition expression, we need to set all bits in read_set because
the row may need to be inserted in a different [sub]partition. In
other words update_row() can be converted into write_row(), which
requires a complete record.
*/
if (bitmap_is_overlapping(&m_part_info->full_part_field_set,
table->write_set))
{
DBUG_PRINT("info", ("partition set full bitmap"));
bitmap_set_all(table->read_set);
}
else
{
/*
Some handlers only read fields as specified by the bitmap for the
read set. For partitioned handlers we always require that the
fields of the partition functions are read such that we can
calculate the partition id to place updated and deleted records.
*/
DBUG_PRINT("info", ("partition set part_field bitmap"));
bitmap_union(table->read_set, &m_part_info->full_part_field_set);
}
}
/* Now we see what the index of our first important partition is */
DBUG_PRINT("info", ("m_part_info->read_partitions: %p",
m_part_info->read_partitions.bitmap));
part_id= bitmap_get_first_set(&(m_part_info->read_partitions));
DBUG_PRINT("info", ("m_part_spec.start_part: %u", (uint) part_id));
if (part_id == MY_BIT_NONE)
{
error= 0;
goto err1;
}
/*
We have a partition and we are scanning with rnd_next
so we bump our cache
*/
DBUG_PRINT("info", ("rnd_init on partition: %u", (uint) part_id));
if (scan)
{
/*
rnd_end() is needed for partitioning to reset internal data if scan
is already in use
*/
rnd_end();
late_extra_cache(part_id);
m_index_scan_type= partition_no_index_scan;
}
for (i= part_id;
i < m_tot_parts;
i= bitmap_get_next_set(&m_part_info->read_partitions, i))
{
if (unlikely((error= m_file[i]->ha_rnd_init(scan))))
goto err;
}
m_scan_value= scan;
m_part_spec.start_part= part_id;
m_part_spec.end_part= m_tot_parts - 1;
m_rnd_init_and_first= TRUE;
DBUG_PRINT("info", ("m_scan_value: %u", m_scan_value));
DBUG_RETURN(0);
err:
if (scan)
late_extra_no_cache(part_id);
/* Call rnd_end for all previously inited partitions. */
for (;
part_id < i;
part_id= bitmap_get_next_set(&m_part_info->read_partitions, part_id))
{
m_file[part_id]->ha_rnd_end();
}
err1:
m_scan_value= 2;
m_part_spec.start_part= NO_CURRENT_PART_ID;
DBUG_RETURN(error);
}
|
O0
|
cpp
|
ha_partition::rnd_init(bool):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
callq 0x8cac20
cmpl $0x1, %eax
jne 0xf46a7c
movq -0x28(%rbp), %rax
movq 0x578(%rax), %rdi
addq $0xc0, %rdi
movq 0x10(%rax), %rax
movq 0x1f8(%rax), %rsi
callq 0x131a5a0
cmpb $0x0, %al
je 0xf46a54
jmp 0xf46a19
jmp 0xf46a1b
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
movq 0x1f0(%rcx), %rcx
movq (%rcx), %rdi
movq 0x10(%rax), %rax
movq 0x1f0(%rax), %rax
movl 0x1c(%rax), %eax
addl $0x1f, %eax
shrl $0x5, %eax
shll $0x2, %eax
movl %eax, %eax
movl %eax, %edx
movl $0xff, %esi
callq 0x7754f0
jmp 0xf46a7a
jmp 0xf46a56
jmp 0xf46a58
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
movq 0x1f0(%rcx), %rdi
movq 0x578(%rax), %rsi
addq $0xc0, %rsi
callq 0x131aaf0
jmp 0xf46a7c
jmp 0xf46a7e
jmp 0xf46a80
movq -0x28(%rbp), %rax
movq 0x578(%rax), %rdi
addq $0x130, %rdi # imm = 0x130
callq 0x131ad70
movl %eax, -0x20(%rbp)
jmp 0xf46a9c
cmpl $-0x1, -0x20(%rbp)
jne 0xf46aae
movl $0x0, -0x18(%rbp)
jmp 0xf46bcd
jmp 0xf46ab0
jmp 0xf46ab2
testb $0x1, -0x11(%rbp)
je 0xf46adb
movq -0x28(%rbp), %rdi
callq 0xf46c00
movq -0x28(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0xf41ee0
movq -0x28(%rbp), %rax
movl $0x6, 0x648(%rax)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x60c(%rcx), %eax
jae 0xf46b3a
movq -0x28(%rbp), %rax
movq 0x548(%rax), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x8ca400
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
je 0xf46b19
jmp 0xf46b79
jmp 0xf46b1b
movq -0x28(%rbp), %rax
movq 0x578(%rax), %rdi
addq $0x130, %rdi # imm = 0x130
movl -0x1c(%rbp), %esi
callq 0x131ae90
movl %eax, -0x1c(%rbp)
jmp 0xf46ae1
movq -0x28(%rbp), %rax
movb -0x11(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
movl %ecx, 0x620(%rax)
movl -0x20(%rbp), %ecx
movl %ecx, 0x618(%rax)
movl 0x60c(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x61c(%rax)
movb $0x1, 0x658(%rax)
jmp 0xf46b6e
jmp 0xf46b70
movl $0x0, -0x4(%rbp)
jmp 0xf46beb
testb $0x1, -0x11(%rbp)
je 0xf46b8b
movq -0x28(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0xf41fb0
jmp 0xf46b8d
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0xf46bcb
movq -0x28(%rbp), %rax
movq 0x548(%rax), %rax
movl -0x20(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x853860
movq -0x28(%rbp), %rax
movq 0x578(%rax), %rdi
addq $0x130, %rdi # imm = 0x130
movl -0x20(%rbp), %esi
callq 0x131ae90
movl %eax, -0x20(%rbp)
jmp 0xf46b8d
jmp 0xf46bcd
movq -0x28(%rbp), %rax
movl $0x2, 0x620(%rax)
movl $0xffffffff, 0x618(%rax) # imm = 0xFFFFFFFF
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_ZN12ha_partition8rnd_initEb:
push rbp
mov rbp, rsp
sub rsp, 30h
mov al, sil
mov [rbp+var_10], rdi
and al, 1
mov [rbp+var_11], al
mov rdi, [rbp+var_10]; this
mov [rbp+var_28], rdi
mov [rbp+var_1C], 0
call _ZNK7handler13get_lock_typeEv; handler::get_lock_type(void)
cmp eax, 1
jnz loc_F46A7C
mov rax, [rbp+var_28]
mov rdi, [rax+578h]
add rdi, 0C0h
mov rax, [rax+10h]
mov rsi, [rax+1F8h]
call bitmap_is_overlapping
cmp al, 0
jz short loc_F46A54
jmp short $+2
loc_F46A19:
jmp short $+2
loc_F46A1B:
mov rax, [rbp+var_28]
mov rcx, [rax+10h]
mov rcx, [rcx+1F0h]
mov rdi, [rcx]
mov rax, [rax+10h]
mov rax, [rax+1F0h]
mov eax, [rax+1Ch]
add eax, 1Fh
shr eax, 5
shl eax, 2
mov eax, eax
mov edx, eax
mov esi, 0FFh
call _memset
jmp short loc_F46A7A
loc_F46A54:
jmp short $+2
loc_F46A56:
jmp short $+2
loc_F46A58:
mov rax, [rbp+var_28]
mov rcx, [rax+10h]
mov rdi, [rcx+1F0h]
mov rsi, [rax+578h]
add rsi, 0C0h
call bitmap_union
loc_F46A7A:
jmp short $+2
loc_F46A7C:
jmp short $+2
loc_F46A7E:
jmp short $+2
loc_F46A80:
mov rax, [rbp+var_28]
mov rdi, [rax+578h]
add rdi, 130h
call bitmap_get_first_set
mov [rbp+var_20], eax
jmp short $+2
loc_F46A9C:
cmp [rbp+var_20], 0FFFFFFFFh
jnz short loc_F46AAE
mov [rbp+var_18], 0
jmp loc_F46BCD
loc_F46AAE:
jmp short $+2
loc_F46AB0:
jmp short $+2
loc_F46AB2:
test [rbp+var_11], 1
jz short loc_F46ADB
mov rdi, [rbp+var_28]; this
call _ZN12ha_partition7rnd_endEv; ha_partition::rnd_end(void)
mov rdi, [rbp+var_28]; this
mov esi, [rbp+var_20]; unsigned int
call _ZN12ha_partition16late_extra_cacheEj; ha_partition::late_extra_cache(uint)
mov rax, [rbp+var_28]
mov dword ptr [rax+648h], 6
loc_F46ADB:
mov eax, [rbp+var_20]
mov [rbp+var_1C], eax
loc_F46AE1:
mov rcx, [rbp+var_28]
mov eax, [rbp+var_1C]
cmp eax, [rcx+60Ch]
jnb short loc_F46B3A
mov rax, [rbp+var_28]
mov rax, [rax+548h]
mov ecx, [rbp+var_1C]
mov rdi, [rax+rcx*8]; this
mov al, [rbp+var_11]
and al, 1
movzx esi, al; bool
call _ZN7handler11ha_rnd_initEb; handler::ha_rnd_init(bool)
mov [rbp+var_18], eax
cmp eax, 0
jz short loc_F46B19
jmp short loc_F46B79
loc_F46B19:
jmp short $+2
loc_F46B1B:
mov rax, [rbp+var_28]
mov rdi, [rax+578h]
add rdi, 130h
mov esi, [rbp+var_1C]
call bitmap_get_next_set
mov [rbp+var_1C], eax
jmp short loc_F46AE1
loc_F46B3A:
mov rax, [rbp+var_28]
mov cl, [rbp+var_11]
and cl, 1
movzx ecx, cl
mov [rax+620h], ecx
mov ecx, [rbp+var_20]
mov [rax+618h], ecx
mov ecx, [rax+60Ch]
sub ecx, 1
mov [rax+61Ch], ecx
mov byte ptr [rax+658h], 1
jmp short $+2
loc_F46B6E:
jmp short $+2
loc_F46B70:
mov [rbp+var_4], 0
jmp short loc_F46BEB
loc_F46B79:
test [rbp+var_11], 1
jz short loc_F46B8B
mov rdi, [rbp+var_28]; this
mov esi, [rbp+var_20]; unsigned int
call _ZN12ha_partition19late_extra_no_cacheEj; ha_partition::late_extra_no_cache(uint)
loc_F46B8B:
jmp short $+2
loc_F46B8D:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_1C]
jnb short loc_F46BCB
mov rax, [rbp+var_28]
mov rax, [rax+548h]
mov ecx, [rbp+var_20]
mov rdi, [rax+rcx*8]; this
call _ZN7handler10ha_rnd_endEv; handler::ha_rnd_end(void)
mov rax, [rbp+var_28]
mov rdi, [rax+578h]
add rdi, 130h
mov esi, [rbp+var_20]
call bitmap_get_next_set
mov [rbp+var_20], eax
jmp short loc_F46B8D
loc_F46BCB:
jmp short $+2
loc_F46BCD:
mov rax, [rbp+var_28]
mov dword ptr [rax+620h], 2
mov dword ptr [rax+618h], 0FFFFFFFFh
mov eax, [rbp+var_18]
mov [rbp+var_4], eax
loc_F46BEB:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
|
long long ha_partition::rnd_init(ha_partition *this, char a2)
{
unsigned int first_set; // [rsp+10h] [rbp-20h]
unsigned int i; // [rsp+14h] [rbp-1Ch]
unsigned int v5; // [rsp+18h] [rbp-18h]
if ( (unsigned int)handler::get_lock_type(this) == 1 )
{
if ( (unsigned __int8)bitmap_is_overlapping(
*((_QWORD *)this + 175) + 192LL,
*(_QWORD *)(*((_QWORD *)this + 2) + 504LL)) )
memset(**(_QWORD **)(*((_QWORD *)this + 2) + 496LL), 255LL);
else
bitmap_union(*(_QWORD *)(*((_QWORD *)this + 2) + 496LL), *((_QWORD *)this + 175) + 192LL);
}
first_set = bitmap_get_first_set(*((_QWORD *)this + 175) + 304LL);
if ( first_set == -1 )
{
v5 = 0;
}
else
{
if ( (a2 & 1) != 0 )
{
ha_partition::rnd_end(this);
ha_partition::late_extra_cache(this, first_set);
*((_DWORD *)this + 402) = 6;
}
for ( i = first_set; ; i = bitmap_get_next_set(*((_QWORD *)this + 175) + 304LL, i) )
{
if ( i >= *((_DWORD *)this + 387) )
{
*((_DWORD *)this + 392) = a2 & 1;
*((_DWORD *)this + 390) = first_set;
*((_DWORD *)this + 391) = *((_DWORD *)this + 387) - 1;
*((_BYTE *)this + 1624) = 1;
return 0;
}
v5 = handler::ha_rnd_init(*(handler **)(*((_QWORD *)this + 169) + 8LL * i), a2 & 1);
if ( v5 )
break;
}
if ( (a2 & 1) != 0 )
ha_partition::late_extra_no_cache(this, first_set);
while ( first_set < i )
{
handler::ha_rnd_end(*(handler **)(*((_QWORD *)this + 169) + 8LL * first_set));
first_set = bitmap_get_next_set(*((_QWORD *)this + 175) + 304LL, first_set);
}
}
*((_DWORD *)this + 392) = 2;
*((_DWORD *)this + 390) = -1;
return v5;
}
|
unlock_data:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00f469dd
LAB_00f469dd:
MOV RDI,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RDI + 0x9c],EAX
MOV byte ptr [RDI + 0xb0],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RDI + 0xa8],RAX
CALL 0x00d3e520
JMP 0x00f46a03
LAB_00f46a03:
ADD RSP,0x20
POP RBP
RET
|
/* Event_scheduler::unlock_data(char const*, unsigned int) */
void __thiscall Event_scheduler::unlock_data(Event_scheduler *this,char *param_1,uint param_2)
{
*(uint *)(this + 0x9c) = param_2;
this[0xb0] = (Event_scheduler)0x0;
*(char **)(this + 0xa8) = param_1;
coro_mutex_unlock((st_mysql_mutex *)this);
return;
}
|
|
66,070 |
calculate_segment_checksum
|
seiftnesse[P]memoryallocator/src/custom_alloc_util.c
|
uint32_t calculate_segment_checksum(segment_t *s) {
if (!s) return 0;
// Create a temporary structure with the fields we want to include in the checksum
struct {
int is_free;
int size;
uintptr_t next;
uintptr_t prev;
uint32_t allocation_id;
uint32_t magic;
} checksum_data;
// Fill the structure with segment data
checksum_data.is_free = s->is_free;
checksum_data.size = s->size;
checksum_data.next = (uintptr_t) (s->next);
checksum_data.prev = (uintptr_t) (s->prev);
checksum_data.allocation_id = s->allocation_id;
checksum_data.magic = s->magic;
return fnv1a_hash(&checksum_data, sizeof(checksum_data));
}
|
O3
|
c
|
calculate_segment_checksum:
testq %rdi, %rdi
je 0x28c2
movq (%rdi), %rax
movq %rax, -0x20(%rsp)
movups 0x8(%rdi), %xmm0
movups %xmm0, -0x18(%rsp)
movq 0x24(%rdi), %rax
movq %rax, -0x8(%rsp)
movl $0x811c9dc5, %eax # imm = 0x811C9DC5
xorl %ecx, %ecx
movzbl -0x20(%rsp,%rcx), %edx
xorl %eax, %edx
imull $0x1000193, %edx, %eax # imm = 0x1000193
incq %rcx
cmpq $0x20, %rcx
jne 0x28ab
retq
xorl %eax, %eax
retq
|
calculate_segment_checksum:
test rdi, rdi
jz short loc_28C2
mov rax, [rdi]
mov [rsp+var_20], rax
movups xmm0, xmmword ptr [rdi+8]
movups [rsp+var_18], xmm0
mov rax, [rdi+24h]
mov [rsp+var_8], rax
mov eax, 811C9DC5h
xor ecx, ecx
loc_28AB:
movzx edx, byte ptr [rsp+rcx+var_20]
xor edx, eax
imul eax, edx, 1000193h
inc rcx
cmp rcx, 20h ; ' '
jnz short loc_28AB
retn
loc_28C2:
xor eax, eax
retn
|
long long calculate_segment_checksum(long long *a1)
{
long long result; // rax
long long i; // rcx
long long v3; // [rsp+0h] [rbp-20h]
__int128 v4; // [rsp+8h] [rbp-18h]
long long v5; // [rsp+18h] [rbp-8h]
if ( !a1 )
return 0LL;
v3 = *a1;
v4 = *(_OWORD *)(a1 + 1);
v5 = *(long long *)((char *)a1 + 36);
LODWORD(result) = -2128831035;
for ( i = 0LL; i != 32; ++i )
result = 16777619 * ((unsigned int)result ^ *((unsigned __int8 *)&v3 + i));
return result;
}
|
calculate_segment_checksum:
TEST RDI,RDI
JZ 0x001028c2
MOV RAX,qword ptr [RDI]
MOV qword ptr [RSP + -0x20],RAX
MOVUPS XMM0,xmmword ptr [RDI + 0x8]
MOVUPS xmmword ptr [RSP + -0x18],XMM0
MOV RAX,qword ptr [RDI + 0x24]
MOV qword ptr [RSP + -0x8],RAX
MOV EAX,0x811c9dc5
XOR ECX,ECX
LAB_001028ab:
MOVZX EDX,byte ptr [RSP + RCX*0x1 + -0x20]
XOR EDX,EAX
IMUL EAX,EDX,0x1000193
INC RCX
CMP RCX,0x20
JNZ 0x001028ab
RET
LAB_001028c2:
XOR EAX,EAX
RET
|
uint calculate_segment_checksum(int8 *param_1)
{
uint uVar1;
long lVar2;
int8 local_20;
int8 local_18;
int8 uStack_10;
int8 local_8;
if (param_1 != (int8 *)0x0) {
local_20 = *param_1;
local_18 = param_1[1];
uStack_10 = param_1[2];
local_8 = *(int8 *)((long)param_1 + 0x24);
uVar1 = 0x811c9dc5;
lVar2 = 0;
do {
uVar1 = (*(byte *)((long)&local_20 + lVar2) ^ uVar1) * 0x1000193;
lVar2 = lVar2 + 1;
} while (lVar2 != 0x20);
return uVar1;
}
return 0;
}
|
|
66,071 |
translog_get_first_needed_file
|
eloqsql/storage/maria/ma_loghandler.c
|
uint32 translog_get_first_needed_file()
{
uint32 file_no;
mysql_mutex_lock(&log_descriptor.purger_lock);
file_no= log_descriptor.min_need_file;
mysql_mutex_unlock(&log_descriptor.purger_lock);
return file_no;
}
|
O3
|
c
|
translog_get_first_needed_file:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpq $0x0, 0xbb17e7(%rip) # 0xbff680
jne 0x4dece
leaq 0xbb179e(%rip), %rdi # 0xbff640
callq 0x29220
movl 0xbb178b(%rip), %ebx # 0xbff638
movq 0xbb17cc(%rip), %rdi # 0xbff680
testq %rdi, %rdi
jne 0x4ded5
leaq 0xbb1780(%rip), %rdi # 0xbff640
callq 0x291e0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x2ccfc
jmp 0x4dea7
leaq 0x338134(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x4deb9
|
translog_get_first_needed_file:
push rbp
mov rbp, rsp
push rbx
push rax
cmp cs:qword_BFF680, 0
jnz short loc_4DECE
lea rdi, unk_BFF640
call _pthread_mutex_lock
loc_4DEA7:
mov ebx, dword ptr cs:qword_BFF638
mov rdi, cs:qword_BFF680
test rdi, rdi
jnz short loc_4DED5
loc_4DEB9:
lea rdi, unk_BFF640
call _pthread_mutex_unlock
mov eax, ebx
add rsp, 8
pop rbx
pop rbp
retn
loc_4DECE:
call translog_get_first_needed_file_cold_1
jmp short loc_4DEA7
loc_4DED5:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_4DEB9
|
long long translog_get_first_needed_file(long long a1)
{
unsigned int v1; // ebx
if ( qword_BFF680 )
translog_get_first_needed_file_cold_1(a1);
else
pthread_mutex_lock(&unk_BFF640);
v1 = qword_BFF638;
if ( qword_BFF680 )
((void ( *)(long long))PSI_server[44])(qword_BFF680);
pthread_mutex_unlock(&unk_BFF640);
return v1;
}
|
translog_get_first_needed_file:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
CMP qword ptr [0x00cff680],0x0
JNZ 0x0014dece
LEA RDI,[0xcff640]
CALL 0x00129220
LAB_0014dea7:
MOV EBX,dword ptr [0x00cff638]
MOV RDI,qword ptr [0x00cff680]
TEST RDI,RDI
JNZ 0x0014ded5
LAB_0014deb9:
LEA RDI,[0xcff640]
CALL 0x001291e0
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_0014dece:
CALL 0x0012ccfc
JMP 0x0014dea7
LAB_0014ded5:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0014deb9
|
int4 translog_get_first_needed_file(void)
{
int4 uVar1;
if (DAT_00cff680 == 0) {
pthread_mutex_lock((pthread_mutex_t *)&DAT_00cff640);
}
else {
translog_get_first_needed_file_cold_1();
}
uVar1 = DAT_00cff638;
if (DAT_00cff680 != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)&DAT_00cff640);
return uVar1;
}
|
|
66,072 |
lunasvg::Bitmap::convertToRGBA()
|
dmazzella[P]pylunasvg/lunasvg/source/lunasvg.cpp
|
void Bitmap::convertToRGBA()
{
if(m_surface == nullptr)
return;
auto data = plutovg_surface_get_data(m_surface);
auto width = plutovg_surface_get_width(m_surface);
auto height = plutovg_surface_get_height(m_surface);
auto stride = plutovg_surface_get_stride(m_surface);
plutovg_convert_argb_to_rgba(data, data, width, height, stride);
}
|
O0
|
cpp
|
lunasvg::Bitmap::convertToRGBA():
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, (%rax)
jne 0xc8dc
jmp 0xc937
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x656e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq (%rax), %rdi
callq 0x65700
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x14(%rbp)
movq (%rax), %rdi
callq 0x65720
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x18(%rbp)
movq (%rax), %rdi
callq 0x65740
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
callq 0x65ce0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
_ZN7lunasvg6Bitmap13convertToRGBAEv:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_28], rax
cmp qword ptr [rax], 0
jnz short loc_C8DC
jmp short loc_C937
loc_C8DC:
mov rax, [rbp+var_28]
mov rdi, [rax]
call plutovg_surface_get_data
mov rcx, rax
mov rax, [rbp+var_28]
mov [rbp+var_10], rcx
mov rdi, [rax]
call plutovg_surface_get_width
mov ecx, eax
mov rax, [rbp+var_28]
mov [rbp+var_14], ecx
mov rdi, [rax]
call plutovg_surface_get_height
mov ecx, eax
mov rax, [rbp+var_28]
mov [rbp+var_18], ecx
mov rdi, [rax]
call plutovg_surface_get_stride
mov [rbp+var_1C], eax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_10]
mov edx, [rbp+var_14]
mov ecx, [rbp+var_18]
mov r8d, [rbp+var_1C]
call plutovg_convert_argb_to_rgba
loc_C937:
add rsp, 30h
pop rbp
retn
|
lunasvg::Bitmap * lunasvg::Bitmap::convertToRGBA(lunasvg::Bitmap *this)
{
lunasvg::Bitmap *result; // rax
unsigned int stride; // [rsp+14h] [rbp-1Ch]
unsigned int height; // [rsp+18h] [rbp-18h]
unsigned int width; // [rsp+1Ch] [rbp-14h]
long long data; // [rsp+20h] [rbp-10h]
result = this;
if ( *(_QWORD *)this )
{
data = plutovg_surface_get_data(*(_QWORD *)this);
width = plutovg_surface_get_width(*(_QWORD *)this);
height = plutovg_surface_get_height(*(_QWORD *)this);
stride = plutovg_surface_get_stride(*(_QWORD *)this);
return (lunasvg::Bitmap *)plutovg_convert_argb_to_rgba(data, data, width, height, stride);
}
return result;
}
|
convertToRGBA:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RAX],0x0
JNZ 0x0010c8dc
JMP 0x0010c937
LAB_0010c8dc:
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX]
CALL 0x001656e0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x10],RCX
MOV RDI,qword ptr [RAX]
CALL 0x00165700
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x14],ECX
MOV RDI,qword ptr [RAX]
CALL 0x00165720
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x18],ECX
MOV RDI,qword ptr [RAX]
CALL 0x00165740
MOV dword ptr [RBP + -0x1c],EAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
MOV ECX,dword ptr [RBP + -0x18]
MOV R8D,dword ptr [RBP + -0x1c]
CALL 0x00165ce0
LAB_0010c937:
ADD RSP,0x30
POP RBP
RET
|
/* lunasvg::Bitmap::convertToRGBA() */
void __thiscall lunasvg::Bitmap::convertToRGBA(Bitmap *this)
{
int4 uVar1;
int4 uVar2;
int4 uVar3;
int8 uVar4;
if (*(long *)this != 0) {
uVar4 = plutovg_surface_get_data(*(int8 *)this);
uVar1 = plutovg_surface_get_width(*(int8 *)this);
uVar2 = plutovg_surface_get_height(*(int8 *)this);
uVar3 = plutovg_surface_get_stride(*(int8 *)this);
plutovg_convert_argb_to_rgba(uVar4,uVar4,uVar1,uVar2,uVar3);
}
return;
}
|
|
66,073 |
ggml_add_cast
|
ngxson[P]ggml-easy/ggml/src/ggml.c
|
struct ggml_tensor * ggml_add_cast(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b,
enum ggml_type type) {
return ggml_add_cast_impl(ctx, a, b, type);
}
|
O3
|
c
|
ggml_add_cast:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rdx), %rax
cmpq 0x10(%rsi), %rax
jne 0x1a3bf
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x17560
testb %al, %al
je 0x1a3bf
movl (%r14), %eax
imulq $0x38, %rax, %rcx
leaq 0x4ea4b(%rip), %rdx # 0x68dc0
cmpb $0x0, 0x20(%rcx,%rdx)
jne 0x1a386
cmpl $0x1, %eax
je 0x1a386
cmpl $0x1e, %eax
jne 0x1a3e0
leaq 0x10(%r14), %rcx
movq %r15, %rdi
movl %ebp, %esi
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x19c13
movl $0x2, 0x50(%rax)
movq %r14, 0x98(%rax)
movq %rbx, 0xa0(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3024d(%rip), %rdi # 0x4a613
leaq 0x30291(%rip), %rdx # 0x4a65e
leaq 0x32332(%rip), %rcx # 0x4c706
movl $0x765, %esi # imm = 0x765
xorl %eax, %eax
callq 0x17c60
leaq 0x3022c(%rip), %rdi # 0x4a613
leaq 0x30270(%rip), %rdx # 0x4a65e
leaq 0x3232c(%rip), %rcx # 0x4c721
movl $0x76a, %esi # imm = 0x76A
jmp 0x1a3d9
|
ggml_add_cast:
push rbp
push r15
push r14
push rbx
push rax
mov rax, [rdx+10h]
cmp rax, [rsi+10h]
jnz short loc_1A3BF
mov ebp, ecx
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov rdi, rdx
call _ggml_can_repeat
test al, al
jz short loc_1A3BF
mov eax, [r14]
imul rcx, rax, 38h ; '8'
lea rdx, type_traits
cmp byte ptr [rcx+rdx+20h], 0
jnz short loc_1A386
cmp eax, 1
jz short loc_1A386
cmp eax, 1Eh
jnz short loc_1A3E0
loc_1A386:
lea rcx, [r14+10h]
mov rdi, r15
mov esi, ebp
mov edx, 4
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
mov dword ptr [rax+50h], 2
mov [rax+98h], r14
mov [rax+0A0h], rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_1A3BF:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlCanRepeatR; "ggml_can_repeat_rows(b, a)"
mov esi, 765h
loc_1A3D9:
xor eax, eax
call _ggml_abort
loc_1A3E0:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlIsQuantize_0; "ggml_is_quantized(a->type) || a->type ="...
mov esi, 76Ah
jmp short loc_1A3D9
|
long long ggml_add_cast(long long a1, long long *a2, _QWORD *a3, unsigned int a4, int a5, int a6)
{
long long v8; // rax
long long result; // rax
const char *v10; // rcx
int v11; // esi
if ( a3[2] != a2[2] || !ggml_can_repeat(a3, a2) )
{
v10 = "ggml_can_repeat_rows(b, a)";
v11 = 1893;
goto LABEL_8;
}
v8 = *(unsigned int *)a2;
if ( !LOBYTE((&type_traits)[7 * v8 + 4]) && (_DWORD)v8 != 1 && (_DWORD)v8 != 30 )
{
v10 = "ggml_is_quantized(a->type) || a->type == GGML_TYPE_F16 || a->type == GGML_TYPE_BF16";
v11 = 1898;
LABEL_8:
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c",
v11,
(unsigned int)"GGML_ASSERT(%s) failed",
(_DWORD)v10,
a5,
a6);
}
result = ggml_new_tensor_impl(a1, a4, 4u, a2 + 2, 0LL, 0LL);
*(_DWORD *)(result + 80) = 2;
*(_QWORD *)(result + 152) = a2;
*(_QWORD *)(result + 160) = a3;
return result;
}
|
ggml_add_cast:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RAX,qword ptr [RDX + 0x10]
CMP RAX,qword ptr [RSI + 0x10]
JNZ 0x0011a3bf
MOV EBP,ECX
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV RDI,RDX
CALL 0x00117560
TEST AL,AL
JZ 0x0011a3bf
MOV EAX,dword ptr [R14]
IMUL RCX,RAX,0x38
LEA RDX,[0x168dc0]
CMP byte ptr [RCX + RDX*0x1 + 0x20],0x0
JNZ 0x0011a386
CMP EAX,0x1
JZ 0x0011a386
CMP EAX,0x1e
JNZ 0x0011a3e0
LAB_0011a386:
LEA RCX,[R14 + 0x10]
MOV RDI,R15
MOV ESI,EBP
MOV EDX,0x4
XOR R8D,R8D
XOR R9D,R9D
CALL 0x00119c13
MOV dword ptr [RAX + 0x50],0x2
MOV qword ptr [RAX + 0x98],R14
MOV qword ptr [RAX + 0xa0],RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0011a3bf:
LEA RDI,[0x14a613]
LEA RDX,[0x14a65e]
LEA RCX,[0x14c706]
MOV ESI,0x765
LAB_0011a3d9:
XOR EAX,EAX
CALL 0x00117c60
LAB_0011a3e0:
LEA RDI,[0x14a613]
LEA RDX,[0x14a65e]
LEA RCX,[0x14c721]
MOV ESI,0x76a
JMP 0x0011a3d9
|
void ggml_add_cast(int8 param_1,uint *param_2,long param_3,int4 param_4)
{
uint uVar1;
char cVar2;
long lVar3;
char *pcVar4;
int8 uVar5;
if (*(long *)(param_3 + 0x10) == *(long *)(param_2 + 4)) {
cVar2 = ggml_can_repeat(param_3);
if (cVar2 != '\0') {
uVar1 = *param_2;
if (((type_traits[(ulong)uVar1 * 0x38 + 0x20] != '\0') || (uVar1 == 1)) || (uVar1 == 0x1e)) {
lVar3 = ggml_new_tensor_impl(param_1,param_4,4,param_2 + 4,0,0);
*(int4 *)(lVar3 + 0x50) = 2;
*(uint **)(lVar3 + 0x98) = param_2;
*(long *)(lVar3 + 0xa0) = param_3;
return;
}
pcVar4 = "ggml_is_quantized(a->type) || a->type == GGML_TYPE_F16 || a->type == GGML_TYPE_BF16"
;
uVar5 = 0x76a;
goto LAB_0011a3d9;
}
}
pcVar4 = "ggml_can_repeat_rows(b, a)";
uVar5 = 0x765;
LAB_0011a3d9:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c",uVar5,
"GGML_ASSERT(%s) failed",pcVar4);
}
|
|
66,074 |
js_module_set_import_meta
|
bluesky950520[P]quickjs/quickjs-libc.c
|
int js_module_set_import_meta(JSContext *ctx, JSValue func_val,
JS_BOOL use_realpath, JS_BOOL is_main)
{
JSModuleDef *m;
char buf[PATH_MAX + 16];
JSValue meta_obj;
JSAtom module_name_atom;
const char *module_name;
assert(JS_VALUE_GET_TAG(func_val) == JS_TAG_MODULE);
m = JS_VALUE_GET_PTR(func_val);
module_name_atom = JS_GetModuleName(ctx, m);
module_name = JS_AtomToCString(ctx, module_name_atom);
JS_FreeAtom(ctx, module_name_atom);
if (!module_name)
return -1;
if (!strchr(module_name, ':')) {
strcpy(buf, "file://");
#if !defined(_WIN32) && !defined(__wasi__)
/* realpath() cannot be used with modules compiled with qjsc
because the corresponding module source code is not
necessarily present */
if (use_realpath) {
char *res = realpath(module_name, buf + strlen(buf));
if (!res) {
JS_ThrowTypeError(ctx, "realpath failure");
JS_FreeCString(ctx, module_name);
return -1;
}
} else
#endif
{
js__pstrcat(buf, sizeof(buf), module_name);
}
} else {
js__pstrcpy(buf, sizeof(buf), module_name);
}
JS_FreeCString(ctx, module_name);
meta_obj = JS_GetImportMeta(ctx, m);
if (JS_IsException(meta_obj))
return -1;
JS_DefinePropertyValueStr(ctx, meta_obj, "url",
JS_NewString(ctx, buf),
JS_PROP_C_W_E);
JS_DefinePropertyValueStr(ctx, meta_obj, "main",
JS_NewBool(ctx, is_main),
JS_PROP_C_W_E);
JS_FreeValue(ctx, meta_obj);
return 0;
}
|
O1
|
c
|
js_module_set_import_meta:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1028, %rsp # imm = 0x1028
movl %r8d, %ebp
movl %ecx, %r13d
movq %rsi, %r15
movq %rdi, %rbx
callq 0x302a8
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x1fbeb
movq %rax, %r12
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1fbc4
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
testq %r12, %r12
je 0x13d53
movq %r12, %rdi
movl $0x3a, %esi
callq 0xe270
testq %rax, %rax
je 0x13d68
leaq 0x10(%rsp), %rdi
movl $0x1010, %esi # imm = 0x1010
movq %r12, %rdx
callq 0x1a618
movq %rbx, %rdi
movq %r12, %rsi
callq 0x202c9
movq %rbx, %rdi
movq %r15, %rsi
callq 0x302c3
movq %rdx, %r12
cmpl $0x6, %r12d
je 0x13d53
movq %rax, %r15
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0xe240
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1f2f3
movq %rdx, %r9
movl $0x7, %r14d
movl %r14d, (%rsp)
leaq 0x868d2(%rip), %rcx # 0x9a5db
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rax, %r8
callq 0x26043
xorl %r8d, %r8d
testl %ebp, %ebp
setne %r8b
movl %r14d, (%rsp)
leaq 0x86502(%rip), %rcx # 0x9a230
movl $0x1, %r9d
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x26043
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1cc9f
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x1028, %rsp # imm = 0x1028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movabsq $0x2f2f3a656c6966, %rax # imm = 0x2F2F3A656C6966
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
testl %r13d, %r13d
je 0x13dbd
callq 0xe240
leaq (%rsp,%rax), %rsi
addq $0x10, %rsi
movq %r12, %rdi
callq 0xe590
testq %rax, %rax
jne 0x13cb8
leaq 0x86479(%rip), %rsi # 0x9a21f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21953
movq %rbx, %rdi
movq %r12, %rsi
callq 0x202c9
jmp 0x13d53
movl $0x1010, %esi # imm = 0x1010
movq %r12, %rdx
callq 0x1a656
jmp 0x13cb8
|
js_module_set_import_meta:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 1028h
mov ebp, r8d
mov r13d, ecx
mov r15, rsi
mov rbx, rdi
call JS_GetModuleName
mov r14d, eax
mov rdi, rbx
mov esi, eax
call JS_AtomToCString
mov r12, rax
mov rdi, rbx
mov esi, r14d
call JS_FreeAtom
mov r14d, 0FFFFFFFFh
test r12, r12
jz loc_13D53
mov rdi, r12
mov esi, 3Ah ; ':'
call _strchr
test rax, rax
jz loc_13D68
lea rdi, [rsp+1058h+var_1048]
mov esi, 1010h
mov rdx, r12
call js__pstrcpy
loc_13CB8:
mov rdi, rbx
mov rsi, r12
call JS_FreeCString
mov rdi, rbx
mov rsi, r15
call JS_GetImportMeta
mov r12, rdx
cmp r12d, 6
jz short loc_13D53
mov r15, rax
lea r14, [rsp+1058h+var_1048]
mov rdi, r14
call _strlen
mov rdi, rbx
mov rsi, r14
mov rdx, rax
call JS_NewStringLen
mov r9, rdx
mov r14d, 7
mov [rsp+1058h+var_1058], r14d
lea rcx, aCouldNotStartC+11h; "url"
mov rdi, rbx
mov rsi, r15
mov rdx, r12
mov r8, rax
call JS_DefinePropertyValueStr
xor r8d, r8d
test ebp, ebp
setnz r8b
mov [rsp+1058h+var_1058], r14d
lea rcx, aMain; "main"
mov r9d, 1
mov rdi, rbx
mov rsi, r15
mov rdx, r12
call JS_DefinePropertyValueStr
mov rdi, rbx
mov rsi, r15
mov rdx, r12
call JS_FreeValue
xor r14d, r14d
loc_13D53:
mov eax, r14d
add rsp, 1028h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_13D68:
mov rax, 2F2F3A656C6966h
mov [rsp+1058h+var_1048], rax
lea rdi, [rsp+1058h+var_1048]
test r13d, r13d
jz short loc_13DBD
call _strlen
lea rsi, [rsp+rax+1058h+var_1058]
add rsi, 10h
mov rdi, r12
call _realpath
test rax, rax
jnz loc_13CB8
lea rsi, aRealpathFailur; "realpath failure"
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
mov rdi, rbx
mov rsi, r12
call JS_FreeCString
jmp short loc_13D53
loc_13DBD:
mov esi, 1010h
mov rdx, r12
call js__pstrcat
jmp loc_13CB8
|
long long js_module_set_import_meta(long long a1, long long a2, long long a3, int a4, int a5)
{
unsigned int ModuleName; // r14d
long long v8; // r12
unsigned int v9; // r14d
long long ImportMeta; // rax
long long v11; // rdx
long long v12; // r12
long long v13; // r15
long long v14; // rax
int v15; // eax
int v16; // edx
long long v18; // rax
int v19; // edx
int v20; // ecx
int v21; // r8d
int v22; // r9d
_QWORD v23[521]; // [rsp+10h] [rbp-1048h] BYREF
ModuleName = JS_GetModuleName();
v8 = JS_AtomToCString(a1, ModuleName);
JS_FreeAtom(a1, ModuleName);
v9 = -1;
if ( v8 )
{
if ( strchr(v8, 58LL) )
{
js__pstrcpy(v23, 4112LL, v8);
}
else
{
v23[0] = 0x2F2F3A656C6966LL;
if ( a4 )
{
v18 = strlen(v23);
if ( !realpath(v8, (char *)v23 + v18) )
{
JS_ThrowTypeError(a1, (unsigned int)"realpath failure", v19, v20, v21, v22);
JS_FreeCString(a1, v8);
return v9;
}
}
else
{
js__pstrcat(v23, 4112LL, v8);
}
}
JS_FreeCString(a1, v8);
ImportMeta = JS_GetImportMeta(a1, a2);
v12 = v11;
if ( (_DWORD)v11 != 6 )
{
v13 = ImportMeta;
v14 = strlen(v23);
v15 = JS_NewStringLen(a1, v23, v14);
JS_DefinePropertyValueStr(a1, v13, v12, (unsigned int)"url", v15, v16, 7);
JS_DefinePropertyValueStr(a1, v13, v12, (unsigned int)"main", a5 != 0, 1, 7);
JS_FreeValue(a1, v13, v12);
return 0;
}
}
return v9;
}
|
js_module_set_import_meta:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x1028
MOV EBP,R8D
MOV R13D,ECX
MOV R15,RSI
MOV RBX,RDI
CALL 0x001302a8
MOV R14D,EAX
MOV RDI,RBX
MOV ESI,EAX
CALL 0x0011fbeb
MOV R12,RAX
MOV RDI,RBX
MOV ESI,R14D
CALL 0x0011fbc4
MOV R14D,0xffffffff
TEST R12,R12
JZ 0x00113d53
MOV RDI,R12
MOV ESI,0x3a
CALL 0x0010e270
TEST RAX,RAX
JZ 0x00113d68
LEA RDI,[RSP + 0x10]
MOV ESI,0x1010
MOV RDX,R12
CALL 0x0011a618
LAB_00113cb8:
MOV RDI,RBX
MOV RSI,R12
CALL 0x001202c9
MOV RDI,RBX
MOV RSI,R15
CALL 0x001302c3
MOV R12,RDX
CMP R12D,0x6
JZ 0x00113d53
MOV R15,RAX
LEA R14,[RSP + 0x10]
MOV RDI,R14
CALL 0x0010e240
MOV RDI,RBX
MOV RSI,R14
MOV RDX,RAX
CALL 0x0011f2f3
MOV R9,RDX
MOV R14D,0x7
MOV dword ptr [RSP],R14D
LEA RCX,[0x19a5db]
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R12
MOV R8,RAX
CALL 0x00126043
XOR R8D,R8D
TEST EBP,EBP
SETNZ R8B
MOV dword ptr [RSP],R14D
LEA RCX,[0x19a230]
MOV R9D,0x1
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R12
CALL 0x00126043
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R12
CALL 0x0011cc9f
XOR R14D,R14D
LAB_00113d53:
MOV EAX,R14D
ADD RSP,0x1028
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00113d68:
MOV RAX,0x2f2f3a656c6966
MOV qword ptr [RSP + 0x10],RAX
LEA RDI,[RSP + 0x10]
TEST R13D,R13D
JZ 0x00113dbd
CALL 0x0010e240
LEA RSI,[RSP + RAX*0x1]
ADD RSI,0x10
MOV RDI,R12
CALL 0x0010e590
TEST RAX,RAX
JNZ 0x00113cb8
LEA RSI,[0x19a21f]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x00121953
MOV RDI,RBX
MOV RSI,R12
CALL 0x001202c9
JMP 0x00113d53
LAB_00113dbd:
MOV ESI,0x1010
MOV RDX,R12
CALL 0x0011a656
JMP 0x00113cb8
|
int8
js_module_set_import_meta
(int8 param_1,int8 param_2,int8 param_3,int param_4,int param_5)
{
int4 uVar1;
char *__s;
char *pcVar2;
int8 uVar3;
size_t sVar4;
int8 uVar5;
int8 uVar6;
int1 auVar7 [16];
char local_1048 [4120];
uVar1 = JS_GetModuleName();
__s = (char *)JS_AtomToCString(param_1,uVar1);
JS_FreeAtom(param_1,uVar1);
uVar6 = 0xffffffff;
if (__s != (char *)0x0) {
pcVar2 = strchr(__s,0x3a);
if (pcVar2 == (char *)0x0) {
builtin_strncpy(local_1048,"file://",8);
if (param_4 == 0) {
js__pstrcat(local_1048,0x1010,__s);
}
else {
sVar4 = strlen(local_1048);
pcVar2 = realpath(__s,local_1048 + sVar4);
if (pcVar2 == (char *)0x0) {
JS_ThrowTypeError(param_1,"realpath failure");
JS_FreeCString(param_1,__s);
return 0xffffffff;
}
}
}
else {
js__pstrcpy(local_1048,0x1010,__s);
}
JS_FreeCString(param_1,__s);
auVar7 = JS_GetImportMeta(param_1,param_2);
uVar5 = auVar7._8_8_;
uVar3 = auVar7._0_8_;
if (auVar7._8_4_ != 6) {
sVar4 = strlen(local_1048);
auVar7 = JS_NewStringLen(param_1,local_1048,sVar4);
JS_DefinePropertyValueStr(param_1,uVar3,uVar5,"url",auVar7._0_8_,auVar7._8_8_,7);
JS_DefinePropertyValueStr(param_1,uVar3,uVar5,&DAT_0019a230,param_5 != 0,1,7);
JS_FreeValue(param_1,uVar3,uVar5);
uVar6 = 0;
}
}
return uVar6;
}
|
|
66,075 |
ggml_fp32_to_bf16
|
llama.cpp/ggml/src/ggml.c
|
ggml_bf16_t ggml_fp32_to_bf16(float x) {
#define ggml_fp32_to_bf16 do_not_use__ggml_fp32_to_bf16__in_ggml
return GGML_FP32_TO_BF16(x);
}
|
O3
|
c
|
ggml_fp32_to_bf16:
movd %xmm0, %ecx
movl %ecx, %edx
andl $0x7fffffff, %edx # imm = 0x7FFFFFFF
movl %ecx, %eax
shrl $0x10, %eax
cmpl $0x7f800001, %edx # imm = 0x7F800001
jb 0x1910f
orl $0x40, %eax
retq
andl $0x1, %eax
addl %ecx, %eax
addl $0x7fff, %eax # imm = 0x7FFF
shrl $0x10, %eax
retq
|
ggml_fp32_to_bf16:
movd ecx, xmm0
mov edx, ecx
and edx, 7FFFFFFFh
mov eax, ecx
shr eax, 10h
cmp edx, 7F800001h
jb short loc_1910F
or eax, 40h
retn
loc_1910F:
and eax, 1
add eax, ecx
add eax, 7FFFh
shr eax, 10h
retn
|
long long ggml_fp32_to_bf16(__m128i a1)
{
unsigned int v1; // ecx
v1 = _mm_cvtsi128_si32(a1);
if ( (v1 & 0x7FFFFFFF) < 0x7F800001 )
return (v1 + (BYTE2(v1) & 1) + 0x7FFF) >> 16;
else
return HIWORD(v1) | 0x40;
}
|
ggml_fp32_to_bf16:
MOVD ECX,XMM0
MOV EDX,ECX
AND EDX,0x7fffffff
MOV EAX,ECX
SHR EAX,0x10
CMP EDX,0x7f800001
JC 0x0011910f
OR EAX,0x40
RET
LAB_0011910f:
AND EAX,0x1
ADD EAX,ECX
ADD EAX,0x7fff
SHR EAX,0x10
RET
|
uint ggml_fp32_to_bf16(uint param_1)
{
if (0x7f800000 < (param_1 & 0x7fffffff)) {
return param_1 >> 0x10 | 0x40;
}
return (param_1 >> 0x10 & 1) + param_1 + 0x7fff >> 0x10;
}
|
|
66,076 |
init_memory_class(unsigned int)
|
eloqsql/storage/perfschema/pfs_instr_class.cc
|
int init_memory_class(uint memory_class_sizing)
{
int result= 0;
memory_class_dirty_count= memory_class_allocated_count= 0;
memory_class_max= memory_class_sizing;
memory_class_lost= 0;
if (memory_class_max > 0)
{
memory_class_array= PFS_MALLOC_ARRAY(& builtin_memory_memory_class,
memory_class_max,
sizeof(PFS_memory_class), PFS_memory_class,
MYF(MY_ZEROFILL));
if (unlikely(memory_class_array == NULL))
return 1;
}
else
memory_class_array= NULL;
return result;
}
|
O3
|
cpp
|
init_memory_class(unsigned int):
andl $0x0, 0x3ab26b(%rip) # 0x3d3150
andl $0x0, 0x3ab268(%rip) # 0x3d3154
movl %edi, %esi
movq %rsi, 0x3aa9cb(%rip) # 0x3d28c0
andq $0x0, 0x3aa9cb(%rip) # 0x3d28c8
testl %edi, %edi
je 0x27f2a
pushq %rbp
movq %rsp, %rbp
leaq 0x3a8874(%rip), %rdi # 0x3d0780
pushq $0x20
popq %rcx
movl $0xc0, %edx
callq 0x2cd3c
movq %rax, 0x3ab238(%rip) # 0x3d3158
testq %rax, %rax
popq %rbp
jne 0x27f32
pushq $0x1
popq %rax
retq
andq $0x0, 0x3ab226(%rip) # 0x3d3158
xorl %eax, %eax
retq
|
_Z17init_memory_classj:
and cs:_ZL28memory_class_allocated_count, 0; memory_class_allocated_count
and cs:_ZL24memory_class_dirty_count, 0; memory_class_dirty_count
mov esi, edi
mov cs:memory_class_max, rsi
and cs:memory_class_lost, 0
test edi, edi
jz short loc_27F2A
push rbp
mov rbp, rsp
lea rdi, builtin_memory_memory_class
push 20h ; ' '
pop rcx
mov edx, 0C0h
call _Z16pfs_malloc_arrayP24PFS_builtin_memory_classmmm; pfs_malloc_array(PFS_builtin_memory_class *,ulong,ulong,ulong)
mov cs:_ZL18memory_class_array, rax; memory_class_array
test rax, rax
pop rbp
jnz short loc_27F32
push 1
pop rax
retn
loc_27F2A:
and cs:_ZL18memory_class_array, 0; memory_class_array
loc_27F32:
xor eax, eax
retn
|
long long init_memory_class(unsigned int a1)
{
memory_class_allocated_count = 0;
memory_class_dirty_count = 0;
memory_class_max = a1;
memory_class_lost = 0LL;
if ( a1 )
{
memory_class_array = pfs_malloc_array(&builtin_memory_memory_class, a1, 192LL, 32LL);
if ( !memory_class_array )
return 1LL;
}
else
{
memory_class_array = 0LL;
}
return 0LL;
}
|
init_memory_class:
AND dword ptr [0x004d3150],0x0
AND dword ptr [0x004d3154],0x0
MOV ESI,EDI
MOV qword ptr [0x004d28c0],RSI
AND qword ptr [0x004d28c8],0x0
TEST EDI,EDI
JZ 0x00127f2a
PUSH RBP
MOV RBP,RSP
LEA RDI,[0x4d0780]
PUSH 0x20
POP RCX
MOV EDX,0xc0
CALL 0x0012cd3c
MOV qword ptr [0x004d3158],RAX
TEST RAX,RAX
POP RBP
JNZ 0x00127f32
PUSH 0x1
POP RAX
RET
LAB_00127f2a:
AND qword ptr [0x004d3158],0x0
LAB_00127f32:
XOR EAX,EAX
RET
|
/* init_memory_class(unsigned int) */
int8 init_memory_class(uint param_1)
{
memory_class_allocated_count = 0;
memory_class_dirty_count = 0;
memory_class_max = (ulong)param_1;
memory_class_lost = 0;
if (param_1 == 0) {
memory_class_array = 0;
}
else {
memory_class_array =
pfs_malloc_array((PFS_builtin_memory_class *)builtin_memory_memory_class,memory_class_max,
0xc0,0x20);
if (memory_class_array == 0) {
return 1;
}
}
return 0;
}
|
|
66,077 |
my_strnxfrm_tis620_nopad
|
eloqsql/strings/ctype-tis620.c
|
static size_t
my_strnxfrm_tis620_nopad(CHARSET_INFO *cs,
uchar *dst, size_t dstlen, uint nweights,
const uchar *src, size_t srclen, uint flags)
{
size_t len, dstlen0= dstlen;
len= MY_MIN(dstlen, srclen);
memcpy(dst, src, len);
len= thai2sortable(dst, len);
set_if_smaller(dstlen, nweights);
set_if_smaller(len, dstlen);
len= my_strxfrm_pad_desc_and_reverse_nopad(cs, dst, dst + len, dst + dstlen,
(uint)(dstlen - len), flags, 0);
if ((flags & MY_STRXFRM_PAD_TO_MAXLEN) && len < dstlen0)
{
size_t fill_length= dstlen0 - len;
memset(dst + len, 0x00, fill_length);
len= dstlen0;
}
return len;
}
|
O0
|
c
|
my_strnxfrm_tis620_nopad:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x48a6e
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x48a76
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x24230
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x48810
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
cmpq %rcx, %rax
jbe 0x48ab3
movl -0x1c(%rbp), %eax
movq %rax, -0x18(%rbp)
jmp 0x48ab5
jmp 0x48ab7
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x48ac9
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x48acb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rcx
addq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
subq -0x38(%rbp), %rax
movl %eax, %r8d
movl 0x10(%rbp), %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x42f90
movq %rax, -0x38(%rbp)
movl 0x10(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x48b42
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x48b42
movq -0x40(%rbp), %rax
subq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rdx
xorl %esi, %esi
callq 0x24190
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
|
my_strnxfrm_tis620_nopad:
push rbp
mov rbp, rsp
sub rsp, 60h
mov eax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_18]
cmp rax, [rbp+var_30]
jnb short loc_48A6E
mov rax, [rbp+var_18]
mov [rbp+var_50], rax
jmp short loc_48A76
loc_48A6E:
mov rax, [rbp+var_30]
mov [rbp+var_50], rax
loc_48A76:
mov rax, [rbp+var_50]
mov [rbp+var_38], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_38]
call _memcpy
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
call thai2sortable
mov [rbp+var_38], rax
mov rax, [rbp+var_18]
mov ecx, [rbp+var_1C]
cmp rax, rcx
jbe short loc_48AB3
mov eax, [rbp+var_1C]
mov [rbp+var_18], rax
loc_48AB3:
jmp short $+2
loc_48AB5:
jmp short $+2
loc_48AB7:
mov rax, [rbp+var_38]
cmp rax, [rbp+var_18]
jbe short loc_48AC9
mov rax, [rbp+var_18]
mov [rbp+var_38], rax
loc_48AC9:
jmp short $+2
loc_48ACB:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_10]
add rdx, [rbp+var_38]
mov rcx, [rbp+var_10]
add rcx, [rbp+var_18]
mov rax, [rbp+var_18]
sub rax, [rbp+var_38]
mov r8d, eax
mov r9d, [rbp+arg_0]
xor eax, eax
mov [rsp+60h+var_60], 0
call my_strxfrm_pad_desc_and_reverse_nopad
mov [rbp+var_38], rax
mov eax, [rbp+arg_0]
and eax, 80h
cmp eax, 0
jz short loc_48B42
mov rax, [rbp+var_38]
cmp rax, [rbp+var_40]
jnb short loc_48B42
mov rax, [rbp+var_40]
sub rax, [rbp+var_38]
mov [rbp+var_48], rax
mov rdi, [rbp+var_10]
add rdi, [rbp+var_38]
mov rdx, [rbp+var_48]
xor esi, esi
call _memset
mov rax, [rbp+var_40]
mov [rbp+var_38], rax
loc_48B42:
mov rax, [rbp+var_38]
add rsp, 60h
pop rbp
retn
|
unsigned long long my_strnxfrm_tis620_nopad(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
unsigned int a4,
long long a5,
unsigned long long a6,
unsigned int a7)
{
long long v8; // [rsp+10h] [rbp-50h]
unsigned long long v10; // [rsp+28h] [rbp-38h]
unsigned long long v11; // [rsp+28h] [rbp-38h]
unsigned long long v13; // [rsp+48h] [rbp-18h]
v13 = a3;
if ( a3 >= a6 )
v8 = a6;
else
v8 = a3;
memcpy(a2, a5, v8);
v10 = thai2sortable(a2, v8);
if ( v13 > a4 )
v13 = a4;
if ( v10 > v13 )
v10 = v13;
v11 = my_strxfrm_pad_desc_and_reverse_nopad(
a1,
(long long)a2,
(unsigned long long)&a2[v10],
(unsigned long long)&a2[v13],
(int)v13 - (int)v10,
a7,
0);
if ( (a7 & 0x80) != 0 && v11 < a3 )
{
memset(&a2[v11], 0LL, a3 - v11);
return a3;
}
return v11;
}
|
my_strnxfrm_tis620_nopad:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x00148a6e
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00148a76
LAB_00148a6e:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x50],RAX
LAB_00148a76:
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x38]
CALL 0x00124230
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x00148810
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x1c]
CMP RAX,RCX
JBE 0x00148ab3
MOV EAX,dword ptr [RBP + -0x1c]
MOV qword ptr [RBP + -0x18],RAX
LAB_00148ab3:
JMP 0x00148ab5
LAB_00148ab5:
JMP 0x00148ab7
LAB_00148ab7:
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x18]
JBE 0x00148ac9
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x38],RAX
LAB_00148ac9:
JMP 0x00148acb
LAB_00148acb:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x10]
ADD RDX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr [RBP + -0x38]
MOV R8D,EAX
MOV R9D,dword ptr [RBP + 0x10]
XOR EAX,EAX
MOV dword ptr [RSP],0x0
CALL 0x00142f90
MOV qword ptr [RBP + -0x38],RAX
MOV EAX,dword ptr [RBP + 0x10]
AND EAX,0x80
CMP EAX,0x0
JZ 0x00148b42
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x00148b42
MOV RAX,qword ptr [RBP + -0x40]
SUB RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x48]
XOR ESI,ESI
CALL 0x00124190
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x38],RAX
LAB_00148b42:
MOV RAX,qword ptr [RBP + -0x38]
ADD RSP,0x60
POP RBP
RET
|
ulong my_strnxfrm_tis620_nopad
(int8 param_1,void *param_2,ulong param_3,uint param_4,void *param_5,
ulong param_6,uint param_7)
{
size_t local_58;
ulong local_40;
ulong local_20;
local_58 = param_6;
if (param_3 < param_6) {
local_58 = param_3;
}
memcpy(param_2,param_5,local_58);
local_40 = thai2sortable(param_2,local_58);
local_20 = param_3;
if (param_4 < param_3) {
local_20 = (ulong)param_4;
}
if (local_20 < local_40) {
local_40 = local_20;
}
local_40 = my_strxfrm_pad_desc_and_reverse_nopad
(param_1,param_2,(long)param_2 + local_40,(long)param_2 + local_20,
(int)local_20 - (int)local_40,param_7,0);
if (((param_7 & 0x80) != 0) && (local_40 < param_3)) {
memset((void *)((long)param_2 + local_40),0,param_3 - local_40);
local_40 = param_3;
}
return local_40;
}
|
|
66,078 |
VertexLoaderTester::VertexLoaderTester(std::unique_ptr<VertexLoaderBase, std::default_delete<VertexLoaderBase>>, std::unique_ptr<VertexLoaderBase, std::default_delete<VertexLoaderBase>>, TVtxDesc const&, VAT const&)
|
Dolphin-anty/Source/Core/VideoCommon/VertexLoaderBase.cpp
|
VertexLoaderTester(std::unique_ptr<VertexLoaderBase> a_, std::unique_ptr<VertexLoaderBase> b_,
const TVtxDesc& vtx_desc, const VAT& vtx_attr)
: VertexLoaderBase(vtx_desc, vtx_attr), a(std::move(a_)), b(std::move(b_))
{
ASSERT(a && b);
if (a->m_vertex_size == b->m_vertex_size && a->m_native_components == b->m_native_components &&
a->m_native_vtx_decl.stride == b->m_native_vtx_decl.stride)
{
// These are generated from the VAT and vertex desc, so they should match.
// m_native_vtx_decl.stride isn't set yet, though.
ASSERT(m_vertex_size == a->m_vertex_size && m_native_components == a->m_native_components);
memcpy(&m_native_vtx_decl, &a->m_native_vtx_decl, sizeof(PortableVertexDeclaration));
}
else
{
PanicAlertFmt("Can't compare vertex loaders that expect different vertex formats!\n"
"a: m_vertex_size {}, m_native_components {:#010x}, stride {}\n"
"b: m_vertex_size {}, m_native_components {:#010x}, stride {}",
a->m_vertex_size, a->m_native_components, a->m_native_vtx_decl.stride,
b->m_vertex_size, b->m_native_components, b->m_native_vtx_decl.stride);
}
}
|
O3
|
cpp
|
VertexLoaderTester::VertexLoaderTester(std::unique_ptr<VertexLoaderBase, std::default_delete<VertexLoaderBase>>, std::unique_ptr<VertexLoaderBase, std::default_delete<VertexLoaderBase>>, TVtxDesc const&, VAT const&):
pushq %rbx
movq %rdi, %rbx
leaq 0xa3d881(%rip), %rax # 0xe19778
movq %rax, (%rdi)
movq 0x150(%rdi), %rdi
testq %rdi, %rdi
je 0x3dbf15
movq 0x160(%rbx), %rsi
subq %rdi, %rsi
callq 0x10fa70
movq 0x138(%rbx), %rdi
testq %rdi, %rdi
je 0x3dbf30
movq 0x148(%rbx), %rsi
subq %rdi, %rsi
callq 0x10fa70
movq 0x130(%rbx), %rdi
testq %rdi, %rdi
je 0x3dbf42
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x130(%rbx)
movq 0x128(%rbx), %rdi
testq %rdi, %rdi
je 0x3dbf5f
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x168, %esi # imm = 0x168
movq %rbx, %rdi
popq %rbx
jmp 0x10fa70
nop
|
_ZN18VertexLoaderTesterD0Ev:
push rbx
mov rbx, rdi
lea rax, off_E19778
mov [rdi], rax
mov rdi, [rdi+150h]; void *
test rdi, rdi
jz short loc_3DBF15
mov rsi, [rbx+160h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3DBF15:
mov rdi, [rbx+138h]; void *
test rdi, rdi
jz short loc_3DBF30
mov rsi, [rbx+148h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3DBF30:
mov rdi, [rbx+130h]
test rdi, rdi
jz short loc_3DBF42
mov rax, [rdi]
call qword ptr [rax+8]
loc_3DBF42:
mov qword ptr [rbx+130h], 0
mov rdi, [rbx+128h]
test rdi, rdi
jz short loc_3DBF5F
mov rax, [rdi]
call qword ptr [rax+8]
loc_3DBF5F:
mov esi, 168h; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
|
void VertexLoaderTester::~VertexLoaderTester(VertexLoaderTester *this)
{
void *v2; // rdi
void *v3; // rdi
long long v4; // rdi
long long v5; // rdi
*(_QWORD *)this = off_E19778;
v2 = (void *)*((_QWORD *)this + 42);
if ( v2 )
operator delete(v2, *((_QWORD *)this + 44) - (_QWORD)v2);
v3 = (void *)*((_QWORD *)this + 39);
if ( v3 )
operator delete(v3, *((_QWORD *)this + 41) - (_QWORD)v3);
v4 = *((_QWORD *)this + 38);
if ( v4 )
(*(void ( **)(long long))(*(_QWORD *)v4 + 8LL))(v4);
*((_QWORD *)this + 38) = 0LL;
v5 = *((_QWORD *)this + 37);
if ( v5 )
(*(void ( **)(long long))(*(_QWORD *)v5 + 8LL))(v5);
operator delete(this, 0x168uLL);
}
|
operator():
SUB RSP,0x48
LEA RAX,[0xb76ff9]
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x18],0x19
LEA R9,[RSP + 0x38]
MOV qword ptr [R9],0x0
LEA RAX,[RSP + 0x20]
MOV qword ptr [R9 + 0x8],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x10]
MOVUPS xmmword ptr [RSP],XMM0
LEA RCX,[0xb76f00]
XOR EDI,EDI
MOV ESI,0x2
MOV EDX,0x24
MOV R8D,0x258
CALL 0x00ac226b
ADD RSP,0x48
RET
|
/* bool Common::MsgAlertFmt<0ul, Jit64::stXx(UGeckoInstruction)::$_0::TEMPNAMEPLACEHOLDERVALUE()
const::FMT_COMPILE_STRING>(bool, Common::MsgType, Common::Log::LogType, char const*, int,
Jit64::stXx(UGeckoInstruction)::$_0::TEMPNAMEPLACEHOLDERVALUE() const::FMT_COMPILE_STRING const&)
*/
bool Common::operator()(void)
{
int1 uVar1;
int1 local_28 [24];
int8 local_10;
int1 *local_8;
local_10 = 0;
local_8 = local_28;
uVar1 = MsgAlertFmtImpl((Common *)0x0,2,0x24,
"/workspace/llm4binary/github2025/Dolphin-anty/Source/Core/Core/PowerPC/Jit64/Jit_LoadStore.cpp"
,600,&local_10,0xb76ff9,0x19);
return (bool)uVar1;
}
|
|
66,079 |
convert_error_to_warning(THD*)
|
eloqsql/sql/sql_error.cc
|
void convert_error_to_warning(THD *thd)
{
DBUG_ASSERT(thd->is_error());
push_warning(thd, Sql_condition::WARN_LEVEL_WARN,
thd->get_stmt_da()->sql_errno(),
thd->get_stmt_da()->message());
thd->clear_error();
}
|
O0
|
cpp
|
convert_error_to_warning(THD*):
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x8abd8e
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7ddd20
movq %rax, %rdi
callq 0x7ec100
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7ddd20
movq %rax, %rdi
callq 0x7ec130
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %edx
movq %rax, %rcx
movl $0x1, %esi
callq 0x8ab370
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x811a50
addq $0x20, %rsp
popq %rbp
retq
|
_Z24convert_error_to_warningP3THD:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
jmp short $+2
loc_8ABD8E:
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
mov rdi, [rbp+var_8]; this
call _ZN3THD11get_stmt_daEv; THD::get_stmt_da(void)
mov rdi, rax; this
call _ZNK16Diagnostics_area9sql_errnoEv; Diagnostics_area::sql_errno(void)
mov [rbp+var_C], eax
mov rdi, [rbp+var_8]; this
call _ZN3THD11get_stmt_daEv; THD::get_stmt_da(void)
mov rdi, rax; this
call _ZNK16Diagnostics_area7messageEv; Diagnostics_area::message(void)
mov rdi, [rbp+var_18]
mov edx, [rbp+var_C]
mov rcx, rax
mov esi, 1
call _Z12push_warningP3THDN21Sql_state_errno_level18enum_warning_levelEjPKc; push_warning(THD *,Sql_state_errno_level::enum_warning_level,uint,char const*)
mov rdi, [rbp+var_8]; this
xor esi, esi; bool
call _ZN3THD11clear_errorEb; THD::clear_error(bool)
add rsp, 20h
pop rbp
retn
|
long long convert_error_to_warning(THD *a1)
{
Diagnostics_area *stmt_da; // rax
Diagnostics_area *v2; // rax
long long v3; // rax
unsigned int v5; // [rsp+14h] [rbp-Ch]
stmt_da = (Diagnostics_area *)THD::get_stmt_da(a1);
v5 = Diagnostics_area::sql_errno(stmt_da);
v2 = (Diagnostics_area *)THD::get_stmt_da(a1);
v3 = Diagnostics_area::message(v2);
push_warning(a1, 1u, v5, v3);
return THD::clear_error(a1, 0);
}
|
__cxx_global_var_init.9:
PUSH RBP
MOV RBP,RSP
LEA RDI,[0x264ca6c]
MOV ESI,0x3800000
CALL 0x008db900
POP RBP
RET
|
void __cxx_global_var_init_9(void)
{
date_conv_mode_t::date_conv_mode_t((date_conv_mode_t *)&TIME_MODE_FOR_XXX_TO_DATE,0x3800000);
return;
}
|
|
66,080 |
maria_ft_add_word
|
eloqsql/storage/maria/ma_ft_parser.c
|
static int maria_ft_add_word(MYSQL_FTPARSER_PARAM *param,
const char *word, int word_len,
MYSQL_FTPARSER_BOOLEAN_INFO *boolean_info
__attribute__((unused)))
{
TREE *wtree;
FT_WORD w;
MY_FT_PARSER_PARAM *ft_param=param->mysql_ftparam;
DBUG_ENTER("maria_ft_add_word");
wtree= ft_param->wtree;
if (param->flags & MYSQL_FTFLAGS_NEED_COPY)
{
uchar *ptr;
DBUG_ASSERT(wtree->with_delete == 0);
ptr= (uchar *)alloc_root(ft_param->mem_root, word_len);
memcpy(ptr, word, word_len);
w.pos= ptr;
}
else
w.pos= (uchar*) word;
w.len= word_len;
if (!tree_insert(wtree, &w, 0, wtree->custom_arg))
{
delete_tree(wtree, 0);
DBUG_RETURN(1);
}
DBUG_RETURN(0);
}
|
O0
|
c
|
maria_ft_add_word:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl 0x34(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x48b91
jmp 0x48b5f
jmp 0x48b61
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x1c(%rbp), %rsi
callq 0xee730
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x2a0b0
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x48b99
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x230(%rax), %rcx
leaq -0x48(%rbp), %rsi
xorl %edx, %edx
callq 0xff280
cmpq $0x0, %rax
jne 0x48bd3
movq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0xff0b0
movl $0x1, -0x4(%rbp)
jmp 0x48bdc
jmp 0x48bd5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
maria_ft_add_word:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_28], rcx
mov rax, [rbp+var_10]
mov rax, [rax+18h]
mov [rbp+var_50], rax
mov rax, [rbp+var_50]
mov rax, [rax]
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
mov eax, [rax+34h]
and eax, 1
cmp eax, 0
jz short loc_48B91
jmp short $+2
loc_48B5F:
jmp short $+2
loc_48B61:
mov rax, [rbp+var_50]
mov rdi, [rax+8]
movsxd rsi, [rbp+var_1C]
call alloc_root
mov [rbp+var_58], rax
mov rdi, [rbp+var_58]
mov rsi, [rbp+var_18]
movsxd rdx, [rbp+var_1C]
call _memcpy
mov rax, [rbp+var_58]
mov [rbp+var_48], rax
jmp short loc_48B99
loc_48B91:
mov rax, [rbp+var_18]
mov [rbp+var_48], rax
loc_48B99:
mov eax, [rbp+var_1C]
mov [rbp+var_40], eax
mov rdi, [rbp+var_30]
mov rax, [rbp+var_30]
mov rcx, [rax+230h]
lea rsi, [rbp+var_48]
xor edx, edx
call tree_insert
cmp rax, 0
jnz short loc_48BD3
mov rdi, [rbp+var_30]
xor esi, esi
call delete_tree
mov [rbp+var_4], 1
jmp short loc_48BDC
loc_48BD3:
jmp short $+2
loc_48BD5:
mov [rbp+var_4], 0
loc_48BDC:
mov eax, [rbp+var_4]
add rsp, 60h
pop rbp
retn
|
long long maria_ft_add_word(long long a1, long long a2, int a3, long long a4)
{
long long v5; // [rsp+8h] [rbp-58h]
long long *v6; // [rsp+10h] [rbp-50h]
long long v7; // [rsp+18h] [rbp-48h] BYREF
int v8; // [rsp+20h] [rbp-40h]
long long v9; // [rsp+30h] [rbp-30h]
long long v10; // [rsp+38h] [rbp-28h]
int v11; // [rsp+44h] [rbp-1Ch]
long long v12; // [rsp+48h] [rbp-18h]
long long v13; // [rsp+50h] [rbp-10h]
v13 = a1;
v12 = a2;
v11 = a3;
v10 = a4;
v6 = *(long long **)(a1 + 24);
v9 = *v6;
if ( (*(_DWORD *)(a1 + 52) & 1) != 0 )
{
v5 = alloc_root(v6[1], v11);
memcpy(v5, v12, v11);
v7 = v5;
}
else
{
v7 = v12;
}
v8 = v11;
if ( tree_insert(v9, &v7, 0LL, *(_QWORD *)(v9 + 560)) )
{
return 0;
}
else
{
delete_tree(v9, 0LL);
return 1;
}
}
|
maria_ft_add_word:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x34]
AND EAX,0x1
CMP EAX,0x0
JZ 0x00148b91
JMP 0x00148b5f
LAB_00148b5f:
JMP 0x00148b61
LAB_00148b61:
MOV RAX,qword ptr [RBP + -0x50]
MOV RDI,qword ptr [RAX + 0x8]
MOVSXD RSI,dword ptr [RBP + -0x1c]
CALL 0x001ee730
MOV qword ptr [RBP + -0x58],RAX
MOV RDI,qword ptr [RBP + -0x58]
MOV RSI,qword ptr [RBP + -0x18]
MOVSXD RDX,dword ptr [RBP + -0x1c]
CALL 0x0012a0b0
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x00148b99
LAB_00148b91:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x48],RAX
LAB_00148b99:
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x40],EAX
MOV RDI,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RAX + 0x230]
LEA RSI,[RBP + -0x48]
XOR EDX,EDX
CALL 0x001ff280
CMP RAX,0x0
JNZ 0x00148bd3
MOV RDI,qword ptr [RBP + -0x30]
XOR ESI,ESI
CALL 0x001ff0b0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00148bdc
LAB_00148bd3:
JMP 0x00148bd5
LAB_00148bd5:
MOV dword ptr [RBP + -0x4],0x0
LAB_00148bdc:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x60
POP RBP
RET
|
bool maria_ft_add_word(long param_1,void *param_2,int param_3,int8 param_4)
{
void *__dest;
long lVar1;
void *local_50;
int local_48;
long local_38;
int8 local_30;
int local_24;
void *local_20;
long local_18;
local_38 = **(long **)(param_1 + 0x18);
local_50 = param_2;
local_30 = param_4;
local_24 = param_3;
local_20 = param_2;
local_18 = param_1;
if ((*(uint *)(param_1 + 0x34) & 1) != 0) {
__dest = (void *)alloc_root((*(long **)(param_1 + 0x18))[1],(long)param_3);
memcpy(__dest,local_20,(long)local_24);
local_50 = __dest;
}
local_48 = local_24;
lVar1 = tree_insert(local_38,&local_50,0,*(int8 *)(local_38 + 0x230));
if (lVar1 == 0) {
delete_tree(local_38,0);
}
return lVar1 == 0;
}
|
|
66,081 |
google::protobuf::compiler::java::ImmutableStringFieldLiteGenerator::GenerateKotlinDslMembers(google::protobuf::io::Printer*) const
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/java/string_field_lite.cc
|
void ImmutableStringFieldLiteGenerator::GenerateKotlinDslMembers(
io::Printer* printer) const {
WriteFieldDocComment(printer, descriptor_);
printer->Print(variables_,
"$kt_deprecation$public var $kt_name$: kotlin.String\n"
" @JvmName(\"${$get$kt_capitalized_name$$}$\")\n"
" get() = $kt_dsl_builder$.${$get$capitalized_name$$}$()\n"
" @JvmName(\"${$set$kt_capitalized_name$$}$\")\n"
" set(value) {\n"
" $kt_dsl_builder$.${$set$capitalized_name$$}$(value)\n"
" }\n");
WriteFieldAccessorDocComment(printer, descriptor_, CLEARER,
/* builder */ false);
printer->Print(variables_,
"public fun ${$clear$kt_capitalized_name$$}$() {\n"
" $kt_dsl_builder$.${$clear$capitalized_name$$}$()\n"
"}\n");
if (HasHazzer(descriptor_)) {
WriteFieldAccessorDocComment(printer, descriptor_, HAZZER);
printer->Print(
variables_,
"public fun ${$has$kt_capitalized_name$$}$(): kotlin.Boolean {\n"
" return $kt_dsl_builder$.${$has$capitalized_name$$}$()\n"
"}\n");
}
}
|
O3
|
cpp
|
google::protobuf::compiler::java::ImmutableStringFieldLiteGenerator::GenerateKotlinDslMembers(google::protobuf::io::Printer*) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %rsi
movq %rbx, %rdi
callq 0xcfb21
leaq 0x10(%r15), %r14
leaq 0xf8228(%rip), %rdx # 0x1e1f97
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16cd32
movq 0x8(%r15), %rsi
movq %rbx, %rdi
movl $0x3, %edx
xorl %ecx, %ecx
callq 0xcff9a
leaq 0xeffa5(%rip), %rdx # 0x1d9d39
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16cd32
movq 0x8(%r15), %r12
movb 0x1(%r12), %al
notb %al
testb $0x60, %al
jne 0xe9dba
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r12, %rdi
callq 0x11d7ce
testq %rax, %rax
jne 0xe9ddb
movb 0x1(%r12), %al
testb $0x2, %al
jne 0xe9ddb
movq 0x10(%r12), %rcx
cmpb $0x2, 0x3(%rcx)
jne 0xe9e08
movq 0x8(%r15), %rsi
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xcff9a
leaq 0xeffad(%rip), %rdx # 0x1d9d9f
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x16cd32
testb $0x10, %al
sete %cl
movq 0x28(%r12), %rax
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0xe9dae
cmpl $0x1, 0x4(%rax)
jne 0xe9ddb
movq 0x20(%rax), %rax
testb $0x2, 0x1(%rax)
jne 0xe9dae
jmp 0xe9ddb
|
_ZNK6google8protobuf8compiler4java33ImmutableStringFieldLiteGenerator24GenerateKotlinDslMembersEPNS0_2io7PrinterE:
push r15; int
push r14; int
push r12; int
push rbx; char
push rax; int
mov rbx, rsi
mov r15, rdi
mov rsi, [rdi+8]; google::protobuf::io::Printer *
mov rdi, rbx; this
call _ZN6google8protobuf8compiler4java20WriteFieldDocCommentEPNS0_2io7PrinterEPKNS0_15FieldDescriptorE; google::protobuf::compiler::java::WriteFieldDocComment(google::protobuf::io::Printer *,google::protobuf::FieldDescriptor const*)
lea r14, [r15+10h]
lea rdx, aKtDeprecationP_2; "$kt_deprecation$public var $kt_name$: k"...
mov rdi, rbx; this
mov rsi, r14
call _ZN6google8protobuf2io7Printer5PrintERKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES9_St4lessIS9_ESaISt4pairIKS9_S9_EEEPKc; google::protobuf::io::Printer::Print(std::map<std::string,std::string> const&,char const*)
mov rsi, [r15+8]; google::protobuf::FieldDescriptor *
mov rdi, rbx; this
mov edx, 3
xor ecx, ecx
call _ZN6google8protobuf8compiler4java28WriteFieldAccessorDocCommentEPNS0_2io7PrinterEPKNS0_15FieldDescriptorENS2_17FieldAccessorTypeEb; google::protobuf::compiler::java::WriteFieldAccessorDocComment(google::protobuf::io::Printer *,google::protobuf::FieldDescriptor const*,google::protobuf::compiler::java::FieldAccessorType,bool)
lea rdx, aPublicFunClear; "public fun ${$clear$kt_capitalized_name"...
mov rdi, rbx; this
mov rsi, r14
call _ZN6google8protobuf2io7Printer5PrintERKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES9_St4lessIS9_ESaISt4pairIKS9_S9_EEEPKc; google::protobuf::io::Printer::Print(std::map<std::string,std::string> const&,char const*)
mov r12, [r15+8]
mov al, [r12+1]
not al
test al, 60h
jnz short loc_E9DBA
loc_E9DAE:
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
loc_E9DBA:
mov rdi, r12; this
call _ZNK6google8protobuf15FieldDescriptor12message_typeEv; google::protobuf::FieldDescriptor::message_type(void)
test rax, rax
jnz short loc_E9DDB
mov al, [r12+1]
test al, 2
jnz short loc_E9DDB
mov rcx, [r12+10h]
cmp byte ptr [rcx+3], 2
jnz short loc_E9E08
loc_E9DDB:
mov rsi, [r15+8]; google::protobuf::FieldDescriptor *
mov rdi, rbx; this
xor edx, edx
xor ecx, ecx
call _ZN6google8protobuf8compiler4java28WriteFieldAccessorDocCommentEPNS0_2io7PrinterEPKNS0_15FieldDescriptorENS2_17FieldAccessorTypeEb; google::protobuf::compiler::java::WriteFieldAccessorDocComment(google::protobuf::io::Printer *,google::protobuf::FieldDescriptor const*,google::protobuf::compiler::java::FieldAccessorType,bool)
lea rdx, aPublicFunHasKt; "public fun ${$has$kt_capitalized_name$$"...
mov rdi, rbx; this
mov rsi, r14
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
jmp _ZN6google8protobuf2io7Printer5PrintERKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES9_St4lessIS9_ESaISt4pairIKS9_S9_EEEPKc; google::protobuf::io::Printer::Print(std::map<std::string,std::string> const&,char const*)
loc_E9E08:
test al, 10h
setz cl
mov rax, [r12+28h]
test rax, rax
setz dl
or dl, cl
jnz short loc_E9DAE
cmp dword ptr [rax+4], 1
jnz short loc_E9DDB
mov rax, [rax+20h]
test byte ptr [rax+1], 2
jnz short loc_E9DAE
jmp short loc_E9DDB
|
GenerateKotlinDslMembers:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R15,RDI
MOV RSI,qword ptr [RDI + 0x8]
MOV RDI,RBX
CALL 0x001cfb21
LEA R14,[R15 + 0x10]
LEA RDX,[0x2e1f97]
MOV RDI,RBX
MOV RSI,R14
CALL 0x0026cd32
MOV RSI,qword ptr [R15 + 0x8]
MOV RDI,RBX
MOV EDX,0x3
XOR ECX,ECX
CALL 0x001cff9a
LEA RDX,[0x2d9d39]
MOV RDI,RBX
MOV RSI,R14
CALL 0x0026cd32
MOV R12,qword ptr [R15 + 0x8]
MOV AL,byte ptr [R12 + 0x1]
NOT AL
TEST AL,0x60
JNZ 0x001e9dba
LAB_001e9dae:
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
LAB_001e9dba:
MOV RDI,R12
CALL 0x0021d7ce
TEST RAX,RAX
JNZ 0x001e9ddb
MOV AL,byte ptr [R12 + 0x1]
TEST AL,0x2
JNZ 0x001e9ddb
MOV RCX,qword ptr [R12 + 0x10]
CMP byte ptr [RCX + 0x3],0x2
JNZ 0x001e9e08
LAB_001e9ddb:
MOV RSI,qword ptr [R15 + 0x8]
MOV RDI,RBX
XOR EDX,EDX
XOR ECX,ECX
CALL 0x001cff9a
LEA RDX,[0x2d9d9f]
MOV RDI,RBX
MOV RSI,R14
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
JMP 0x0026cd32
LAB_001e9e08:
TEST AL,0x10
SETZ CL
MOV RAX,qword ptr [R12 + 0x28]
TEST RAX,RAX
SETZ DL
OR DL,CL
JNZ 0x001e9dae
CMP dword ptr [RAX + 0x4],0x1
JNZ 0x001e9ddb
MOV RAX,qword ptr [RAX + 0x20]
TEST byte ptr [RAX + 0x1],0x2
JNZ 0x001e9dae
JMP 0x001e9ddb
|
/* google::protobuf::compiler::java::ImmutableStringFieldLiteGenerator::GenerateKotlinDslMembers(google::protobuf::io::Printer*)
const */
void __thiscall
google::protobuf::compiler::java::ImmutableStringFieldLiteGenerator::GenerateKotlinDslMembers
(ImmutableStringFieldLiteGenerator *this,Printer *param_1)
{
map *pmVar1;
FieldDescriptor *this_00;
long lVar2;
WriteFieldDocComment(param_1,*(FieldDescriptor **)(this + 8));
pmVar1 = (map *)(this + 0x10);
io::Printer::Print(param_1,pmVar1,
"$kt_deprecation$public var $kt_name$: kotlin.String\n @JvmName(\"${$get$kt_capitalized_name$$}$\")\n get() = $kt_dsl_builder$.${$get$capitalized_name$$}$()\n @JvmName(\"${$set$kt_capitalized_name$$}$\")\n set(value) {\n $kt_dsl_builder$.${$set$capitalized_name$$}$(value)\n }\n"
);
WriteFieldAccessorDocComment(param_1,*(int8 *)(this + 8),3,0);
io::Printer::Print(param_1,pmVar1,
"public fun ${$clear$kt_capitalized_name$$}$() {\n $kt_dsl_builder$.${$clear$capitalized_name$$}$()\n}\n"
);
this_00 = *(FieldDescriptor **)(this + 8);
if (((~(byte)this_00[1] & 0x60) != 0) &&
((((lVar2 = FieldDescriptor::message_type(this_00), lVar2 != 0 || (((byte)this_00[1] & 2) != 0)
) || (*(char *)(*(long *)(this_00 + 0x10) + 3) == '\x02')) ||
((lVar2 = *(long *)(this_00 + 0x28), lVar2 != 0 && ((byte)this_00[1] & 0x10) != 0 &&
((*(int *)(lVar2 + 4) != 1 || ((*(byte *)(*(long *)(lVar2 + 0x20) + 1) & 2) == 0)))))))) {
WriteFieldAccessorDocComment(param_1,*(int8 *)(this + 8),0,0);
io::Printer::Print(param_1,pmVar1,
"public fun ${$has$kt_capitalized_name$$}$(): kotlin.Boolean {\n return $kt_dsl_builder$.${$has$capitalized_name$$}$()\n}\n"
);
return;
}
return;
}
|
||
66,082 |
row_import_cleanup(row_prebuilt_t*, dberr_t)
|
eloqsql/storage/innobase/row/row0import.cc
|
dberr_t
row_import_cleanup(
/*===============*/
row_prebuilt_t* prebuilt, /*!< in/out: prebuilt from handler */
dberr_t err) /*!< in: error code */
{
if (err != DB_SUCCESS) {
dict_table_t* table = prebuilt->table;
table->file_unreadable = true;
if (table->space) {
fil_close_tablespace(table->space_id);
table->space = NULL;
}
prebuilt->trx->error_info = NULL;
ib::info() << "Discarding tablespace of table "
<< table->name << ": " << err;
for (dict_index_t* index = UT_LIST_GET_FIRST(table->indexes);
index;
index = UT_LIST_GET_NEXT(indexes, index)) {
index->page = FIL_NULL;
}
}
DBUG_EXECUTE_IF("ib_import_before_commit_crash", DBUG_SUICIDE(););
prebuilt->trx->commit();
if (prebuilt->trx->dict_operation_lock_mode) {
row_mysql_unlock_data_dictionary(prebuilt->trx);
}
prebuilt->trx->op_info = "";
DBUG_EXECUTE_IF("ib_import_before_checkpoint_crash", DBUG_SUICIDE(););
return(err);
}
|
O0
|
cpp
|
row_import_cleanup(row_prebuilt_t*, dberr_t):
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp # imm = 0x1E0
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x188(%rbp)
movl %esi, -0x18c(%rbp)
cmpl $0x0, -0x18c(%rbp)
je 0x10a0500
movq -0x188(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x198(%rbp)
movq -0x198(%rbp), %rax
movq 0x40(%rax), %rcx
andq $-0x400001, %rcx # imm = 0xFFBFFFFF
orq $0x400000, %rcx # imm = 0x400000
movq %rcx, 0x40(%rax)
movq -0x198(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x10a03ce
movq -0x198(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x11d9e70
movq -0x198(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x188(%rbp), %rax
movq 0x18(%rax), %rax
movq $0x0, 0x900(%rax)
leaq -0x180(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
xorl %esi, %esi
movl $0x178, %edx # imm = 0x178
callq 0x7584b0
movq -0x1c0(%rbp), %rdi
callq 0xfc5010
movq -0x1c0(%rbp), %rdi
leaq 0x38176d(%rip), %rsi # 0x1421b85
callq 0xfca0f0
movq %rax, -0x1b8(%rbp)
jmp 0x10a0426
movq -0x1b8(%rbp), %rdi
movq -0x198(%rbp), %rsi
addq $0x10, %rsi
callq 0xfc77b0
movq %rax, -0x1c8(%rbp)
jmp 0x10a0446
movq -0x1c8(%rbp), %rdi
leaq 0x37e816(%rip), %rsi # 0x141ec6a
callq 0xfc80c0
movq %rax, -0x1d0(%rbp)
jmp 0x10a0462
movq -0x1d0(%rbp), %rdi
movl -0x18c(%rbp), %esi
callq 0x1141f50
jmp 0x10a0476
leaq -0x180(%rbp), %rdi
callq 0x1141f90
movq -0x198(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x1b0(%rbp)
cmpq $0x0, -0x1b0(%rbp)
je 0x10a04fe
movq -0x1b0(%rbp), %rax
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq 0x20(%rax), %rcx
movabsq $0xffffffff, %rdx # imm = 0xFFFFFFFF
orq %rdx, %rcx
movq %rcx, 0x20(%rax)
movq -0x1b0(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x1b0(%rbp)
jmp 0x10a0497
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x1141f90
jmp 0x10a059a
jmp 0x10a0500
jmp 0x10a0502
jmp 0x10a0504
movq -0x188(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1130f50
movq -0x188(%rbp), %rax
movq 0x18(%rax), %rax
testb $0x1, 0x8b9(%rax)
je 0x10a0552
jmp 0x10a052a
jmp 0x10a052c
jmp 0x10a052e
jmp 0x10a0530
jmp 0x10a0532
movq -0x188(%rbp), %rax
movq 0x18(%rax), %rax
movb $0x0, 0x8b9(%rax)
leaq 0xa6b075(%rip), %rdi # 0x1b0b5c0
callq 0x119eed0
jmp 0x10a0552
movq -0x188(%rbp), %rax
movq 0x18(%rax), %rax
leaq 0x33c276(%rip), %rcx # 0x13dc7da
movq %rcx, 0x898(%rax)
jmp 0x10a056d
movl -0x18c(%rbp), %eax
movl %eax, -0x1d4(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x10a05c6
movl -0x1d4(%rbp), %eax
addq $0x1e0, %rsp # imm = 0x1E0
popq %rbp
retq
movq -0x1a0(%rbp), %rax
movq %rax, -0x1e0(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x10a05c6
movq -0x1e0(%rbp), %rdi
callq 0x7589b0
callq 0x758480
nopl (%rax,%rax)
|
_ZL18row_import_cleanupP14row_prebuilt_t7dberr_t:
push rbp
mov rbp, rsp
sub rsp, 1E0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_188], rdi
mov [rbp+var_18C], esi
cmp [rbp+var_18C], 0
jz loc_10A0500
mov rax, [rbp+var_188]
mov rax, [rax+8]
mov [rbp+var_198], rax
mov rax, [rbp+var_198]
mov rcx, [rax+40h]
and rcx, 0FFFFFFFFFFBFFFFFh
or rcx, 400000h
mov [rax+40h], rcx
mov rax, [rbp+var_198]
cmp qword ptr [rax+30h], 0
jz short loc_10A03CE
mov rax, [rbp+var_198]
mov rdi, [rax+38h]; unsigned __int64
call _Z20fil_close_tablespacem; fil_close_tablespace(ulong)
mov rax, [rbp+var_198]
mov qword ptr [rax+30h], 0
loc_10A03CE:
mov rax, [rbp+var_188]
mov rax, [rax+18h]
mov qword ptr [rax+900h], 0
lea rdi, [rbp+var_180]
mov [rbp+var_1C0], rdi
xor esi, esi
mov edx, 178h
call _memset
mov rdi, [rbp+var_1C0]; this
call _ZN2ib4infoC2Ev; ib::info::info(void)
mov rdi, [rbp+var_1C0]
lea rsi, aDiscardingTabl; "Discarding tablespace of table "
call _ZN2ib6loggerlsILm32EEERS0_RAT__Kc; ib::logger::operator<<<32ul>(char const(&)[32ul])
mov [rbp+var_1B8], rax
jmp short $+2
loc_10A0426:
mov rdi, [rbp+var_1B8]
mov rsi, [rbp+var_198]
add rsi, 10h
call _ZN2ib6loggerlsI12table_name_tEERS0_RKT_; ib::logger::operator<<<table_name_t>(table_name_t const&)
mov [rbp+var_1C8], rax
jmp short $+2
loc_10A0446:
mov rdi, [rbp+var_1C8]
lea rsi, asc_141EC69+1; ": "
call _ZN2ib6loggerlsILm3EEERS0_RAT__Kc; ib::logger::operator<<<3ul>(char const(&)[3ul])
mov [rbp+var_1D0], rax
jmp short $+2
loc_10A0462:
mov rdi, [rbp+var_1D0]
mov esi, [rbp+var_18C]
call _ZN2ib6loggerlsE7dberr_t; ib::logger::operator<<(dberr_t)
jmp short $+2
loc_10A0476:
lea rdi, [rbp+var_180]; this
call _ZN2ib4infoD2Ev; ib::info::~info()
mov rax, [rbp+var_198]
mov rax, [rax+98h]
mov [rbp+var_1B0], rax
loc_10A0497:
cmp [rbp+var_1B0], 0
jz short loc_10A04FE
mov rax, [rbp+var_1B0]
mov rcx, 0FFFFFFFF00000000h
and rcx, [rax+20h]
mov rdx, 0FFFFFFFFh
or rcx, rdx
mov [rax+20h], rcx
mov rax, [rbp+var_1B0]
mov rax, [rax+60h]
mov [rbp+var_1B0], rax
jmp short loc_10A0497
mov rcx, rax
mov eax, edx
mov [rbp+var_1A0], rcx
mov [rbp+var_1A4], eax
lea rdi, [rbp+var_180]; this
call _ZN2ib4infoD2Ev; ib::info::~info()
jmp loc_10A059A
loc_10A04FE:
jmp short $+2
loc_10A0500:
jmp short $+2
loc_10A0502:
jmp short $+2
loc_10A0504:
mov rax, [rbp+var_188]
mov rdi, [rax+18h]; this
call _ZN5trx_t6commitEv; trx_t::commit(void)
mov rax, [rbp+var_188]
mov rax, [rax+18h]
test byte ptr [rax+8B9h], 1
jz short loc_10A0552
jmp short $+2
loc_10A052A:
jmp short $+2
loc_10A052C:
jmp short $+2
loc_10A052E:
jmp short $+2
loc_10A0530:
jmp short $+2
loc_10A0532:
mov rax, [rbp+var_188]
mov rax, [rax+18h]
mov byte ptr [rax+8B9h], 0
lea rdi, dict_sys; this
call _ZN10dict_sys_t6unlockEv; dict_sys_t::unlock(void)
jmp short $+2
loc_10A0552:
mov rax, [rbp+var_188]
mov rax, [rax+18h]
lea rcx, byte_13DC7DA
mov [rax+898h], rcx
jmp short $+2
loc_10A056D:
mov eax, [rbp+var_18C]
mov [rbp+var_1D4], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_10A05C6
mov eax, [rbp+var_1D4]
add rsp, 1E0h
pop rbp
retn
loc_10A059A:
mov rax, [rbp+var_1A0]
mov [rbp+var_1E0], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_10A05C6
mov rdi, [rbp+var_1E0]
call __Unwind_Resume
loc_10A05C6:
call ___stack_chk_fail
|
long long row_import_cleanup(long long a1, unsigned int a2)
{
long long v3; // [rsp+10h] [rbp-1D0h]
long long v4; // [rsp+18h] [rbp-1C8h]
long long v5; // [rsp+28h] [rbp-1B8h]
long long i; // [rsp+30h] [rbp-1B0h]
_QWORD *v7; // [rsp+48h] [rbp-198h]
_BYTE v8[376]; // [rsp+60h] [rbp-180h] BYREF
unsigned long long v9; // [rsp+1D8h] [rbp-8h]
v9 = __readfsqword(0x28u);
if ( a2 )
{
v7 = *(_QWORD **)(a1 + 8);
v7[8] = v7[8] & 0xFFFFFFFFFFBFFFFFLL | 0x400000;
if ( v7[6] )
{
fil_close_tablespace(v7[7]);
v7[6] = 0LL;
}
*(_QWORD *)(*(_QWORD *)(a1 + 24) + 2304LL) = 0LL;
memset(v8, 0LL);
ib::info::info((ib::info *)v8);
v5 = ib::logger::operator<<<32ul>((long long)v8, (long long)"Discarding tablespace of table ");
v4 = ib::logger::operator<<<table_name_t>(v5, (long long)(v7 + 2));
v3 = ib::logger::operator<<<3ul>(v4, (long long)": ");
ib::logger::operator<<(v3, a2);
ib::info::~info((ib::info *)v8);
for ( i = v7[19]; i; i = *(_QWORD *)(i + 96) )
*(_QWORD *)(i + 32) = *(_QWORD *)(i + 32) & 0xFFFFFFFF00000000LL | 0xFFFFFFFF;
}
trx_t::commit(*(trx_t **)(a1 + 24));
if ( (*(_BYTE *)(*(_QWORD *)(a1 + 24) + 2233LL) & 1) != 0 )
{
*(_BYTE *)(*(_QWORD *)(a1 + 24) + 2233LL) = 0;
dict_sys_t::unlock((dict_sys_t *)&dict_sys);
}
*(_QWORD *)(*(_QWORD *)(a1 + 24) + 2200LL) = &byte_13DC7DA;
return a2;
}
|
innobase_register_trx:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
JMP 0x010a0356
LAB_010a0356:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x48]
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x20]
XOR ESI,ESI
CALL 0x00d1a730
MOV RAX,qword ptr [RBP + -0x18]
TEST byte ptr [RAX + 0x8a6],0x1
JNZ 0x010a03b9
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x8a6],0x1
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x180000
CALL 0x0097d260
CMP RAX,0x0
JZ 0x010a03b7
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x20]
MOV ESI,0x1
CALL 0x00d1a730
LAB_010a03b7:
JMP 0x010a03b9
LAB_010a03b9:
ADD RSP,0x20
POP RBP
RET
|
/* innobase_register_trx(handlerton*, THD*, trx_t*) */
void innobase_register_trx(handlerton *param_1,THD *param_2,trx_t *param_3)
{
ulonglong uVar1;
long lVar2;
uVar1 = *(ulonglong *)(param_3 + 0x48);
trans_register_ha(param_2,false,param_1,uVar1);
if (((byte)param_3[0x8a6] & 1) == 0) {
param_3[0x8a6] = (trx_t)0x1;
lVar2 = thd_test_options(param_2,0x180000);
if (lVar2 != 0) {
trans_register_ha(param_2,true,param_1,uVar1);
}
}
return;
}
|
|
66,083 |
int10_to_str
|
eloqsql/strings/int2str.c
|
char *int10_to_str(long int val,char *dst,int radix)
{
char buffer[65];
register char *p;
long int new_val;
unsigned long int uval = (unsigned long int) val;
if (radix < 0) /* -10 */
{
if (val < 0)
{
*dst++ = '-';
/* Avoid integer overflow in (-val) for LONGLONG_MIN (BUG#31799). */
uval = (unsigned long int)0 - uval;
}
}
p = &buffer[sizeof(buffer)-1];
*p = '\0';
new_val= (long) (uval / 10);
*--p = '0'+ (char) (uval - (unsigned long) new_val * 10);
val = new_val;
while (val != 0)
{
new_val=val/10;
*--p = '0' + (char) (val-new_val*10);
val= new_val;
}
while ((*dst++ = *p++) != 0) ;
return dst-1;
}
|
O0
|
c
|
int10_to_str:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x58(%rbp)
movq %rsi, -0x60(%rbp)
movl %edx, -0x64(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpl $0x0, -0x64(%rbp)
jge 0xddb26
cmpq $0x0, -0x58(%rbp)
jge 0xddb24
movq -0x60(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x60(%rbp)
movb $0x2d, (%rax)
xorl %eax, %eax
subq -0x80(%rbp), %rax
movq %rax, -0x80(%rbp)
jmp 0xddb26
leaq -0x50(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movb $0x0, (%rax)
movq -0x80(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x78(%rbp)
movq -0x80(%rbp), %rax
imulq $0xa, -0x78(%rbp), %rcx
subq %rcx, %rax
movsbl %al, %eax
addl $0x30, %eax
movb %al, %cl
movq -0x70(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x70(%rbp)
movb %cl, -0x1(%rax)
movq -0x78(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0xddbc2
movq -0x58(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x78(%rbp)
movq -0x58(%rbp), %rax
imulq $0xa, -0x78(%rbp), %rcx
subq %rcx, %rax
movsbl %al, %eax
addl $0x30, %eax
movb %al, %cl
movq -0x70(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x70(%rbp)
movb %cl, -0x1(%rax)
movq -0x78(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0xddb79
jmp 0xddbc4
movq -0x70(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x70(%rbp)
movb (%rax), %al
movq -0x60(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x60(%rbp)
movb %al, (%rcx)
movsbl %al, %eax
cmpl $0x0, %eax
je 0xddbf0
jmp 0xddbc4
movq -0x60(%rbp), %rax
decq %rax
movq %rax, -0x88(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xddc20
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
callq 0x29420
nopw %cs:(%rax,%rax)
nop
|
int10_to_str:
push rbp
mov rbp, rsp
sub rsp, 90h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov [rbp+var_64], edx
mov rax, [rbp+var_58]
mov [rbp+var_80], rax
cmp [rbp+var_64], 0
jge short loc_DDB26
cmp [rbp+var_58], 0
jge short loc_DDB24
mov rax, [rbp+var_60]
mov rcx, rax
add rcx, 1
mov [rbp+var_60], rcx
mov byte ptr [rax], 2Dh ; '-'
xor eax, eax
sub rax, [rbp+var_80]
mov [rbp+var_80], rax
loc_DDB24:
jmp short $+2
loc_DDB26:
lea rax, [rbp+var_50]
add rax, 40h ; '@'
mov [rbp+var_70], rax
mov rax, [rbp+var_70]
mov byte ptr [rax], 0
mov rax, [rbp+var_80]
mov ecx, 0Ah
xor edx, edx
div rcx
mov [rbp+var_78], rax
mov rax, [rbp+var_80]
imul rcx, [rbp+var_78], 0Ah
sub rax, rcx
movsx eax, al
add eax, 30h ; '0'
mov cl, al
mov rax, [rbp+var_70]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_70], rdx
mov [rax-1], cl
mov rax, [rbp+var_78]
mov [rbp+var_58], rax
loc_DDB79:
cmp [rbp+var_58], 0
jz short loc_DDBC2
mov rax, [rbp+var_58]
mov ecx, 0Ah
cqo
idiv rcx
mov [rbp+var_78], rax
mov rax, [rbp+var_58]
imul rcx, [rbp+var_78], 0Ah
sub rax, rcx
movsx eax, al
add eax, 30h ; '0'
mov cl, al
mov rax, [rbp+var_70]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_70], rdx
mov [rax-1], cl
mov rax, [rbp+var_78]
mov [rbp+var_58], rax
jmp short loc_DDB79
loc_DDBC2:
jmp short $+2
loc_DDBC4:
mov rax, [rbp+var_70]
mov rcx, rax
add rcx, 1
mov [rbp+var_70], rcx
mov al, [rax]
mov rcx, [rbp+var_60]
mov rdx, rcx
add rdx, 1
mov [rbp+var_60], rdx
mov [rcx], al
movsx eax, al
cmp eax, 0
jz short loc_DDBF0
jmp short loc_DDBC4
loc_DDBF0:
mov rax, [rbp+var_60]
dec rax
mov [rbp+var_88], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_DDC20
mov rax, [rbp+var_88]
add rsp, 90h
pop rbp
retn
loc_DDC20:
call ___stack_chk_fail
|
_BYTE * int10_to_str(long long a1, _BYTE *a2, int a3)
{
_BYTE *v3; // rax
_BYTE *v4; // rax
_BYTE *v5; // rcx
unsigned long long v7; // [rsp+10h] [rbp-80h]
_BYTE *v8; // [rsp+20h] [rbp-70h]
_BYTE *v9; // [rsp+30h] [rbp-60h]
signed long long i; // [rsp+38h] [rbp-58h]
_BYTE v11[9]; // [rsp+7Fh] [rbp-11h] BYREF
unsigned long long v12; // [rsp+88h] [rbp-8h]
v12 = __readfsqword(0x28u);
v9 = a2;
v7 = a1;
if ( a3 < 0 && a1 < 0 )
{
v9 = a2 + 1;
*a2 = 45;
v7 = -a1;
}
v11[1] = 0;
v8 = v11;
v11[0] = v7 % 0xA + 48;
for ( i = v7 / 0xA; i; i /= 10LL )
{
v3 = v8--;
*(v3 - 1) = i % 10 + 48;
}
do
{
v4 = v8++;
LOBYTE(v4) = *v4;
v5 = v9++;
*v5 = (_BYTE)v4;
}
while ( (_BYTE)v4 );
return v9 - 1;
}
|
int10_to_str:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV dword ptr [RBP + -0x64],EDX
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x80],RAX
CMP dword ptr [RBP + -0x64],0x0
JGE 0x001ddb26
CMP qword ptr [RBP + -0x58],0x0
JGE 0x001ddb24
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x60],RCX
MOV byte ptr [RAX],0x2d
XOR EAX,EAX
SUB RAX,qword ptr [RBP + -0x80]
MOV qword ptr [RBP + -0x80],RAX
LAB_001ddb24:
JMP 0x001ddb26
LAB_001ddb26:
LEA RAX,[RBP + -0x50]
ADD RAX,0x40
MOV qword ptr [RBP + -0x70],RAX
MOV RAX,qword ptr [RBP + -0x70]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x80]
MOV ECX,0xa
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x80]
IMUL RCX,qword ptr [RBP + -0x78],0xa
SUB RAX,RCX
MOVSX EAX,AL
ADD EAX,0x30
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x70]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RBP + -0x70],RDX
MOV byte ptr [RAX + -0x1],CL
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0x58],RAX
LAB_001ddb79:
CMP qword ptr [RBP + -0x58],0x0
JZ 0x001ddbc2
MOV RAX,qword ptr [RBP + -0x58]
MOV ECX,0xa
CQO
IDIV RCX
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x58]
IMUL RCX,qword ptr [RBP + -0x78],0xa
SUB RAX,RCX
MOVSX EAX,AL
ADD EAX,0x30
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x70]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RBP + -0x70],RDX
MOV byte ptr [RAX + -0x1],CL
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0x58],RAX
JMP 0x001ddb79
LAB_001ddbc2:
JMP 0x001ddbc4
LAB_001ddbc4:
MOV RAX,qword ptr [RBP + -0x70]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x70],RCX
MOV AL,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x60]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x60],RDX
MOV byte ptr [RCX],AL
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x001ddbf0
JMP 0x001ddbc4
LAB_001ddbf0:
MOV RAX,qword ptr [RBP + -0x60]
DEC RAX
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001ddc20
MOV RAX,qword ptr [RBP + -0x88]
ADD RSP,0x90
POP RBP
RET
LAB_001ddc20:
CALL 0x00129420
|
char * int10_to_str(ulong param_1,char *param_2,int param_3)
{
char cVar1;
char *pcVar2;
long in_FS_OFFSET;
ulong local_88;
char *local_78;
char *local_68;
ulong local_60;
char local_1a [10];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_88 = param_1;
local_68 = param_2;
if ((param_3 < 0) && ((long)param_1 < 0)) {
local_68 = param_2 + 1;
*param_2 = '-';
local_88 = -param_1;
}
local_1a[2] = 0;
local_1a[1] = (char)local_88 + (char)(local_88 / 10) * -10 + '0';
local_78 = local_1a + 1;
local_60 = local_88 / 10;
while (pcVar2 = local_68, local_60 != 0) {
local_78[-1] = (char)local_60 + (char)((long)local_60 / 10) * -10 + '0';
local_78 = local_78 + -1;
local_60 = (long)local_60 / 10;
}
do {
local_68 = pcVar2;
cVar1 = *local_78;
*local_68 = cVar1;
local_78 = local_78 + 1;
pcVar2 = local_68 + 1;
} while (cVar1 != '\0');
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_68;
}
|
|
66,084 |
bprintf
|
corpus-core[P]colibri-stateless/src/util/bytes.c
|
char* bprintf(buffer_t* buf, const char* fmt, ...) {
buffer_t tmp_buf = {0};
if (buf == NULL) buf = &tmp_buf;
va_list args;
va_start(args, fmt);
const char* last_pos = fmt;
const char* p;
for (p = fmt; *p; p++) {
if (*p == '%') {
if (p != last_pos) buffer_append(buf, bytes((uint8_t*) last_pos, p - last_pos));
switch (*(p + 1)) {
case 's':
buffer_add_chars(buf, va_arg(args, const char*));
break;
case 'x':
case 'b':
buffer_add_hex_chars(buf, va_arg(args, bytes_t), NULL, NULL);
break;
case 'u': {
uint32_t len = buf->data.len;
buffer_add_hex_chars(buf, bytes_remove_leading_zeros(va_arg(args, bytes_t)), NULL, NULL);
if (buf->data.data[len] == '0') {
buffer_splice(buf, len, 1, bytes(NULL, 0));
buf->data.data[buf->data.len] = 0;
}
break;
}
case 'J': {
json_t val = va_arg(args, json_t);
buffer_append(buf, bytes((uint8_t*) val.start, val.len));
break;
}
case 'j': {
json_t val = va_arg(args, json_t);
if (val.type == JSON_TYPE_STRING)
buffer_append(buf, bytes((uint8_t*) val.start + 1, val.len - 2));
else
buffer_append(buf, bytes((uint8_t*) val.start, val.len));
break;
}
case 'l': {
uint64_t value = va_arg(args, uint64_t);
char tmp[20] = {0};
if (*(p + 2) == 'x') {
p++;
if (!*(p + 1)) break;
sprintf(tmp, "%" PRIx64, value);
}
else
sprintf(tmp, "%" PRIu64, value);
buffer_add_chars(buf, tmp);
break;
}
case 'd': {
uint32_t value = va_arg(args, uint32_t);
char tmp[20] = {0};
if (*(p + 2) == 'x') {
p++;
if (!*(p + 1)) break;
sprintf(tmp, "%" PRIx32, value);
}
else
sprintf(tmp, "%" PRIu32, value);
buffer_add_chars(buf, tmp);
break;
}
case 'c': {
char c = va_arg(args, int);
buffer_append(buf, bytes((uint8_t*) &c, 1));
break;
}
case 'z': {
char* s = ssz_dump_to_str(va_arg(args, ssz_ob_t), false, false);
buffer_add_chars(buf, s);
safe_free(s);
break;
}
case 'Z': {
char* s = ssz_dump_to_str(va_arg(args, ssz_ob_t), false, true);
buffer_add_chars(buf, s);
safe_free(s);
break;
}
}
p++;
last_pos = p + 1;
if (!*(p + 1)) break;
}
}
va_end(args);
if (last_pos != p)
buffer_add_chars(buf, last_pos);
else if (buffer_append(buf, bytes(NULL, 1)))
buf->data.len--;
return (char*) buf->data.data;
}
|
O3
|
c
|
bprintf:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x80(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x12e1b
movaps %xmm0, 0xb0(%rsp)
movaps %xmm1, 0xc0(%rsp)
movaps %xmm2, 0xd0(%rsp)
movaps %xmm3, 0xe0(%rsp)
movaps %xmm4, 0xf0(%rsp)
movaps %xmm5, 0x100(%rsp)
movaps %xmm6, 0x110(%rsp)
movaps %xmm7, 0x120(%rsp)
xorps %xmm0, %xmm0
leaq 0x60(%rsp), %rax
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
testq %rdi, %rdi
cmoveq %rax, %rbx
movq %rsi, 0x30(%rsp)
leaq 0x170(%rsp), %rax
movq %rax, 0x28(%rsp)
movabsq $0x3000000010, %rax # imm = 0x3000000010
movq %rax, 0x20(%rsp)
leaq 0x2c04b(%rip), %r13 # 0x3eea8
leaq 0x40(%rsp), %r15
leaq 0x2c06b(%rip), %rbp # 0x3eed4
movq %r14, %rdx
movzbl (%r14), %eax
cmpl $0x25, %eax
je 0x12e82
testl %eax, %eax
jne 0x13202
jmp 0x1320a
cmpq %rdx, %r14
je 0x12e94
movl %r14d, %esi
subl %edx, %esi
movq %rbx, %rdi
callq 0x12651
movzbl 0x1(%r14), %eax
cmpl $0x72, %eax
jg 0x12ed6
leal -0x62(%rax), %ecx
cmpl $0xa, %ecx
ja 0x12f0e
leaq 0x1(%r14), %rax
movslq (%r13,%rcx,4), %rcx
addq %r13, %rcx
jmpq *%rcx
movl 0x20(%rsp), %ecx
cmpq $0x28, %rcx
ja 0x131d0
movq %rcx, %rax
addq 0x30(%rsp), %rax
addl $0x8, %ecx
movl %ecx, 0x20(%rsp)
jmp 0x131de
addl $-0x73, %eax
cmpl $0x7, %eax
ja 0x131f4
movslq (%rbp,%rax,4), %rax
addq %rbp, %rax
jmpq *%rax
movl 0x20(%rsp), %ecx
cmpq $0x28, %rcx
ja 0x1306e
movq %rcx, %rax
addq 0x30(%rsp), %rax
addl $0x8, %ecx
movl %ecx, 0x20(%rsp)
jmp 0x1307c
cmpl $0x4a, %eax
je 0x13052
cmpl $0x5a, %eax
jne 0x131f4
movq 0x28(%rsp), %rax
leaq 0x18(%rax), %rcx
movq %rcx, 0x28(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movups (%rax), %xmm0
movups %xmm0, (%rsp)
xorl %edi, %edi
movl $0x1, %esi
jmp 0x12f84
movl 0x20(%rsp), %ecx
cmpq $0x20, %rcx
ja 0x12fc6
movq %rcx, %rax
addq 0x30(%rsp), %rax
addl $0x10, %ecx
movl %ecx, 0x20(%rsp)
jmp 0x12fd4
movq 0x28(%rsp), %rax
leaq 0x18(%rax), %rcx
movq %rcx, 0x28(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movups (%rax), %xmm0
movups %xmm0, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
callq 0x13fad
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
callq 0x129cf
movq %r12, %rdi
callq 0x50c0
jmp 0x131f4
movl 0x20(%rsp), %ecx
cmpq $0x20, %rcx
ja 0x1308c
movq %rcx, %rax
addq 0x30(%rsp), %rax
addl $0x10, %ecx
movl %ecx, 0x20(%rsp)
jmp 0x1309a
movq 0x28(%rsp), %rax
leaq 0x10(%rax), %rcx
movq %rcx, 0x28(%rsp)
movl (%rax), %esi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x129fe
jmp 0x131f4
movl 0x20(%rsp), %edx
cmpq $0x28, %rdx
ja 0x13129
movq %rdx, %rcx
addq 0x30(%rsp), %rcx
addl $0x8, %edx
movl %edx, 0x20(%rsp)
jmp 0x13137
movq 0x28(%rsp), %rax
leaq 0x18(%rax), %rcx
movq %rcx, 0x28(%rsp)
movq (%rax), %rdx
movl 0x8(%rax), %esi
cmpl $0x1, 0x10(%rax)
jne 0x13066
addl $-0x2, %esi
incq %rdx
jmp 0x13066
movl 0x20(%rsp), %edx
cmpq $0x28, %rdx
ja 0x13171
movq %rdx, %rcx
addq 0x30(%rsp), %rcx
addl $0x8, %edx
movl %edx, 0x20(%rsp)
jmp 0x1317f
movq 0x28(%rsp), %rax
leaq 0x18(%rax), %rcx
movq %rcx, 0x28(%rsp)
movq (%rax), %rdx
movl 0x8(%rax), %esi
movq %rbx, %rdi
jmp 0x131ef
movq 0x28(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x28(%rsp)
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x129cf
jmp 0x131f4
movq 0x28(%rsp), %rax
leaq 0x10(%rax), %rcx
movq %rcx, 0x28(%rsp)
movl (%rax), %esi
movq 0x8(%rax), %rax
cmpl $0x2, %esi
jb 0x130c5
leal -0x2(%rsi), %ecx
leaq (%rax,%rcx), %rdx
incq %rdx
cmpb $0x0, (%rax)
jne 0x130c5
decl %esi
incq %rax
cmpl $0x1, %esi
ja 0x130af
movl $0x1, %esi
jmp 0x130c8
movq %rax, %rdx
movl (%rbx), %r12d
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x129fe
movq 0x8(%rbx), %rax
cmpb $0x30, (%rax,%r12)
jne 0x131f4
movl (%rbx), %esi
decl %esi
movq %rbx, %rdi
callq 0x125e5
leal 0x1(%r12), %eax
movl (%rbx), %edx
subl %eax, %edx
je 0x13116
movq 0x8(%rbx), %rcx
leaq (%rcx,%r12), %rdi
movl %eax, %esi
addq %rcx, %rsi
callq 0x50a0
movl (%rbx), %r12d
decl %r12d
movl %r12d, (%rbx)
movq 0x8(%rbx), %rax
movl %r12d, %ecx
movb $0x0, (%rax,%rcx)
jmp 0x131f4
movq 0x28(%rsp), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movl $0x0, 0x50(%rsp)
cmpb $0x78, 0x2(%r14)
leaq 0x2bc0d(%rip), %rsi # 0x3ed63
leaq 0x2bead(%rip), %rcx # 0x3f00a
cmoveq %rcx, %rsi
cmoveq %rax, %r14
movq %r15, %rdi
xorl %eax, %eax
callq 0x5310
jmp 0x131b6
movq 0x28(%rsp), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x28(%rsp)
movl (%rcx), %edx
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movl $0x0, 0x50(%rsp)
cmpb $0x78, 0x2(%r14)
leaq 0x2c17d(%rip), %rsi # 0x3f31a
leaq 0x2c1ca(%rip), %rcx # 0x3f36e
cmoveq %rcx, %rsi
cmoveq %rax, %r14
movq %r15, %rdi
xorl %eax, %eax
callq 0x5310
movq %r15, %rdi
callq 0x5140
leal 0x1(%rax), %esi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x12651
decl (%rbx)
jmp 0x131f4
movq 0x28(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x28(%rsp)
movb (%rax), %al
movb %al, 0x40(%rsp)
movq %rbx, %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0x12651
leaq 0x2(%r14), %rdx
cmpb $0x0, 0x2(%r14)
je 0x1320f
incq %r14
incq %r14
jmp 0x12e6c
cmpq %r14, %rdx
je 0x13230
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x129cf
movq 0x8(%rbx), %rax
addq $0x138, %rsp # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x12651
testl %eax, %eax
je 0x1321a
decl (%rbx)
jmp 0x1321a
|
bprintf:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 138h
mov r14, rsi
mov rbx, rdi
lea rsi, [rsp+168h+var_E8]
mov [rsi+10h], rdx
mov [rsi+18h], rcx
mov [rsi+20h], r8
mov [rsi+28h], r9
test al, al
jz short loc_12E1B
movaps [rsp+168h+var_B8], xmm0
movaps [rsp+168h+var_A8], xmm1
movaps [rsp+168h+var_98], xmm2
movaps [rsp+168h+var_88], xmm3
movaps [rsp+168h+var_78], xmm4
movaps [rsp+168h+var_68], xmm5
movaps [rsp+168h+var_58], xmm6
movaps [rsp+168h+var_48], xmm7
loc_12E1B:
xorps xmm0, xmm0
lea rax, [rsp+168h+var_108]
movaps xmmword ptr [rax], xmm0
mov qword ptr [rax+10h], 0
test rdi, rdi
cmovz rbx, rax
mov [rsp+168h+var_138], rsi
lea rax, [rsp+168h+arg_0]
mov [rsp+168h+var_140], rax
mov rax, 3000000010h
mov [rsp+168h+var_148], rax
lea r13, jpt_12EB2
lea r15, [rsp+168h+var_128]
lea rbp, jpt_12EEA
mov rdx, r14
loc_12E6C:
movzx eax, byte ptr [r14]
cmp eax, 25h ; '%'
jz short loc_12E82
test eax, eax
jnz loc_13202
jmp loc_1320A
loc_12E82:
cmp r14, rdx
jz short loc_12E94
mov esi, r14d
sub esi, edx
mov rdi, rbx
call buffer_append
loc_12E94:
movzx eax, byte ptr [r14+1]
cmp eax, 72h ; 'r'
jg short loc_12ED6
lea ecx, [rax-62h]; switch 11 cases
cmp ecx, 0Ah
ja short def_12EB2; jumptable 0000000000012EB2 default case
lea rax, [r14+1]
movsxd rcx, ds:(jpt_12EB2 - 3EEA8h)[r13+rcx*4]
add rcx, r13
jmp rcx; switch jump
loc_12EB4:
mov ecx, dword ptr [rsp+168h+var_148]; jumptable 0000000000012EB2 case 99
cmp rcx, 28h ; '('
ja loc_131D0
mov rax, rcx
add rax, [rsp+168h+var_138]
add ecx, 8
mov dword ptr [rsp+168h+var_148], ecx
jmp loc_131DE
loc_12ED6:
add eax, 0FFFFFF8Dh; switch 8 cases
cmp eax, 7
ja def_12EEA; jumptable 0000000000012EB2 cases 101-105,107
movsxd rax, ss:(jpt_12EEA - 3EED4h)[rbp+rax*4]
add rax, rbp
jmp rax; switch jump
loc_12EEC:
mov ecx, dword ptr [rsp+168h+var_148]; jumptable 0000000000012EEA case 115
cmp rcx, 28h ; '('
ja loc_1306E
mov rax, rcx
add rax, [rsp+168h+var_138]
add ecx, 8
mov dword ptr [rsp+168h+var_148], ecx
jmp loc_1307C
def_12EB2:
cmp eax, 4Ah ; 'J'; jumptable 0000000000012EB2 default case
jz loc_13052
cmp eax, 5Ah ; 'Z'
jnz def_12EEA; jumptable 0000000000012EB2 cases 101-105,107
mov rax, [rsp+168h+var_140]
lea rcx, [rax+18h]
mov [rsp+168h+var_140], rcx
mov rcx, [rax+10h]
mov [rsp+168h+var_158], rcx
movups xmm0, xmmword ptr [rax]
movups [rsp+168h+var_168], xmm0
xor edi, edi
mov esi, 1
jmp short loc_12F84
loc_12F47:
mov ecx, dword ptr [rsp+168h+var_148]; jumptable 0000000000012EB2 case 98
cmp rcx, 20h ; ' '
ja short loc_12FC6
mov rax, rcx
add rax, [rsp+168h+var_138]
add ecx, 10h
mov dword ptr [rsp+168h+var_148], ecx
jmp short loc_12FD4
loc_12F62:
mov rax, [rsp+168h+var_140]; jumptable 0000000000012EEA case 122
lea rcx, [rax+18h]
mov [rsp+168h+var_140], rcx
mov rcx, [rax+10h]
mov [rsp+168h+var_158], rcx
movups xmm0, xmmword ptr [rax]
movups [rsp+168h+var_168], xmm0
xor edi, edi
xor esi, esi
loc_12F84:
call ssz_dump_to_str
mov r12, rax
mov rdi, rbx
mov rsi, rax
call buffer_add_chars
mov rdi, r12
call _free
jmp def_12EEA; jumptable 0000000000012EB2 cases 101-105,107
loc_12FA4:
mov ecx, dword ptr [rsp+168h+var_148]; jumptable 0000000000012EEA case 117
cmp rcx, 20h ; ' '
ja loc_1308C
mov rax, rcx
add rax, [rsp+168h+var_138]
add ecx, 10h
mov dword ptr [rsp+168h+var_148], ecx
jmp loc_1309A
loc_12FC6:
mov rax, [rsp+168h+var_140]
lea rcx, [rax+10h]
mov [rsp+168h+var_140], rcx
loc_12FD4:
mov esi, [rax]
mov rdx, [rax+8]
mov rdi, rbx
xor ecx, ecx
xor r8d, r8d
call buffer_add_hex_chars
jmp def_12EEA; jumptable 0000000000012EB2 cases 101-105,107
loc_12FEC:
mov edx, dword ptr [rsp+168h+var_148]; jumptable 0000000000012EB2 case 108
cmp rdx, 28h ; '('
ja loc_13129
mov rcx, rdx
add rcx, [rsp+168h+var_138]
add edx, 8
mov dword ptr [rsp+168h+var_148], edx
jmp loc_13137
loc_1300E:
mov rax, [rsp+168h+var_140]; jumptable 0000000000012EB2 case 106
lea rcx, [rax+18h]
mov [rsp+168h+var_140], rcx
mov rdx, [rax]
mov esi, [rax+8]
cmp dword ptr [rax+10h], 1
jnz short loc_13066
add esi, 0FFFFFFFEh
inc rdx
jmp short loc_13066
loc_13030:
mov edx, dword ptr [rsp+168h+var_148]; jumptable 0000000000012EB2 case 100
cmp rdx, 28h ; '('
ja loc_13171
mov rcx, rdx
add rcx, [rsp+168h+var_138]
add edx, 8
mov dword ptr [rsp+168h+var_148], edx
jmp loc_1317F
loc_13052:
mov rax, [rsp+168h+var_140]
lea rcx, [rax+18h]
mov [rsp+168h+var_140], rcx
mov rdx, [rax]
mov esi, [rax+8]
loc_13066:
mov rdi, rbx
jmp loc_131EF
loc_1306E:
mov rax, [rsp+168h+var_140]
lea rcx, [rax+8]
mov [rsp+168h+var_140], rcx
loc_1307C:
mov rsi, [rax]
mov rdi, rbx
call buffer_add_chars
jmp def_12EEA; jumptable 0000000000012EB2 cases 101-105,107
loc_1308C:
mov rax, [rsp+168h+var_140]
lea rcx, [rax+10h]
mov [rsp+168h+var_140], rcx
loc_1309A:
mov esi, [rax]
mov rax, [rax+8]
cmp esi, 2
jb short loc_130C5
lea ecx, [rsi-2]
lea rdx, [rax+rcx]
inc rdx
loc_130AF:
cmp byte ptr [rax], 0
jnz short loc_130C5
dec esi
inc rax
cmp esi, 1
ja short loc_130AF
mov esi, 1
jmp short loc_130C8
loc_130C5:
mov rdx, rax
loc_130C8:
mov r12d, [rbx]
mov rdi, rbx
xor ecx, ecx
xor r8d, r8d
call buffer_add_hex_chars
mov rax, [rbx+8]
cmp byte ptr [rax+r12], 30h ; '0'
jnz def_12EEA; jumptable 0000000000012EB2 cases 101-105,107
mov esi, [rbx]
dec esi
mov rdi, rbx
call buffer_grow
lea eax, [r12+1]
mov edx, [rbx]
sub edx, eax
jz short loc_13116
mov rcx, [rbx+8]
lea rdi, [rcx+r12]
mov esi, eax
add rsi, rcx
call _memmove
mov r12d, [rbx]
dec r12d
loc_13116:
mov [rbx], r12d
mov rax, [rbx+8]
mov ecx, r12d
mov byte ptr [rax+rcx], 0
jmp def_12EEA; jumptable 0000000000012EB2 cases 101-105,107
loc_13129:
mov rcx, [rsp+168h+var_140]
lea rdx, [rcx+8]
mov [rsp+168h+var_140], rdx
loc_13137:
mov rdx, [rcx]
xorps xmm0, xmm0
movaps [rsp+168h+var_128], xmm0
mov [rsp+168h+var_118], 0
cmp byte ptr [r14+2], 78h ; 'x'
lea rsi, aStatesLu+7; "%lu"
lea rcx, aLx; "%lx"
cmovz rsi, rcx
cmovz r14, rax
mov rdi, r15
xor eax, eax
call _sprintf
jmp short loc_131B6
loc_13171:
mov rcx, [rsp+168h+var_140]
lea rdx, [rcx+8]
mov [rsp+168h+var_140], rdx
loc_1317F:
mov edx, [rcx]
xorps xmm0, xmm0
movaps [rsp+168h+var_128], xmm0
mov [rsp+168h+var_118], 0
cmp byte ptr [r14+2], 78h ; 'x'
lea rsi, aGindexDepthIsT+1Bh; "%u"
lea rcx, aLX+4; "%x"
cmovz rsi, rcx
cmovz r14, rax
mov rdi, r15
xor eax, eax
call _sprintf
loc_131B6:
mov rdi, r15
call _strlen
lea esi, [rax+1]
mov rdi, rbx
mov rdx, r15
call buffer_append
dec dword ptr [rbx]
jmp short def_12EEA; jumptable 0000000000012EB2 cases 101-105,107
loc_131D0:
mov rax, [rsp+168h+var_140]
lea rcx, [rax+8]
mov [rsp+168h+var_140], rcx
loc_131DE:
mov al, [rax]
mov byte ptr [rsp+168h+var_128], al
mov rdi, rbx
mov esi, 1
mov rdx, r15
loc_131EF:
call buffer_append
def_12EEA:
lea rdx, [r14+2]; jumptable 0000000000012EB2 cases 101-105,107
cmp byte ptr [r14+2], 0
jz short loc_1320F
inc r14
loc_13202:
inc r14
jmp loc_12E6C
loc_1320A:
cmp rdx, r14
jz short loc_13230
loc_1320F:
mov rdi, rbx
mov rsi, rdx
call buffer_add_chars
loc_1321A:
mov rax, [rbx+8]
add rsp, 138h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_13230:
mov rdi, rbx
mov esi, 1
xor edx, edx
call buffer_append
test eax, eax
jz short loc_1321A
dec dword ptr [rbx]
jmp short loc_1321A
|
long long bprintf(unsigned int *a1, _BYTE *a2, long long a3, long long a4, long long a5, long long a6, ...)
{
_BYTE *v6; // r14
unsigned int *v7; // rbx
long long v8; // rdx
long long *v9; // rax
long long *v10; // rax
_BYTE v11[24]; // kr00_24
long long v12; // rax
char *v13; // rax
_BYTE v14[24]; // kr28_24
long long v15; // r12
char *v16; // rax
__int128 v17; // kr40_16
long long *v18; // rcx
_BYTE v19[24]; // kr60_24
__int128 *v20; // rdx
unsigned int v21; // esi
unsigned int *v22; // rcx
_BYTE v23[24]; // kr88_24
unsigned int *v24; // rdi
long long v25; // kr18_8
__int128 v26; // kr50_16
unsigned int v27; // esi
_BYTE *v28; // rax
long long v29; // rdx
long long v30; // r12
long long v31; // kr20_8
long long v32; // rdx
const char *v33; // rsi
long long v34; // kr78_8
int v35; // eax
long long v36; // kr80_8
va_list va; // [rsp+20h] [rbp-148h] BYREF
__int128 v39; // [rsp+40h] [rbp-128h] BYREF
int v40; // [rsp+50h] [rbp-118h]
__int128 v41; // [rsp+60h] [rbp-108h] BYREF
long long v42; // [rsp+70h] [rbp-F8h]
long long v43; // [rsp+90h] [rbp-D8h]
long long v44; // [rsp+98h] [rbp-D0h]
long long v45; // [rsp+A0h] [rbp-C8h]
long long v46; // [rsp+A8h] [rbp-C0h]
v6 = a2;
v7 = a1;
v43 = a3;
v44 = a4;
v45 = a5;
v46 = a6;
v41 = 0LL;
v42 = 0LL;
if ( !a1 )
v7 = (unsigned int *)&v41;
va_start(va, a6);
va[0].gp_offset = 16;
v8 = (long long)a2;
while ( *v6 == 37 )
{
if ( v6 != (_BYTE *)v8 )
buffer_append(v7, (_DWORD)v6 - v8, v8);
if ( (unsigned __int8)v6[1] > 0x72u )
{
switch ( v6[1] )
{
case 's':
if ( va[0].gp_offset > 0x28uLL )
{
v25 = va_arg(va, _QWORD);
v10 = &v25;
}
else
{
v10 = (long long *)((char *)va[0].reg_save_area + va[0].gp_offset);
va[0].gp_offset += 8;
}
buffer_add_chars(v7, *v10);
goto LABEL_59;
case 'u':
if ( va[0].gp_offset > 0x20uLL )
{
v26 = va_arg(va, _OWORD);
v16 = (char *)&v26;
}
else
{
v16 = (char *)va[0].reg_save_area + va[0].gp_offset;
va[0].gp_offset += 16;
}
v27 = *(_DWORD *)v16;
v28 = (_BYTE *)*((_QWORD *)v16 + 1);
if ( v27 < 2 )
goto LABEL_43;
v29 = (long long)&v28[v27 - 1];
break;
case 'x':
LABEL_19:
if ( va[0].gp_offset > 0x20uLL )
{
v17 = va_arg(va, _OWORD);
v13 = (char *)&v17;
}
else
{
v13 = (char *)va[0].reg_save_area + va[0].gp_offset;
va[0].gp_offset += 16;
}
buffer_add_hex_chars(v7, *(_DWORD *)v13, *((_QWORD *)v13 + 1), 0LL, 0LL);
goto LABEL_59;
case 'z':
*(struct {_BYTE field_0[24];} *)v14 = va_arg(va, struct {_BYTE field_0[24];});
v12 = ssz_dump_to_str(
0,
0,
v8,
*(_QWORD *)&v14[16],
a5,
a6,
*(_QWORD *)v14,
*(_QWORD *)&v14[8],
*(_QWORD *)&v14[16]);
goto LABEL_22;
default:
goto LABEL_59;
}
while ( !*v28 )
{
--v27;
++v28;
if ( v27 <= 1 )
{
v27 = 1;
goto LABEL_44;
}
}
LABEL_43:
v29 = (long long)v28;
LABEL_44:
v30 = *v7;
buffer_add_hex_chars(v7, v27, v29, 0LL, 0LL);
if ( *(_BYTE *)(*((_QWORD *)v7 + 1) + v30) == 48 )
{
buffer_grow((long long)v7, *v7 - 1);
if ( *v7 != (_DWORD)v30 + 1 )
{
memmove(*((_QWORD *)v7 + 1) + v30, *((_QWORD *)v7 + 1) + (unsigned int)(v30 + 1), *v7 - ((_DWORD)v30 + 1));
LODWORD(v30) = *v7 - 1;
}
*v7 = v30;
*(_BYTE *)(*((_QWORD *)v7 + 1) + (unsigned int)v30) = 0;
}
}
else
{
switch ( v6[1] )
{
case 'b':
goto LABEL_19;
case 'c':
if ( va[0].gp_offset > 0x28uLL )
{
v36 = va_arg(va, _QWORD);
v9 = &v36;
}
else
{
v9 = (long long *)((char *)va[0].reg_save_area + va[0].gp_offset);
va[0].gp_offset += 8;
}
LOBYTE(v39) = *(_BYTE *)v9;
v24 = v7;
v21 = 1;
v20 = &v39;
goto LABEL_58;
case 'd':
if ( va[0].gp_offset > 0x28uLL )
{
v34 = va_arg(va, _QWORD);
v22 = (unsigned int *)&v34;
}
else
{
v22 = (unsigned int *)((char *)va[0].reg_save_area + va[0].gp_offset);
va[0].gp_offset += 8;
}
v32 = *v22;
v39 = 0LL;
v40 = 0;
v33 = "%u";
if ( v6[2] == 120 )
{
v33 = "%x";
++v6;
}
goto LABEL_55;
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'k':
goto LABEL_59;
case 'j':
*(struct {_BYTE field_0[24];} *)v19 = va_arg(va, struct {_BYTE field_0[24];});
v20 = *(__int128 **)v19;
v21 = *(_DWORD *)&v19[8];
if ( *(_DWORD *)&v19[16] == 1 )
{
v21 -= 2;
v20 = (__int128 *)(*(_QWORD *)v19 + 1LL);
}
goto LABEL_34;
case 'l':
if ( va[0].gp_offset > 0x28uLL )
{
v31 = va_arg(va, _QWORD);
v18 = &v31;
}
else
{
v18 = (long long *)((char *)va[0].reg_save_area + va[0].gp_offset);
va[0].gp_offset += 8;
}
v32 = *v18;
v39 = 0LL;
v40 = 0;
v33 = "%lu";
if ( v6[2] == 120 )
{
v33 = "%lx";
++v6;
}
LABEL_55:
sprintf(&v39, v33, v32);
v35 = strlen(&v39);
buffer_append(v7, v35 + 1, (long long)&v39);
--*v7;
goto LABEL_59;
default:
if ( (_DWORD)v6 == 73 )
{
*(struct {_BYTE field_0[24];} *)v23 = va_arg(va, struct {_BYTE field_0[24];});
v20 = *(__int128 **)v23;
v21 = *(_DWORD *)&v23[8];
LABEL_34:
v24 = v7;
LABEL_58:
buffer_append(v24, v21, (long long)v20);
goto LABEL_59;
}
if ( (_DWORD)v6 != 89 )
goto LABEL_59;
*(struct {_BYTE field_0[24];} *)v11 = va_arg(va, struct {_BYTE field_0[24];});
v12 = ssz_dump_to_str(
0,
1,
v8,
*(_QWORD *)&v11[16],
a5,
a6,
*(_QWORD *)v11,
*(_QWORD *)&v11[8],
*(_QWORD *)&v11[16]);
break;
}
LABEL_22:
v15 = v12;
buffer_add_chars(v7, v12);
free(v15);
}
LABEL_59:
v8 = (long long)(v6 + 2);
if ( !v6[2] )
goto LABEL_63;
++v6;
LABEL_61:
++v6;
}
if ( *v6 )
goto LABEL_61;
if ( (_BYTE *)v8 != v6 )
{
LABEL_63:
buffer_add_chars(v7, v8);
return *((_QWORD *)v7 + 1);
}
if ( (unsigned int)buffer_append(v7, 1u, 0LL) )
--*v7;
return *((_QWORD *)v7 + 1);
}
|
bprintf:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x138
MOV R14,RSI
MOV RBX,RDI
LEA RSI,[RSP + 0x80]
MOV qword ptr [RSI + 0x10],RDX
MOV qword ptr [RSI + 0x18],RCX
MOV qword ptr [RSI + 0x20],R8
MOV qword ptr [RSI + 0x28],R9
TEST AL,AL
JZ 0x00112e1b
MOVAPS xmmword ptr [RSP + 0xb0],XMM0
MOVAPS xmmword ptr [RSP + 0xc0],XMM1
MOVAPS xmmword ptr [RSP + 0xd0],XMM2
MOVAPS xmmword ptr [RSP + 0xe0],XMM3
MOVAPS xmmword ptr [RSP + 0xf0],XMM4
MOVAPS xmmword ptr [RSP + 0x100],XMM5
MOVAPS xmmword ptr [RSP + 0x110],XMM6
MOVAPS xmmword ptr [RSP + 0x120],XMM7
LAB_00112e1b:
XORPS XMM0,XMM0
LEA RAX,[RSP + 0x60]
MOVAPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],0x0
TEST RDI,RDI
CMOVZ RBX,RAX
MOV qword ptr [RSP + 0x30],RSI
LEA RAX,[RSP + 0x170]
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,0x3000000010
MOV qword ptr [RSP + 0x20],RAX
LEA R13,[0x13eea8]
LEA R15,[RSP + 0x40]
LEA RBP,[0x13eed4]
MOV RDX,R14
LAB_00112e6c:
MOVZX EAX,byte ptr [R14]
CMP EAX,0x25
JZ 0x00112e82
TEST EAX,EAX
JNZ 0x00113202
JMP 0x0011320a
LAB_00112e82:
CMP R14,RDX
JZ 0x00112e94
MOV ESI,R14D
SUB ESI,EDX
MOV RDI,RBX
CALL 0x00112651
LAB_00112e94:
MOVZX EAX,byte ptr [R14 + 0x1]
CMP EAX,0x72
JG 0x00112ed6
LEA ECX,[RAX + -0x62]
CMP ECX,0xa
JA 0x00112f0e
LEA RAX,[R14 + 0x1]
MOVSXD RCX,dword ptr [R13 + RCX*0x4]
ADD RCX,R13
switchD:
JMP RCX
caseD_63:
MOV ECX,dword ptr [RSP + 0x20]
CMP RCX,0x28
JA 0x001131d0
MOV RAX,RCX
ADD RAX,qword ptr [RSP + 0x30]
ADD ECX,0x8
MOV dword ptr [RSP + 0x20],ECX
JMP 0x001131de
LAB_00112ed6:
ADD EAX,-0x73
CMP EAX,0x7
JA 0x001131f4
MOVSXD RAX,dword ptr [RBP + RAX*0x4]
ADD RAX,RBP
switchD:
JMP RAX
caseD_73:
MOV ECX,dword ptr [RSP + 0x20]
CMP RCX,0x28
JA 0x0011306e
MOV RAX,RCX
ADD RAX,qword ptr [RSP + 0x30]
ADD ECX,0x8
MOV dword ptr [RSP + 0x20],ECX
JMP 0x0011307c
LAB_00112f0e:
CMP EAX,0x4a
JZ 0x00113052
CMP EAX,0x5a
JNZ 0x001131f4
MOV RAX,qword ptr [RSP + 0x28]
LEA RCX,[RAX + 0x18]
MOV qword ptr [RSP + 0x28],RCX
MOV RCX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x10],RCX
MOVUPS XMM0,xmmword ptr [RAX]
MOVUPS xmmword ptr [RSP],XMM0
XOR EDI,EDI
MOV ESI,0x1
JMP 0x00112f84
caseD_62:
MOV ECX,dword ptr [RSP + 0x20]
CMP RCX,0x20
JA 0x00112fc6
MOV RAX,RCX
ADD RAX,qword ptr [RSP + 0x30]
ADD ECX,0x10
MOV dword ptr [RSP + 0x20],ECX
JMP 0x00112fd4
caseD_7a:
MOV RAX,qword ptr [RSP + 0x28]
LEA RCX,[RAX + 0x18]
MOV qword ptr [RSP + 0x28],RCX
MOV RCX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x10],RCX
MOVUPS XMM0,xmmword ptr [RAX]
MOVUPS xmmword ptr [RSP],XMM0
XOR EDI,EDI
XOR ESI,ESI
LAB_00112f84:
CALL 0x00113fad
MOV R12,RAX
MOV RDI,RBX
MOV RSI,RAX
CALL 0x001129cf
MOV RDI,R12
CALL 0x001050c0
JMP 0x001131f4
caseD_75:
MOV ECX,dword ptr [RSP + 0x20]
CMP RCX,0x20
JA 0x0011308c
MOV RAX,RCX
ADD RAX,qword ptr [RSP + 0x30]
ADD ECX,0x10
MOV dword ptr [RSP + 0x20],ECX
JMP 0x0011309a
LAB_00112fc6:
MOV RAX,qword ptr [RSP + 0x28]
LEA RCX,[RAX + 0x10]
MOV qword ptr [RSP + 0x28],RCX
LAB_00112fd4:
MOV ESI,dword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
MOV RDI,RBX
XOR ECX,ECX
XOR R8D,R8D
CALL 0x001129fe
JMP 0x001131f4
caseD_6c:
MOV EDX,dword ptr [RSP + 0x20]
CMP RDX,0x28
JA 0x00113129
MOV RCX,RDX
ADD RCX,qword ptr [RSP + 0x30]
ADD EDX,0x8
MOV dword ptr [RSP + 0x20],EDX
JMP 0x00113137
caseD_6a:
MOV RAX,qword ptr [RSP + 0x28]
LEA RCX,[RAX + 0x18]
MOV qword ptr [RSP + 0x28],RCX
MOV RDX,qword ptr [RAX]
MOV ESI,dword ptr [RAX + 0x8]
CMP dword ptr [RAX + 0x10],0x1
JNZ 0x00113066
ADD ESI,-0x2
INC RDX
JMP 0x00113066
caseD_64:
MOV EDX,dword ptr [RSP + 0x20]
CMP RDX,0x28
JA 0x00113171
MOV RCX,RDX
ADD RCX,qword ptr [RSP + 0x30]
ADD EDX,0x8
MOV dword ptr [RSP + 0x20],EDX
JMP 0x0011317f
LAB_00113052:
MOV RAX,qword ptr [RSP + 0x28]
LEA RCX,[RAX + 0x18]
MOV qword ptr [RSP + 0x28],RCX
MOV RDX,qword ptr [RAX]
MOV ESI,dword ptr [RAX + 0x8]
LAB_00113066:
MOV RDI,RBX
JMP 0x001131ef
LAB_0011306e:
MOV RAX,qword ptr [RSP + 0x28]
LEA RCX,[RAX + 0x8]
MOV qword ptr [RSP + 0x28],RCX
LAB_0011307c:
MOV RSI,qword ptr [RAX]
MOV RDI,RBX
CALL 0x001129cf
JMP 0x001131f4
LAB_0011308c:
MOV RAX,qword ptr [RSP + 0x28]
LEA RCX,[RAX + 0x10]
MOV qword ptr [RSP + 0x28],RCX
LAB_0011309a:
MOV ESI,dword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x8]
CMP ESI,0x2
JC 0x001130c5
LEA ECX,[RSI + -0x2]
LEA RDX,[RAX + RCX*0x1]
INC RDX
LAB_001130af:
CMP byte ptr [RAX],0x0
JNZ 0x001130c5
DEC ESI
INC RAX
CMP ESI,0x1
JA 0x001130af
MOV ESI,0x1
JMP 0x001130c8
LAB_001130c5:
MOV RDX,RAX
LAB_001130c8:
MOV R12D,dword ptr [RBX]
MOV RDI,RBX
XOR ECX,ECX
XOR R8D,R8D
CALL 0x001129fe
MOV RAX,qword ptr [RBX + 0x8]
CMP byte ptr [RAX + R12*0x1],0x30
JNZ 0x001131f4
MOV ESI,dword ptr [RBX]
DEC ESI
MOV RDI,RBX
CALL 0x001125e5
LEA EAX,[R12 + 0x1]
MOV EDX,dword ptr [RBX]
SUB EDX,EAX
JZ 0x00113116
MOV RCX,qword ptr [RBX + 0x8]
LEA RDI,[RCX + R12*0x1]
MOV ESI,EAX
ADD RSI,RCX
CALL 0x001050a0
MOV R12D,dword ptr [RBX]
DEC R12D
LAB_00113116:
MOV dword ptr [RBX],R12D
MOV RAX,qword ptr [RBX + 0x8]
MOV ECX,R12D
MOV byte ptr [RAX + RCX*0x1],0x0
JMP 0x001131f4
LAB_00113129:
MOV RCX,qword ptr [RSP + 0x28]
LEA RDX,[RCX + 0x8]
MOV qword ptr [RSP + 0x28],RDX
LAB_00113137:
MOV RDX,qword ptr [RCX]
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOV dword ptr [RSP + 0x50],0x0
CMP byte ptr [R14 + 0x2],0x78
LEA RSI,[0x13ed63]
LEA RCX,[0x13f00a]
CMOVZ RSI,RCX
CMOVZ R14,RAX
MOV RDI,R15
XOR EAX,EAX
CALL 0x00105310
JMP 0x001131b6
LAB_00113171:
MOV RCX,qword ptr [RSP + 0x28]
LEA RDX,[RCX + 0x8]
MOV qword ptr [RSP + 0x28],RDX
LAB_0011317f:
MOV EDX,dword ptr [RCX]
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOV dword ptr [RSP + 0x50],0x0
CMP byte ptr [R14 + 0x2],0x78
LEA RSI,[0x13f31a]
LEA RCX,[0x13f36e]
CMOVZ RSI,RCX
CMOVZ R14,RAX
MOV RDI,R15
XOR EAX,EAX
CALL 0x00105310
LAB_001131b6:
MOV RDI,R15
CALL 0x00105140
LEA ESI,[RAX + 0x1]
MOV RDI,RBX
MOV RDX,R15
CALL 0x00112651
DEC dword ptr [RBX]
JMP 0x001131f4
LAB_001131d0:
MOV RAX,qword ptr [RSP + 0x28]
LEA RCX,[RAX + 0x8]
MOV qword ptr [RSP + 0x28],RCX
LAB_001131de:
MOV AL,byte ptr [RAX]
MOV byte ptr [RSP + 0x40],AL
MOV RDI,RBX
MOV ESI,0x1
MOV RDX,R15
LAB_001131ef:
CALL 0x00112651
caseD_65:
LEA RDX,[R14 + 0x2]
CMP byte ptr [R14 + 0x2],0x0
JZ 0x0011320f
INC R14
LAB_00113202:
INC R14
JMP 0x00112e6c
LAB_0011320a:
CMP RDX,R14
JZ 0x00113230
LAB_0011320f:
MOV RDI,RBX
MOV RSI,RDX
CALL 0x001129cf
LAB_0011321a:
MOV RAX,qword ptr [RBX + 0x8]
ADD RSP,0x138
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00113230:
MOV RDI,RBX
MOV ESI,0x1
XOR EDX,EDX
CALL 0x00112651
TEST EAX,EAX
JZ 0x0011321a
DEC dword ptr [RBX]
JMP 0x0011321a
|
int8
bprintf(int4 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,uint *param_9,
char *param_10,int8 param_11,int8 param_12,int8 param_13,
int8 param_14)
{
byte bVar1;
char in_AL;
uint uVar2;
int iVar3;
void *__ptr;
size_t sVar4;
uint *puVar5;
ulong uVar6;
uint uVar7;
char *pcVar8;
uint uVar9;
int8 uVar10;
char *pcVar11;
char *pcVar12;
uint *local_140;
char local_128 [32];
uint local_108 [8];
uint local_e8 [4];
int8 local_d8;
int8 local_d0;
int8 local_c8;
int8 local_c0;
int4 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
local_d8 = param_11;
local_d0 = param_12;
local_c8 = param_13;
local_c0 = param_14;
if (in_AL != '\0') {
local_b8 = param_1;
local_a8 = param_2;
local_98 = param_3;
local_88 = param_4;
local_78 = param_5;
local_68 = param_6;
local_58 = param_7;
local_48 = param_8;
}
local_108[0] = 0;
local_108[1] = 0;
local_108[2] = 0;
local_108[3] = 0;
local_108[4] = 0;
local_108[5] = 0;
if (param_9 == (uint *)0x0) {
param_9 = local_108;
}
local_140 = (uint *)&stack0x00000008;
uVar7 = 0x10;
pcVar12 = param_10;
while( true ) {
if (*pcVar12 != '%') break;
if (pcVar12 != param_10) {
buffer_append(param_9,(int)pcVar12 - (int)param_10);
}
bVar1 = pcVar12[1];
if (0x72 < bVar1) {
switch(bVar1) {
case 0x73:
uVar6 = (ulong)uVar7;
if (uVar6 < 0x29) {
uVar7 = uVar7 + 8;
puVar5 = (uint *)((long)local_e8 + uVar6);
}
else {
puVar5 = local_140;
local_140 = local_140 + 2;
}
buffer_add_chars(param_9,*(int8 *)puVar5);
break;
case 0x75:
uVar6 = (ulong)uVar7;
if (uVar6 < 0x21) {
uVar7 = uVar7 + 0x10;
puVar5 = (uint *)((long)local_e8 + uVar6);
}
else {
puVar5 = local_140;
local_140 = local_140 + 4;
}
uVar9 = *puVar5;
pcVar11 = *(char **)(puVar5 + 2);
if (1 < uVar9) {
pcVar8 = pcVar11 + (ulong)(uVar9 - 2) + 1;
do {
if (*pcVar11 != '\0') goto LAB_001130c8;
uVar9 = uVar9 - 1;
pcVar11 = pcVar11 + 1;
} while (1 < uVar9);
uVar9 = 1;
pcVar11 = pcVar8;
}
LAB_001130c8:
uVar2 = *param_9;
uVar6 = (ulong)uVar2;
buffer_add_hex_chars(param_9,uVar9,pcVar11,0,0);
if (*(char *)(*(long *)(param_9 + 2) + uVar6) == '0') {
buffer_grow(param_9,*param_9 - 1);
uVar2 = uVar2 + 1;
uVar9 = *param_9 - uVar2;
if (uVar9 != 0) {
memmove((void *)(*(long *)(param_9 + 2) + uVar6),
(void *)((ulong)uVar2 + *(long *)(param_9 + 2)),(ulong)uVar9);
uVar6 = (ulong)(*param_9 - 1);
}
*param_9 = (uint)uVar6;
*(int1 *)(*(long *)(param_9 + 2) + uVar6) = 0;
}
break;
case 0x78:
switchD_00112eb2_caseD_62:
uVar6 = (ulong)uVar7;
if (uVar6 < 0x21) {
uVar7 = uVar7 + 0x10;
puVar5 = (uint *)((long)local_e8 + uVar6);
}
else {
puVar5 = local_140;
local_140 = local_140 + 4;
}
buffer_add_hex_chars(param_9,*puVar5,*(int8 *)(puVar5 + 2),0,0);
break;
case 0x7a:
uVar10 = 0;
LAB_00112f84:
local_140 = local_140 + 6;
__ptr = (void *)ssz_dump_to_str(0,uVar10);
buffer_add_chars(param_9);
free(__ptr);
}
goto switchD_00112eb2_caseD_65;
}
if (10 < bVar1 - 0x62) {
if (bVar1 == 0x4a) {
pcVar11 = *(char **)local_140;
uVar9 = local_140[2];
goto LAB_00113066;
}
if (bVar1 == 0x5a) {
uVar10 = 1;
goto LAB_00112f84;
}
goto switchD_00112eb2_caseD_65;
}
switch((uint)bVar1) {
case 0x62:
goto switchD_00112eb2_caseD_62;
case 99:
uVar6 = (ulong)uVar7;
if (uVar6 < 0x29) {
uVar7 = uVar7 + 8;
puVar5 = (uint *)((long)local_e8 + uVar6);
}
else {
puVar5 = local_140;
local_140 = local_140 + 2;
}
local_128[0] = (char)*puVar5;
uVar9 = 1;
pcVar11 = local_128;
break;
case 100:
uVar6 = (ulong)uVar7;
if (uVar6 < 0x29) {
uVar7 = uVar7 + 8;
puVar5 = (uint *)((long)local_e8 + uVar6);
}
else {
puVar5 = local_140;
local_140 = local_140 + 2;
}
local_128[0] = '\0';
local_128[1] = '\0';
local_128[2] = '\0';
local_128[3] = '\0';
local_128[4] = '\0';
local_128[5] = '\0';
local_128[6] = '\0';
local_128[7] = '\0';
local_128[8] = '\0';
local_128[9] = '\0';
local_128[10] = '\0';
local_128[0xb] = '\0';
local_128[0xc] = '\0';
local_128[0xd] = '\0';
local_128[0xe] = '\0';
local_128[0xf] = '\0';
local_128[0x10] = '\0';
local_128[0x11] = '\0';
local_128[0x12] = '\0';
local_128[0x13] = '\0';
pcVar11 = "%u";
if (pcVar12[2] == 'x') {
pcVar11 = "%x";
pcVar12 = pcVar12 + 1;
}
sprintf(local_128,pcVar11,(ulong)*puVar5);
goto LAB_001131b6;
default:
goto switchD_00112eb2_caseD_65;
case 0x6a:
pcVar11 = *(char **)local_140;
uVar9 = local_140[2];
if (local_140[4] == 1) {
uVar9 = uVar9 - 2;
pcVar11 = pcVar11 + 1;
}
LAB_00113066:
local_140 = local_140 + 6;
break;
case 0x6c:
uVar6 = (ulong)uVar7;
if (uVar6 < 0x29) {
uVar7 = uVar7 + 8;
puVar5 = (uint *)((long)local_e8 + uVar6);
}
else {
puVar5 = local_140;
local_140 = local_140 + 2;
}
local_128[0] = '\0';
local_128[1] = '\0';
local_128[2] = '\0';
local_128[3] = '\0';
local_128[4] = '\0';
local_128[5] = '\0';
local_128[6] = '\0';
local_128[7] = '\0';
local_128[8] = '\0';
local_128[9] = '\0';
local_128[10] = '\0';
local_128[0xb] = '\0';
local_128[0xc] = '\0';
local_128[0xd] = '\0';
local_128[0xe] = '\0';
local_128[0xf] = '\0';
local_128[0x10] = '\0';
local_128[0x11] = '\0';
local_128[0x12] = '\0';
local_128[0x13] = '\0';
pcVar11 = "%lu";
if (pcVar12[2] == 'x') {
pcVar11 = "%lx";
pcVar12 = pcVar12 + 1;
}
sprintf(local_128,pcVar11,*(int8 *)puVar5);
LAB_001131b6:
sVar4 = strlen(local_128);
buffer_append(param_9,(int)sVar4 + 1,local_128);
*param_9 = *param_9 - 1;
goto switchD_00112eb2_caseD_65;
}
buffer_append(param_9,uVar9,pcVar11);
switchD_00112eb2_caseD_65:
param_10 = pcVar12 + 2;
if (pcVar12[2] == '\0') goto LAB_0011320f;
pcVar12 = pcVar12 + 1;
LAB_00113202:
pcVar12 = pcVar12 + 1;
}
if (*pcVar12 != '\0') goto LAB_00113202;
if (param_10 == pcVar12) {
iVar3 = buffer_append(param_9,1,0);
if (iVar3 != 0) {
*param_9 = *param_9 - 1;
}
}
else {
LAB_0011320f:
buffer_add_chars(param_9,param_10);
}
return *(int8 *)(param_9 + 2);
}
|
|
66,085 |
SchemaConverter::_add_primitive(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, BuiltinRule const&)
|
monkey531[P]llama/common/json-schema-to-grammar.cpp
|
std::string _add_primitive(const std::string & name, const BuiltinRule & rule) {
auto n = _add_rule(name, rule.content);
for (const auto & dep : rule.deps) {
BuiltinRule dep_rule;
auto it = PRIMITIVE_RULES.find(dep);
if (it == PRIMITIVE_RULES.end()) {
it = STRING_FORMAT_RULES.find(dep);
if (it == STRING_FORMAT_RULES.end()) {
_errors.push_back("Rule " + dep + " not known");
continue;
}
}
if (_rules.find(dep) == _rules.end()) {
_add_primitive(dep, it->second);
}
}
return n;
}
|
O0
|
cpp
|
SchemaConverter::_add_primitive(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, BuiltinRule const&):
subq $0x168, %rsp # imm = 0x168
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x160(%rsp)
movq %rsi, 0x158(%rsp)
movq %rdx, 0x150(%rsp)
movq %rcx, 0x148(%rsp)
movq 0x158(%rsp), %rsi
movq %rsi, 0x38(%rsp)
movb $0x0, 0x147(%rsp)
movq 0x150(%rsp), %rdx
movq 0x148(%rsp), %rcx
callq 0x19f520
movq 0x148(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x138(%rsp)
movq 0x138(%rsp), %rdi
callq 0x8c350
movq %rax, 0x130(%rsp)
movq 0x138(%rsp), %rdi
callq 0x8c380
movq %rax, 0x128(%rsp)
leaq 0x130(%rsp), %rdi
leaq 0x128(%rsp), %rsi
callq 0x8c2b0
testb $0x1, %al
jne 0x1a595a
jmp 0x1a5bfb
leaq 0x130(%rsp), %rdi
callq 0x8cd10
movq %rax, 0x120(%rsp)
leaq 0xe8(%rsp), %rdi
callq 0x1b2eb0
movq 0x120(%rsp), %rsi
leaq 0x92b4d(%rip), %rdi # 0x2384d8
callq 0x1a5c90
movq %rax, 0x20(%rsp)
jmp 0x1a5997
movq 0x20(%rsp), %rax
movq %rax, 0xe0(%rsp)
leaq 0x92b2d(%rip), %rdi # 0x2384d8
callq 0x1a5cc0
movq %rax, 0xc8(%rsp)
leaq 0xe0(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x1a5d80
testb $0x1, %al
jne 0x1a59d6
jmp 0x1a5b1f
movq 0x120(%rsp), %rsi
leaq 0x92b2b(%rip), %rdi # 0x238510
callq 0x1a5c90
movq %rax, 0x18(%rsp)
jmp 0x1a59f1
movq 0x18(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0xe0(%rsp)
leaq 0x92afb(%rip), %rdi # 0x238510
callq 0x1a5cc0
movq %rax, 0xb8(%rsp)
leaq 0xe0(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x1a5d80
testb $0x1, %al
jne 0x1a5a40
jmp 0x1a5b1d
movq 0x38(%rsp), %rax
addq $0xc8, %rax
movq %rax, 0x10(%rsp)
movq 0x120(%rsp), %rdx
leaq 0x1cb90(%rip), %rsi # 0x1c25ef
leaq 0x78(%rsp), %rdi
callq 0x64380
jmp 0x1a5a6b
leaq 0x1cb83(%rip), %rdx # 0x1c25f5
leaq 0x98(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x63410
jmp 0x1a5a86
movq 0x10(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x63a20
jmp 0x1a5a9a
leaq 0x98(%rsp), %rdi
callq 0x510d0
leaq 0x78(%rsp), %rdi
callq 0x510d0
movl $0x3, 0x74(%rsp)
jmp 0x1a5bb5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd8(%rsp)
movl %eax, 0xd4(%rsp)
jmp 0x1a5be2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd8(%rsp)
movl %eax, 0xd4(%rsp)
jmp 0x1a5b0e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd8(%rsp)
movl %eax, 0xd4(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x510d0
leaq 0x78(%rsp), %rdi
callq 0x510d0
jmp 0x1a5be2
jmp 0x1a5b1f
movq 0x38(%rsp), %rdi
addq $0x28, %rdi
movq 0x120(%rsp), %rsi
callq 0x19fa30
movq %rax, 0x8(%rsp)
jmp 0x1a5b3c
movq 0x38(%rsp), %rdi
movq 0x8(%rsp), %rax
movq %rax, 0x68(%rsp)
addq $0x28, %rdi
callq 0x19a3c0
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x19a3a0
testb $0x1, %al
jne 0x1a5b6e
jmp 0x1a5bad
movq 0x120(%rsp), %rax
movq %rax, (%rsp)
leaq 0xe0(%rsp), %rdi
callq 0x1b2ee0
movq 0x38(%rsp), %rsi
movq (%rsp), %rdx
movq %rax, %rcx
addq $0x20, %rcx
leaq 0x40(%rsp), %rdi
callq 0x1a58a0
jmp 0x1a5ba3
leaq 0x40(%rsp), %rdi
callq 0x510d0
movl $0x0, 0x74(%rsp)
leaq 0xe8(%rsp), %rdi
callq 0x1986b0
movl 0x74(%rsp), %eax
testl %eax, %eax
je 0x1a5bce
jmp 0x1a5bcc
jmp 0x1a5bd0
jmp 0x1a5bd0
leaq 0x130(%rsp), %rdi
callq 0x8ccf0
jmp 0x1a593c
leaq 0xe8(%rsp), %rdi
callq 0x1986b0
movq 0x28(%rsp), %rdi
callq 0x510d0
jmp 0x1a5c2c
movb $0x1, 0x147(%rsp)
movl $0x1, 0x74(%rsp)
testb $0x1, 0x147(%rsp)
jne 0x1a5c1f
movq 0x28(%rsp), %rdi
callq 0x510d0
movq 0x30(%rsp), %rax
addq $0x168, %rsp # imm = 0x168
retq
movq 0xd8(%rsp), %rdi
callq 0x50940
nopl (%rax)
|
_ZN15SchemaConverter14_add_primitiveERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERK11BuiltinRule:
sub rsp, 168h
mov [rsp+168h+var_140], rdi; int
mov rax, rdi
mov [rsp+168h+var_138], rax; int
mov qword ptr [rsp+168h+var_8], rdi; char
mov qword ptr [rsp+168h+var_10], rsi; int
mov [rsp+168h+var_18], rdx; __int64
mov qword ptr [rsp+168h+var_20], rcx; int
mov rsi, qword ptr [rsp+168h+var_10]; int
mov qword ptr [rsp+168h+var_130], rsi; int
mov [rsp+168h+var_21], 0
mov rdx, [rsp+168h+var_18]; int
mov rcx, qword ptr [rsp+168h+var_20]; int
call _ZN15SchemaConverter9_add_ruleERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES7_; SchemaConverter::_add_rule(std::string const&,std::string const&)
mov rax, qword ptr [rsp+168h+var_20]
add rax, 20h ; ' '
mov qword ptr [rsp+168h+var_30], rax; int
mov rdi, qword ptr [rsp+168h+var_30]
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE5beginEv; std::vector<std::string>::begin(void)
mov qword ptr [rsp+168h+var_38], rax; int
mov rdi, qword ptr [rsp+168h+var_30]
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE3endEv; std::vector<std::string>::end(void)
mov qword ptr [rsp+168h+var_40], rax; int
loc_1A593C:
lea rdi, [rsp+168h+var_38]
lea rsi, [rsp+168h+var_40]
call _ZN9__gnu_cxxneIPKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEEbRKNS_17__normal_iteratorIT_T0_EESH_; __gnu_cxx::operator!=<std::string const*,std::vector<std::string>>(__gnu_cxx::__normal_iterator<std::string const*,std::vector<std::string>> const&,__gnu_cxx::__normal_iterator<std::string const*,std::vector<std::string>> const&)
test al, 1
jnz short loc_1A595A
jmp loc_1A5BFB
loc_1A595A:
lea rdi, [rsp+168h+var_38]
call _ZNK9__gnu_cxx17__normal_iteratorIPKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEdeEv; __gnu_cxx::__normal_iterator<std::string const*,std::vector<std::string>>::operator*(void)
mov qword ptr [rsp+168h+var_48], rax; int
lea rdi, [rsp+168h+var_80]; this
call _ZN11BuiltinRuleC2Ev; BuiltinRule::BuiltinRule(void)
mov rsi, qword ptr [rsp+168h+var_48]
lea rdi, _Z15PRIMITIVE_RULESB5cxx11; PRIMITIVE_RULES
call _ZNSt13unordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE11BuiltinRuleSt4hashIS5_ESt8equal_toIS5_ESaISt4pairIKS5_S6_EEE4findERSC_; std::unordered_map<std::string,BuiltinRule>::find(std::string const&)
mov [rsp+168h+var_148], rax; void *
jmp short $+2
loc_1A5997:
mov rax, [rsp+168h+var_148]
mov qword ptr [rsp+168h+var_88], rax; char
lea rdi, _Z15PRIMITIVE_RULESB5cxx11; PRIMITIVE_RULES
call _ZNSt13unordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE11BuiltinRuleSt4hashIS5_ESt8equal_toIS5_ESaISt4pairIKS5_S6_EEE3endEv; std::unordered_map<std::string,BuiltinRule>::end(void)
mov qword ptr [rsp+168h+var_A0], rax; int
lea rdi, [rsp+168h+var_88]
lea rsi, [rsp+168h+var_A0]
call _ZNSt8__detaileqERKNS_19_Node_iterator_baseISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE11BuiltinRuleELb1EEESD_; std::__detail::operator==(std::__detail::_Node_iterator_base<std::pair<std::string const,BuiltinRule>,true> const&,std::__detail::_Node_iterator_base<std::pair<std::string const,BuiltinRule>,true> const&)
test al, 1
jnz short loc_1A59D6
jmp loc_1A5B1F
loc_1A59D6:
mov rsi, qword ptr [rsp+168h+var_48]
lea rdi, _Z19STRING_FORMAT_RULESB5cxx11; STRING_FORMAT_RULES
call _ZNSt13unordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE11BuiltinRuleSt4hashIS5_ESt8equal_toIS5_ESaISt4pairIKS5_S6_EEE4findERSC_; std::unordered_map<std::string,BuiltinRule>::find(std::string const&)
mov qword ptr [rsp+168h+var_150], rax; int
jmp short $+2
loc_1A59F1:
mov rax, qword ptr [rsp+168h+var_150]
mov [rsp+168h+var_A8], rax
mov rax, [rsp+168h+var_A8]
mov qword ptr [rsp+168h+var_88], rax
lea rdi, _Z19STRING_FORMAT_RULESB5cxx11; STRING_FORMAT_RULES
call _ZNSt13unordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE11BuiltinRuleSt4hashIS5_ESt8equal_toIS5_ESaISt4pairIKS5_S6_EEE3endEv; std::unordered_map<std::string,BuiltinRule>::end(void)
mov [rsp+168h+var_B0], rax
lea rdi, [rsp+168h+var_88]
lea rsi, [rsp+168h+var_B0]
call _ZNSt8__detaileqERKNS_19_Node_iterator_baseISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE11BuiltinRuleELb1EEESD_; std::__detail::operator==(std::__detail::_Node_iterator_base<std::pair<std::string const,BuiltinRule>,true> const&,std::__detail::_Node_iterator_base<std::pair<std::string const,BuiltinRule>,true> const&)
test al, 1
jnz short loc_1A5A40
jmp loc_1A5B1D
loc_1A5A40:
mov rax, qword ptr [rsp+168h+var_130]
add rax, 0C8h
mov [rsp+168h+var_158], rax; void *
mov rdx, qword ptr [rsp+168h+var_48]; int
lea rsi, aRule; "Rule "
lea rdi, [rsp+168h+var_F0]; int
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
jmp short $+2
loc_1A5A6B:
lea rdx, aNotKnown; " not known"
lea rdi, [rsp+168h+var_D0]
lea rsi, [rsp+168h+var_F0]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
jmp short $+2
loc_1A5A86:
mov rdi, [rsp+168h+var_158]
lea rsi, [rsp+168h+var_D0]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE9push_backEOS5_; std::vector<std::string>::push_back(std::string&&)
jmp short $+2
loc_1A5A9A:
lea rdi, [rsp+168h+var_D0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+168h+var_F0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov [rsp+168h+var_F4], 3
jmp loc_1A5BB5
mov rcx, rax
mov eax, edx
mov [rsp+arg_D0], rcx
mov [rsp+arg_CC], eax
jmp loc_1A5BE2
mov rcx, rax
mov eax, edx
mov [rsp+arg_D0], rcx
mov [rsp+arg_CC], eax
jmp short loc_1A5B0E
mov rcx, rax
mov eax, edx
mov [rsp+arg_D0], rcx
mov [rsp+arg_CC], eax
lea rdi, [rsp+arg_90]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_1A5B0E:
lea rdi, [rsp+arg_70]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp loc_1A5BE2
loc_1A5B1D:
jmp short $+2
loc_1A5B1F:
mov rdi, qword ptr [rsp+168h+var_130]
add rdi, 28h ; '('
mov rsi, qword ptr [rsp+168h+var_48]
call _ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_St4lessIS5_ESaISt4pairIKS5_S5_EEE4findERS9_; std::map<std::string,std::string>::find(std::string const&)
mov qword ptr [rsp+168h+var_160], rax; int
jmp short $+2
loc_1A5B3C:
mov rdi, qword ptr [rsp+168h+var_130]
mov rax, qword ptr [rsp+168h+var_160]
mov qword ptr [rsp+168h+var_100], rax; int
add rdi, 28h ; '('
call _ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_St4lessIS5_ESaISt4pairIKS5_S5_EEE3endEv; std::map<std::string,std::string>::end(void)
mov qword ptr [rsp+168h+var_108], rax; int
lea rdi, [rsp+168h+var_100]
lea rsi, [rsp+168h+var_108]
call _ZSteqRKSt17_Rb_tree_iteratorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_EESB_; std::operator==(std::_Rb_tree_iterator<std::pair<std::string const,std::string>> const&,std::_Rb_tree_iterator<std::pair<std::string const,std::string>> const&)
test al, 1
jnz short loc_1A5B6E
jmp short loc_1A5BAD
loc_1A5B6E:
mov rax, qword ptr [rsp+168h+var_48]
mov [rsp+168h+var_168], rax; int
lea rdi, [rsp+168h+var_88]
call _ZNKSt8__detail14_Node_iteratorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE11BuiltinRuleELb0ELb1EEptEv; std::__detail::_Node_iterator<std::pair<std::string const,BuiltinRule>,false,true>::operator->(void)
mov rsi, qword ptr [rsp+168h+var_130]; int
mov rdx, [rsp+168h+var_168]; int
mov rcx, rax
add rcx, 20h ; ' '; int
lea rdi, [rsp+168h+var_128]; int
call _ZN15SchemaConverter14_add_primitiveERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERK11BuiltinRule; SchemaConverter::_add_primitive(std::string const&,BuiltinRule const&)
jmp short $+2
loc_1A5BA3:
lea rdi, [rsp+168h+var_128]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_1A5BAD:
mov [rsp+168h+var_F4], 0
loc_1A5BB5:
lea rdi, [rsp+168h+var_80]; this
call _ZN11BuiltinRuleD2Ev; BuiltinRule::~BuiltinRule()
mov eax, [rsp+168h+var_F4]
test eax, eax
jz short loc_1A5BCE
jmp short $+2
loc_1A5BCC:
jmp short loc_1A5BD0
loc_1A5BCE:
jmp short $+2
loc_1A5BD0:
lea rdi, [rsp+168h+var_38]
call _ZN9__gnu_cxx17__normal_iteratorIPKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEppEv; __gnu_cxx::__normal_iterator<std::string const*,std::vector<std::string>>::operator++(void)
jmp loc_1A593C
loc_1A5BE2:
lea rdi, [rsp+arg_E0]; this
call _ZN11BuiltinRuleD2Ev; BuiltinRule::~BuiltinRule()
mov rdi, [rsp+arg_20]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_1A5C2C
loc_1A5BFB:
mov [rsp+168h+var_21], 1
mov [rsp+168h+var_F4], 1
test [rsp+168h+var_21], 1
jnz short loc_1A5C1F
mov rdi, [rsp+168h+var_140]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_1A5C1F:
mov rax, [rsp+168h+var_138]
add rsp, 168h
retn
loc_1A5C2C:
mov rdi, [rsp+arg_D0]
call __Unwind_Resume
|
long long SchemaConverter::_add_primitive(long long a1, long long a2, long long a3, long long a4)
{
int v4; // eax
int v5; // r8d
int v6; // r9d
int v8; // [rsp+0h] [rbp-168h]
long long v9; // [rsp+8h] [rbp-160h]
int v10; // [rsp+10h] [rbp-158h]
int v11[2]; // [rsp+18h] [rbp-150h]
void *v12; // [rsp+20h] [rbp-148h]
int v13; // [rsp+28h] [rbp-140h]
long long v14; // [rsp+30h] [rbp-138h]
int v15[2]; // [rsp+38h] [rbp-130h]
char v16[8]; // [rsp+40h] [rbp-128h] BYREF
int v17; // [rsp+48h] [rbp-120h]
int v18; // [rsp+50h] [rbp-118h]
int v19; // [rsp+58h] [rbp-110h]
int v20[2]; // [rsp+60h] [rbp-108h] BYREF
int v21[2]; // [rsp+68h] [rbp-100h] BYREF
char v22; // [rsp+70h] [rbp-F8h]
int v23; // [rsp+74h] [rbp-F4h]
int v24[6]; // [rsp+78h] [rbp-F0h] BYREF
char v25; // [rsp+90h] [rbp-D8h]
int v26[8]; // [rsp+98h] [rbp-D0h] BYREF
long long v27; // [rsp+B8h] [rbp-B0h] BYREF
long long v28; // [rsp+C0h] [rbp-A8h]
char v29[8]; // [rsp+C8h] [rbp-A0h] BYREF
long long v30; // [rsp+D0h] [rbp-98h]
int v31; // [rsp+D8h] [rbp-90h]
char v32[8]; // [rsp+E0h] [rbp-88h] BYREF
_BYTE v33[56]; // [rsp+E8h] [rbp-80h] BYREF
int v34[2]; // [rsp+120h] [rbp-48h]
int v35[2]; // [rsp+128h] [rbp-40h] BYREF
int v36[2]; // [rsp+130h] [rbp-38h] BYREF
int v37[2]; // [rsp+138h] [rbp-30h]
char v38; // [rsp+147h] [rbp-21h]
int v39[2]; // [rsp+148h] [rbp-20h]
long long v40; // [rsp+150h] [rbp-18h]
int v41[2]; // [rsp+158h] [rbp-10h]
char v42[8]; // [rsp+160h] [rbp-8h]
v13 = a1;
v14 = a1;
*(_QWORD *)v42 = a1;
*(_QWORD *)v41 = a2;
v40 = a3;
*(_QWORD *)v39 = a4;
*(_QWORD *)v15 = a2;
v38 = 0;
SchemaConverter::_add_rule(a1, a2, a3, a4);
*(_QWORD *)v37 = *(_QWORD *)v39 + 32LL;
*(_QWORD *)v36 = std::vector<std::string>::begin(*(_QWORD *)v39 + 32LL);
*(_QWORD *)v35 = std::vector<std::string>::end(*(_QWORD *)v39 + 32LL);
while ( __gnu_cxx::operator!=<std::string const*,std::vector<std::string>>((long long)v36, (long long)v35) )
{
*(_QWORD *)v34 = __gnu_cxx::__normal_iterator<std::string const*,std::vector<std::string>>::operator*((long long)v36);
BuiltinRule::BuiltinRule((BuiltinRule *)v33);
v12 = (void *)std::unordered_map<std::string,BuiltinRule>::find(&PRIMITIVE_RULES[abi:cxx11], *(_QWORD *)v34);
*(_QWORD *)v32 = v12;
*(_QWORD *)v29 = std::unordered_map<std::string,BuiltinRule>::end(&PRIMITIVE_RULES[abi:cxx11]);
if ( (std::__detail::operator==(v32, v29) & 1) != 0
&& (*(_QWORD *)v11 = std::unordered_map<std::string,BuiltinRule>::find(
&STRING_FORMAT_RULES[abi:cxx11],
*(_QWORD *)v34),
v28 = *(_QWORD *)v11,
*(_QWORD *)v32 = *(_QWORD *)v11,
v27 = std::unordered_map<std::string,BuiltinRule>::end(&STRING_FORMAT_RULES[abi:cxx11]),
(std::__detail::operator==(v32, &v27) & 1) != 0) )
{
v10 = v15[0] + 200;
std::operator+<char>((long long)v24, (long long)"Rule ", *(long long *)v34);
std::operator+<char>((long long)v26, (long long)v24, (long long)" not known");
std::vector<std::string>::push_back(*(_QWORD *)v15 + 200LL, (long long)v26);
std::string::~string(v26);
std::string::~string(v24);
v23 = 3;
}
else
{
v9 = std::map<std::string,std::string>::find(*(_QWORD *)v15 + 40LL, *(long long *)v34);
*(_QWORD *)v21 = v9;
*(_QWORD *)v20 = std::map<std::string,std::string>::end(*(_QWORD *)v15 + 40LL);
if ( std::operator==(v21, v20) )
{
v8 = v34[0];
v4 = std::__detail::_Node_iterator<std::pair<std::string const,BuiltinRule>,false,true>::operator->(v32);
SchemaConverter::_add_primitive(
(int)v16,
v15[0],
v8,
v4 + 32,
v5,
v6,
v8,
v9,
v10,
v11[0],
v12,
v13,
v14,
v15[0],
*(int *)v16,
v17,
v18,
v19,
v20[0],
v21[0],
v22,
v24[0],
v24[2],
v24[4],
v25,
v26[0],
v26[2],
v26[4],
v26[6],
v27,
v28,
*(int *)v29,
v30,
v31,
v32[0]);
std::string::~string(v16);
}
v23 = 0;
}
BuiltinRule::~BuiltinRule((BuiltinRule *)v33);
__gnu_cxx::__normal_iterator<std::string const*,std::vector<std::string>>::operator++(v36);
}
return v14;
}
| |||
66,086 |
SchemaConverter::_add_primitive(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, BuiltinRule const&)
|
monkey531[P]llama/common/json-schema-to-grammar.cpp
|
std::string _add_primitive(const std::string & name, const BuiltinRule & rule) {
auto n = _add_rule(name, rule.content);
for (const auto & dep : rule.deps) {
BuiltinRule dep_rule;
auto it = PRIMITIVE_RULES.find(dep);
if (it == PRIMITIVE_RULES.end()) {
it = STRING_FORMAT_RULES.find(dep);
if (it == STRING_FORMAT_RULES.end()) {
_errors.push_back("Rule " + dep + " not known");
continue;
}
}
if (_rules.find(dep) == _rules.end()) {
_add_primitive(dep, it->second);
}
}
return n;
}
|
O2
|
cpp
|
SchemaConverter::_add_primitive(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, BuiltinRule const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, (%rsp)
callq 0x83c28
movq 0x20(%r14), %r15
movq 0x28(%r14), %rax
movq %rax, 0x28(%rsp)
leaq 0x40(%rsp), %rbp
leaq 0x28(%rbx), %rax
movq %rax, 0x20(%rsp)
leaq 0x30(%rbx), %rax
movq %rax, 0x18(%rsp)
movq %rbx, 0x10(%rsp)
leaq 0xc8(%rbx), %rax
movq %rax, 0x8(%rsp)
leaq 0x88(%rsp), %r13
leaq 0xa8(%rsp), %r12
cmpq 0x28(%rsp), %r15
je 0x8706e
movq %rbp, 0x30(%rsp)
andq $0x0, 0x38(%rsp)
movb $0x0, 0x40(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbp)
andq $0x0, 0x20(%rbp)
leaq 0x4937f(%rip), %rdi # 0xd0338
movq %r15, %rsi
callq 0x8b05c
movq %rax, %rbx
testq %rax, %rax
jne 0x86fe0
leaq 0x493a0(%rip), %rdi # 0xd0370
movq %r15, %rsi
callq 0x8b05c
movq %rax, %rbx
testq %rax, %rax
je 0x87014
movq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x83f0e
cmpq 0x18(%rsp), %rax
jne 0x8705b
addq $0x28, %rbx
leaq 0x68(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x86f26
leaq 0x68(%rsp), %rdi
jmp 0x87056
movq %r13, %rbx
movq %r13, %rdi
leaq 0xfd3b(%rip), %rsi # 0x96d5c
movq %r15, %rdx
callq 0x28671
movq %r12, %r14
movq %r12, %rdi
movq %rbx, %rsi
leaq 0xfd29(%rip), %rdx # 0x96d62
callq 0x282ce
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x6d408
movq %r14, %rdi
callq 0x20d88
movq %rbx, %rdi
callq 0x20d88
leaq 0x30(%rsp), %rdi
callq 0x8219e
addq $0x20, %r15
jmp 0x86f8b
movq (%rsp), %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x20d88
jmp 0x87099
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x20d88
jmp 0x870b1
jmp 0x870ae
jmp 0x870ae
jmp 0x870ae
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x8219e
movq (%rsp), %rdi
callq 0x20d88
movq %rbx, %rdi
callq 0x20ba0
|
_ZN15SchemaConverter14_add_primitiveERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERK11BuiltinRule:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0C8h
mov r14, rcx
mov rbx, rsi
mov [rsp+0F8h+var_F8], rdi
call _ZN15SchemaConverter9_add_ruleERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES7_; SchemaConverter::_add_rule(std::string const&,std::string const&)
mov r15, [r14+20h]
mov rax, [r14+28h]
mov [rsp+0F8h+var_D0], rax
lea rbp, [rsp+0F8h+var_B8]
lea rax, [rbx+28h]
mov [rsp+0F8h+var_D8], rax
lea rax, [rbx+30h]
mov [rsp+0F8h+var_E0], rax
mov [rsp+0F8h+var_E8], rbx
lea rax, [rbx+0C8h]
mov [rsp+0F8h+var_F0], rax
lea r13, [rsp+0F8h+var_70]
lea r12, [rsp+0F8h+var_50]
loc_86F8B:
cmp r15, [rsp+0F8h+var_D0]
jz loc_8706E
mov [rsp+0F8h+var_C8], rbp
and [rsp+0F8h+var_C0], 0
mov [rsp+0F8h+var_B8], 0
xorps xmm0, xmm0
movups xmmword ptr [rbp+10h], xmm0
and qword ptr [rbp+20h], 0
lea rdi, _Z15PRIMITIVE_RULESB5cxx11; PRIMITIVE_RULES
mov rsi, r15
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_11BuiltinRuleESaIS9_ENSt8__detail10_Select1stESt8equal_toIS5_ESt4hashIS5_ENSB_18_Mod_range_hashingENSB_20_Default_ranged_hashENSB_20_Prime_rehash_policyENSB_17_Hashtable_traitsILb1ELb0ELb1EEEE4findERS7_; std::_Hashtable<std::string,std::pair<std::string const,BuiltinRule>,std::allocator<std::pair<std::string const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(std::string const&)
mov rbx, rax
test rax, rax
jnz short loc_86FE0
lea rdi, _Z19STRING_FORMAT_RULESB5cxx11; STRING_FORMAT_RULES
mov rsi, r15
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_11BuiltinRuleESaIS9_ENSt8__detail10_Select1stESt8equal_toIS5_ESt4hashIS5_ENSB_18_Mod_range_hashingENSB_20_Default_ranged_hashENSB_20_Prime_rehash_policyENSB_17_Hashtable_traitsILb1ELb0ELb1EEEE4findERS7_; std::_Hashtable<std::string,std::pair<std::string const,BuiltinRule>,std::allocator<std::pair<std::string const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(std::string const&)
mov rbx, rax
test rax, rax
jz short loc_87014
loc_86FE0:
mov rdi, [rsp+0F8h+var_D8]
mov rsi, r15
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_S5_ESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EE4findERS7_; std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::string>>>::find(std::string const&)
cmp rax, [rsp+0F8h+var_E0]
jnz short loc_8705B
add rbx, 28h ; '('
lea rdi, [rsp+0F8h+var_90]
mov rsi, [rsp+0F8h+var_E8]
mov rdx, r15
mov rcx, rbx
call _ZN15SchemaConverter14_add_primitiveERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERK11BuiltinRule; SchemaConverter::_add_primitive(std::string const&,BuiltinRule const&)
lea rdi, [rsp+0F8h+var_90]
jmp short loc_87056
loc_87014:
mov rbx, r13
mov rdi, r13
lea rsi, aRule; "Rule "
mov rdx, r15
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
mov r14, r12
mov rdi, r12
mov rsi, rbx
lea rdx, aNotKnown; " not known"
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
mov rdi, [rsp+0F8h+var_F0]
mov rsi, r14
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJS5_EEERS5_DpOT_; std::vector<std::string>::emplace_back<std::string>(std::string &&)
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx; void *
loc_87056:
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_8705B:
lea rdi, [rsp+0F8h+var_C8]; this
call _ZN11BuiltinRuleD2Ev; BuiltinRule::~BuiltinRule()
add r15, 20h ; ' '
jmp loc_86F8B
loc_8706E:
mov rax, [rsp+0F8h+var_F8]
add rsp, 0C8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rdi, [rsp+arg_A0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_87099
mov rbx, rax
loc_87099:
lea rdi, [rsp+arg_80]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_870B1
jmp short loc_870AE
jmp short loc_870AE
jmp short $+2
loc_870AE:
mov rbx, rax
loc_870B1:
lea rdi, [rsp+arg_28]; this
call _ZN11BuiltinRuleD2Ev; BuiltinRule::~BuiltinRule()
mov rdi, [rsp+0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __Unwind_Resume
|
long long SchemaConverter::_add_primitive(long long a1, long long a2, _QWORD *a3, _QWORD *a4)
{
long long v5; // r15
long long v6; // rax
int v7; // ebx
long long v8; // rax
int v9; // r8d
int v10; // r9d
_DWORD *v11; // rdi
long long v13; // [rsp+0h] [rbp-F8h]
long long v14; // [rsp+8h] [rbp-F0h]
int v15; // [rsp+10h] [rbp-E8h]
long long v16; // [rsp+18h] [rbp-E0h]
long long v17; // [rsp+20h] [rbp-D8h]
long long v18; // [rsp+28h] [rbp-D0h]
_DWORD *v19; // [rsp+30h] [rbp-C8h] BYREF
long long v20; // [rsp+38h] [rbp-C0h]
_DWORD v21[4]; // [rsp+40h] [rbp-B8h] BYREF
__int128 v22; // [rsp+50h] [rbp-A8h]
long long v23; // [rsp+60h] [rbp-98h]
_DWORD v24[6]; // [rsp+68h] [rbp-90h] BYREF
char v25; // [rsp+80h] [rbp-78h]
_DWORD v26[6]; // [rsp+88h] [rbp-70h] BYREF
char v27; // [rsp+A0h] [rbp-58h]
_BYTE v28[80]; // [rsp+A8h] [rbp-50h] BYREF
v13 = a1;
SchemaConverter::_add_rule(a1, a2, a3, a4);
v5 = a4[4];
v18 = a4[5];
v17 = a2 + 40;
v16 = a2 + 48;
v15 = a2;
v14 = a2 + 200;
while ( v5 != v18 )
{
v19 = v21;
v20 = 0LL;
LOBYTE(v21[0]) = 0;
v22 = 0LL;
v23 = 0LL;
v6 = std::_Hashtable<std::string,std::pair<std::string const,BuiltinRule>,std::allocator<std::pair<std::string const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(
&PRIMITIVE_RULES[abi:cxx11],
v5);
v7 = v6;
if ( v6
|| (v8 = std::_Hashtable<std::string,std::pair<std::string const,BuiltinRule>,std::allocator<std::pair<std::string const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(
&STRING_FORMAT_RULES[abi:cxx11],
v5),
v7 = v8,
v8) )
{
if ( std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::string>>>::find(
v17,
v5) != v16 )
goto LABEL_9;
SchemaConverter::_add_primitive(
(unsigned int)v24,
v15,
v5,
v7 + 40,
v9,
v10,
v13,
v14,
v15,
v16,
v17,
v18,
(_DWORD)v19,
v20,
v21[0],
v21[2],
v22,
DWORD2(v22),
v23,
v24[0],
v24[2],
v24[4],
v25,
v26[0],
v26[2],
v26[4],
v27);
v11 = v24;
}
else
{
std::operator+<char>((long long)v26, (long long)"Rule ", v5);
std::operator+<char>((long long)v28, (long long)v26, (long long)" not known");
std::vector<std::string>::emplace_back<std::string>(v14, (long long)v28);
std::string::~string(v28);
v11 = v26;
}
std::string::~string(v11);
LABEL_9:
BuiltinRule::~BuiltinRule((BuiltinRule *)&v19);
v5 += 32LL;
}
return v13;
}
|
_add_primitive:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xc8
MOV R14,RCX
MOV RBX,RSI
MOV qword ptr [RSP],RDI
CALL 0x00183c28
MOV R15,qword ptr [R14 + 0x20]
MOV RAX,qword ptr [R14 + 0x28]
MOV qword ptr [RSP + 0x28],RAX
LEA RBP,[RSP + 0x40]
LEA RAX,[RBX + 0x28]
MOV qword ptr [RSP + 0x20],RAX
LEA RAX,[RBX + 0x30]
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x10],RBX
LEA RAX,[RBX + 0xc8]
MOV qword ptr [RSP + 0x8],RAX
LEA R13,[RSP + 0x88]
LEA R12,[RSP + 0xa8]
LAB_00186f8b:
CMP R15,qword ptr [RSP + 0x28]
JZ 0x0018706e
MOV qword ptr [RSP + 0x30],RBP
AND qword ptr [RSP + 0x38],0x0
MOV byte ptr [RSP + 0x40],0x0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBP + 0x10],XMM0
AND qword ptr [RBP + 0x20],0x0
LAB_00186fb2:
LEA RDI,[0x1d0338]
MOV RSI,R15
CALL 0x0018b05c
MOV RBX,RAX
TEST RAX,RAX
JNZ 0x00186fe0
LAB_00186fc9:
LEA RDI,[0x1d0370]
MOV RSI,R15
CALL 0x0018b05c
MOV RBX,RAX
TEST RAX,RAX
JZ 0x00187014
LAB_00186fe0:
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,R15
CALL 0x00183f0e
CMP RAX,qword ptr [RSP + 0x18]
JNZ 0x0018705b
ADD RBX,0x28
LAB_00186ff8:
LEA RDI,[RSP + 0x68]
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,R15
MOV RCX,RBX
CALL 0x00186f26
LEA RDI,[RSP + 0x68]
JMP 0x00187056
LAB_00187014:
MOV RBX,R13
MOV RDI,R13
LEA RSI,[0x196d5c]
MOV RDX,R15
CALL 0x00128671
LAB_00187029:
MOV R14,R12
MOV RDI,R12
MOV RSI,RBX
LEA RDX,[0x196d62]
CALL 0x001282ce
LAB_0018703e:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,R14
CALL 0x0016d408
LAB_0018704b:
MOV RDI,R14
CALL 0x00120d88
MOV RDI,RBX
LAB_00187056:
CALL 0x00120d88
LAB_0018705b:
LEA RDI,[RSP + 0x30]
CALL 0x0018219e
ADD R15,0x20
JMP 0x00186f8b
LAB_0018706e:
MOV RAX,qword ptr [RSP]
ADD RSP,0xc8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* SchemaConverter::_add_primitive(std::__cxx11::string const&, BuiltinRule const&) */
string * SchemaConverter::_add_primitive(string *param_1,BuiltinRule *param_2)
{
string *psVar1;
long lVar2;
BuiltinRule *pBVar3;
long in_RCX;
string *this;
string *psVar4;
int1 *local_c8;
int8 local_c0;
int1 local_b8 [16];
int8 local_a8;
int8 uStack_a0;
int8 local_98;
string local_90 [32];
string local_70 [32];
string local_50 [32];
_add_rule(param_1,(string *)param_2);
psVar4 = *(string **)(in_RCX + 0x20);
psVar1 = *(string **)(in_RCX + 0x28);
do {
if (psVar4 == psVar1) {
return param_1;
}
local_c0 = 0;
local_b8[0] = 0;
local_a8 = 0;
uStack_a0 = 0;
local_98 = 0;
local_c8 = local_b8;
/* try { // try from 00186fb2 to 00186fc0 has its CatchHandler @ 001870ae */
lVar2 = std::
_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,BuiltinRule>,std::allocator<std::pair<std::__cxx11::string_const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
::find((_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,BuiltinRule>,std::allocator<std::pair<std::__cxx11::string_const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
*)PRIMITIVE_RULES_abi_cxx11_,psVar4);
if (lVar2 == 0) {
/* try { // try from 00186fc9 to 00186fd7 has its CatchHandler @ 001870aa */
lVar2 = std::
_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,BuiltinRule>,std::allocator<std::pair<std::__cxx11::string_const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
::find((_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,BuiltinRule>,std::allocator<std::pair<std::__cxx11::string_const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
*)STRING_FORMAT_RULES_abi_cxx11_,psVar4);
if (lVar2 != 0) goto LAB_00186fe0;
/* try { // try from 00187014 to 00187028 has its CatchHandler @ 001870a8 */
std::operator+((char *)local_70,(string *)"Rule ");
/* try { // try from 00187029 to 0018703d has its CatchHandler @ 00187096 */
std::operator+(local_50,(char *)local_70);
/* try { // try from 0018703e to 0018704a has its CatchHandler @ 00187084 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string>
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)
(param_2 + 200),local_50);
std::__cxx11::string::~string(local_50);
this = local_70;
LAB_00187056:
std::__cxx11::string::~string(this);
}
else {
LAB_00186fe0:
/* try { // try from 00186fe0 to 00186fec has its CatchHandler @ 001870ac */
pBVar3 = (BuiltinRule *)
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::_Select1st<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
::find((_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::_Select1st<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
*)(param_2 + 0x28),psVar4);
if (pBVar3 == param_2 + 0x30) {
/* try { // try from 00186ff8 to 0018700c has its CatchHandler @ 001870ae */
_add_primitive(local_90,param_2);
this = local_90;
goto LAB_00187056;
}
}
BuiltinRule::~BuiltinRule((BuiltinRule *)&local_c8);
psVar4 = psVar4 + 0x20;
} while( true );
}
|
|
66,087 |
js_create_map_iterator
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_create_map_iterator(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int magic)
{
JSIteratorKindEnum kind;
JSMapState *s;
JSMapIteratorData *it;
JSValue enum_obj;
kind = magic >> 2;
magic &= 3;
s = JS_GetOpaque2(ctx, this_val, JS_CLASS_MAP + magic);
if (!s)
return JS_EXCEPTION;
enum_obj = JS_NewObjectClass(ctx, JS_CLASS_MAP_ITERATOR + magic);
if (JS_IsException(enum_obj))
goto fail;
it = js_malloc(ctx, sizeof(*it));
if (!it) {
JS_FreeValue(ctx, enum_obj);
goto fail;
}
it->obj = js_dup(this_val);
it->kind = kind;
it->cur_record = NULL;
JS_SetOpaqueInternal(enum_obj, it);
return enum_obj;
fail:
return JS_EXCEPTION;
}
|
O0
|
c
|
js_create_map_iterator:
subq $0x88, %rsp
movq %rsi, 0x68(%rsp)
movq %rdx, 0x70(%rsp)
movq %rdi, 0x60(%rsp)
movl %ecx, 0x5c(%rsp)
movq %r8, 0x50(%rsp)
movl %r9d, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
sarl $0x2, %eax
movl %eax, 0x48(%rsp)
movl 0x4c(%rsp), %eax
andl $0x3, %eax
movl %eax, 0x4c(%rsp)
movq 0x60(%rsp), %rdi
movl 0x4c(%rsp), %ecx
addl $0x23, %ecx
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
callq 0x383b0
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x8ce3b
movl $0x0, 0x78(%rsp)
movq $0x6, 0x80(%rsp)
jmp 0x8cf4c
movq 0x60(%rsp), %rdi
movl 0x4c(%rsp), %esi
addl $0x2a, %esi
callq 0x2a480
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0x8ce83
jmp 0x8cf38
movq 0x60(%rsp), %rdi
movl $0x20, %esi
callq 0x21cb0
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x8ceb8
movq 0x60(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x23c90
jmp 0x8cf38
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x68(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x216d0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl 0x48(%rsp), %ecx
movq 0x38(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x38(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x38(%rsp), %rdx
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x2a9a0
movq 0x28(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x80(%rsp)
jmp 0x8cf4c
movl $0x0, 0x78(%rsp)
movq $0x6, 0x80(%rsp)
movq 0x78(%rsp), %rax
movq 0x80(%rsp), %rdx
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
|
js_create_map_iterator:
sub rsp, 88h
mov [rsp+88h+var_20], rsi
mov [rsp+88h+var_18], rdx
mov [rsp+88h+var_28], rdi
mov [rsp+88h+var_2C], ecx
mov [rsp+88h+var_38], r8
mov [rsp+88h+var_3C], r9d
mov eax, [rsp+88h+var_3C]
sar eax, 2
mov [rsp+88h+var_40], eax
mov eax, [rsp+88h+var_3C]
and eax, 3
mov [rsp+88h+var_3C], eax
mov rdi, [rsp+88h+var_28]
mov ecx, [rsp+88h+var_3C]
add ecx, 23h ; '#'
mov rsi, [rsp+88h+var_20]
mov rdx, [rsp+88h+var_18]
call JS_GetOpaque2
mov [rsp+88h+var_48], rax
cmp [rsp+88h+var_48], 0
jnz short loc_8CE3B
mov dword ptr [rsp+88h+var_10], 0
mov [rsp+88h+var_8], 6
jmp loc_8CF4C
loc_8CE3B:
mov rdi, [rsp+88h+var_28]
mov esi, [rsp+88h+var_3C]
add esi, 2Ah ; '*'
call JS_NewObjectClass
mov [rsp+88h+var_70], rax
mov [rsp+88h+var_68], rdx
mov rax, [rsp+88h+var_70]
mov [rsp+88h+var_60], rax
mov rax, [rsp+88h+var_68]
mov [rsp+88h+var_58], rax
mov rdi, [rsp+88h+var_60]
mov rsi, [rsp+88h+var_58]
call JS_IsException_1
cmp eax, 0
jz short loc_8CE83
jmp loc_8CF38
loc_8CE83:
mov rdi, [rsp+88h+var_28]
mov esi, 20h ; ' '
call js_malloc
mov [rsp+88h+var_50], rax
cmp [rsp+88h+var_50], 0
jnz short loc_8CEB8
mov rdi, [rsp+88h+var_28]
mov rsi, [rsp+88h+var_60]
mov rdx, [rsp+88h+var_58]
call JS_FreeValue
jmp loc_8CF38
loc_8CEB8:
mov rax, [rsp+88h+var_50]
mov [rsp+88h+var_88], rax
mov rdi, [rsp+88h+var_20]
mov rsi, [rsp+88h+var_18]
call js_dup
mov rcx, rax
mov rax, [rsp+88h+var_88]
mov [rsp+88h+var_80], rcx
mov [rsp+88h+var_78], rdx
mov rcx, [rsp+88h+var_80]
mov [rax], rcx
mov rcx, [rsp+88h+var_78]
mov [rax+8], rcx
mov ecx, [rsp+88h+var_40]
mov rax, [rsp+88h+var_50]
mov [rax+10h], ecx
mov rax, [rsp+88h+var_50]
mov qword ptr [rax+18h], 0
mov rdx, [rsp+88h+var_50]
mov rdi, [rsp+88h+var_60]
mov rsi, [rsp+88h+var_58]
call JS_SetOpaqueInternal
mov rax, [rsp+88h+var_60]
mov [rsp+88h+var_10], rax
mov rax, [rsp+88h+var_58]
mov [rsp+88h+var_8], rax
jmp short loc_8CF4C
loc_8CF38:
mov dword ptr [rsp+88h+var_10], 0
mov [rsp+88h+var_8], 6
loc_8CF4C:
mov rax, [rsp+88h+var_10]
mov rdx, [rsp+88h+var_8]
add rsp, 88h
retn
|
long long js_create_map_iterator(long long a1, _DWORD *a2, unsigned int a3, long long a4, long long a5, int a6)
{
long long v6; // rdx
long long v7; // rdx
long long v9; // [rsp+18h] [rbp-70h]
long long v10; // [rsp+30h] [rbp-58h]
long long v11; // [rsp+38h] [rbp-50h]
int v12; // [rsp+48h] [rbp-40h]
int v13; // [rsp+4Ch] [rbp-3Ch]
long long v15; // [rsp+78h] [rbp-10h]
v12 = a6 >> 2;
v13 = a6 & 3;
if ( JS_GetOpaque2(a1, (long long)a2, a3, v13 + 35) )
{
v9 = JS_NewObjectClass(a1, v13 + 42);
v10 = v6;
if ( !JS_IsException_1(v9, v6) )
{
v11 = js_malloc(a1, 32LL);
if ( v11 )
{
*(_QWORD *)v11 = js_dup(a2, a3);
*(_QWORD *)(v11 + 8) = v7;
*(_DWORD *)(v11 + 16) = v12;
*(_QWORD *)(v11 + 24) = 0LL;
JS_SetOpaqueInternal(v9, v10, v11);
return v9;
}
JS_FreeValue(a1, v9, v10);
}
LODWORD(v15) = 0;
return v15;
}
LODWORD(v15) = 0;
return v15;
}
|
js_create_map_iterator:
SUB RSP,0x88
MOV qword ptr [RSP + 0x68],RSI
MOV qword ptr [RSP + 0x70],RDX
MOV qword ptr [RSP + 0x60],RDI
MOV dword ptr [RSP + 0x5c],ECX
MOV qword ptr [RSP + 0x50],R8
MOV dword ptr [RSP + 0x4c],R9D
MOV EAX,dword ptr [RSP + 0x4c]
SAR EAX,0x2
MOV dword ptr [RSP + 0x48],EAX
MOV EAX,dword ptr [RSP + 0x4c]
AND EAX,0x3
MOV dword ptr [RSP + 0x4c],EAX
MOV RDI,qword ptr [RSP + 0x60]
MOV ECX,dword ptr [RSP + 0x4c]
ADD ECX,0x23
MOV RSI,qword ptr [RSP + 0x68]
MOV RDX,qword ptr [RSP + 0x70]
CALL 0x001383b0
MOV qword ptr [RSP + 0x40],RAX
CMP qword ptr [RSP + 0x40],0x0
JNZ 0x0018ce3b
MOV dword ptr [RSP + 0x78],0x0
MOV qword ptr [RSP + 0x80],0x6
JMP 0x0018cf4c
LAB_0018ce3b:
MOV RDI,qword ptr [RSP + 0x60]
MOV ESI,dword ptr [RSP + 0x4c]
ADD ESI,0x2a
CALL 0x0012a480
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],RDX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x30],RAX
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x30]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x0018ce83
JMP 0x0018cf38
LAB_0018ce83:
MOV RDI,qword ptr [RSP + 0x60]
MOV ESI,0x20
CALL 0x00121cb0
MOV qword ptr [RSP + 0x38],RAX
CMP qword ptr [RSP + 0x38],0x0
JNZ 0x0018ceb8
MOV RDI,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
CALL 0x00123c90
JMP 0x0018cf38
LAB_0018ceb8:
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0x68]
MOV RSI,qword ptr [RSP + 0x70]
CALL 0x001216d0
MOV RCX,RAX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x8],RCX
MOV qword ptr [RSP + 0x10],RDX
MOV RCX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV ECX,dword ptr [RSP + 0x48]
MOV RAX,qword ptr [RSP + 0x38]
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RAX + 0x18],0x0
MOV RDX,qword ptr [RSP + 0x38]
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x30]
CALL 0x0012a9a0
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x78],RAX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x80],RAX
JMP 0x0018cf4c
LAB_0018cf38:
MOV dword ptr [RSP + 0x78],0x0
MOV qword ptr [RSP + 0x80],0x6
LAB_0018cf4c:
MOV RAX,qword ptr [RSP + 0x78]
MOV RDX,qword ptr [RSP + 0x80]
ADD RSP,0x88
RET
|
int1 [16]
js_create_map_iterator
(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,uint param_6)
{
int iVar1;
long lVar2;
int1 (*pauVar4) [16];
int1 auVar5 [16];
int1 auVar6 [16];
int4 local_10;
int4 uStack_c;
int8 local_8;
int8 uVar3;
lVar2 = JS_GetOpaque2(param_1,param_2,param_3,(param_6 & 3) + 0x23);
if (lVar2 == 0) {
local_10 = 0;
local_8 = 6;
}
else {
auVar5 = JS_NewObjectClass(param_1,(param_6 & 3) + 0x2a);
local_8 = auVar5._8_8_;
uVar3 = auVar5._0_8_;
iVar1 = JS_IsException(uVar3,local_8);
if (iVar1 == 0) {
pauVar4 = (int1 (*) [16])js_malloc(param_1,0x20);
if (pauVar4 != (int1 (*) [16])0x0) {
auVar6 = js_dup(param_2,param_3);
*pauVar4 = auVar6;
*(int *)pauVar4[1] = (int)param_6 >> 2;
*(int8 *)(pauVar4[1] + 8) = 0;
JS_SetOpaqueInternal(uVar3,local_8,pauVar4);
local_10 = auVar5._0_4_;
uStack_c = auVar5._4_4_;
goto LAB_0018cf4c;
}
JS_FreeValue(param_1,uVar3,local_8);
}
local_10 = 0;
local_8 = 6;
}
LAB_0018cf4c:
auVar5._4_4_ = uStack_c;
auVar5._0_4_ = local_10;
auVar5._8_8_ = local_8;
return auVar5;
}
|
|
66,088 |
js_create_map_iterator
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_create_map_iterator(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int magic)
{
JSIteratorKindEnum kind;
JSMapState *s;
JSMapIteratorData *it;
JSValue enum_obj;
kind = magic >> 2;
magic &= 3;
s = JS_GetOpaque2(ctx, this_val, JS_CLASS_MAP + magic);
if (!s)
return JS_EXCEPTION;
enum_obj = JS_NewObjectClass(ctx, JS_CLASS_MAP_ITERATOR + magic);
if (JS_IsException(enum_obj))
goto fail;
it = js_malloc(ctx, sizeof(*it));
if (!it) {
JS_FreeValue(ctx, enum_obj);
goto fail;
}
it->obj = js_dup(this_val);
it->kind = kind;
it->cur_record = NULL;
JS_SetOpaqueInternal(enum_obj, it);
return enum_obj;
fail:
return JS_EXCEPTION;
}
|
O1
|
c
|
js_create_map_iterator:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
movl %r9d, %r12d
andl $0x3, %r12d
leal 0x23(%r12), %ecx
callq 0x275b5
testq %rax, %rax
je 0x50001
addl $0x2a, %r12d
movq 0x40(%r13), %rax
movl %r12d, %ecx
shll $0x4, %ecx
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
movq %r13, %rdi
movl %r12d, %ecx
callq 0x20f05
movq %rdx, %r12
cmpl $0x6, %r12d
jne 0x50020
xorl %eax, %eax
xorl %ecx, %ecx
movl $0x6, %r12d
orq %rcx, %rax
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbp
movl $0x20, %esi
movq %r13, %rdi
callq 0xede6
testq %rax, %rax
je 0x50072
sarl $0x2, %ebx
movq %r15, (%rsp)
cmpl $-0x9, %r14d
jb 0x50048
movq (%rsp), %rcx
incl (%rcx)
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movl %ebx, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq %rax, 0x30(%rbp)
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %rbp, %rcx
andq %rax, %rcx
movl %ebp, %eax
jmp 0x5000b
movq 0x18(%r13), %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x1d8c6
jmp 0x50001
|
js_create_map_iterator:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebx, r9d
mov r14, rdx
mov r15, rsi
mov r13, rdi
mov r12d, r9d
and r12d, 3
lea ecx, [r12+23h]
call JS_GetOpaque2
test rax, rax
jz short loc_50001
add r12d, 2Ah ; '*'
mov rax, [r13+40h]
mov ecx, r12d
shl ecx, 4
mov rsi, [rax+rcx]
mov rdx, [rax+rcx+8]
mov rdi, r13
mov ecx, r12d
call JS_NewObjectProtoClass
mov r12, rdx
cmp r12d, 6
jnz short loc_50020
loc_50001:
xor eax, eax
loc_50003:
xor ecx, ecx
mov r12d, 6
loc_5000B:
or rax, rcx
mov rdx, r12
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_50020:
mov rbp, rax
mov esi, 20h ; ' '
mov rdi, r13
call js_malloc
test rax, rax
jz short loc_50072
sar ebx, 2
mov [rsp+38h+var_38], r15
cmp r14d, 0FFFFFFF7h
jb short loc_50048
mov rcx, [rsp+38h+var_38]
inc dword ptr [rcx]
loc_50048:
mov [rax], r15
mov [rax+8], r14
mov [rax+10h], ebx
mov qword ptr [rax+18h], 0
mov [rbp+30h], rax
mov rax, 0FFFFFFFF00000000h
mov rcx, rbp
and rcx, rax
mov eax, ebp
jmp short loc_5000B
loc_50072:
mov rdi, [r13+18h]
mov rsi, rbp
mov rdx, r12
call JS_FreeValueRT
jmp loc_50001
|
unsigned long long js_create_map_iterator(long long a1, _DWORD *a2, long long a3, long long a4, long long a5, int a6)
{
int v8; // r12d
long long v9; // rax
long long v10; // rdx
long long v11; // r12
long long v12; // rax
unsigned long long v13; // rcx
long long v15; // rbp
long long v16; // rax
int v17; // ebx
v8 = a6 & 3;
if ( !JS_GetOpaque2(a1, (long long)a2, a3, v8 + 35) )
goto LABEL_3;
v9 = JS_NewObjectProtoClass(
a1,
*(_QWORD *)(*(_QWORD *)(a1 + 64) + (unsigned int)(16 * (v8 + 42))),
*(_QWORD *)(*(_QWORD *)(a1 + 64) + (unsigned int)(16 * (v8 + 42)) + 8LL),
v8 + 42);
v11 = v10;
if ( (_DWORD)v10 == 6 )
goto LABEL_3;
v15 = v9;
v16 = js_malloc(a1, 32LL);
if ( !v16 )
{
JS_FreeValueRT(*(_QWORD *)(a1 + 24), (_DWORD *)v15, v11);
LABEL_3:
v12 = 0LL;
v13 = 0LL;
return v13 | v12;
}
v17 = a6 >> 2;
if ( (unsigned int)a3 >= 0xFFFFFFF7 )
++*a2;
*(_QWORD *)v16 = a2;
*(_QWORD *)(v16 + 8) = a3;
*(_DWORD *)(v16 + 16) = v17;
*(_QWORD *)(v16 + 24) = 0LL;
*(_QWORD *)(v15 + 48) = v16;
v13 = v15 & 0xFFFFFFFF00000000LL;
v12 = (unsigned int)v15;
return v13 | v12;
}
|
js_create_map_iterator:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EBX,R9D
MOV R14,RDX
MOV R15,RSI
MOV R13,RDI
MOV R12D,R9D
AND R12D,0x3
LEA ECX,[R12 + 0x23]
CALL 0x001275b5
TEST RAX,RAX
JZ 0x00150001
ADD R12D,0x2a
MOV RAX,qword ptr [R13 + 0x40]
MOV ECX,R12D
SHL ECX,0x4
MOV RSI,qword ptr [RAX + RCX*0x1]
MOV RDX,qword ptr [RAX + RCX*0x1 + 0x8]
MOV RDI,R13
MOV ECX,R12D
CALL 0x00120f05
MOV R12,RDX
CMP R12D,0x6
JNZ 0x00150020
LAB_00150001:
XOR EAX,EAX
XOR ECX,ECX
MOV R12D,0x6
LAB_0015000b:
OR RAX,RCX
MOV RDX,R12
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00150020:
MOV RBP,RAX
MOV ESI,0x20
MOV RDI,R13
CALL 0x0010ede6
TEST RAX,RAX
JZ 0x00150072
SAR EBX,0x2
MOV qword ptr [RSP],R15
CMP R14D,-0x9
JC 0x00150048
MOV RCX,qword ptr [RSP]
INC dword ptr [RCX]
LAB_00150048:
MOV qword ptr [RAX],R15
MOV qword ptr [RAX + 0x8],R14
MOV dword ptr [RAX + 0x10],EBX
MOV qword ptr [RAX + 0x18],0x0
MOV qword ptr [RBP + 0x30],RAX
MOV RAX,-0x100000000
MOV RCX,RBP
AND RCX,RAX
MOV EAX,EBP
JMP 0x0015000b
LAB_00150072:
MOV RDI,qword ptr [R13 + 0x18]
MOV RSI,RBP
MOV RDX,R12
CALL 0x0011d8c6
JMP 0x00150001
|
int1 [16]
js_create_map_iterator
(long param_1,int *param_2,int8 param_3,int8 param_4,int8 param_5,
uint param_6)
{
long lVar1;
ulong uVar2;
int8 *puVar3;
ulong uVar4;
int iVar5;
int8 uVar6;
int1 auVar7 [16];
lVar1 = JS_GetOpaque2();
if (lVar1 != 0) {
iVar5 = (param_6 & 3) + 0x2a;
uVar2 = (ulong)(uint)(iVar5 * 0x10);
auVar7 = JS_NewObjectProtoClass
(param_1,*(int8 *)(*(long *)(param_1 + 0x40) + uVar2),
*(int8 *)(*(long *)(param_1 + 0x40) + 8 + uVar2),iVar5);
uVar6 = auVar7._8_8_;
uVar2 = auVar7._0_8_;
if (auVar7._8_4_ != 6) {
puVar3 = (int8 *)js_malloc(param_1,0x20);
if (puVar3 != (int8 *)0x0) {
if (0xfffffff6 < (uint)param_3) {
*param_2 = *param_2 + 1;
}
*puVar3 = param_2;
puVar3[1] = param_3;
*(int *)(puVar3 + 2) = (int)param_6 >> 2;
puVar3[3] = 0;
*(int8 **)(uVar2 + 0x30) = puVar3;
uVar4 = uVar2 & 0xffffffff00000000;
uVar2 = uVar2 & 0xffffffff;
goto LAB_0015000b;
}
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),uVar2,uVar6);
}
}
uVar2 = 0;
uVar4 = 0;
uVar6 = 6;
LAB_0015000b:
auVar7._0_8_ = uVar2 | uVar4;
auVar7._8_8_ = uVar6;
return auVar7;
}
|
|
66,089 |
unreg_request
|
eloqsql/mysys/mf_keycache.c
|
static void unreg_request(SIMPLE_KEY_CACHE_CB *keycache,
BLOCK_LINK *block, int at_end)
{
DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE));
DBUG_ASSERT(block->hash_link); /*backptr to block NULL from free_block()*/
DBUG_ASSERT(block->requests);
DBUG_ASSERT(block->prev_changed && *block->prev_changed == block);
DBUG_ASSERT(!block->next_used);
DBUG_ASSERT(!block->prev_used);
/*
Unregister the request, but do not link erroneous blocks into the
LRU ring.
*/
if (!--block->requests && !(block->status & BLOCK_ERROR))
{
my_bool hot;
if (block->hits_left)
block->hits_left--;
hot= !block->hits_left && at_end &&
keycache->warm_blocks > keycache->min_warm_blocks;
if (hot)
{
if (block->temperature == BLOCK_WARM)
keycache->warm_blocks--;
block->temperature= BLOCK_HOT;
KEYCACHE_DBUG_PRINT("unreg_request", ("#warm_blocks: %lu",
keycache->warm_blocks));
}
link_block(keycache, block, hot, (my_bool)at_end);
block->last_hit_time= keycache->keycache_time;
keycache->keycache_time++;
/*
At this place, the block might be in the LRU ring or not. If an
evicter was waiting for a block, it was selected for eviction and
not linked in the LRU ring.
*/
/*
Check if we should link a hot block to the warm block sub-chain.
It is possible that we select the same block as above. But it can
also be another block. In any case a block from the LRU ring is
selected. In other words it works even if the above block was
selected for eviction and not linked in the LRU ring. Since this
happens only if the LRU ring is empty, the block selected below
would be NULL and the rest of the function skipped.
*/
block= keycache->used_ins;
if (block && keycache->keycache_time - block->last_hit_time >
keycache->age_threshold)
{
unlink_block(keycache, block);
link_block(keycache, block, 0, 0);
if (block->temperature != BLOCK_WARM)
{
keycache->warm_blocks++;
block->temperature= BLOCK_WARM;
}
KEYCACHE_DBUG_PRINT("unreg_request", ("#warm_blocks: %lu",
keycache->warm_blocks));
}
}
}
|
O0
|
c
|
unreg_request:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
jmp 0xe5985
jmp 0xe5987
jmp 0xe5989
jmp 0xe598b
jmp 0xe598d
jmp 0xe598f
jmp 0xe5991
jmp 0xe5993
jmp 0xe5995
jmp 0xe5997
jmp 0xe5999
movq -0x10(%rbp), %rcx
movl 0x38(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x38(%rcx)
cmpl $0x0, %eax
jne 0xe5af7
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xe5af7
movq -0x10(%rbp), %rax
cmpl $0x0, 0x58(%rax)
je 0xe59d9
movq -0x10(%rbp), %rax
movl 0x58(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x58(%rax)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x58(%rcx)
movb %al, -0x16(%rbp)
jne 0xe5a09
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x16(%rbp)
je 0xe5a09
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
seta %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x15(%rbp)
cmpb $0x0, -0x15(%rbp)
je 0xe5a43
movq -0x10(%rbp), %rax
cmpl $0x1, 0x54(%rax)
jne 0xe5a34
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rax
movl $0x2, 0x54(%rax)
jmp 0xe5a41
jmp 0xe5a43
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movb -0x15(%rbp), %cl
movl -0x14(%rbp), %eax
movsbl %cl, %edx
movsbl %al, %ecx
callq 0xe6f60
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0xb8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xe5af5
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rcx
subq 0x60(%rcx), %rax
movq -0x8(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jbe 0xe5af5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe6e30
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0xe6f60
movq -0x10(%rbp), %rax
cmpl $0x1, 0x54(%rax)
je 0xe5aef
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x54(%rax)
jmp 0xe5af1
jmp 0xe5af3
jmp 0xe5af5
jmp 0xe5af7
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
|
unreg_request_0:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
jmp short $+2
loc_E5985:
jmp short $+2
loc_E5987:
jmp short $+2
loc_E5989:
jmp short $+2
loc_E598B:
jmp short $+2
loc_E598D:
jmp short $+2
loc_E598F:
jmp short $+2
loc_E5991:
jmp short $+2
loc_E5993:
jmp short $+2
loc_E5995:
jmp short $+2
loc_E5997:
jmp short $+2
loc_E5999:
mov rcx, [rbp+var_10]
mov eax, [rcx+38h]
add eax, 0FFFFFFFFh
mov [rcx+38h], eax
cmp eax, 0
jnz loc_E5AF7
mov rax, [rbp+var_10]
mov eax, [rax+50h]
and eax, 1
cmp eax, 0
jnz loc_E5AF7
mov rax, [rbp+var_10]
cmp dword ptr [rax+58h], 0
jz short loc_E59D9
mov rax, [rbp+var_10]
mov ecx, [rax+58h]
add ecx, 0FFFFFFFFh
mov [rax+58h], ecx
loc_E59D9:
mov rcx, [rbp+var_10]
xor eax, eax
cmp dword ptr [rcx+58h], 0
mov [rbp+var_16], al
jnz short loc_E5A09
xor eax, eax
cmp [rbp+var_14], 0
mov [rbp+var_16], al
jz short loc_E5A09
mov rax, [rbp+var_8]
mov rax, [rax+68h]
mov rcx, [rbp+var_8]
cmp rax, [rcx+20h]
setnbe al
mov [rbp+var_16], al
loc_E5A09:
mov al, [rbp+var_16]
and al, 1
movzx eax, al
mov [rbp+var_15], al
cmp [rbp+var_15], 0
jz short loc_E5A43
mov rax, [rbp+var_10]
cmp dword ptr [rax+54h], 1
jnz short loc_E5A34
mov rax, [rbp+var_8]
mov rcx, [rax+68h]
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rax+68h], rcx
loc_E5A34:
mov rax, [rbp+var_10]
mov dword ptr [rax+54h], 2
jmp short $+2
loc_E5A41:
jmp short $+2
loc_E5A43:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov cl, [rbp+var_15]
mov eax, [rbp+var_14]
movsx edx, cl
movsx ecx, al
call link_block_0
mov rax, [rbp+var_8]
mov rcx, [rax+30h]
mov rax, [rbp+var_10]
mov [rax+60h], rcx
mov rax, [rbp+var_8]
mov rcx, [rax+30h]
add rcx, 1
mov [rax+30h], rcx
mov rax, [rbp+var_8]
mov rax, [rax+0B8h]
mov [rbp+var_10], rax
cmp [rbp+var_10], 0
jz short loc_E5AF5
mov rax, [rbp+var_8]
mov rax, [rax+30h]
mov rcx, [rbp+var_10]
sub rax, [rcx+60h]
mov rcx, [rbp+var_8]
cmp rax, [rcx+28h]
jbe short loc_E5AF5
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
call unlink_block_0
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
xor ecx, ecx
mov edx, ecx
call link_block_0
mov rax, [rbp+var_10]
cmp dword ptr [rax+54h], 1
jz short loc_E5AEF
mov rax, [rbp+var_8]
mov rcx, [rax+68h]
add rcx, 1
mov [rax+68h], rcx
mov rax, [rbp+var_10]
mov dword ptr [rax+54h], 1
loc_E5AEF:
jmp short $+2
loc_E5AF1:
jmp short $+2
loc_E5AF3:
jmp short $+2
loc_E5AF5:
jmp short $+2
loc_E5AF7:
add rsp, 20h
pop rbp
retn
|
unsigned long long unreg_request_0(_QWORD *a1, long long a2, int a3)
{
unsigned long long result; // rax
bool v4; // [rsp+Ah] [rbp-16h]
unsigned long long v5; // [rsp+10h] [rbp-10h]
result = (unsigned int)(*(_DWORD *)(a2 + 56) - 1);
*(_DWORD *)(a2 + 56) = result;
if ( !(_DWORD)result )
{
result = *(_DWORD *)(a2 + 80) & 1;
if ( !(_DWORD)result )
{
if ( *(_DWORD *)(a2 + 88) )
--*(_DWORD *)(a2 + 88);
v4 = 0;
if ( !*(_DWORD *)(a2 + 88) )
{
v4 = 0;
if ( a3 )
v4 = a1[13] > a1[4];
}
if ( v4 )
{
if ( *(_DWORD *)(a2 + 84) == 1 )
--a1[13];
*(_DWORD *)(a2 + 84) = 2;
}
link_block_0(a1, a2, v4, (unsigned int)(char)a3);
*(_QWORD *)(a2 + 96) = a1[6]++;
result = a1[23];
v5 = result;
if ( result )
{
result = a1[6] - *(_QWORD *)(result + 96);
if ( result > a1[5] )
{
unlink_block_0(a1, v5);
link_block_0(a1, v5, 0LL, 0LL);
result = v5;
if ( *(_DWORD *)(v5 + 84) != 1 )
{
++a1[13];
result = v5;
*(_DWORD *)(v5 + 84) = 1;
}
}
}
}
}
return result;
}
|
unreg_request:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
JMP 0x001e5985
LAB_001e5985:
JMP 0x001e5987
LAB_001e5987:
JMP 0x001e5989
LAB_001e5989:
JMP 0x001e598b
LAB_001e598b:
JMP 0x001e598d
LAB_001e598d:
JMP 0x001e598f
LAB_001e598f:
JMP 0x001e5991
LAB_001e5991:
JMP 0x001e5993
LAB_001e5993:
JMP 0x001e5995
LAB_001e5995:
JMP 0x001e5997
LAB_001e5997:
JMP 0x001e5999
LAB_001e5999:
MOV RCX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RCX + 0x38]
ADD EAX,-0x1
MOV dword ptr [RCX + 0x38],EAX
CMP EAX,0x0
JNZ 0x001e5af7
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x50]
AND EAX,0x1
CMP EAX,0x0
JNZ 0x001e5af7
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x58],0x0
JZ 0x001e59d9
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x58]
ADD ECX,-0x1
MOV dword ptr [RAX + 0x58],ECX
LAB_001e59d9:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP dword ptr [RCX + 0x58],0x0
MOV byte ptr [RBP + -0x16],AL
JNZ 0x001e5a09
XOR EAX,EAX
CMP dword ptr [RBP + -0x14],0x0
MOV byte ptr [RBP + -0x16],AL
JZ 0x001e5a09
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x68]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RCX + 0x20]
SETA AL
MOV byte ptr [RBP + -0x16],AL
LAB_001e5a09:
MOV AL,byte ptr [RBP + -0x16]
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x15],AL
CMP byte ptr [RBP + -0x15],0x0
JZ 0x001e5a43
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x54],0x1
JNZ 0x001e5a34
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x68]
ADD RCX,-0x1
MOV qword ptr [RAX + 0x68],RCX
LAB_001e5a34:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x54],0x2
JMP 0x001e5a41
LAB_001e5a41:
JMP 0x001e5a43
LAB_001e5a43:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV CL,byte ptr [RBP + -0x15]
MOV EAX,dword ptr [RBP + -0x14]
MOVSX EDX,CL
MOVSX ECX,AL
CALL 0x001e6f60
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x60],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x30]
ADD RCX,0x1
MOV qword ptr [RAX + 0x30],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xb8]
MOV qword ptr [RBP + -0x10],RAX
CMP qword ptr [RBP + -0x10],0x0
JZ 0x001e5af5
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x30]
MOV RCX,qword ptr [RBP + -0x10]
SUB RAX,qword ptr [RCX + 0x60]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RCX + 0x28]
JBE 0x001e5af5
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x001e6e30
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
XOR ECX,ECX
MOV EDX,ECX
CALL 0x001e6f60
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x54],0x1
JZ 0x001e5aef
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x68]
ADD RCX,0x1
MOV qword ptr [RAX + 0x68],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x54],0x1
LAB_001e5aef:
JMP 0x001e5af1
LAB_001e5af1:
JMP 0x001e5af3
LAB_001e5af3:
JMP 0x001e5af5
LAB_001e5af5:
JMP 0x001e5af7
LAB_001e5af7:
ADD RSP,0x20
POP RBP
RET
|
void unreg_request(long param_1,long param_2,int param_3)
{
long lVar1;
int iVar2;
bool local_1e;
iVar2 = *(int *)(param_2 + 0x38) + -1;
*(int *)(param_2 + 0x38) = iVar2;
if ((iVar2 == 0) && ((*(uint *)(param_2 + 0x50) & 1) == 0)) {
if (*(int *)(param_2 + 0x58) != 0) {
*(int *)(param_2 + 0x58) = *(int *)(param_2 + 0x58) + -1;
}
local_1e = false;
if ((*(int *)(param_2 + 0x58) == 0) && (local_1e = false, param_3 != 0)) {
local_1e = *(ulong *)(param_1 + 0x20) < *(ulong *)(param_1 + 0x68);
}
if (local_1e != false) {
if (*(int *)(param_2 + 0x54) == 1) {
*(long *)(param_1 + 0x68) = *(long *)(param_1 + 0x68) + -1;
}
*(int4 *)(param_2 + 0x54) = 2;
}
link_block(param_1,param_2,local_1e,(int)(char)param_3);
*(int8 *)(param_2 + 0x60) = *(int8 *)(param_1 + 0x30);
*(long *)(param_1 + 0x30) = *(long *)(param_1 + 0x30) + 1;
lVar1 = *(long *)(param_1 + 0xb8);
if ((lVar1 != 0) &&
(*(ulong *)(param_1 + 0x28) < (ulong)(*(long *)(param_1 + 0x30) - *(long *)(lVar1 + 0x60))))
{
unlink_block(param_1,lVar1);
link_block(param_1,lVar1,0);
if (*(int *)(lVar1 + 0x54) != 1) {
*(long *)(param_1 + 0x68) = *(long *)(param_1 + 0x68) + 1;
*(int4 *)(lVar1 + 0x54) = 1;
}
}
}
return;
}
|
|
66,090 |
used_buffs_urgent_unlock
|
eloqsql/storage/maria/ma_loghandler.c
|
static void used_buffs_urgent_unlock(TRUNSLOG_USED_BUFFERS *buffs)
{
uint i;
DBUG_ENTER("used_buffs_urgent_unlock");
translog_lock();
translog_stop_writing();
translog_unlock();
for (i= buffs->unlck_ptr; i < buffs->wrt_ptr; i++)
{
struct st_translog_buffer *buf= buffs->buff[i];
translog_buffer_lock(buf);
translog_buffer_decrease_writers(buf);
translog_buffer_unlock(buf);
buffs->buff[i]= NULL;
}
used_buffs_init(buffs);
DBUG_VOID_RETURN;
}
|
O0
|
c
|
used_buffs_urgent_unlock:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x2c3c0
callq 0x2bab0
callq 0x2c4b0
movq -0x8(%rbp), %rax
movzbl 0x19(%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movzbl 0x18(%rcx), %ecx
cmpl %ecx, %eax
jae 0x38139
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2c440
movq -0x18(%rbp), %rdi
callq 0x38040
movq -0x18(%rbp), %rdi
callq 0x2c480
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x380e6
movq -0x8(%rbp), %rdi
callq 0x38170
jmp 0x38144
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
used_buffs_urgent_unlock:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
call translog_lock
call translog_stop_writing
call translog_unlock
mov rax, [rbp+var_8]
movzx eax, byte ptr [rax+19h]
mov [rbp+var_C], eax
loc_380E6:
mov eax, [rbp+var_C]
mov rcx, [rbp+var_8]
movzx ecx, byte ptr [rcx+18h]
cmp eax, ecx
jnb short loc_38139
mov rax, [rbp+var_8]
mov ecx, [rbp+var_C]
mov rax, [rax+rcx*8]
mov [rbp+var_18], rax
mov rdi, [rbp+var_18]
call translog_buffer_lock
mov rdi, [rbp+var_18]
call translog_buffer_decrease_writers
mov rdi, [rbp+var_18]
call translog_buffer_unlock
mov rax, [rbp+var_8]
mov ecx, [rbp+var_C]
mov qword ptr [rax+rcx*8], 0
mov eax, [rbp+var_C]
add eax, 1
mov [rbp+var_C], eax
jmp short loc_380E6
loc_38139:
mov rdi, [rbp+var_8]
call used_buffs_init
jmp short $+2
loc_38144:
add rsp, 20h
pop rbp
retn
|
long long used_buffs_urgent_unlock(long long a1)
{
long long v2; // [rsp+8h] [rbp-18h]
unsigned int i; // [rsp+14h] [rbp-Ch]
translog_lock();
translog_stop_writing();
translog_unlock();
for ( i = *(unsigned __int8 *)(a1 + 25); i < *(unsigned __int8 *)(a1 + 24); ++i )
{
v2 = *(_QWORD *)(a1 + 8LL * i);
translog_buffer_lock(v2);
translog_buffer_decrease_writers(v2);
translog_buffer_unlock(v2);
*(_QWORD *)(a1 + 8LL * i) = 0LL;
}
return used_buffs_init(a1);
}
|
used_buffs_urgent_unlock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
CALL 0x0012c3c0
CALL 0x0012bab0
CALL 0x0012c4b0
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,byte ptr [RAX + 0x19]
MOV dword ptr [RBP + -0xc],EAX
LAB_001380e6:
MOV EAX,dword ptr [RBP + -0xc]
MOV RCX,qword ptr [RBP + -0x8]
MOVZX ECX,byte ptr [RCX + 0x18]
CMP EAX,ECX
JNC 0x00138139
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x0012c440
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00138040
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x0012c480
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0xc]
MOV qword ptr [RAX + RCX*0x8],0x0
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
JMP 0x001380e6
LAB_00138139:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00138170
JMP 0x00138144
LAB_00138144:
ADD RSP,0x20
POP RBP
RET
|
void used_buffs_urgent_unlock(long param_1)
{
int8 uVar1;
int4 local_14;
translog_lock();
translog_stop_writing();
translog_unlock();
for (local_14 = (uint)*(byte *)(param_1 + 0x19); local_14 < *(byte *)(param_1 + 0x18);
local_14 = local_14 + 1) {
uVar1 = *(int8 *)(param_1 + (ulong)local_14 * 8);
translog_buffer_lock(uVar1);
translog_buffer_decrease_writers(uVar1);
translog_buffer_unlock(uVar1);
*(int8 *)(param_1 + (ulong)local_14 * 8) = 0;
}
used_buffs_init(param_1);
return;
}
|
|
66,091 |
my_connect_async
|
eloqsql/libmariadb/libmariadb/mariadb_async.c
|
int
my_connect_async(MARIADB_PVIO *pvio,
const struct sockaddr *name, uint namelen, int vio_timeout)
{
int res;
size_socket s_err_size;
struct mysql_async_context *b= pvio->mysql->options.extension->async_context;
my_socket sock;
ma_pvio_get_handle(pvio, &sock);
/* Make the socket non-blocking. */
ma_pvio_blocking(pvio, 0, 0);
b->events_to_wait_for= 0;
/*
Start to connect asynchronously.
If this will block, we suspend the call and return control to the
application context. The application will then resume us when the socket
polls ready for write, indicating that the connection attempt completed.
*/
res= connect(sock, name, namelen);
if (res != 0)
{
#ifdef _WIN32
int wsa_err= WSAGetLastError();
if (wsa_err != WSAEWOULDBLOCK)
return res;
b->events_to_wait_for|= MYSQL_WAIT_EXCEPT;
#else
int err= errno;
if (err != EINPROGRESS && err != EALREADY && err != EAGAIN)
return res;
#endif
b->events_to_wait_for|= MYSQL_WAIT_WRITE;
if (vio_timeout >= 0)
{
b->timeout_value= vio_timeout;
b->events_to_wait_for|= MYSQL_WAIT_TIMEOUT;
}
else
b->timeout_value= 0;
if (b->suspend_resume_hook)
(*b->suspend_resume_hook)(TRUE, b->suspend_resume_hook_user_data);
my_context_yield(&b->async_context);
if (b->suspend_resume_hook)
(*b->suspend_resume_hook)(FALSE, b->suspend_resume_hook_user_data);
if (b->events_occurred & MYSQL_WAIT_TIMEOUT)
return -1;
s_err_size= sizeof(res);
if (getsockopt(sock, SOL_SOCKET, SO_ERROR, (char*) &res, &s_err_size) != 0)
return -1;
if (res)
{
errno= res;
return -1;
}
}
return res;
}
|
O0
|
c
|
my_connect_async:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x23a70
movq -0x10(%rbp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x234e0
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movl -0x34(%rbp), %edi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x13370
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x37b0f
callq 0x13050
movl (%rax), %eax
movl %eax, -0x38(%rbp)
cmpl $0x73, -0x38(%rbp)
je 0x37a26
cmpl $0x72, -0x38(%rbp)
je 0x37a26
cmpl $0xb, -0x38(%rbp)
je 0x37a26
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x37b15
movq -0x30(%rbp), %rax
movl (%rax), %ecx
orl $0x2, %ecx
movl %ecx, (%rax)
cmpl $0x0, -0x20(%rbp)
jl 0x37a4e
movl -0x20(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x30(%rbp), %rax
movl (%rax), %ecx
orl $0x8, %ecx
movl %ecx, (%rax)
jmp 0x37a59
movq -0x30(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x37a7b
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x30(%rbp), %rcx
movq 0x28(%rcx), %rsi
movl $0x1, %edi
callq *%rax
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
callq 0x3f2a0
movq -0x30(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x37aa7
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x30(%rbp), %rcx
movq 0x28(%rcx), %rsi
xorl %edi, %edi
callq *%rax
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x37abf
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x37b15
movl $0x4, -0x28(%rbp)
movl -0x34(%rbp), %edi
movl $0x1, %esi
movl $0x4, %edx
leaq -0x24(%rbp), %rcx
leaq -0x28(%rbp), %r8
callq 0x13300
cmpl $0x0, %eax
je 0x37aee
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x37b15
cmpl $0x0, -0x24(%rbp)
je 0x37b0d
movl -0x24(%rbp), %eax
movl %eax, -0x3c(%rbp)
callq 0x13050
movl -0x3c(%rbp), %ecx
movl %ecx, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x37b15
jmp 0x37b0f
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
|
my_connect_async:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_20], ecx
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_30], rax
mov rdi, [rbp+var_10]
lea rsi, [rbp+var_34]
call ma_pvio_get_handle
mov rdi, [rbp+var_10]
xor esi, esi
xor eax, eax
mov edx, eax
call ma_pvio_blocking
mov rax, [rbp+var_30]
mov dword ptr [rax], 0
mov edi, [rbp+var_34]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
call _connect
mov [rbp+var_24], eax
cmp [rbp+var_24], 0
jz loc_37B0F
call ___errno_location
mov eax, [rax]
mov [rbp+var_38], eax
cmp [rbp+var_38], 73h ; 's'
jz short loc_37A26
cmp [rbp+var_38], 72h ; 'r'
jz short loc_37A26
cmp [rbp+var_38], 0Bh
jz short loc_37A26
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
jmp loc_37B15
loc_37A26:
mov rax, [rbp+var_30]
mov ecx, [rax]
or ecx, 2
mov [rax], ecx
cmp [rbp+var_20], 0
jl short loc_37A4E
mov ecx, [rbp+var_20]
mov rax, [rbp+var_30]
mov [rax+10h], ecx
mov rax, [rbp+var_30]
mov ecx, [rax]
or ecx, 8
mov [rax], ecx
jmp short loc_37A59
loc_37A4E:
mov rax, [rbp+var_30]
mov dword ptr [rax+10h], 0
loc_37A59:
mov rax, [rbp+var_30]
cmp qword ptr [rax+20h], 0
jz short loc_37A7B
mov rax, [rbp+var_30]
mov rax, [rax+20h]
mov rcx, [rbp+var_30]
mov rsi, [rcx+28h]
mov edi, 1
call rax
loc_37A7B:
mov rdi, [rbp+var_30]
add rdi, 38h ; '8'
call my_context_yield
mov rax, [rbp+var_30]
cmp qword ptr [rax+20h], 0
jz short loc_37AA7
mov rax, [rbp+var_30]
mov rax, [rax+20h]
mov rcx, [rbp+var_30]
mov rsi, [rcx+28h]
xor edi, edi
call rax
loc_37AA7:
mov rax, [rbp+var_30]
mov eax, [rax+4]
and eax, 8
cmp eax, 0
jz short loc_37ABF
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_37B15
loc_37ABF:
mov [rbp+var_28], 4
mov edi, [rbp+var_34]
mov esi, 1
mov edx, 4
lea rcx, [rbp+var_24]
lea r8, [rbp+var_28]
call _getsockopt
cmp eax, 0
jz short loc_37AEE
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_37B15
loc_37AEE:
cmp [rbp+var_24], 0
jz short loc_37B0D
mov eax, [rbp+var_24]
mov [rbp+var_3C], eax
call ___errno_location
mov ecx, [rbp+var_3C]
mov [rax], ecx
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_37B15
loc_37B0D:
jmp short $+2
loc_37B0F:
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
loc_37B15:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
|
long long my_connect_async(long long a1, long long a2, unsigned int a3, int a4)
{
unsigned int v5; // [rsp+4h] [rbp-3Ch]
int v6; // [rsp+8h] [rbp-38h]
unsigned int v7; // [rsp+Ch] [rbp-34h] BYREF
long long v8; // [rsp+10h] [rbp-30h]
int v9; // [rsp+18h] [rbp-28h] BYREF
unsigned int v10; // [rsp+1Ch] [rbp-24h] BYREF
int v11; // [rsp+20h] [rbp-20h]
unsigned int v12; // [rsp+24h] [rbp-1Ch]
long long v13; // [rsp+28h] [rbp-18h]
long long v14; // [rsp+30h] [rbp-10h]
v14 = a1;
v13 = a2;
v12 = a3;
v11 = a4;
v8 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 64) + 1152LL) + 40LL);
ma_pvio_get_handle(a1, (long long)&v7);
ma_pvio_blocking(v14, 0, 0LL);
*(_DWORD *)v8 = 0;
v10 = connect(v7, v13, v12);
if ( !v10 )
return v10;
v6 = *(_DWORD *)__errno_location();
if ( v6 == 115 || v6 == 114 || v6 == 11 )
{
*(_DWORD *)v8 |= 2u;
if ( v11 < 0 )
{
*(_DWORD *)(v8 + 16) = 0;
}
else
{
*(_DWORD *)(v8 + 16) = v11;
*(_DWORD *)v8 |= 8u;
}
if ( *(_QWORD *)(v8 + 32) )
(*(void ( **)(long long, _QWORD))(v8 + 32))(1LL, *(_QWORD *)(v8 + 40));
my_context_yield(v8 + 56);
if ( *(_QWORD *)(v8 + 32) )
(*(void ( **)(_QWORD, _QWORD))(v8 + 32))(0LL, *(_QWORD *)(v8 + 40));
if ( (*(_DWORD *)(v8 + 4) & 8) != 0 )
return (unsigned int)-1;
v9 = 4;
if ( (unsigned int)getsockopt(v7, 1LL, 4LL, &v10, &v9) )
return (unsigned int)-1;
if ( v10 )
{
v5 = v10;
*(_DWORD *)__errno_location() = v5;
return (unsigned int)-1;
}
return v10;
}
return v10;
}
|
my_connect_async:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV dword ptr [RBP + -0x20],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[RBP + -0x34]
CALL 0x00123a70
MOV RDI,qword ptr [RBP + -0x10]
XOR ESI,ESI
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001234e0
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],0x0
MOV EDI,dword ptr [RBP + -0x34]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
CALL 0x00113370
MOV dword ptr [RBP + -0x24],EAX
CMP dword ptr [RBP + -0x24],0x0
JZ 0x00137b0f
CALL 0x00113050
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x38],EAX
CMP dword ptr [RBP + -0x38],0x73
JZ 0x00137a26
CMP dword ptr [RBP + -0x38],0x72
JZ 0x00137a26
CMP dword ptr [RBP + -0x38],0xb
JZ 0x00137a26
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00137b15
LAB_00137a26:
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RAX]
OR ECX,0x2
MOV dword ptr [RAX],ECX
CMP dword ptr [RBP + -0x20],0x0
JL 0x00137a4e
MOV ECX,dword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RAX]
OR ECX,0x8
MOV dword ptr [RAX],ECX
JMP 0x00137a59
LAB_00137a4e:
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x10],0x0
LAB_00137a59:
MOV RAX,qword ptr [RBP + -0x30]
CMP qword ptr [RAX + 0x20],0x0
JZ 0x00137a7b
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RCX + 0x28]
MOV EDI,0x1
CALL RAX
LAB_00137a7b:
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0x38
CALL 0x0013f2a0
MOV RAX,qword ptr [RBP + -0x30]
CMP qword ptr [RAX + 0x20],0x0
JZ 0x00137aa7
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RCX + 0x28]
XOR EDI,EDI
CALL RAX
LAB_00137aa7:
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX + 0x4]
AND EAX,0x8
CMP EAX,0x0
JZ 0x00137abf
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00137b15
LAB_00137abf:
MOV dword ptr [RBP + -0x28],0x4
MOV EDI,dword ptr [RBP + -0x34]
MOV ESI,0x1
MOV EDX,0x4
LEA RCX,[RBP + -0x24]
LEA R8,[RBP + -0x28]
CALL 0x00113300
CMP EAX,0x0
JZ 0x00137aee
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00137b15
LAB_00137aee:
CMP dword ptr [RBP + -0x24],0x0
JZ 0x00137b0d
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x3c],EAX
CALL 0x00113050
MOV ECX,dword ptr [RBP + -0x3c]
MOV dword ptr [RAX],ECX
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00137b15
LAB_00137b0d:
JMP 0x00137b0f
LAB_00137b0f:
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
LAB_00137b15:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
int my_connect_async(long param_1,sockaddr *param_2,socklen_t param_3,uint param_4)
{
int iVar1;
int iVar2;
int *piVar3;
int local_3c;
uint *local_38;
socklen_t local_30;
int local_2c;
uint local_28;
socklen_t local_24;
sockaddr *local_20;
long local_18;
local_38 = *(uint **)(*(long *)(*(long *)(param_1 + 0x40) + 0x480) + 0x28);
local_28 = param_4;
local_24 = param_3;
local_20 = param_2;
local_18 = param_1;
ma_pvio_get_handle(param_1,&local_3c);
ma_pvio_blocking(local_18,0,0);
*local_38 = 0;
local_2c = connect(local_3c,local_20,local_24);
if (local_2c != 0) {
piVar3 = __errno_location();
iVar1 = *piVar3;
if (((iVar1 != 0x73) && (iVar1 != 0x72)) && (iVar1 != 0xb)) {
return local_2c;
}
*local_38 = *local_38 | 2;
if ((int)local_28 < 0) {
local_38[4] = 0;
}
else {
local_38[4] = local_28;
*local_38 = *local_38 | 8;
}
if (*(long *)(local_38 + 8) != 0) {
(**(code **)(local_38 + 8))(1,*(int8 *)(local_38 + 10));
}
my_context_yield(local_38 + 0xe);
if (*(long *)(local_38 + 8) != 0) {
(**(code **)(local_38 + 8))(0,*(int8 *)(local_38 + 10));
}
if ((local_38[1] & 8) != 0) {
return -1;
}
local_30 = 4;
iVar2 = getsockopt(local_3c,1,4,&local_2c,&local_30);
iVar1 = local_2c;
if (iVar2 != 0) {
return -1;
}
if (local_2c != 0) {
piVar3 = __errno_location();
*piVar3 = iVar1;
return -1;
}
}
return local_2c;
}
|
|
66,092 |
add_compiled_extra_collation
|
eloqsql/mysys/charset.c
|
void add_compiled_extra_collation(struct charset_info_st *cs)
{
DBUG_ASSERT(cs->number < array_elements(all_charsets));
all_charsets[cs->number]= cs;
cs->state|= MY_CS_AVAILABLE;
if ((my_hash_insert(&charset_name_hash, (uchar*) cs)))
{
CHARSET_INFO *org= (CHARSET_INFO*) my_hash_search(&charset_name_hash,
(uchar*) cs->cs_name.str,
cs->cs_name.length);
cs->cs_name= org->cs_name;
}
}
|
O3
|
c
|
add_compiled_extra_collation:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
leaq 0xb6d164(%rip), %rcx # 0xc02440
movq %rdi, (%rcx,%rax,8)
orb $0x2, 0xd(%rdi)
leaq 0xb71155(%rip), %rdi # 0xc06440
movq %rbx, %rsi
callq 0x96bee
testb %al, %al
je 0x95313
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
leaq 0xb7113a(%rip), %rdi # 0xc06440
callq 0x9698e
movups 0x10(%rax), %xmm0
movups %xmm0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
add_compiled_extra_collation:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
mov eax, [rdi]
lea rcx, all_charsets
mov [rcx+rax*8], rdi
or byte ptr [rdi+0Dh], 2
lea rdi, charset_name_hash
mov rsi, rbx
call my_hash_insert
test al, al
jz short loc_95313
mov rsi, [rbx+10h]
mov rdx, [rbx+18h]
lea rdi, charset_name_hash
call my_hash_search
movups xmm0, xmmword ptr [rax+10h]
movups xmmword ptr [rbx+10h], xmm0
loc_95313:
add rsp, 8
pop rbx
pop rbp
retn
|
long long add_compiled_extra_collation(unsigned int *a1)
{
long long result; // rax
all_charsets[*a1] = a1;
*((_BYTE *)a1 + 13) |= 2u;
result = my_hash_insert(&charset_name_hash, a1);
if ( (_BYTE)result )
{
result = my_hash_search(&charset_name_hash, *((_QWORD *)a1 + 2), *((_QWORD *)a1 + 3));
*((_OWORD *)a1 + 1) = *(_OWORD *)(result + 16);
}
return result;
}
|
add_compiled_extra_collation:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV EAX,dword ptr [RDI]
LEA RCX,[0xd02440]
MOV qword ptr [RCX + RAX*0x8],RDI
OR byte ptr [RDI + 0xd],0x2
LEA RDI,[0xd06440]
MOV RSI,RBX
CALL 0x00196bee
TEST AL,AL
JZ 0x00195313
MOV RSI,qword ptr [RBX + 0x10]
MOV RDX,qword ptr [RBX + 0x18]
LEA RDI,[0xd06440]
CALL 0x0019698e
MOVUPS XMM0,xmmword ptr [RAX + 0x10]
MOVUPS xmmword ptr [RBX + 0x10],XMM0
LAB_00195313:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void add_compiled_extra_collation(uint *param_1)
{
int8 uVar1;
char cVar2;
long lVar3;
(&all_charsets)[*param_1] = param_1;
*(byte *)((long)param_1 + 0xd) = *(byte *)((long)param_1 + 0xd) | 2;
cVar2 = my_hash_insert(charset_name_hash,param_1);
if (cVar2 != '\0') {
lVar3 = my_hash_search(charset_name_hash,*(int8 *)(param_1 + 4),
*(int8 *)(param_1 + 6));
uVar1 = *(int8 *)(lVar3 + 0x18);
*(int8 *)(param_1 + 4) = *(int8 *)(lVar3 + 0x10);
*(int8 *)(param_1 + 6) = uVar1;
}
return;
}
|
|
66,093 |
VoxelInfoBuilder::VoxelInfoBuilder(char const*, voxel_type, bool, bool)
|
untodesu[P]voxelius/game/shared/voxel_registry.cc
|
VoxelInfoBuilder::VoxelInfoBuilder(const char *name, voxel_type type, bool animated, bool blending)
{
prototype.name = name;
prototype.type = type;
prototype.animated = animated;
prototype.blending = blending;
switch(type) {
case voxel_type::CUBE:
prototype.textures.resize(static_cast<std::size_t>(voxel_face::CUBE__NR));
break;
case voxel_type::CROSS:
prototype.textures.resize(static_cast<std::size_t>(voxel_face::CROSS__NR));
break;
case voxel_type::MODEL:
// Custom models should use a different texture
// resource management that is not a voxel atlas
// TODO: actually implement custom models lol
prototype.textures.resize(0);
break;
default:
// Something really bad should happen if we end up here.
// The outside code would static_cast an int to VoxelType
// and possibly fuck a lot of things up to cause this
spdlog::critical("voxel_registry: {}: unknown voxel type {}", name, static_cast<int>(type));
std::terminate();
}
// Physics properties
prototype.touch_type = voxel_touch::SOLID;
prototype.touch_values = glm::fvec3(0.0f, 0.0f, 0.0f);
prototype.surface = voxel_surface::DEFAULT;
// Things set in future by item_def
prototype.item_pick = NULL_ITEM_ID;
}
|
O2
|
cpp
|
VoxelInfoBuilder::VoxelInfoBuilder(char const*, voxel_type, bool, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %r8d, %r15d
movl %ecx, %r12d
movl %edx, %ebp
movq %rdi, %rbx
movq %rsi, (%rsp)
leaq 0x1d0e4a(%rip), %rax # 0x24d488
movq %rax, (%rdi)
xorps %xmm0, %xmm0
andq $0x0, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
leaq 0x30(%rdi), %r14
leaq 0x40(%rdi), %rax
movq %rax, 0x30(%rdi)
andq $0x0, 0x38(%rdi)
movb $0x0, 0x40(%rdi)
movups %xmm0, 0x58(%rdi)
andq $0x0, 0x68(%rdi)
movq %r14, %rdi
callq 0x271c0
movw %bp, 0x50(%rbx)
movb %r12b, 0x52(%rbx)
movb %r15b, 0x53(%rbx)
cmpw $0x3, %bp
jae 0x7c6bf
leaq 0x58(%rbx), %rdi
movzwl %bp, %eax
leaq 0xfd765(%rip), %rcx # 0x179df8
movq (%rcx,%rax,8), %rsi
callq 0x7cbd4
andw $0x0, 0x70(%rbx)
andl $0x0, 0x84(%rbx)
andq $0x0, 0x74(%rbx)
andq $0x0, 0x7a(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movzwl %bp, %eax
leaq 0xc(%rsp), %rcx
movl %eax, (%rcx)
leaq 0xfd640(%rip), %rdi # 0x179d10
pushq $0x29
popq %rsi
movq %rsp, %rdx
callq 0x7cc09
callq 0x26200
jmp 0x7c6e2
movq %rax, %r15
addq $0x8, %rbx
movq %r14, %rdi
callq 0x7cc42
movq %rbx, %rdi
callq 0x3c8c4
movq %r15, %rdi
callq 0x27040
nop
|
_ZN16VoxelInfoBuilderC2EPKc10voxel_typebb:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov r15d, r8d
mov r12d, ecx
mov ebp, edx
mov rbx, rdi
mov [rsp+38h+var_38], rsi
lea rax, off_24D488
mov [rdi], rax
xorps xmm0, xmm0
and qword ptr [rdi+18h], 0
movups xmmword ptr [rdi+8], xmm0
lea r14, [rdi+30h]
lea rax, [rdi+40h]
mov [rdi+30h], rax
and qword ptr [rdi+38h], 0
mov byte ptr [rdi+40h], 0
movups xmmword ptr [rdi+58h], xmm0
and qword ptr [rdi+68h], 0
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6assignEPKc; std::string::assign(char const*)
mov [rbx+50h], bp
mov [rbx+52h], r12b
mov [rbx+53h], r15b
cmp bp, 3
jnb short loc_7C6BF
lea rdi, [rbx+58h]
movzx eax, bp
lea rcx, unk_179DF8
mov rsi, [rcx+rax*8]
call _ZNSt6vectorI12VoxelTextureSaIS0_EE6resizeEm; std::vector<VoxelTexture>::resize(ulong)
and word ptr [rbx+70h], 0
and dword ptr [rbx+84h], 0
and qword ptr [rbx+74h], 0
and qword ptr [rbx+7Ah], 0
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_7C6BF:
movzx eax, bp
lea rcx, [rsp+38h+var_2C]
mov [rcx], eax
lea rdi, aVoxelRegistryU; "voxel_registry: {}: unknown voxel type "...
push 29h ; ')'
pop rsi
mov rdx, rsp
call _ZN6spdlog8criticalIJRPKciEEEvN3fmt3v1119basic_format_stringIcJDpNS5_13type_identityIT_E4typeEEEEDpOS8_; spdlog::critical<char const*&,int>(fmt::v11::basic_format_string<char,fmt::v11::type_identity<char const*&,int>::type>,char const*&,int&&)
call __ZSt9terminatev; std::terminate(void)
jmp short $+2
loc_7C6E2:
mov r15, rax
add rbx, 8
mov rdi, r14; this
call _ZN9VoxelInfoD2Ev; VoxelInfo::~VoxelInfo()
mov rdi, rbx; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, r15
call __Unwind_Resume
|
long long VoxelInfoBuilder::VoxelInfoBuilder(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6)
{
char v6; // r15
char v7; // r12
unsigned __int16 v8; // bp
long long result; // rax
long long v10; // [rsp+0h] [rbp-38h] BYREF
int v11; // [rsp+Ch] [rbp-2Ch]
v6 = a5;
v7 = a4;
v8 = a3;
v10 = a2;
*(_QWORD *)a1 = off_24D488;
*(_QWORD *)(a1 + 24) = 0LL;
*(_OWORD *)(a1 + 8) = 0LL;
*(_QWORD *)(a1 + 48) = a1 + 64;
*(_QWORD *)(a1 + 56) = 0LL;
*(_BYTE *)(a1 + 64) = 0;
*(_OWORD *)(a1 + 88) = 0LL;
*(_QWORD *)(a1 + 104) = 0LL;
std::string::assign(a1 + 48, a2, a3, a4, a5, a6);
*(_WORD *)(a1 + 80) = v8;
*(_BYTE *)(a1 + 82) = v7;
*(_BYTE *)(a1 + 83) = v6;
if ( v8 >= 3u )
{
v11 = v8;
spdlog::critical<char const*&,int>("voxel_registry: {}: unknown voxel type {}", 41LL, &v10);
std::terminate();
}
result = std::vector<VoxelTexture>::resize(a1 + 88, qword_179DF8[v8]);
*(_WORD *)(a1 + 112) = 0;
*(_DWORD *)(a1 + 132) = 0;
*(_QWORD *)(a1 + 116) = 0LL;
*(_QWORD *)(a1 + 122) = 0LL;
return result;
}
|
VoxelInfoBuilder:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R15D,R8D
MOV R12D,ECX
MOV EBP,EDX
MOV RBX,RDI
MOV qword ptr [RSP],RSI
LEA RAX,[0x34d488]
MOV qword ptr [RDI],RAX
XORPS XMM0,XMM0
AND qword ptr [RDI + 0x18],0x0
MOVUPS xmmword ptr [RDI + 0x8],XMM0
LEA R14,[RDI + 0x30]
LEA RAX,[RDI + 0x40]
MOV qword ptr [RDI + 0x30],RAX
AND qword ptr [RDI + 0x38],0x0
MOV byte ptr [RDI + 0x40],0x0
MOVUPS xmmword ptr [RDI + 0x58],XMM0
AND qword ptr [RDI + 0x68],0x0
LAB_0017c66b:
MOV RDI,R14
CALL 0x001271c0
MOV word ptr [RBX + 0x50],BP
MOV byte ptr [RBX + 0x52],R12B
MOV byte ptr [RBX + 0x53],R15B
CMP BP,0x3
JNC 0x0017c6bf
LEA RDI,[RBX + 0x58]
MOVZX EAX,BP
LEA RCX,[0x279df8]
MOV RSI,qword ptr [RCX + RAX*0x8]
CALL 0x0017cbd4
AND word ptr [RBX + 0x70],0x0
AND dword ptr [RBX + 0x84],0x0
AND qword ptr [RBX + 0x74],0x0
AND qword ptr [RBX + 0x7a],0x0
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0017c6bf:
MOVZX EAX,BP
LEA RCX,[RSP + 0xc]
MOV dword ptr [RCX],EAX
LAB_0017c6c9:
LEA RDI,[0x279d10]
PUSH 0x29
POP RSI
MOV RDX,RSP
CALL 0x0017cc09
LAB_0017c6db:
CALL 0x00126200
|
/* VoxelInfoBuilder::VoxelInfoBuilder(char const*, voxel_type, bool, bool) */
void __thiscall
VoxelInfoBuilder::VoxelInfoBuilder
(VoxelInfoBuilder *this,int8 param_1,ushort param_3,VoxelInfoBuilder param_4,
VoxelInfoBuilder param_5)
{
int8 local_38;
uint local_2c;
*(int ***)this = &PTR__VoxelInfoBuilder_0034d488;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(VoxelInfoBuilder **)(this + 0x30) = this + 0x40;
*(int8 *)(this + 0x38) = 0;
this[0x40] = (VoxelInfoBuilder)0x0;
*(int8 *)(this + 0x58) = 0;
*(int8 *)(this + 0x60) = 0;
*(int8 *)(this + 0x68) = 0;
local_38 = param_1;
/* try { // try from 0017c66b to 0017c69b has its CatchHandler @ 0017c6e2 */
std::__cxx11::string::assign((char *)(this + 0x30));
*(ushort *)(this + 0x50) = param_3;
this[0x52] = param_4;
this[0x53] = param_5;
if (param_3 < 3) {
std::vector<VoxelTexture,std::allocator<VoxelTexture>>::resize
((vector<VoxelTexture,std::allocator<VoxelTexture>> *)(this + 0x58),
*(ulong *)(&DAT_00279df8 + (ulong)param_3 * 8));
*(int2 *)(this + 0x70) = 0;
*(int4 *)(this + 0x84) = 0;
*(int8 *)(this + 0x74) = 0;
*(int8 *)(this + 0x7a) = 0;
return;
}
local_2c = (uint)param_3;
/* try { // try from 0017c6c9 to 0017c6da has its CatchHandler @ 0017c6e0 */
spdlog::critical<char_const*&,int>
((spdlog *)"voxel_registry: {}: unknown voxel type {}",0x29,&local_38);
/* WARNING: Subroutine does not return */
std::terminate();
}
|
|
66,094 |
ma_update_blob_record
|
eloqsql/storage/maria/ma_dynrec.c
|
my_bool _ma_update_blob_record(MARIA_HA *info, MARIA_RECORD_POS pos,
const uchar *oldrec __attribute__ ((unused)),
const uchar *record)
{
uchar *rec_buff;
int error;
ulong reclength,reclength2,extra;
my_bool buff_alloced;
extra= (ALIGN_SIZE(MARIA_MAX_DYN_BLOCK_HEADER)+MARIA_SPLIT_LENGTH+
MARIA_DYN_DELETE_BLOCK_HEADER);
reclength= (info->s->base.pack_reclength+
_ma_calc_total_blob_length(info,record)+ extra);
#ifdef NOT_USED /* We now support big rows */
if (reclength > MARIA_DYN_MAX_ROW_LENGTH)
{
my_errno=HA_ERR_TO_BIG_ROW;
return 1;
}
#endif
alloc_on_stack(*info->stack_end_ptr, rec_buff, buff_alloced, reclength);
if (!rec_buff)
{
my_errno= HA_ERR_OUT_OF_MEM; /* purecov: inspected */
return(1);
}
reclength2= _ma_rec_pack(info, rec_buff+
ALIGN_SIZE(MARIA_MAX_DYN_BLOCK_HEADER),
record);
if (!reclength2)
{
error= 1;
goto err;
}
DBUG_ASSERT(reclength2 <= reclength);
error=update_dynamic_record(info,pos,
rec_buff+ALIGN_SIZE(MARIA_MAX_DYN_BLOCK_HEADER),
reclength2);
err:
stack_alloc_free(rec_buff, buff_alloced);
return(error != 0);
}
|
O0
|
c
|
ma_update_blob_record:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq $0x5c, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x3a0(%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x3cb30
movq %rax, %rcx
movq -0x78(%rbp), %rax
addq %rcx, %rax
addq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movq (%rax), %rax
leaq -0x68(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
cmpq -0x68(%rbp), %rax
jbe 0x3ccd7
movq -0x70(%rbp), %rcx
subq -0x68(%rbp), %rcx
movl $0x10000, %eax # imm = 0x10000
cmpq %rcx, %rax
jb 0x3ccb8
movq -0x70(%rbp), %rcx
subq -0x68(%rbp), %rcx
movl $0x8000, %eax # imm = 0x8000
cmpq %rcx, %rax
jae 0x3ccd7
movl $0x1000, %eax # imm = 0x1000
cmpq -0x68(%rbp), %rax
ja 0x3ccd7
movb $0x0, -0x59(%rbp)
movq -0x48(%rbp), %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x38(%rbp)
jmp 0x3ccef
movb $0x1, -0x59(%rbp)
movq -0x48(%rbp), %rsi
xorl %edi, %edi
movl $0x10010, %edx # imm = 0x10010
callq 0xf3830
movq %rax, -0x38(%rbp)
jmp 0x3ccf1
cmpq $0x0, -0x38(%rbp)
jne 0x3cd09
callq 0xf6090
movl $0x80, (%rax)
movb $0x1, -0x9(%rbp)
jmp 0x3cd73
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x18, %rsi
movq -0x30(%rbp), %rdx
callq 0x3ba70
movl %eax, %eax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x3cd34
movl $0x1, -0x3c(%rbp)
jmp 0x3cd57
jmp 0x3cd36
jmp 0x3cd38
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
addq $0x18, %rdx
movq -0x50(%rbp), %rcx
callq 0x3c240
movsbl %al, %eax
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rdi
movsbl -0x59(%rbp), %esi
callq 0x3cbd0
cmpl $0x0, -0x3c(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
movb %al, -0x79(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x3cd93
movb -0x79(%rbp), %al
movq %rbp, %rsp
popq %rbp
retq
callq 0x2a270
nopl (%rax,%rax)
|
_ma_update_blob_record:
push rbp
mov rbp, rsp
sub rsp, 80h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
mov [rbp+var_30], rcx
mov [rbp+var_58], 5Ch ; '\'
mov rax, [rbp+var_18]
mov rax, [rax]
mov rax, [rax+3A0h]
mov [rbp+var_78], rax
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_30]
call _ma_calc_total_blob_length
mov rcx, rax
mov rax, [rbp+var_78]
add rax, rcx
add rax, [rbp+var_58]
mov [rbp+var_48], rax
mov rax, [rbp+var_48]
mov [rbp+var_68], rax
mov rax, [rbp+var_18]
mov rax, [rax+78h]
mov rax, [rax]
lea rcx, [rbp+var_68]
sub rax, rcx
mov [rbp+var_70], rax
mov rax, [rbp+var_70]
cmp rax, [rbp+var_68]
jbe short loc_3CCD7
mov rcx, [rbp+var_70]
sub rcx, [rbp+var_68]
mov eax, 10000h
cmp rax, rcx
jb short loc_3CCB8
mov rcx, [rbp+var_70]
sub rcx, [rbp+var_68]
mov eax, 8000h
cmp rax, rcx
jnb short loc_3CCD7
mov eax, 1000h
cmp rax, [rbp+var_68]
ja short loc_3CCD7
loc_3CCB8:
mov [rbp+var_59], 0
mov rcx, [rbp+var_48]
add rcx, 0Fh
and rcx, 0FFFFFFFFFFFFFFF0h
mov rax, rsp
sub rax, rcx
mov rsp, rax
mov [rbp+var_38], rax
jmp short loc_3CCEF
loc_3CCD7:
mov [rbp+var_59], 1
mov rsi, [rbp+var_48]
xor edi, edi
mov edx, offset stru_10010
call my_malloc
mov [rbp+var_38], rax
loc_3CCEF:
jmp short $+2
loc_3CCF1:
cmp [rbp+var_38], 0
jnz short loc_3CD09
call _my_thread_var
mov dword ptr [rax], 80h
mov [rbp+var_9], 1
jmp short loc_3CD73
loc_3CD09:
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_38]
add rsi, 18h
mov rdx, [rbp+var_30]
call _ma_rec_pack
mov eax, eax
mov [rbp+var_50], rax
cmp [rbp+var_50], 0
jnz short loc_3CD34
mov [rbp+var_3C], 1
jmp short loc_3CD57
loc_3CD34:
jmp short $+2
loc_3CD36:
jmp short $+2
loc_3CD38:
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_38]
add rdx, 18h
mov rcx, [rbp+var_50]
call update_dynamic_record
movsx eax, al
mov [rbp+var_3C], eax
loc_3CD57:
mov rdi, [rbp+var_38]
movsx esi, [rbp+var_59]
call stack_alloc_free
cmp [rbp+var_3C], 0
setnz al
and al, 1
movzx eax, al
mov [rbp+var_9], al
loc_3CD73:
mov al, [rbp+var_9]
mov [rbp+var_79], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_3CD93
mov al, [rbp+var_79]
mov rsp, rbp
pop rbp
retn
loc_3CD93:
call ___stack_chk_fail
|
bool ma_update_blob_record(long long a1, long long a2, long long a3, _BYTE *a4)
{
unsigned int v4; // eax
long long v6; // [rsp+0h] [rbp-80h] BYREF
long long v7; // [rsp+8h] [rbp-78h]
unsigned long long v8; // [rsp+10h] [rbp-70h]
unsigned long long v9; // [rsp+18h] [rbp-68h] BYREF
char v10; // [rsp+27h] [rbp-59h]
long long v11; // [rsp+28h] [rbp-58h]
unsigned long long v12; // [rsp+30h] [rbp-50h]
unsigned long long v13; // [rsp+38h] [rbp-48h]
int updated; // [rsp+44h] [rbp-3Ch]
long long v15; // [rsp+48h] [rbp-38h]
_BYTE *v16; // [rsp+50h] [rbp-30h]
long long v17; // [rsp+58h] [rbp-28h]
long long v18; // [rsp+60h] [rbp-20h]
_DWORD *v19; // [rsp+68h] [rbp-18h]
unsigned long long v21; // [rsp+78h] [rbp-8h]
v21 = __readfsqword(0x28u);
v19 = (_DWORD *)a1;
v18 = a2;
v17 = a3;
v16 = a4;
v11 = 92LL;
v7 = *(_QWORD *)(*(_QWORD *)a1 + 928LL);
v13 = ma_calc_total_blob_length((_QWORD *)a1, (long long)a4, a3) + v7 + 92;
v9 = v13;
v8 = **(_QWORD **)(a1 + 120) - (_QWORD)&v9;
if ( v8 <= v13 || v8 - v9 <= 0x10000 && (v8 - v9 <= 0x8000 || v9 < 0x1000) )
{
v10 = 1;
v15 = my_malloc(0LL, v13, &stru_10010);
}
else
{
v10 = 0;
v15 = (long long)&v6 - ((v13 + 15) & 0xFFFFFFFFFFFFFFF0LL);
}
if ( v15 )
{
v4 = ma_rec_pack(v19, (_BYTE *)(v15 + 24), v16);
v12 = v4;
if ( v4 )
updated = update_dynamic_record((long long)v19, v18, v15 + 24, v12);
else
updated = 1;
stack_alloc_free(v15, v10);
return updated != 0;
}
else
{
*(_DWORD *)my_thread_var() = 128;
return 1;
}
}
|
_ma_update_blob_record:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
MOV qword ptr [RBP + -0x30],RCX
MOV qword ptr [RBP + -0x58],0x5c
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x3a0]
MOV qword ptr [RBP + -0x78],RAX
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x30]
CALL 0x0013cb30
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,RCX
ADD RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x78]
MOV RAX,qword ptr [RAX]
LEA RCX,[RBP + -0x68]
SUB RAX,RCX
MOV qword ptr [RBP + -0x70],RAX
MOV RAX,qword ptr [RBP + -0x70]
CMP RAX,qword ptr [RBP + -0x68]
JBE 0x0013ccd7
MOV RCX,qword ptr [RBP + -0x70]
SUB RCX,qword ptr [RBP + -0x68]
MOV EAX,0x10000
CMP RAX,RCX
JC 0x0013ccb8
MOV RCX,qword ptr [RBP + -0x70]
SUB RCX,qword ptr [RBP + -0x68]
MOV EAX,0x8000
CMP RAX,RCX
JNC 0x0013ccd7
MOV EAX,0x1000
CMP RAX,qword ptr [RBP + -0x68]
JA 0x0013ccd7
LAB_0013ccb8:
MOV byte ptr [RBP + -0x59],0x0
MOV RCX,qword ptr [RBP + -0x48]
ADD RCX,0xf
AND RCX,-0x10
MOV RAX,RSP
SUB RAX,RCX
MOV RSP,RAX
MOV qword ptr [RBP + -0x38],RAX
JMP 0x0013ccef
LAB_0013ccd7:
MOV byte ptr [RBP + -0x59],0x1
MOV RSI,qword ptr [RBP + -0x48]
XOR EDI,EDI
MOV EDX,0x10010
CALL 0x001f3830
MOV qword ptr [RBP + -0x38],RAX
LAB_0013ccef:
JMP 0x0013ccf1
LAB_0013ccf1:
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x0013cd09
CALL 0x001f6090
MOV dword ptr [RAX],0x80
MOV byte ptr [RBP + -0x9],0x1
JMP 0x0013cd73
LAB_0013cd09:
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x38]
ADD RSI,0x18
MOV RDX,qword ptr [RBP + -0x30]
CALL 0x0013ba70
MOV EAX,EAX
MOV qword ptr [RBP + -0x50],RAX
CMP qword ptr [RBP + -0x50],0x0
JNZ 0x0013cd34
MOV dword ptr [RBP + -0x3c],0x1
JMP 0x0013cd57
LAB_0013cd34:
JMP 0x0013cd36
LAB_0013cd36:
JMP 0x0013cd38
LAB_0013cd38:
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x38]
ADD RDX,0x18
MOV RCX,qword ptr [RBP + -0x50]
CALL 0x0013c240
MOVSX EAX,AL
MOV dword ptr [RBP + -0x3c],EAX
LAB_0013cd57:
MOV RDI,qword ptr [RBP + -0x38]
MOVSX ESI,byte ptr [RBP + -0x59]
CALL 0x0013cbd0
CMP dword ptr [RBP + -0x3c],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x9],AL
LAB_0013cd73:
MOV AL,byte ptr [RBP + -0x9]
MOV byte ptr [RBP + -0x79],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0013cd93
MOV AL,byte ptr [RBP + -0x79]
MOV RSP,RBP
POP RBP
RET
LAB_0013cd93:
CALL 0x0012a270
|
int8
_ma_update_blob_record(long *param_1,int8 param_2,int8 param_3,int8 param_4)
{
int8 uVar1;
long *plVar2;
char cVar3;
uint uVar4;
long lVar5;
int4 *puVar6;
ulong uVar7;
int1 *puVar8;
int iVar9;
int1 *puVar10;
long in_FS_OFFSET;
int1 auStack_88 [7];
bool local_81;
long local_80;
ulong local_78;
ulong local_70;
char local_61;
long local_60;
ulong local_58;
ulong local_50;
int local_44;
int1 *local_40;
int8 local_38;
int8 local_30;
int8 local_28;
long *local_20;
bool local_11;
long local_10;
puVar8 = auStack_88;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_60 = 0x5c;
local_80 = *(long *)(*param_1 + 0x3a0);
local_38 = param_4;
local_30 = param_3;
local_28 = param_2;
local_20 = param_1;
lVar5 = _ma_calc_total_blob_length(param_1,param_4);
local_70 = local_80 + lVar5 + local_60;
local_78 = *(long *)local_20[0xf] - (long)&local_70;
local_50 = local_70;
if ((local_70 < local_78) &&
((0x10000 < local_78 - local_70 || ((0x8000 < local_78 - local_70 && (0xfff < local_70)))))) {
local_61 = '\0';
puVar8 = auStack_88 + -(local_70 + 0xf & 0xfffffffffffffff0);
local_40 = puVar8;
}
else {
local_61 = '\x01';
local_40 = (int1 *)my_malloc(0,local_70,0x10010);
}
plVar2 = local_20;
uVar1 = local_38;
if (local_40 == (int1 *)0x0) {
*(int8 *)(puVar8 + -8) = 0x13ccfd;
puVar6 = (int4 *)_my_thread_var();
*puVar6 = 0x80;
local_11 = true;
}
else {
puVar10 = local_40 + 0x18;
*(int8 *)(puVar8 + -8) = 0x13cd1e;
uVar4 = _ma_rec_pack(plVar2,puVar10,uVar1);
plVar2 = local_20;
uVar1 = local_28;
uVar7 = (ulong)uVar4;
local_58 = uVar7;
if (uVar7 == 0) {
local_44 = 1;
}
else {
puVar10 = local_40 + 0x18;
*(int8 *)(puVar8 + -8) = 0x13cd51;
cVar3 = update_dynamic_record(plVar2,uVar1,puVar10,uVar7);
local_44 = (int)cVar3;
}
puVar10 = local_40;
iVar9 = (int)local_61;
*(int8 *)(puVar8 + -8) = 0x13cd64;
stack_alloc_free(puVar10,iVar9);
local_11 = local_44 != 0;
}
local_81 = local_11;
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),local_11);
}
/* WARNING: Subroutine does not return */
*(int8 *)(puVar8 + -8) = 0x13cd98;
__stack_chk_fail();
}
|
|
66,095 |
ratio
|
eloqsql/strings/dtoa.c
|
static double ratio(Bigint *a, Bigint *b)
{
U da, db;
int k, ka, kb;
dval(&da)= b2d(a, &ka);
dval(&db)= b2d(b, &kb);
k= ka - kb + 32*(a->wds - b->wds);
if (k > 0)
word0(&da)+= (ULong)(k*Exp_msk1 * 1.0);
else
{
k= -k;
word0(&db)+= k*Exp_msk1;
}
return dval(&da) / dval(&db);
}
|
O0
|
c
|
ratio:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x5a800
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x5a800
movsd %xmm0, -0x20(%rbp)
movl -0x28(%rbp), %eax
subl -0x2c(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x14(%rcx), %ecx
movq -0x10(%rbp), %rdx
subl 0x14(%rdx), %ecx
shll $0x5, %ecx
addl %ecx, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0x5a4a4
movl -0x24(%rbp), %eax
shll $0x14, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x5a4b8
xorl %eax, %eax
subl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
shll $0x14, %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movsd -0x18(%rbp), %xmm0
divsd -0x20(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
ratio:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rdi, [rbp+var_8]
lea rsi, [rbp+var_28]
call b2d
movsd [rbp+var_18], xmm0
mov rdi, [rbp+var_10]
lea rsi, [rbp+var_2C]
call b2d
movsd [rbp+var_20], xmm0
mov eax, [rbp+var_28]
sub eax, [rbp+var_2C]
mov rcx, [rbp+var_8]
mov ecx, [rcx+14h]
mov rdx, [rbp+var_10]
sub ecx, [rdx+14h]
shl ecx, 5
add eax, ecx
mov [rbp+var_24], eax
cmp [rbp+var_24], 0
jle short loc_5A4A4
mov eax, [rbp+var_24]
shl eax, 14h
add eax, dword ptr [rbp+var_18+4]
mov dword ptr [rbp+var_18+4], eax
jmp short loc_5A4B8
loc_5A4A4:
xor eax, eax
sub eax, [rbp+var_24]
mov [rbp+var_24], eax
mov eax, [rbp+var_24]
shl eax, 14h
add eax, dword ptr [rbp+var_20+4]
mov dword ptr [rbp+var_20+4], eax
loc_5A4B8:
movsd xmm0, [rbp+var_18]
divsd xmm0, [rbp+var_20]
add rsp, 30h
pop rbp
retn
|
double ratio(long long a1, long long a2)
{
int v3; // [rsp+4h] [rbp-2Ch] BYREF
int v4; // [rsp+8h] [rbp-28h] BYREF
int v5; // [rsp+Ch] [rbp-24h]
double v6; // [rsp+10h] [rbp-20h]
double v7; // [rsp+18h] [rbp-18h]
long long v8; // [rsp+20h] [rbp-10h]
long long v9; // [rsp+28h] [rbp-8h]
v9 = a1;
v8 = a2;
v7 = b2d(a1, &v4);
v6 = b2d(v8, &v3);
v5 = 32 * (*(_DWORD *)(v9 + 20) - *(_DWORD *)(v8 + 20)) + v4 - v3;
if ( v5 <= 0 )
{
v5 = -v5;
HIDWORD(v6) += v5 << 20;
}
else
{
HIDWORD(v7) += v5 << 20;
}
return v7 / v6;
}
|
ratio:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[RBP + -0x28]
CALL 0x0015a800
MOVSD qword ptr [RBP + -0x18],XMM0
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[RBP + -0x2c]
CALL 0x0015a800
MOVSD qword ptr [RBP + -0x20],XMM0
MOV EAX,dword ptr [RBP + -0x28]
SUB EAX,dword ptr [RBP + -0x2c]
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x14]
MOV RDX,qword ptr [RBP + -0x10]
SUB ECX,dword ptr [RDX + 0x14]
SHL ECX,0x5
ADD EAX,ECX
MOV dword ptr [RBP + -0x24],EAX
CMP dword ptr [RBP + -0x24],0x0
JLE 0x0015a4a4
MOV EAX,dword ptr [RBP + -0x24]
SHL EAX,0x14
ADD EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x14],EAX
JMP 0x0015a4b8
LAB_0015a4a4:
XOR EAX,EAX
SUB EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x24],EAX
MOV EAX,dword ptr [RBP + -0x24]
SHL EAX,0x14
ADD EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x1c],EAX
LAB_0015a4b8:
MOVSD XMM0,qword ptr [RBP + -0x18]
DIVSD XMM0,qword ptr [RBP + -0x20]
ADD RSP,0x30
POP RBP
RET
|
double ratio(long param_1,long param_2)
{
int iVar1;
double dVar2;
int local_34;
int local_30 [2];
int8 local_28;
int8 local_20;
long local_18;
long local_10;
local_18 = param_2;
local_10 = param_1;
local_20 = (double)b2d(param_1,local_30);
dVar2 = (double)b2d(local_18,&local_34);
iVar1 = (local_30[0] - local_34) + (*(int *)(local_10 + 0x14) - *(int *)(local_18 + 0x14)) * 0x20;
if (iVar1 < 1) {
local_28._4_4_ = (int)((ulong)dVar2 >> 0x20);
local_28 = (double)CONCAT44(iVar1 * -0x100000 + local_28._4_4_,SUB84(dVar2,0));
}
else {
local_20 = (double)CONCAT44(iVar1 * 0x100000 + local_20._4_4_,(int4)local_20);
local_28 = dVar2;
}
return local_20 / local_28;
}
|
|
66,096 |
stbi__zexpand
|
dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-image.h
|
static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes
{
char *q;
unsigned int cur, limit, old_limit;
z->zout = zout;
if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG");
cur = (unsigned int) (z->zout - z->zout_start);
limit = old_limit = (unsigned) (z->zout_end - z->zout_start);
if (UINT_MAX - cur < (unsigned) n) return stbi__err("outofmem", "Out of memory");
while (cur + n > limit) {
if(limit > UINT_MAX / 2) return stbi__err("outofmem", "Out of memory");
limit *= 2;
}
q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit);
STBI_NOTUSED(old_limit);
if (q == NULL) return stbi__err("outofmem", "Out of memory");
z->zout_start = q;
z->zout = q + cur;
z->zout_end = q + limit;
return 1;
}
|
O1
|
c
|
stbi__zexpand:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, 0x20(%rdi)
cmpl $0x0, 0x38(%rdi)
je 0x35ede
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
subq %rdi, %r14
addl %r14d, %edx
jb 0x35f1f
movl 0x30(%rbx), %eax
subl %edi, %eax
cmpl %eax, %edx
jbe 0x35ef3
testl %eax, %eax
js 0x35f1f
addl %eax, %eax
jmp 0x35ed2
movq %fs:0x0, %rax
leaq 0x11d1a(%rip), %rcx # 0x47c0b
jmp 0x35f32
movl %eax, %r15d
movq %r15, %rsi
callq 0xa540
testq %rax, %rax
je 0x35f1f
movq %rax, 0x28(%rbx)
movl %r14d, %ecx
addq %rax, %rcx
movq %rcx, 0x20(%rbx)
addq %rax, %r15
movq %r15, 0x30(%rbx)
movl $0x1, %eax
jmp 0x35f3b
movq %fs:0x0, %rax
leaq 0x11c71(%rip), %rcx # 0x47ba3
movq %rcx, -0x8(%rax)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
|
stbi__zexpand:
push r15
push r14
push rbx
mov [rdi+20h], rsi
cmp dword ptr [rdi+38h], 0
jz short loc_35EDE
mov r14, rsi
mov rbx, rdi
mov rdi, [rdi+28h]
sub r14, rdi
add edx, r14d
jb short loc_35F1F
mov eax, [rbx+30h]
sub eax, edi
loc_35ED2:
cmp edx, eax
jbe short loc_35EF3
test eax, eax
js short loc_35F1F
add eax, eax
jmp short loc_35ED2
loc_35EDE:
mov rax, fs:0
lea rcx, aOutputBufferLi; "output buffer limit"
jmp short loc_35F32
loc_35EF3:
mov r15d, eax
mov rsi, r15
call _realloc
test rax, rax
jz short loc_35F1F
mov [rbx+28h], rax
mov ecx, r14d
add rcx, rax
mov [rbx+20h], rcx
add r15, rax
mov [rbx+30h], r15
mov eax, 1
jmp short loc_35F3B
loc_35F1F:
mov rax, fs:0
lea rcx, aOutofmem; "outofmem"
loc_35F32:
mov [rax-8], rcx
xor eax, eax
loc_35F3B:
pop rbx
pop r14
pop r15
retn
|
long long stbi__zexpand(long long a1, long long a2, int a3, long long a4)
{
long long v5; // rdi
bool v6; // cf
long long v7; // rdx
unsigned int i; // eax
unsigned long long v9; // rax
const char *v10; // rcx
long long v11; // r15
long long v12; // rax
*(_QWORD *)(a1 + 32) = a2;
if ( *(_DWORD *)(a1 + 56) )
{
v5 = *(_QWORD *)(a1 + 40);
v6 = __CFADD__(a2 - v5, a3);
v7 = (unsigned int)(a2 - v5 + a3);
if ( !v6 )
{
for ( i = *(_DWORD *)(a1 + 48) - v5; (unsigned int)v7 > i; i *= 2 )
{
if ( (i & 0x80000000) != 0 )
goto LABEL_10;
}
v11 = i;
v12 = realloc(v5, i, v7, a4);
if ( v12 )
{
*(_QWORD *)(a1 + 40) = v12;
*(_QWORD *)(a1 + 32) = v12 + (unsigned int)(a2 - v5);
*(_QWORD *)(a1 + 48) = v12 + v11;
return 1LL;
}
}
LABEL_10:
v9 = __readfsqword(0);
v10 = "outofmem";
}
else
{
v9 = __readfsqword(0);
v10 = "output buffer limit";
}
*(_QWORD *)(v9 - 8) = v10;
return 0LL;
}
|
stbi__zexpand:
PUSH R15
PUSH R14
PUSH RBX
MOV qword ptr [RDI + 0x20],RSI
CMP dword ptr [RDI + 0x38],0x0
JZ 0x00135ede
MOV R14,RSI
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x28]
SUB R14,RDI
ADD EDX,R14D
JC 0x00135f1f
MOV EAX,dword ptr [RBX + 0x30]
SUB EAX,EDI
LAB_00135ed2:
CMP EDX,EAX
JBE 0x00135ef3
TEST EAX,EAX
JS 0x00135f1f
ADD EAX,EAX
JMP 0x00135ed2
LAB_00135ede:
MOV RAX,qword ptr FS:[0x0]
LEA RCX,[0x147c0b]
JMP 0x00135f32
LAB_00135ef3:
MOV R15D,EAX
MOV RSI,R15
CALL 0x0010a540
TEST RAX,RAX
JZ 0x00135f1f
MOV qword ptr [RBX + 0x28],RAX
MOV ECX,R14D
ADD RCX,RAX
MOV qword ptr [RBX + 0x20],RCX
ADD R15,RAX
MOV qword ptr [RBX + 0x30],R15
MOV EAX,0x1
JMP 0x00135f3b
LAB_00135f1f:
MOV RAX,qword ptr FS:[0x0]
LEA RCX,[0x147ba3]
LAB_00135f32:
MOV qword ptr [RAX + -0x8],RCX
XOR EAX,EAX
LAB_00135f3b:
POP RBX
POP R14
POP R15
RET
|
int8 stbi__zexpand(long param_1,long param_2,uint param_3)
{
void *__ptr;
uint uVar1;
void *pvVar2;
long lVar3;
char *pcVar4;
uint uVar5;
long *in_FS_OFFSET;
*(long *)(param_1 + 0x20) = param_2;
if (*(int *)(param_1 + 0x38) == 0) {
lVar3 = *in_FS_OFFSET;
pcVar4 = "output buffer limit";
}
else {
__ptr = *(void **)(param_1 + 0x28);
uVar5 = (uint)(param_2 - (long)__ptr);
if (!CARRY4(param_3,uVar5)) {
for (uVar1 = *(int *)(param_1 + 0x30) - (int)__ptr; uVar1 < param_3 + uVar5; uVar1 = uVar1 * 2
) {
if ((int)uVar1 < 0) goto LAB_00135f1f;
}
pvVar2 = realloc(__ptr,(ulong)uVar1);
if (pvVar2 != (void *)0x0) {
*(void **)(param_1 + 0x28) = pvVar2;
*(ulong *)(param_1 + 0x20) = (param_2 - (long)__ptr & 0xffffffffU) + (long)pvVar2;
*(ulong *)(param_1 + 0x30) = (ulong)uVar1 + (long)pvVar2;
return 1;
}
}
LAB_00135f1f:
lVar3 = *in_FS_OFFSET;
pcVar4 = "outofmem";
}
*(char **)(lVar3 + -8) = pcVar4;
return 0;
}
|
|
66,097 |
find_export_entry
|
bluesky950520[P]quickjs/quickjs.c
|
static JSExportEntry *find_export_entry(JSContext *ctx, const JSModuleDef *m,
JSAtom export_name)
{
JSExportEntry *me;
int i;
for(i = 0; i < m->export_entries_count; i++) {
me = &m->export_entries[i];
if (me->export_name == export_name)
return me;
}
return NULL;
}
|
O2
|
c
|
find_export_entry:
movl 0x30(%rdi), %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
shlq $0x5, %rcx
pushq $-0x20
popq %rdx
leaq 0x20(%rdx), %r8
cmpq %r8, %rcx
je 0x2913c
movq 0x28(%rdi), %r9
cmpl %esi, 0x38(%r9,%rdx)
movq %r8, %rdx
jne 0x2911f
addq %r8, %r9
movq %r9, %rax
retq
|
find_export_entry:
mov ecx, [rdi+30h]
xor eax, eax
test ecx, ecx
cmovle ecx, eax
shl rcx, 5
push 0FFFFFFFFFFFFFFE0h
pop rdx
loc_2911F:
lea r8, [rdx+20h]
cmp rcx, r8
jz short locret_2913C
mov r9, [rdi+28h]
cmp [r9+rdx+38h], esi
mov rdx, r8
jnz short loc_2911F
add r9, r8
mov rax, r9
locret_2913C:
retn
|
long long find_export_entry(long long a1, int a2)
{
long long v2; // rcx
long long result; // rax
long long v4; // rcx
long long i; // rdx
long long v6; // r8
long long v7; // r9
v2 = *(unsigned int *)(a1 + 48);
result = 0LL;
if ( (int)v2 <= 0 )
v2 = 0LL;
v4 = 32 * v2;
for ( i = -32LL; ; i += 32LL )
{
v6 = i + 32;
if ( v4 == i + 32 )
break;
v7 = *(_QWORD *)(a1 + 40);
if ( *(_DWORD *)(v7 + i + 56) == a2 )
return v6 + v7;
}
return result;
}
|
find_export_entry:
MOV ECX,dword ptr [RDI + 0x30]
XOR EAX,EAX
TEST ECX,ECX
CMOVLE ECX,EAX
SHL RCX,0x5
PUSH -0x20
POP RDX
LAB_0012911f:
LEA R8,[RDX + 0x20]
CMP RCX,R8
JZ 0x0012913c
MOV R9,qword ptr [RDI + 0x28]
CMP dword ptr [R9 + RDX*0x1 + 0x38],ESI
MOV RDX,R8
JNZ 0x0012911f
ADD R9,R8
MOV RAX,R9
LAB_0012913c:
RET
|
long find_export_entry(long param_1,int param_2)
{
long lVar1;
int *piVar2;
ulong uVar3;
long lVar4;
uVar3 = (ulong)*(uint *)(param_1 + 0x30);
if ((int)*(uint *)(param_1 + 0x30) < 1) {
uVar3 = 0;
}
lVar4 = -0x20;
do {
lVar1 = lVar4 + 0x20;
if (uVar3 * 0x20 == lVar1) {
return 0;
}
piVar2 = (int *)(*(long *)(param_1 + 0x28) + 0x38 + lVar4);
lVar4 = lVar1;
} while (*piVar2 != param_2);
return *(long *)(param_1 + 0x28) + lVar1;
}
|
|
66,098 |
void OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::appendLocalPointVaryingStencil<float>(int const*, int, int const*, int)
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchTableFactory.cpp
|
void
PatchTableBuilder::LocalPointHelper::appendLocalPointVaryingStencil(
int const * varyingIndices, int patchPointIndex,
Index const sourcePoints[], int sourcePointOffset) {
Index varyingPoint =
sourcePoints[varyingIndices[patchPointIndex]] + sourcePointOffset;
StencilTableReal<REAL>* t = _stencilTableVarying.Get<REAL>();
t->_sizes.push_back(1);
t->_indices.push_back(varyingPoint);
t->_weights.push_back((REAL) 1.0);
}
|
O0
|
cpp
|
void OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::appendLocalPointVaryingStencil<float>(int const*, int, int const*, int):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
addq $0x50, %rdi
callq 0xc9ca0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
movl $0x1, -0x34(%rbp)
leaq -0x34(%rbp), %rsi
callq 0xc5900
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
leaq -0x28(%rbp), %rsi
callq 0xc4210
movq -0x30(%rbp), %rdi
addq $0x58, %rdi
movss 0x98b32(%rip), %xmm0 # 0x1ea000
movss %xmm0, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0xd2740
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
|
_ZN10OpenSubdiv6v3_6_03Far17PatchTableBuilder16LocalPointHelper30appendLocalPointVaryingStencilIfEEvPKiiS6_i:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
mov [rbp+var_24], r8d
mov rdi, [rbp+var_8]
mov rax, [rbp+var_20]
mov rcx, [rbp+var_10]
movsxd rdx, [rbp+var_14]
movsxd rcx, dword ptr [rcx+rdx*4]
mov eax, [rax+rcx*4]
add eax, [rbp+var_24]
mov [rbp+var_28], eax
add rdi, 50h ; 'P'
call __ZNK10OpenSubdiv6v3_6_03Far10PatchTable15StencilTablePtr3GetIfEEPNS1_16StencilTableRealIT_EEv; OpenSubdiv::v3_6_0::Far::PatchTable::StencilTablePtr::Get<float>(void)
mov [rbp+var_30], rax
mov rdi, [rbp+var_30]
add rdi, 10h
mov [rbp+var_34], 1
lea rsi, [rbp+var_34]
call __ZNSt6vectorIiSaIiEE9push_backEOi; std::vector<int>::push_back(int &&)
mov rdi, [rbp+var_30]
add rdi, 40h ; '@'
lea rsi, [rbp+var_28]
call __ZNSt6vectorIiSaIiEE9push_backERKi; std::vector<int>::push_back(int const&)
mov rdi, [rbp+var_30]
add rdi, 58h ; 'X'
movss xmm0, cs:dword_1EA000
movss [rbp+var_38], xmm0
lea rsi, [rbp+var_38]
call __ZNSt6vectorIfSaIfEE9push_backEOf; std::vector<float>::push_back(float &&)
add rsp, 40h
pop rbp
retn
|
long long OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::appendLocalPointVaryingStencil<float>(
long long a1,
long long a2,
int a3,
long long a4,
int a5)
{
int v6; // [rsp+8h] [rbp-38h] BYREF
int v7; // [rsp+Ch] [rbp-34h] BYREF
long long v8; // [rsp+10h] [rbp-30h]
_DWORD v9[2]; // [rsp+18h] [rbp-28h] BYREF
long long v10; // [rsp+20h] [rbp-20h]
int v11; // [rsp+2Ch] [rbp-14h]
long long v12; // [rsp+30h] [rbp-10h]
long long v13; // [rsp+38h] [rbp-8h]
v13 = a1;
v12 = a2;
v11 = a3;
v10 = a4;
v9[1] = a5;
v9[0] = a5 + *(_DWORD *)(a4 + 4LL * *(int *)(a2 + 4LL * a3));
v8 = OpenSubdiv::v3_6_0::Far::PatchTable::StencilTablePtr::Get<float>(a1 + 80);
v7 = 1;
std::vector<int>::push_back(v8 + 16, &v7);
std::vector<int>::push_back(v8 + 64, v9);
v6 = 1065353216;
return std::vector<float>::push_back(v8 + 88, &v6);
}
| |||
66,099 |
void OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::appendLocalPointVaryingStencil<float>(int const*, int, int const*, int)
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchTableFactory.cpp
|
void
PatchTableBuilder::LocalPointHelper::appendLocalPointVaryingStencil(
int const * varyingIndices, int patchPointIndex,
Index const sourcePoints[], int sourcePointOffset) {
Index varyingPoint =
sourcePoints[varyingIndices[patchPointIndex]] + sourcePointOffset;
StencilTableReal<REAL>* t = _stencilTableVarying.Get<REAL>();
t->_sizes.push_back(1);
t->_indices.push_back(varyingPoint);
t->_weights.push_back((REAL) 1.0);
}
|
O2
|
cpp
|
void OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::appendLocalPointVaryingStencil<float>(int const*, int, int const*, int):
pushq %r14
pushq %rbx
subq $0x18, %rsp
movslq %edx, %rax
movslq (%rsi,%rax,4), %rax
addl (%rcx,%rax,4), %r8d
leaq 0x14(%rsp), %rbx
movl %r8d, (%rbx)
movq 0x50(%rdi), %r14
leaq 0x10(%r14), %rdi
leaq 0x10(%rsp), %rsi
movl $0x1, (%rsi)
callq 0x54910
leaq 0x40(%r14), %rdi
movq %rbx, %rsi
callq 0x4f610
addq $0x58, %r14
leaq 0xc(%rsp), %rsi
movl $0x3f800000, (%rsi) # imm = 0x3F800000
movq %r14, %rdi
callq 0x4f840
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
|
_ZN10OpenSubdiv6v3_6_03Far17PatchTableBuilder16LocalPointHelper30appendLocalPointVaryingStencilIfEEvPKiiS6_i:
push r14
push rbx
sub rsp, 18h
movsxd rax, edx
movsxd rax, dword ptr [rsi+rax*4]
add r8d, [rcx+rax*4]
lea rbx, [rsp+28h+var_14]
mov [rbx], r8d
mov r14, [rdi+50h]
lea rdi, [r14+10h]
lea rsi, [rsp+28h+var_18]
mov dword ptr [rsi], 1
call __ZNSt6vectorIiSaIiEE12emplace_backIJiEEERiDpOT_; std::vector<int>::emplace_back<int>(int &&)
lea rdi, [r14+40h]
mov rsi, rbx
call __ZNSt6vectorIiSaIiEE9push_backERKi; std::vector<int>::push_back(int const&)
add r14, 58h ; 'X'
lea rsi, [rsp+28h+var_1C]
mov dword ptr [rsi], 3F800000h
mov rdi, r14
call __ZNSt6vectorIfSaIfEE12emplace_backIJfEEERfDpOT_; std::vector<float>::emplace_back<float>(float &&)
add rsp, 18h
pop rbx
pop r14
retn
|
long long OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::appendLocalPointVaryingStencil<float>(
long long a1,
long long a2,
int a3,
long long a4,
int a5)
{
long long v5; // r14
int v7; // [rsp+Ch] [rbp-1Ch] BYREF
int v8; // [rsp+10h] [rbp-18h] BYREF
_DWORD v9[5]; // [rsp+14h] [rbp-14h] BYREF
v9[0] = *(_DWORD *)(a4 + 4LL * *(int *)(a2 + 4LL * a3)) + a5;
v5 = *(_QWORD *)(a1 + 80);
v8 = 1;
std::vector<int>::emplace_back<int>(v5 + 16, &v8);
std::vector<int>::push_back(v5 + 64, v9);
v7 = 1065353216;
return std::vector<float>::emplace_back<float>(v5 + 88, &v7);
}
|
appendLocalPointVaryingStencil<float>:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOVSXD RAX,EDX
MOVSXD RAX,dword ptr [RSI + RAX*0x4]
ADD R8D,dword ptr [RCX + RAX*0x4]
LEA RBX,[RSP + 0x14]
MOV dword ptr [RBX],R8D
MOV R14,qword ptr [RDI + 0x50]
LEA RDI,[R14 + 0x10]
LEA RSI,[RSP + 0x10]
MOV dword ptr [RSI],0x1
CALL 0x00154910
LEA RDI,[R14 + 0x40]
MOV RSI,RBX
CALL 0x0014f610
ADD R14,0x58
LEA RSI,[RSP + 0xc]
MOV dword ptr [RSI],0x3f800000
MOV RDI,R14
CALL 0x0014f840
ADD RSP,0x18
POP RBX
POP R14
RET
|
/* void
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::appendLocalPointVaryingStencil<float>(int
const*, int, int const*, int) */
void __thiscall
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::LocalPointHelper::appendLocalPointVaryingStencil<float>
(LocalPointHelper *this,int *param_1,int param_2,int *param_3,int param_4)
{
long lVar1;
float local_1c;
int local_18;
int local_14;
local_14 = param_4 + param_3[param_1[param_2]];
lVar1 = *(long *)(this + 0x50);
local_18 = 1;
std::vector<int,std::allocator<int>>::emplace_back<int>
((vector<int,std::allocator<int>> *)(lVar1 + 0x10),&local_18);
std::vector<int,std::allocator<int>>::push_back
((vector<int,std::allocator<int>> *)(lVar1 + 0x40),&local_14);
local_1c = 1.0;
std::vector<float,std::allocator<float>>::emplace_back<float>
((vector<float,std::allocator<float>> *)(lVar1 + 0x58),&local_1c);
return;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.